def tearDown(self):
        curs = self.conn.cursor()
        curs.execute("DROP TABLE table1")
        curs.execute("DROP TABLE table2")
        self.conn.commit()

        ConnectingTestCase.tearDown(self)

 def setUp(self):
     ConnectingTestCase.setUp(self)
     self.curs = self.conn.cursor()
     self.DATE = psycopg2.extensions.PYDATE
     self.TIME = psycopg2.extensions.PYTIME
     self.DATETIME = psycopg2.extensions.PYDATETIME
     self.INTERVAL = psycopg2.extensions.PYINTERVAL

    def setUp(self):
        ConnectingTestCase.setUp(self)

        cur = self.conn.cursor()
        cur.execute('''
            CREATE TEMPORARY TABLE table1 (
              id int PRIMARY KEY
            )''')
        self.conn.commit()

 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()

    def setUp(self):
        ConnectingTestCase.setUp(self)

        self.sync_conn = self.conn
        self.conn = self.connect(async=True)

        self.wait(self.conn)

        curs = self.conn.cursor()
        curs.execute('''
            CREATE TEMPORARY TABLE table1 (
              id int PRIMARY KEY
            )''')
        self.wait(curs)

    def setUp(self):
        ConnectingTestCase.setUp(self)
        from psycopg2.extras import NamedTupleConnection

        try:
            from collections import namedtuple
        except ImportError:
            return

        self.conn = self.connect(connection_factory=NamedTupleConnection)
        curs = self.conn.cursor()
        curs.execute("CREATE TEMPORARY TABLE nttest (i int, s text)")
        curs.execute("INSERT INTO nttest VALUES (1, 'foo')")
        curs.execute("INSERT INTO nttest VALUES (2, 'bar')")
        curs.execute("INSERT INTO nttest VALUES (3, 'baz')")
        self.conn.commit()

    def tearDown(self):
        if self.tmpdir:
            shutil.rmtree(self.tmpdir, ignore_errors=True)

        if self.conn.closed:
            return

        if self.lo_oid is not None:
            self.conn.rollback()
            try:
                lo = self.conn.lobject(self.lo_oid, "n")
            except psycopg2.OperationalError:
                pass
            else:
                lo.unlink()

        ConnectingTestCase.tearDown(self)

 def setUp(self):
     ConnectingTestCase.setUp(self)
     self.conn.set_isolation_level(ISOLATION_LEVEL_SERIALIZABLE)
     curs = self.conn.cursor()
     curs.execute('''
         CREATE TEMPORARY TABLE table1 (
           id int PRIMARY KEY
         )''')
     # The constraint is set to deferrable for the commit_failed test
     curs.execute('''
         CREATE TEMPORARY TABLE table2 (
           id int PRIMARY KEY,
           table1_id int,
           CONSTRAINT table2__table1_id__fk
             FOREIGN KEY (table1_id) REFERENCES table1(id) DEFERRABLE)''')
     curs.execute('INSERT INTO table1 VALUES (1)')
     curs.execute('INSERT INTO table2 VALUES (1, 1)')
     self.conn.commit()

 def setUp(self):
     ConnectingTestCase.setUp(self)
     self._create_temp_table()

 def setUp(self):
     ConnectingTestCase.setUp(self)
     self.lo_oid = None
     self.tmpdir = None

 def connect(self):
     conn = ConnectingTestCase.connect(self)
     conn.set_isolation_level(ISOLATION_LEVEL_SERIALIZABLE)
     return conn

 def setUp(self):
     self._cb = psycopg2.extensions.get_wait_callback()
     psycopg2.extensions.set_wait_callback(self.crappy_callback)
     ConnectingTestCase.setUp(self)
     self.to_error = None