crate 0.35.1__py2.py3-none-any.whl → 1.0.0.dev0__py2.py3-none-any.whl

crate/client/sqlalchemy/predicates/__init__.py

@@ -1,99 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-
-from sqlalchemy.sql.expression import ColumnElement, literal
-from sqlalchemy.ext.compiler import compiles
-
-
-class Match(ColumnElement):
-    inherit_cache = True
-
-    def __init__(self, column, term, match_type=None, options=None):
-        super(Match, self).__init__()
-        self.column = column
-        self.term = term
-        self.match_type = match_type
-        self.options = options
-
-    def compile_column(self, compiler):
-        if isinstance(self.column, dict):
-            column = ', '.join(
-                sorted(["{0} {1}".format(compiler.process(k), v)
-                       for k, v in self.column.items()])
-            )
-            return "({0})".format(column)
-        else:
-            return "{0}".format(compiler.process(self.column))
-
-    def compile_term(self, compiler):
-        return compiler.process(literal(self.term))
-
-    def compile_using(self, compiler):
-        if self.match_type:
-            using = "using {0}".format(self.match_type)
-            with_clause = self.with_clause()
-            if with_clause:
-                using = ' '.join([using, with_clause])
-            return using
-        if self.options:
-            raise ValueError("missing match_type. " +
-                             "It's not allowed to specify options " +
-                             "without match_type")
-
-    def with_clause(self):
-        if self.options:
-            options = ', '.join(
-                sorted(["{0}={1}".format(k, v)
-                       for k, v in self.options.items()])
-            )
-
-            return "with ({0})".format(options)
-
-
-def match(column, term, match_type=None, options=None):
-    """Generates match predicate for fulltext search
-
-    :param column: A reference to a column or an index, or a subcolumn, or a
-     dictionary of subcolumns with boost values.
-
-    :param term: The term to match against. This string is analyzed and the
-     resulting tokens are compared to the index.
-
-    :param match_type (optional): The match type. Determine how the term is
-     applied and the score calculated.
-
-    :param options (optional): The match options. Specify match type behaviour.
-     (Not possible without a specified match type.) Match options must be
-     supplied as a dictionary.
-    """
-    return Match(column, term, match_type, options)
-
-
-@compiles(Match)
-def compile_match(match, compiler, **kwargs):
-    func = "match(%s, %s)" % (
-        match.compile_column(compiler),
-        match.compile_term(compiler)
-    )
-    using = match.compile_using(compiler)
-    if using:
-        func = ' '.join([func, using])
-    return func

crate/client/sqlalchemy/sa_version.py

@@ -1,28 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-
-import sqlalchemy as sa
-from verlib2 import Version
-
-SA_VERSION = Version(sa.__version__)
-
-SA_1_4 = Version('1.4.0b1')
-SA_2_0 = Version('2.0.0')

crate/client/sqlalchemy/support.py

@@ -1,62 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-
-def insert_bulk(pd_table, conn, keys, data_iter):
-    """
-    Use CrateDB's "bulk operations" endpoint as a fast path for pandas' and Dask's `to_sql()` [1] method.
-
-    The idea is to break out of SQLAlchemy, compile the insert statement, and use the raw
-    DBAPI connection client, in order to invoke a request using `bulk_parameters` [2]::
-
-        cursor.execute(sql=sql, bulk_parameters=data)
-
-    The vanilla implementation, used by SQLAlchemy, is::
-
-        data = [dict(zip(keys, row)) for row in data_iter]
-        conn.execute(pd_table.table.insert(), data)
-
-    Batch chunking will happen outside of this function, for example [3] demonstrates
-    the relevant code in `pandas.io.sql`.
-
-    [1] https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html
-    [2] https://crate.io/docs/crate/reference/en/latest/interfaces/http.html#bulk-operations
-    [3] https://github.com/pandas-dev/pandas/blob/v2.0.1/pandas/io/sql.py#L1011-L1027
-    """
-
-    # Compile SQL statement and materialize batch.
-    sql = str(pd_table.table.insert().compile(bind=conn))
-    data = list(data_iter)
-
-    # For debugging and tracing the batches running through this method.
-    if logger.level == logging.DEBUG:
-        logger.debug(f"Bulk SQL:     {sql}")
-        logger.debug(f"Bulk records: {len(data)}")
-        # logger.debug(f"Bulk data:    {data}")
-
-    # Invoke bulk insert operation.
-    cursor = conn._dbapi_connection.cursor()
-    cursor.execute(sql=sql, bulk_parameters=data)
-    cursor.close()

