tests: use a "clean" default_connection due to tests contaminating each other

Author: paultiq

tests/fast/api/test_duckdb_connection.py

@@ -24,23 +24,23 @@ def tmp_database(tmp_path_factory):
 # wrapped by the 'duckdb' module, to execute with the 'default_connection'
 class TestDuckDBConnection(object):
     @pytest.mark.parametrize('pandas', [NumpyPandas(), ArrowPandas()])
-    def test_append(self, pandas):
-        duckdb.execute("Create table integers (i integer)")
+    def test_append(self, pandas, default_con):
+        default_con.execute("Create table integers (i integer)")
         df_in = pandas.DataFrame(
             {
                 'numbers': [1, 2, 3, 4, 5],
             }
         )
-        duckdb.append('integers', df_in)
-        assert duckdb.execute('select count(*) from integers').fetchone()[0] == 5
+        default_con.append('integers', df_in)
+        assert default_con.execute('select count(*) from integers').fetchone()[0] == 5
         # cleanup
-        duckdb.execute("drop table integers")
+        default_con.execute("drop table integers")
 
-    def test_default_connection_from_connect(self):
-        duckdb.sql('create or replace table connect_default_connect (i integer)')
+    def test_default_connection_from_connect(self, default_con):
+        default_con.sql('create or replace table connect_default_connect (i integer)')
         con = duckdb.connect(':default:')
         con.sql('select i from connect_default_connect')
-        duckdb.sql('drop table connect_default_connect')
+        default_con.sql('drop table connect_default_connect')
         with pytest.raises(duckdb.Error):
             con.sql('select i from connect_default_connect')
 
@@ -57,31 +57,31 @@ def test_arrow(self):
 
     def test_begin_commit(self):
         duckdb.begin()
-        duckdb.execute("create table tbl as select 1")
+        duckdb.execute("create table tbl_1 as select 1")
         duckdb.commit()
-        res = duckdb.table("tbl")
-        duckdb.execute("drop table tbl")
+        res = duckdb.table("tbl_1")
+        duckdb.execute("drop table tbl_1")
 
-    def test_begin_rollback(self):
-        duckdb.begin()
-        duckdb.execute("create table tbl as select 1")
-        duckdb.rollback()
+    def test_begin_rollback(self, default_con):
+        default_con.begin()
+        default_con.execute("create table tbl_1rb as select 1")
+        default_con.rollback()
         with pytest.raises(duckdb.CatalogException):
             # Table does not exist
-            res = duckdb.table("tbl")
+            res = default_con.table("tbl_1rb")
 
-    def test_cursor(self):
-        duckdb.execute("create table tbl as select 3")
+    def test_cursor(self, default_con):
+        default_con.execute("create table tbl_3 as select 3")
         duckdb_cursor = duckdb.cursor()
-        res = duckdb_cursor.table("tbl").fetchall()
+        res = duckdb_cursor.table("tbl_3").fetchall()
         assert res == [(3,)]
-        duckdb_cursor.execute("drop table tbl")
+        duckdb_cursor.execute("drop table tbl_3")
         with pytest.raises(duckdb.CatalogException):
             # 'tbl' no longer exists
-            duckdb.table("tbl")
+            default_con.table("tbl_3")
 
-    def test_cursor_lifetime(self):
-        con = duckdb.connect()
+    def test_cursor_lifetime(self, default_con):
+        con = default_con
 
         def use_cursors():
             cursors = []
@@ -103,12 +103,12 @@ def test_df(self):
         assert res == ref
 
     def test_duplicate(self):
-        duckdb.execute("create table tbl as select 5")
+        duckdb.execute("create table tbl_5 as select 5")
         dup_conn = duckdb.duplicate()
-        dup_conn.table("tbl").fetchall()
-        duckdb.execute("drop table tbl")
+        dup_conn.table("tbl_5").fetchall()
+        duckdb.execute("drop table tbl_5")
         with pytest.raises(duckdb.CatalogException):
