Python extensions.cursor方法代码示例

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def as_string(self, context):
        # is it a connection or cursor?
        if isinstance(context, ext.connection):
            conn = context
        elif isinstance(context, ext.cursor):
            conn = context.connection
        else:
            raise TypeError("context must be a connection or a cursor")

        a = ext.adapt(self._wrapped)
        if hasattr(a, 'prepare'):
            a.prepare(conn)

        rv = a.getquoted()
        if sys.version_info[0] >= 3 and isinstance(rv, bytes):
            rv = rv.decode(ext.encodings[conn.encoding])

        return rv 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_subclass_rollback(self):
        rollbacks = []
        class MyConn(ext.connection):
            def rollback(self):
                rollbacks.append(None)
                super(MyConn, self).rollback()

        try:
            with self.connect(connection_factory=MyConn) as conn:
                curs = conn.cursor()
                curs.execute("insert into test_with values (11)")
                1/0
        except ZeroDivisionError:
            pass
        else:
            self.assert_("exception not raised")

        self.assertEqual(conn.status, ext.STATUS_READY)
        self.assert_(rollbacks)

        curs = conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), []) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_with_error(self):
        try:
            with self.conn as conn:
                with conn.cursor() as curs:
                    curs.execute("insert into test_with values (5)")
                    1/0
        except ZeroDivisionError:
            pass

        self.assertEqual(self.conn.status, ext.STATUS_READY)
        self.assert_(not self.conn.closed)
        self.assert_(curs.closed)

        curs = self.conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), []) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def _pipeDbCursorToTsvFile(self, dbCursor, tsvFile, include_columns=True):
        """
        Pipe any arbitrary DB cursor to a TSV file.
        """
        # Extract DB columns.
        columns = dbCursor.description
        numColumns = len(columns)

        if include_columns:
            # Write TSV header.
            for i in range(numColumns - 1):
                # 0th index is column name.
                tsvFile.write("%s\t" % columns[i][0])
            tsvFile.write("%s\n" % columns[numColumns - 1][0])

        # By default, cursor iterates through both header and data rows.
        self._numRows = 0
        row = dbCursor.fetchone()
        while row is not None:
            for i in range(numColumns - 1):
                tsvFile.write("%s\t" % row[i])
            tsvFile.write("%s\n" % row[numColumns - 1])
            row = dbCursor.fetchone()
            self._numRows += 1 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def _processPatientEpisodeDbCursor(self):
        """
        Convert self.patientEpisodeInput from DB cursor to TSV file.
        """
        # Instantiate patientEpisodeTempFile.
        patientEpisodeTempFile = open(self._patientEpisodeTempFileName, "w")
        self._pipeDbCursorToTsvFile(self.patientEpisodeInput, patientEpisodeTempFile)
        patientEpisodeTempFile.close()
        self.patientsProcessed = True

        if LocalEnv.DATABASE_CONNECTOR_NAME == 'psycopg2':
            return self.patientEpisodeInput.rowcount
        elif LocalEnv.DATABASE_CONNECTOR_NAME == 'sqlite3':
        # In sqlite3, rowcount is somehow "always" -1; See for details:
        # https://docs.python.org/3.0/library/sqlite3.html#sqlite3.Cursor.rowcount
            return self._numRows #self.patientEpisodeInput.rowcount 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def _pipeDbCursorToTsvFile(self, dbCursor, tsvFile):
        """
        Pipe any arbitrary DB cursor to a TSV file.
        """
        # Extract DB columns.
        columns = dbCursor.description
        numColumns = len(columns)

        # Write TSV header.
        for i in range(numColumns - 1):
            # 0th index is column name.
            tsvFile.write("%s\t" % columns[i][0])
        tsvFile.write("%s\n" % columns[numColumns - 1][0])

        # By default, cursor iterates through both header and data rows.
        self._numRows = 0
        row = dbCursor.fetchone()
        while row is not None:
            for i in range(numColumns - 1):
                tsvFile.write("%s\t" % row[i])
            tsvFile.write("%s\n" % row[numColumns - 1])
            row = dbCursor.fetchone()
            self._numRows += 1 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def setPatientEpisodeInput(self, patientEpisodeInput, \
        patientIdColumn = "patient_id", timestampColumn = "item_date"):
        """
        Define the input patient episode list for the feature matrix.
        patientEpisodeInput: TSV file descriptor or DB cursor.
        patientIdColumn: Name of TSV column or DB column.
        timestampColumn: Name of TSV column or DB column.
        """
        # Verify patientEpisodeInput is TSV file or DB cursor.
        if not isinstance(patientEpisodeInput, cursor) and \
            not isinstance(patientEpisodeInput, file):
            raise TypeError("patientEpisodeInput must be DB cursor or TSV file.")

        self.patientEpisodeInput = patientEpisodeInput
        self.patientEpisodeIdColumn = patientIdColumn
        self.patientEpisodeTimeColumn = timestampColumn 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def _solve_conn_curs(conn_or_curs):
    """Return the connection and a DBAPI cursor from a connection or cursor."""
    if conn_or_curs is None:
        raise psycopg2.ProgrammingError("no connection or cursor provided")

    if hasattr(conn_or_curs, 'execute'):
        conn = conn_or_curs.connection
        curs = conn.cursor(cursor_factory=_cursor)
    else:
        conn = conn_or_curs
        curs = conn.cursor(cursor_factory=_cursor)

    return conn, curs 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def cursor(self, *args: Any, **kwargs: Any) -> TimeTrackingCursor:
        kwargs.setdefault('cursor_factory', TimeTrackingCursor)
        return connection.cursor(self, *args, **kwargs) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def setUp(self):
        ConnectingTestCase.setUp(self)
        curs = self.conn.cursor()
        try:
            curs.execute("delete from test_with")
            self.conn.commit()
        except psycopg2.ProgrammingError:
            # assume table doesn't exist
            self.conn.rollback()
            curs.execute("create table test_with (id integer primary key)")
            self.conn.commit() 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_with_ok(self):
        with self.conn as conn:
            self.assert_(self.conn is conn)
            self.assertEqual(conn.status, ext.STATUS_READY)
            curs = conn.cursor()
            curs.execute("insert into test_with values (1)")
            self.assertEqual(conn.status, ext.STATUS_BEGIN)

        self.assertEqual(self.conn.status, ext.STATUS_READY)
        self.assert_(not self.conn.closed)

        curs = self.conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), [(1,)]) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_with_connect_idiom(self):
        with self.connect() as conn:
            self.assertEqual(conn.status, ext.STATUS_READY)
            curs = conn.cursor()
            curs.execute("insert into test_with values (2)")
            self.assertEqual(conn.status, ext.STATUS_BEGIN)

        self.assertEqual(self.conn.status, ext.STATUS_READY)
        self.assert_(not self.conn.closed)

        curs = self.conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), [(2,)]) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_with_error_db(self):
        def f():
            with self.conn as conn:
                curs = conn.cursor()
                curs.execute("insert into test_with values ('a')")

        self.assertRaises(psycopg2.DataError, f)
        self.assertEqual(self.conn.status, ext.STATUS_READY)
        self.assert_(not self.conn.closed)

        curs = self.conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), []) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_with_error_python(self):
        def f():
            with self.conn as conn:
                curs = conn.cursor()
                curs.execute("insert into test_with values (3)")
                1/0

        self.assertRaises(ZeroDivisionError, f)
        self.assertEqual(self.conn.status, ext.STATUS_READY)
        self.assert_(not self.conn.closed)

        curs = self.conn.cursor()
        curs.execute("select * from test_with")
        self.assertEqual(curs.fetchall(), []) 

# 需要导入模块: from psycopg2 import extensions [as 别名]
# 或者: from psycopg2.extensions import cursor [as 别名]
def test_subclass(self):
        closes = []
        class MyCurs(ext.cursor):
            def close(self):
                closes.append(None)
                super(MyCurs, self).close()

        with self.conn.cursor(cursor_factory=MyCurs) as curs:
            self.assert_(isinstance(curs, MyCurs))

        self.assert_(curs.closed)
        self.assert_(closes)