crate/client/sqlalchemy/tests/__init__.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from ..compat.api13 import monkeypatch_amend_select_sa14, monkeypatch_add_connectionfairy_driver_connection
-from ..sa_version import SA_1_4, SA_VERSION
-from ...test_util import ParametrizedTestCase
-
-# `sql.select()` of SQLAlchemy 1.3 uses old calling semantics,
-# but the test cases already need the modern ones.
-if SA_VERSION < SA_1_4:
-    monkeypatch_amend_select_sa14()
-    monkeypatch_add_connectionfairy_driver_connection()
-
-from unittest import TestLoader, TestSuite
-from .connection_test import SqlAlchemyConnectionTest
-from .dict_test import SqlAlchemyDictTypeTest
-from .datetime_test import SqlAlchemyDateAndDateTimeTest
-from .compiler_test import SqlAlchemyCompilerTest, SqlAlchemyDDLCompilerTest
-from .update_test import SqlAlchemyUpdateTest
-from .match_test import SqlAlchemyMatchTest
-from .bulk_test import SqlAlchemyBulkTest
-from .insert_from_select_test import SqlAlchemyInsertFromSelectTest
-from .create_table_test import SqlAlchemyCreateTableTest
-from .array_test import SqlAlchemyArrayTypeTest
-from .dialect_test import SqlAlchemyDialectTest
-from .function_test import SqlAlchemyFunctionTest
-from .warnings_test import SqlAlchemyWarningsTest
-from .query_caching import SqlAlchemyQueryCompilationCaching
-
-
-makeSuite = TestLoader().loadTestsFromTestCase
-
-
-def test_suite_unit():
-    tests = TestSuite()
-    tests.addTest(makeSuite(SqlAlchemyConnectionTest))
-    tests.addTest(makeSuite(SqlAlchemyDictTypeTest))
-    tests.addTest(makeSuite(SqlAlchemyDateAndDateTimeTest))
-    tests.addTest(makeSuite(SqlAlchemyCompilerTest))
-    tests.addTest(makeSuite(SqlAlchemyDDLCompilerTest))
-    tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": None}))
-    tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 0, 12)}))
-    tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 1, 10)}))
-    tests.addTest(makeSuite(SqlAlchemyUpdateTest))
-    tests.addTest(makeSuite(SqlAlchemyMatchTest))
-    tests.addTest(makeSuite(SqlAlchemyCreateTableTest))
-    tests.addTest(makeSuite(SqlAlchemyBulkTest))
-    tests.addTest(makeSuite(SqlAlchemyInsertFromSelectTest))
-    tests.addTest(makeSuite(SqlAlchemyInsertFromSelectTest))
-    tests.addTest(makeSuite(SqlAlchemyDialectTest))
-    tests.addTest(makeSuite(SqlAlchemyFunctionTest))
-    tests.addTest(makeSuite(SqlAlchemyArrayTypeTest))
-    tests.addTest(makeSuite(SqlAlchemyWarningsTest))
-    return tests
-
-
-def test_suite_integration():
-    tests = TestSuite()
-    tests.addTest(makeSuite(SqlAlchemyQueryCompilationCaching))
-    return tests

crate/client/sqlalchemy/tests/array_test.py