-            dup_conn.table("tbl").fetchall()
+            dup_conn.table("tbl_5").fetchall()
 
     def test_readonly_properties(self):
         duckdb.execute("select 42")
@@ -123,11 +123,11 @@ def test_execute(self):
     def test_executemany(self):
         # executemany does not keep an open result set
         # TODO: shouldn't we also have a version that executes a query multiple times with different parameters, returning all of the results?
-        duckdb.execute("create table tbl (i integer, j varchar)")
-        duckdb.executemany("insert into tbl VALUES (?, ?)", [(5, 'test'), (2, 'duck'), (42, 'quack')])
-        res = duckdb.table("tbl").fetchall()
+        duckdb.execute("create table tbl_many (i integer, j varchar)")
+        duckdb.executemany("insert into tbl_many VALUES (?, ?)", [(5, 'test'), (2, 'duck'), (42, 'quack')])
+        res = duckdb.table("tbl_many").fetchall()
         assert res == [(5, 'test'), (2, 'duck'), (42, 'quack')]
-        duckdb.execute("drop table tbl")
+        duckdb.execute("drop table tbl_many")
 
     def test_pystatement(self):
         with pytest.raises(duckdb.ParserException, match='seledct'):
@@ -163,8 +163,8 @@ def test_pystatement(self):
             duckdb.execute(statements[0])
         assert duckdb.execute(statements[0], {'1': 42}).fetchall() == [(42,)]
 
-        duckdb.execute("create table tbl(a integer)")
-        statements = duckdb.extract_statements('insert into tbl select $1')
+        duckdb.execute("create table tbl_a(a integer)")
+        statements = duckdb.extract_statements('insert into tbl_a select $1')
         assert statements[0].expected_result_type == [
             duckdb.ExpectedResultType.CHANGED_ROWS,
             duckdb.ExpectedResultType.QUERY_RESULT,
@@ -174,23 +174,23 @@ def test_pystatement(self):
         ):
             duckdb.executemany(statements[0])
         duckdb.executemany(statements[0], [(21,), (22,), (23,)])
-        assert duckdb.table('tbl').fetchall() == [(21,), (22,), (23,)]
-        duckdb.execute("drop table tbl")
+        assert duckdb.table('tbl_a').fetchall() == [(21,), (22,), (23,)]
+        duckdb.execute("drop table tbl_a")
 
     def test_fetch_arrow_table(self):
         # Needed for 'fetch_arrow_table'
         pyarrow = pytest.importorskip("pyarrow")
 
-        duckdb.execute("Create Table test (a integer)")
+        duckdb.execute("Create Table test_arrow_tble (a integer)")
 
         for i in range(1024):
             for j in range(2):
-                duckdb.execute("Insert Into test values ('" + str(i) + "')")
-        duckdb.execute("Insert Into test values ('5000')")
-        duckdb.execute("Insert Into test values ('6000')")
+                duckdb.execute("Insert Into test_arrow_tble values ('" + str(i) + "')")
+        duckdb.execute("Insert Into test_arrow_tble values ('5000')")
+        duckdb.execute("Insert Into test_arrow_tble values ('6000')")
         sql = '''
         SELECT  a, COUNT(*) AS repetitions
-        FROM    test
+        FROM    test_arrow_tble
         GROUP BY a
         '''
 
@@ -200,7 +200,7 @@ def test_fetch_arrow_table(self):
 
         arrow_df = arrow_table.to_pandas()
         assert result_df['repetitions'].sum() == arrow_df['repetitions'].sum()
-        duckdb.execute("drop table test")
+        duckdb.execute("drop table test_arrow_tble")
 
     def test_fetch_df(self):
         ref = [([1, 2, 3],)]
@@ -210,22 +210,22 @@ def test_fetch_df(self):
         assert res == ref
 
     def test_fetch_df_chunk(self):