@@ -1,111 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-
-
-from unittest import TestCase
-from unittest.mock import patch, MagicMock
-
-import sqlalchemy as sa
-from sqlalchemy.sql import operators
-from sqlalchemy.orm import Session
-try:
-    from sqlalchemy.orm import declarative_base
-except ImportError:
-    from sqlalchemy.ext.declarative import declarative_base
-
-from crate.client.cursor import Cursor
-
-fake_cursor = MagicMock(name='fake_cursor')
-FakeCursor = MagicMock(name='FakeCursor', spec=Cursor)
-FakeCursor.return_value = fake_cursor
-
-
-@patch('crate.client.connection.Cursor', FakeCursor)
-class SqlAlchemyArrayTypeTest(TestCase):
-
-    def setUp(self):
-        self.engine = sa.create_engine('crate://')
-        Base = declarative_base()
-        self.metadata = sa.MetaData()
-
-        class User(Base):
-            __tablename__ = 'users'
-
-            name = sa.Column(sa.String, primary_key=True)
-            friends = sa.Column(sa.ARRAY(sa.String))
-            scores = sa.Column(sa.ARRAY(sa.Integer))
-
-        self.User = User
-        self.session = Session(bind=self.engine)
-
-    def assertSQL(self, expected_str, actual_expr):
-        self.assertEqual(expected_str, str(actual_expr).replace('\n', ''))
-
-    def test_create_with_array(self):
-        t1 = sa.Table('t', self.metadata,
-                      sa.Column('int_array', sa.ARRAY(sa.Integer)),
-                      sa.Column('str_array', sa.ARRAY(sa.String))
-                      )
-        t1.create(self.engine)
-        fake_cursor.execute.assert_called_with(
-            ('\nCREATE TABLE t (\n\t'
-             'int_array ARRAY(INT), \n\t'
-             'str_array ARRAY(STRING)\n)\n\n'),
-            ())
-
-    def test_array_insert(self):
-        trillian = self.User(name='Trillian', friends=['Arthur', 'Ford'])
-        self.session.add(trillian)
-        self.session.commit()
-        fake_cursor.execute.assert_called_with(
-            ("INSERT INTO users (name, friends, scores) VALUES (?, ?, ?)"),
-            ('Trillian', ['Arthur', 'Ford'], None))
-
-    def test_any(self):
-        s = self.session.query(self.User.name) \
-                .filter(self.User.friends.any("arthur"))
-        self.assertSQL(
-            "SELECT users.name AS users_name FROM users "
-            "WHERE ? = ANY (users.friends)",
-            s
-        )
-
-    def test_any_with_operator(self):
-        s = self.session.query(self.User.name) \
-                .filter(self.User.scores.any(6, operator=operators.lt))
-        self.assertSQL(
-            "SELECT users.name AS users_name FROM users "
-            "WHERE ? < ANY (users.scores)",
-            s
-        )
-
-    def test_multidimensional_arrays(self):
-        t1 = sa.Table('t', self.metadata,
-                      sa.Column('unsupported_array',
-                                sa.ARRAY(sa.Integer, dimensions=2)),
-                      )
-        err = None
-        try:
-            t1.create(self.engine)
-        except NotImplementedError as e:
-            err = e
-        self.assertEqual(str(err),
-                         "CrateDB doesn't support multidimensional arrays")

crate/client/sqlalchemy/tests/bulk_test.py

@@ -1,256 +0,0 @@
-# -*- coding: utf-8; -*-
-#
-# Licensed to CRATE Technology GmbH ("Crate") under one or more contributor
-# license agreements.  See the NOTICE file distributed with this work for
-# additional information regarding copyright ownership.  Crate licenses
-# this file to you under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.  You may
-# obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# However, if you have executed another commercial license agreement
-# with Crate these terms will supersede the license and you may use the
-# software solely pursuant to the terms of the relevant commercial agreement.
-import math
-import sys
-from unittest import TestCase, skipIf
-from unittest.mock import patch, MagicMock
-
-import sqlalchemy as sa
-from sqlalchemy.orm import Session
-
-from crate.client.sqlalchemy.sa_version import SA_VERSION, SA_2_0, SA_1_4
-
-try:
-    from sqlalchemy.orm import declarative_base
-except ImportError:
-    from sqlalchemy.ext.declarative import declarative_base
-
-from crate.client.cursor import Cursor
-
-
-fake_cursor = MagicMock(name='fake_cursor')
-FakeCursor = MagicMock(name='FakeCursor', spec=Cursor, return_value=fake_cursor)
-
-
-class SqlAlchemyBulkTest(TestCase):
-
-    def setUp(self):
-        self.engine = sa.create_engine('crate://')
-        Base = declarative_base()
-
-        class Character(Base):
-            __tablename__ = 'characters'
-
-            name = sa.Column(sa.String, primary_key=True)
-            age = sa.Column(sa.Integer)
-
-        self.character = Character
-        self.session = Session(bind=self.engine)
-
-    @skipIf(SA_VERSION >= SA_2_0, "SQLAlchemy 2.x uses modern bulk INSERT mode")
-    @patch('crate.client.connection.Cursor', FakeCursor)
-    def test_bulk_save_legacy(self):
-        """
-        Verify legacy SQLAlchemy bulk INSERT mode.
-
-        > bulk_save_objects: Perform a bulk save of the given list of objects.
-        > This method is a legacy feature as of the 2.0 series of SQLAlchemy. For modern
-        > bulk INSERT and UPDATE, see the sections ORM Bulk INSERT Statements and ORM Bulk
-        > UPDATE by Primary Key.
-        >
-        > -- https://docs.sqlalchemy.org/orm/session_api.html#sqlalchemy.orm.Session.bulk_save_objects
-
-        > The Session includes legacy methods for performing "bulk" INSERT and UPDATE
-        > statements. These methods share implementations with the SQLAlchemy 2.0
-        > versions of these features, described at ORM Bulk INSERT Statements and
-        > ORM Bulk UPDATE by Primary Key, however lack many features, namely RETURNING
-        > support as well as support for session-synchronization.
-        >
-        > -- https://docs.sqlalchemy.org/orm/queryguide/dml.html#legacy-session-bulk-insert-methods
-
-        > The 1.4 version of the "ORM bulk insert" methods are really not very efficient and
-        > don't grant that much of a performance bump vs. regular ORM `session.add()`, provided
-        > in both cases the objects you provide already have their primary key values assigned.
-        > SQLAlchemy 2.0 made a much more comprehensive change to how this all works as well so
-        > that all INSERT methods are essentially extremely fast now, relative to the 1.x series.
-        >
-        > -- https://github.com/sqlalchemy/sqlalchemy/discussions/6935#discussioncomment-4789701
-        """
-        chars = [
-            self.character(name='Arthur', age=35),
-            self.character(name='Banshee', age=26),
-            self.character(name='Callisto', age=37),
-        ]
-
-        fake_cursor.description = ()
-        fake_cursor.rowcount = len(chars)
-        fake_cursor.executemany.return_value = [
-            {'rowcount': 1},
-            {'rowcount': 1},
-            {'rowcount': 1},
-        ]
-        self.session.bulk_save_objects(chars)
-        (stmt, bulk_args), _ = fake_cursor.executemany.call_args
-
-        expected_stmt = "INSERT INTO characters (name, age) VALUES (?, ?)"
-        self.assertEqual(expected_stmt, stmt)
-
-        expected_bulk_args = (
-            ('Arthur', 35),
-            ('Banshee', 26),
-            ('Callisto', 37)
-        )
-        self.assertSequenceEqual(expected_bulk_args, bulk_args)
-
-    @skipIf(SA_VERSION < SA_2_0, "SQLAlchemy 1.x uses legacy bulk INSERT mode")
-    @patch('crate.client.connection.Cursor', FakeCursor)
-    def test_bulk_save_modern(self):
-        """
-        Verify modern SQLAlchemy bulk INSERT mode.
-
-        > A list of parameter dictionaries sent to the `Session.execute.params` parameter,
-        > separate from the Insert object itself, will invoke *bulk INSERT mode* for the
-        > statement, which essentially means the operation will optimize as much as
-        > possible for many rows.
-        >
-        > -- https://docs.sqlalchemy.org/orm/queryguide/dml.html#orm-queryguide-bulk-insert
-
-        > We have been looking into getting performance optimizations
-        > from `bulk_save()` to be inherently part of `add_all()`.
-        >
-        > -- https://github.com/sqlalchemy/sqlalchemy/discussions/6935#discussioncomment-1233465
-
-        > The remaining performance limitation, that the `cursor.executemany()` DBAPI method
-        > does not allow for rows to be fetched, is resolved for most backends by *foregoing*
-        > the use of `executemany()` and instead restructuring individual INSERT statements
-        > to each accommodate a large number of rows in a single statement that is invoked
-        > using `cursor.execute()`. This approach originates from the `psycopg2` fast execution
-        > helpers feature of the `psycopg2` DBAPI, which SQLAlchemy incrementally added more
-        > and more support towards in recent release series.
-        >
-        > -- https://docs.sqlalchemy.org/core/connections.html#engine-insertmanyvalues
-        """
-
-        # Don't truncate unittest's diff output on `assertListEqual`.
-        self.maxDiff = None
-
-        chars = [
-            self.character(name='Arthur', age=35),
-            self.character(name='Banshee', age=26),
-            self.character(name='Callisto', age=37),
-        ]
-
-        fake_cursor.description = ()
-        fake_cursor.rowcount = len(chars)
-        fake_cursor.execute.return_value = [
-            {'rowcount': 1},
-            {'rowcount': 1},
-            {'rowcount': 1},
-        ]
-        self.session.add_all(chars)
-        self.session.commit()
-        (stmt, bulk_args), _ = fake_cursor.execute.call_args
-
-        expected_stmt = "INSERT INTO characters (name, age) VALUES (?, ?), (?, ?), (?, ?)"
-        self.assertEqual(expected_stmt, stmt)
-
-        expected_bulk_args = (
-            'Arthur', 35,
-            'Banshee', 26,
-            'Callisto', 37,
-        )
-        self.assertSequenceEqual(expected_bulk_args, bulk_args)
-
-    @skipIf(sys.version_info < (3, 8), "SQLAlchemy/pandas is not supported on Python <3.8")
-    @skipIf(SA_VERSION < SA_1_4, "SQLAlchemy 1.3 is not supported by pandas")
-    @patch('crate.client.connection.Cursor', mock_cursor=FakeCursor)
-    def test_bulk_save_pandas(self, mock_cursor):
-        """
-        Verify bulk INSERT with pandas.
-        """
-        from pandas._testing import makeTimeDataFrame
-        from crate.client.sqlalchemy.support import insert_bulk
-
-        # 42 records / 8 chunksize = 5.25, which means 6 batches will be emitted.
-        INSERT_RECORDS = 42
-        CHUNK_SIZE = 8
-        OPCOUNT = math.ceil(INSERT_RECORDS / CHUNK_SIZE)
-
-        # Create a DataFrame to feed into the database.
-        df = makeTimeDataFrame(nper=INSERT_RECORDS, freq="S")
-
-        dburi = "crate://localhost:4200"
-        engine = sa.create_engine(dburi, echo=True)
-        retval = df.to_sql(
-            name="test-testdrive",
-            con=engine,
-            if_exists="replace",
-            index=False,
-            chunksize=CHUNK_SIZE,
-            method=insert_bulk,
-        )
-        self.assertIsNone(retval)
-
-        # Initializing the query has an overhead of two calls to the cursor object, probably one
-        # initial connection from the DB-API driver, to inquire the database version, and another
-        # one, for SQLAlchemy. SQLAlchemy will use it to inquire the table schema using `information_schema`,
-        # and to eventually issue the `CREATE TABLE ...` statement.
-        effective_op_count = mock_cursor.call_count - 2
-
-        # Verify number of batches.
-        self.assertEqual(effective_op_count, OPCOUNT)
-
-    @skipIf(sys.version_info < (3, 8), "SQLAlchemy/Dask is not supported on Python <3.8")
-    @skipIf(SA_VERSION < SA_1_4, "SQLAlchemy 1.3 is not supported by pandas")
-    @patch('crate.client.connection.Cursor', mock_cursor=FakeCursor)
-    def test_bulk_save_dask(self, mock_cursor):
-        """
-        Verify bulk INSERT with Dask.
-        """
-        import dask.dataframe as dd
-        from pandas._testing import makeTimeDataFrame
-        from crate.client.sqlalchemy.support import insert_bulk
-
-        # 42 records / 4 partitions means each partition has a size of 10.5 elements.
-        # Because the chunk size 8 is slightly smaller than 10, the partition will not
-        # fit into it, so two batches will be emitted to the database for each data
-        # partition. 4 partitions * 2 batches = 8 insert operations will be emitted.
-        # Those settings are a perfect example of non-optimal settings, and have been
-        # made so on purpose, in order to demonstrate that using optimal settings
-        # is crucial.
-        INSERT_RECORDS = 42
-        NPARTITIONS = 4
-        CHUNK_SIZE = 8
-        OPCOUNT = math.ceil(INSERT_RECORDS / NPARTITIONS / CHUNK_SIZE) * NPARTITIONS
-
-        # Create a DataFrame to feed into the database.
-        df = makeTimeDataFrame(nper=INSERT_RECORDS, freq="S")
-        ddf = dd.from_pandas(df, npartitions=NPARTITIONS)
-
-        dburi = "crate://localhost:4200"
-        retval = ddf.to_sql(
-            name="test-testdrive",
-            uri=dburi,
-            if_exists="replace",
-            index=False,
-            chunksize=CHUNK_SIZE,
-            method=insert_bulk,
-            parallel=True,
-        )
-        self.assertIsNone(retval)
-
-        # Each of the insert operation incurs another call to the cursor object. This is probably
-        # the initial connection from the DB-API driver, to inquire the database version.
-        # This compensation formula has been determined empirically / by educated guessing.
-        effective_op_count = (mock_cursor.call_count - 2 * NPARTITIONS) - 2
-
-        # Verify number of batches.
-        self.assertEqual(effective_op_count, OPCOUNT)