-        duckdb.execute("CREATE table t as select range a from range(3000);")
-        query = duckdb.execute("SELECT a FROM t")
+        duckdb.execute("CREATE table t_df_chunk as select range a from range(3000);")
+        query = duckdb.execute("SELECT a FROM t_df_chunk")
         cur_chunk = query.fetch_df_chunk()
         assert cur_chunk['a'][0] == 0
         assert len(cur_chunk) == 2048
         cur_chunk = query.fetch_df_chunk()
         assert cur_chunk['a'][0] == 2048
         assert len(cur_chunk) == 952
-        duckdb.execute("DROP TABLE t")
+        duckdb.execute("DROP TABLE t_df_chunk")
 
     def test_fetch_record_batch(self):
         # Needed for 'fetch_arrow_table'
         pyarrow = pytest.importorskip("pyarrow")
 
-        duckdb.execute("CREATE table t as select range a from range(3000);")
-        duckdb.execute("SELECT a FROM t")
+        duckdb.execute("CREATE table t_record_batch as select range a from range(3000);")
+        duckdb.execute("SELECT a FROM t_record_batch")
         record_batch_reader = duckdb.fetch_record_batch(1024)
         chunk = record_batch_reader.read_all()
         assert len(chunk) == 3000
@@ -286,13 +286,13 @@ def test_query(self):
     def test_register(self):
         assert None != duckdb.register
 
-    def test_register_relation(self):
-        con = duckdb.connect()
+    def test_register_relation(self, default_con):
+        con = default_con
         rel = con.sql('select [5,4,3]')
-        con.register("relation", rel)
+        con.register("relation_rr", rel)
 
-        con.sql("create table tbl as select * from relation")
-        assert con.table('tbl').fetchall() == [([5, 4, 3],)]
+        con.sql("create table tbl_reg_rel as select * from relation_rr")
+        assert con.table('tbl_reg_rel').fetchall() == [([5, 4, 3],)]
 
     def test_unregister_problematic_behavior(self, duckdb_cursor):
         # We have a VIEW called 'vw' in the Catalog
@@ -314,10 +314,10 @@ def test_unregister_problematic_behavior(self, duckdb_cursor):
         assert duckdb_cursor.execute("select * from vw").fetchone() == (0,)
 
     @pytest.mark.parametrize('pandas', [NumpyPandas(), ArrowPandas()])
-    def test_relation_out_of_scope(self, pandas):
+    def test_relation_out_of_scope(self, pandas, default_con):
         def temporary_scope():
             # Create a connection, we will return this
-            con = duckdb.connect()
+            con = default_con
             # Create a dataframe
             df = pandas.DataFrame({'a': [1, 2, 3]})
             # The dataframe has to be registered as well
@@ -333,8 +333,8 @@ def temporary_scope():
 
     def test_table(self):
         con = duckdb.connect()
-        con.execute("create table tbl as select 1")
-        assert [(1,)] == con.table("tbl").fetchall()
+        con.execute("create table tbl_test_table as select 1")
+        assert [(1,)] == con.table("tbl_test_table").fetchall()
 
     def test_table_function(self):
         assert None != duckdb.table_function
@@ -356,16 +356,15 @@ def test_close(self):
     def test_interrupt(self):
         assert None != duckdb.interrupt
 
-    def test_wrap_shadowing(self):
+    def test_wrap_shadowing(self, default_con):
         pd = NumpyPandas()
-        import duckdb
 
         df = pd.DataFrame({"a": [1, 2, 3]})
-        res = duckdb.sql("from df").fetchall()
+        res = default_con.sql("from df").fetchall()
         assert res == [(1,), (2,), (3,)]
 
-    def test_wrap_coverage(self):
-        con = duckdb.default_connection
+    def test_wrap_coverage(self, default_con):
+        con = default_con
 
         # Skip all of the initial __xxxx__ methods
         connection_methods = dir(con)