patito 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

patito/duckdb.py

@@ -104,7 +104,7 @@ def create_pydantic_model(relation: "duckdb.DuckDBPyRelation") -> Type[Model]:
     return create_model(  # type: ignore
         relation.alias,
         __base__=Model,
-        **pydantic_annotations,
+        **pydantic_annotations,  # pyright: ignore
     )
 
 
@@ -115,7 +115,7 @@ def _enum_type_name(field_properties: dict) -> str:
     The same enum values, regardless of ordering, will always be given the same name.
     """
     enum_values = ", ".join(repr(value) for value in sorted(field_properties["enum"]))
-    value_hash = hashlib.md5(enum_values.encode("utf-8")).hexdigest()  # noqa: S324
+    value_hash = hashlib.md5(enum_values.encode("utf-8")).hexdigest()  # noqa: #S303
     return f"enum__{value_hash}"
 
 
@@ -170,24 +170,24 @@ class Relation(Generic[ModelType]):
                   The path must point to an existing file with either a ``.csv``
                   or ``.parquet`` file extension.
                 - A native DuckDB relation object (``duckdb.DuckDBPyRelation``).
-                - A ``patito.Relation`` object.
+                - A ``patito.duckdb.Relation`` object.
 
             database: Which database to load the relation into. If not provided,
                 the default DuckDB database will be used.
 
             model: Sub-class of ``patito.Model`` which specifies how to deserialize rows
-                when fetched with methods such as :ref:`Relation.get()<Relation.get>`
-                and ``__iter__()``.
+                when fetched with methods such as
+                :ref:`Relation.get()<duckdb.Relation.get>` and ``__iter__()``.
 
                 Will also be used to create a strict table schema if
-                :ref:`Relation.create_table()<Relation.create_table>`.
+                :ref:`Relation.create_table()<duckdb.Relation.create_table>`.
                 schema should be constructed.
 
-                If not provided, a dynamic model fitting the relation schema will be created
-                when required.
+                If not provided, a dynamic model fitting the relation schema will be
+                created when required.
 
                 Can also be set later dynamically by invoking
-                :ref:`Relation.set_model()<Relation.set_model>`.
+                :ref:`Relation.set_model()<duckdb.Relation.set_model>`.
 
         Raises:
             ValueError: If any one of the following cases are encountered:
@@ -204,7 +204,7 @@ class Relation(Generic[ModelType]):
 
             >>> import patito as pt
             >>> df = pt.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
-            >>> pt.Relation(df).filter("a > 2").to_df()
+            >>> pt.duckdb.Relation(df).filter("a > 2").to_df()
             shape: (1, 2)
             ┌─────┬─────┐
             │ a   ┆ b   │
@@ -216,7 +216,7 @@ class Relation(Generic[ModelType]):
 
             Instantiated from an SQL query:
 
-            >>> pt.Relation("select 1 as a, 2 as b").to_df()
+            >>> pt.duckdb.Relation("select 1 as a, 2 as b").to_df()
             shape: (1, 2)
             ┌─────┬─────┐
             │ a   ┆ b   │
@@ -296,7 +296,7 @@ class Relation(Generic[ModelType]):
         Examples:
             >>> import patito as pt
             >>> df = pt.DataFrame({"a": [1, 2, 3], "b": ["X", "Y", "X"]})
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.aggregate(
             ...     "b",
             ...     "sum(a)",
@@ -311,7 +311,6 @@ class Relation(Generic[ModelType]):
             │ str ┆ f64    ┆ str         ┆ i64   │
             ╞═════╪════════╪═════════════╪═══════╡
             │ X   ┆ 4.0    ┆ X           ┆ 3     │
-            ├╌╌╌╌╌┼╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌┤
             │ Y   ┆ 2.0    ┆ Y           ┆ 2     │
             └─────┴────────┴─────────────┴───────┘
         """
@@ -347,7 +346,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as column_1, 2 as column_2")
+            >>> relation = pt.duckdb.Relation("select 1 as column_1, 2 as column_2")
             >>> relation.add_suffix("_renamed").to_df()
             shape: (1, 2)
             ┌──────────────────┬──────────────────┐
@@ -413,7 +412,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as column_1, 2 as column_2")
+            >>> relation = pt.duckdb.Relation("select 1 as column_1, 2 as column_2")
             >>> relation.add_prefix("renamed_").to_df()
             shape: (1, 2)
             ┌──────────────────┬──────────────────┐
@@ -464,8 +463,8 @@ class Relation(Generic[ModelType]):
         """
         Return ``True`` if the given predicate(s) are true for all rows in the relation.
 
-        See :ref:`Relation.filter()<Relation.filter>` for additional information
-        regarding the parameters.
+        See :func:`Relation.filter()` for additional information regarding the
+        parameters.
 
         Args:
             filters: SQL predicates to satisfy.
@@ -480,7 +479,7 @@ class Relation(Generic[ModelType]):
             ...         "zero": [0, 0, 0],
             ...     }
             ... )
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.all(zero=0)
             True
             >>> relation.all(
@@ -520,14 +519,14 @@ class Relation(Generic[ModelType]):
             The following case statement...
 
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.to_relation("select 1 as a union select 2 as a")
             >>> relation.case(
             ...     from_column="a",
             ...     to_column="b",
             ...     mapping={1: "one", 2: "two"},
             ...     default="three",
-            ... ).to_df()
+            ... ).order(by="a").to_df()
             shape: (2, 2)
             ┌─────┬─────┐
             │ a   ┆ b   │
@@ -535,7 +534,6 @@ class Relation(Generic[ModelType]):
             │ i64 ┆ str │
             ╞═════╪═════╡
             │ 1   ┆ one │
-            ├╌╌╌╌╌┼╌╌╌╌╌┤
             │ 2   ┆ two │
             └─────┴─────┘
 
@@ -547,7 +545,7 @@ class Relation(Generic[ModelType]):
             ...     default="three",
             ...     as_column="b",
             ... )
-            >>> relation.select(f"*, {case_statement}").to_df()
+            >>> relation.select(f"*, {case_statement}").order(by="a").to_df()
             shape: (2, 2)
             ┌─────┬─────┐
             │ a   ┆ b   │
@@ -555,7 +553,6 @@ class Relation(Generic[ModelType]):
             │ i64 ┆ str │
             ╞═════╪═════╡
             │ 1   ┆ one │
-            ├╌╌╌╌╌┼╌╌╌╌╌┤
             │ 2   ┆ two │
             └─────┴─────┘
         """
@@ -580,15 +577,15 @@ class Relation(Generic[ModelType]):
         Cast the columns of the relation to types compatible with the associated model.
 
         The associated model must either be set by invoking
-        :ref:`Relation.set_model() <Relation.set_model>` or provided with the ``model``
-        parameter.
+        :ref:`Relation.set_model() <duckdb.Relation.set_model>` or provided with the
+        ``model`` parameter.
 
         Any columns of the relation that are not part of the given model schema will be
         left as-is.
 
         Args:
-            model: If :ref:`Relation.set_model() <Relation.set_model>` has not been
-                invoked or is intended to be overwritten.
+            model: If :ref:`Relation.set_model() <duckdb.Relation.set_model>` has not
+                been invoked or is intended to be overwritten.
             strict: If set to ``False``, columns which are technically compliant with
                 the specified field type, will not be casted. For example, a column
                 annotated with ``int`` is technically compliant with ``SMALLINT``, even
@@ -607,31 +604,31 @@ class Relation(Generic[ModelType]):
             >>> class Schema(pt.Model):
             ...     float_column: float
             ...
-            >>> relation = pt.Relation("select 1 as float_column")
+            >>> relation = pt.duckdb.Relation("select 1 as float_column")
             >>> relation.types["float_column"]
-            'INTEGER'
+            INTEGER
             >>> relation.cast(model=Schema).types["float_column"]
-            'DOUBLE'
+            DOUBLE
 
-            >>> relation = pt.Relation("select 1::FLOAT as float_column")
+            >>> relation = pt.duckdb.Relation("select 1::FLOAT as float_column")
             >>> relation.cast(model=Schema).types["float_column"]
-            'FLOAT'
+            FLOAT
             >>> relation.cast(model=Schema, strict=True).types["float_column"]
-            'DOUBLE'
+            DOUBLE
 
             >>> class Schema(pt.Model):
             ...     column_1: float
             ...     column_2: float
             ...
-            >>> relation = pt.Relation("select 1 as column_1, 2 as column_2").set_model(
-            ...     Schema
-            ... )
+            >>> relation = pt.duckdb.Relation(
+            ...     "select 1 as column_1, 2 as column_2"
+            ... ).set_model(Schema)
             >>> relation.types
-            {'column_1': 'INTEGER', 'column_2': 'INTEGER'}
+            {'column_1': INTEGER, 'column_2': INTEGER}
             >>> relation.cast(include=["column_1"]).types
-            {'column_1': 'DOUBLE', 'column_2': 'INTEGER'}
+            {'column_1': DOUBLE, 'column_2': INTEGER}
             >>> relation.cast(exclude=["column_1"]).types
-            {'column_1': 'INTEGER', 'column_2': 'DOUBLE'}
+            {'column_1': INTEGER, 'column_2': DOUBLE}
         """
         if model is not None:
             relation = self.set_model(model)
@@ -650,7 +647,8 @@ class Relation(Generic[ModelType]):
 
         if include is not None and exclude is not None:
             raise ValueError(
-                f"Both include and exclude provided to {self.__class__.__name__}.cast()!"
+                "Both include and exclude provided to "
+                f"{self.__class__.__name__}.cast()!"
             )
         elif include is not None:
             include = set(include)
@@ -701,7 +699,7 @@ class Relation(Generic[ModelType]):
             ...         "c": [None, 8.0, 9.0],
             ...     }
             ... )
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.coalesce(a=2, b="six").to_df()
             shape: (3, 3)
             ┌─────┬──────┬──────┐
@@ -710,9 +708,7 @@ class Relation(Generic[ModelType]):
             │ i64 ┆ str  ┆ f64  │
             ╞═════╪══════╪══════╡
             │ 1   ┆ four ┆ null │
-            ├╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
             │ 2   ┆ five ┆ 8.0  │
-            ├╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌┤
             │ 3   ┆ six  ┆ 9.0  │
             └─────┴──────┴──────┘
         """
@@ -732,7 +728,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> pt.Relation("select 1 as a, 2 as b").columns
+            >>> pt.duckdb.Relation("select 1 as a, 2 as b").columns
             ['a', 'b']
         """
         # Under certain specific circumstances columns are suffixed with
@@ -748,13 +744,13 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as a")
+            >>> relation = pt.duckdb.Relation("select 1 as a")
             >>> relation.count()
             1
             >>> (relation + relation).count()
             2
 
-            The :ref:`Relation.__len__()<Relation.__len__>` method invokes
+            The :ref:`Relation.__len__()<duckdb.Relation.__len__>` method invokes
             ``Relation.count()`` under the hood, and is equivalent:
 
             >>> len(relation)
@@ -768,9 +764,10 @@ class Relation(Generic[ModelType]):
         """
         Create new database table based on relation.
 
-        If ``self.model`` is set with :ref:`Relation.set_model()<Relation.set_model>`,
-        then the model is used to infer the table schema.
-        Otherwise, a permissive table schema is created based on the relation data.
+        If ``self.model`` is set with
+        :ref:`Relation.set_model()<duckdb.Relation.set_model>`, then the model is used
+        to infer the table schema. Otherwise, a permissive table schema is created based
+        on the relation data.
 
         Returns:
             Relation: A relation pointing to the newly created table.
@@ -780,15 +777,15 @@ class Relation(Generic[ModelType]):
             >>> import patito as pt
 
             >>> df = pt.DataFrame({"enum_column": ["A", "A", "B"]})
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.create_table("permissive_table").types
-            {'enum_column': 'VARCHAR'}
+            {'enum_column': VARCHAR}
 
             >>> class TableSchema(pt.Model):
             ...     enum_column: Literal["A", "B", "C"]
             ...
             >>> relation.set_model(TableSchema).create_table("strict_table").types
-            {'enum_column': 'enum__7ba49365cc1b0fd57e61088b3bc9aa25'}
+            {'enum_column': enum__7ba49365cc1b0fd57e61088b3bc9aa25}
         """
         if self.model is not None:
             self.database.create_table(name=name, model=self.model)
@@ -810,7 +807,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> df = pt.DataFrame({"column": ["A", "A", "B"]})
             >>> relation = db.to_relation(df)
             >>> relation.create_view("my_view")
@@ -822,9 +819,7 @@ class Relation(Generic[ModelType]):
             │ str    │
             ╞════════╡
             │ A      │
-            ├╌╌╌╌╌╌╌╌┤
             │ A      │
-            ├╌╌╌╌╌╌╌╌┤
             │ B      │
             └────────┘
         """
@@ -840,7 +835,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as a, 2 as b, 3 as c")
+            >>> relation = pt.duckdb.Relation("select 1 as a, 2 as b, 3 as c")
             >>> relation.columns
             ['a', 'b', 'c']
             >>> relation.drop("c").columns
@@ -861,10 +856,10 @@ class Relation(Generic[ModelType]):
             >>> import patito as pt
             >>> df = pt.DataFrame(
             ...     [[1, 2, 3], [1, 2, 3], [3, 2, 1]],
-            ...     columns=["a", "b", "c"],
+            ...     schema=["a", "b", "c"],
             ...     orient="row",
             ... )
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.to_df()
             shape: (3, 3)
             ┌─────┬─────┬─────┐
@@ -873,9 +868,7 @@ class Relation(Generic[ModelType]):
             │ i64 ┆ i64 ┆ i64 │
             ╞═════╪═════╪═════╡
             │ 1   ┆ 2   ┆ 3   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
             │ 1   ┆ 2   ┆ 3   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
             │ 3   ┆ 2   ┆ 1   │
             └─────┴─────┴─────┘
             >>> relation.distinct().to_df()
@@ -886,7 +879,6 @@ class Relation(Generic[ModelType]):
             │ i64 ┆ i64 ┆ i64 │
             ╞═════╪═════╪═════╡
             │ 1   ┆ 2   ┆ 3   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌┤
             │ 3   ┆ 2   ┆ 1   │
             └─────┴─────┴─────┘
         """
@@ -904,8 +896,10 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> relation_123 = pt.Relation("select 1 union select 2 union select 3")
-            >>> relation_123.to_df()
+            >>> relation_123 = pt.duckdb.Relation(
+            ...     "select 1 union select 2 union select 3"
+            ... )
+            >>> relation_123.order(by="1").to_df()
             shape: (3, 1)
             ┌─────┐
             │ 1   │
@@ -913,12 +907,10 @@ class Relation(Generic[ModelType]):
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 2   │
-            ├╌╌╌╌╌┤
             │ 3   │
             └─────┘
-            >>> relation_2 = pt.Relation("select 2")
+            >>> relation_2 = pt.duckdb.Relation("select 2")
             >>> relation_2.to_df()
             shape: (1, 1)
             ┌─────┐
@@ -928,7 +920,7 @@ class Relation(Generic[ModelType]):
             ╞═════╡
             │ 2   │
             └─────┘
-            >>> relation_123.except_(relation_2).to_df()
+            >>> relation_123.except_(relation_2).order(by="1").to_df()
             shape: (2, 1)
             ┌─────┐
             │ 1   │
@@ -936,7 +928,6 @@ class Relation(Generic[ModelType]):
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 3   │
             └─────┘
         """
@@ -945,7 +936,7 @@ class Relation(Generic[ModelType]):
             schema_change=False,
         )
 
-    def execute(self) -> duckdb.DuckDBPyResult:
+    def execute(self) -> duckdb.DuckDBPyRelation:
         """
         Execute built relation query and return result object.
 
@@ -954,11 +945,11 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation(
+            >>> relation = pt.duckdb.Relation(
             ...     "select 1 as a, 2 as b union select 3 as a, 4 as b"
             ... )
             >>> result = relation.aggregate("sum(a)", group_by="").execute()
-            >>> result.description()
+            >>> result.description
             [('sum(a)', 'NUMBER', None, None, None, None, None)]
             >>> result.fetchall()
             [(4,)]
@@ -989,7 +980,7 @@ class Relation(Generic[ModelType]):
             >>> import patito as pt
             >>> import polars as pl
             >>> df = pt.DataFrame({"product_id": [1, 2, 3], "price": [10, 10, 20]})
-            >>> relation = pt.Relation(df).set_alias("my_relation")
+            >>> relation = pt.duckdb.Relation(df).set_alias("my_relation")
 
             The ``.get()`` method will by default return a dynamically constructed
             Patito model if no model has been associated with the given relation:
@@ -998,8 +989,8 @@ class Relation(Generic[ModelType]):
             my_relation(product_id=1, price=10)
 
             If a Patito model has been associated with the relation, by the use of
-            :ref:`Relation.set_model()<Relation.set_model>`, then the given model will
-            be used to represent the return type:
+            :ref:`Relation.set_model()<duckdb.Relation.set_model>`, then the given model
+            will be used to represent the return type:
 
             >>> class Product(pt.Model):
             ...     product_id: int = pt.Field(unique=True)
@@ -1039,7 +1030,7 @@ class Relation(Generic[ModelType]):
         else:
             relation = self
         result = relation.execute()
-        row = cast(tuple, result.fetchone())
+        row = result.fetchone()
         if row is None or result.fetchone() is not None:
             args = [repr(f) for f in filters]
             args.extend(f"{key}={value!r}" for key, value in equalities.items())
@@ -1099,7 +1090,7 @@ class Relation(Generic[ModelType]):
             ...         "string": ["A", "A", "B", "B"],
             ...     }
             ... )
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.filter("number % 2 = 0").to_df()
             shape: (2, 2)
             ┌────────┬────────┐
@@ -1108,7 +1099,6 @@ class Relation(Generic[ModelType]):
             │ i64    ┆ str    │
             ╞════════╪════════╡
             │ 2      ┆ A      │
-            ├╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
             │ 4      ┆ B      │
             └────────┴────────┘
 
@@ -1143,8 +1133,8 @@ class Relation(Generic[ModelType]):
         """
         Join relation with other relation source based on condition.
 
-        See :ref:`Relation.inner_join() <Relation.inner_join>` and
-        :ref:`Relation.left_join() <Relation.left_join>` for alternative method
+        See :ref:`duckdb.Relation.inner_join() <duckdb.Relation.inner_join>` and
+        :ref:`Relation.left_join() <duckdb.Relation.left_join>` for alternative method
         shortcuts instead of using ``how``.
 
         Args:
@@ -1165,14 +1155,14 @@ class Relation(Generic[ModelType]):
             ...         "supplier_id": [2, 1, 3],
             ...     }
             ... )
-            >>> products = pt.Relation(products_df)
+            >>> products = pt.duckdb.Relation(products_df)
             >>> supplier_df = pt.DataFrame(
             ...     {
             ...         "id": [1, 2],
             ...         "supplier_name": ["Banana Republic", "Applies Inc."],
             ...     }
             ... )
-            >>> suppliers = pt.Relation(supplier_df)
+            >>> suppliers = pt.duckdb.Relation(supplier_df)
             >>> products.set_alias("p").join(
             ...     suppliers.set_alias("s"),
             ...     on="p.supplier_id = s.id",
@@ -1185,7 +1175,6 @@ class Relation(Generic[ModelType]):
             │ str          ┆ i64         ┆ i64 ┆ str             │
             ╞══════════════╪═════════════╪═════╪═════════════════╡
             │ apple        ┆ 2           ┆ 2   ┆ Applies Inc.    │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ banana       ┆ 1           ┆ 1   ┆ Banana Republic │
             └──────────────┴─────────────┴─────┴─────────────────┘
 
@@ -1201,9 +1190,7 @@ class Relation(Generic[ModelType]):
             │ str          ┆ i64         ┆ i64  ┆ str             │
             ╞══════════════╪═════════════╪══════╪═════════════════╡
             │ apple        ┆ 2           ┆ 2    ┆ Applies Inc.    │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ banana       ┆ 1           ┆ 1    ┆ Banana Republic │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ oranges      ┆ 3           ┆ null ┆ null            │
             └──────────────┴─────────────┴──────┴─────────────────┘
         """
@@ -1234,14 +1221,14 @@ class Relation(Generic[ModelType]):
             ...         "supplier_id": [2, 1, 3],
             ...     }
             ... )
-            >>> products = pt.Relation(products_df)
+            >>> products = pt.duckdb.Relation(products_df)
             >>> supplier_df = pt.DataFrame(
             ...     {
             ...         "id": [1, 2],
             ...         "supplier_name": ["Banana Republic", "Applies Inc."],
             ...     }
             ... )
-            >>> suppliers = pt.Relation(supplier_df)
+            >>> suppliers = pt.duckdb.Relation(supplier_df)
             >>> products.set_alias("p").inner_join(
             ...     suppliers.set_alias("s"),
             ...     on="p.supplier_id = s.id",
@@ -1253,7 +1240,6 @@ class Relation(Generic[ModelType]):
             │ str          ┆ i64         ┆ i64 ┆ str             │
             ╞══════════════╪═════════════╪═════╪═════════════════╡
             │ apple        ┆ 2           ┆ 2   ┆ Applies Inc.    │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ banana       ┆ 1           ┆ 1   ┆ Banana Republic │
             └──────────────┴─────────────┴─────┴─────────────────┘
         """
@@ -1286,14 +1272,14 @@ class Relation(Generic[ModelType]):
             ...         "supplier_id": [2, 1, 3],
             ...     }
             ... )
-            >>> products = pt.Relation(products_df)
+            >>> products = pt.duckdb.Relation(products_df)
             >>> supplier_df = pt.DataFrame(
             ...     {
             ...         "id": [1, 2],
             ...         "supplier_name": ["Banana Republic", "Applies Inc."],
             ...     }
             ... )
-            >>> suppliers = pt.Relation(supplier_df)
+            >>> suppliers = pt.duckdb.Relation(supplier_df)
             >>> products.set_alias("p").left_join(
             ...     suppliers.set_alias("s"),
             ...     on="p.supplier_id = s.id",
@@ -1305,9 +1291,7 @@ class Relation(Generic[ModelType]):
             │ str          ┆ i64         ┆ i64  ┆ str             │
             ╞══════════════╪═════════════╪══════╪═════════════════╡
             │ apple        ┆ 2           ┆ 2    ┆ Applies Inc.    │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ banana       ┆ 1           ┆ 1    ┆ Banana Republic │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ oranges      ┆ 3           ┆ null ┆ null            │
             └──────────────┴─────────────┴──────┴─────────────────┘
         """
@@ -1335,10 +1319,10 @@ class Relation(Generic[ModelType]):
         Example:
             >>> import patito as pt
             >>> relation = (
-            ...     pt.Relation("select 1 as column")
-            ...     + pt.Relation("select 2 as column")
-            ...     + pt.Relation("select 3 as column")
-            ...     + pt.Relation("select 4 as column")
+            ...     pt.duckdb.Relation("select 1 as column")
+            ...     + pt.duckdb.Relation("select 2 as column")
+            ...     + pt.duckdb.Relation("select 3 as column")
+            ...     + pt.duckdb.Relation("select 4 as column")
             ... )
             >>> relation.limit(2).to_df()
             shape: (2, 1)
@@ -1348,7 +1332,6 @@ class Relation(Generic[ModelType]):
             │ i64    │
             ╞════════╡
             │ 1      │
-            ├╌╌╌╌╌╌╌╌┤
             │ 2      │
             └────────┘
             >>> relation.limit(2, offset=2).to_df()
@@ -1359,7 +1342,6 @@ class Relation(Generic[ModelType]):
             │ i64    │
             ╞════════╡
             │ 3      │
-            ├╌╌╌╌╌╌╌╌┤
             │ 4      │
             └────────┘
         """
@@ -1392,14 +1374,11 @@ class Relation(Generic[ModelType]):
             │ str     ┆ i64 │
             ╞═════════╪═════╡
             │ Alice   ┆ 20  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Bob     ┆ 20  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Charles ┆ 30  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Diana   ┆ 35  │
             └─────────┴─────┘
-            >>> relation = pt.Relation(df)
+            >>> relation = pt.duckdb.Relation(df)
             >>> relation.order(by="age desc").to_df()
             shape: (4, 2)
             ┌─────────┬─────┐
@@ -1408,11 +1387,8 @@ class Relation(Generic[ModelType]):
             │ str     ┆ i64 │
             ╞═════════╪═════╡
             │ Diana   ┆ 35  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Charles ┆ 30  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Alice   ┆ 20  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Bob     ┆ 20  │
             └─────────┴─────┘
             >>> relation.order(by=["age desc", "name desc"]).to_df()
@@ -1423,11 +1399,8 @@ class Relation(Generic[ModelType]):
             │ str     ┆ i64 │
             ╞═════════╪═════╡
             │ Diana   ┆ 35  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Charles ┆ 30  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Bob     ┆ 20  │
-            ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
             │ Alice   ┆ 20  │
             └─────────┴─────┘
         """
@@ -1456,7 +1429,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.to_relation("select 1 as a").create_table("my_table")
             >>> db.table("my_table").to_df()
             shape: (1, 1)
@@ -1476,7 +1449,6 @@ class Relation(Generic[ModelType]):
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 2   │
             └─────┘
         """
@@ -1509,7 +1481,7 @@ class Relation(Generic[ModelType]):
             >>> import patito as pt
             >>> df1 = pt.DataFrame({"a": [1, 1, 2], "b": [1, 1, 2]})
             >>> df2 = pt.DataFrame({"a": [1, 1, 3], "b": [1, 1, 3]})
-            >>> pt.Relation(df1).intersect(pt.Relation(df2)).to_df()
+            >>> pt.duckdb.Relation(df1).intersect(pt.duckdb.Relation(df2)).to_df()
             shape: (1, 2)
             ┌─────┬─────┐
             │ a   ┆ b   │
@@ -1546,7 +1518,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.to_relation(pt.DataFrame({"original_column": [1, 2, 3]}))
             >>> relation.select("*").to_df()
             shape: (3, 1)
@@ -1556,9 +1528,7 @@ class Relation(Generic[ModelType]):
             │ i64             │
             ╞═════════════════╡
             │ 1               │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ 2               │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ 3               │
             └─────────────────┘
             >>> relation.select("*", multiplied_column="2 * original_column").to_df()
@@ -1569,9 +1539,7 @@ class Relation(Generic[ModelType]):
             │ i64             ┆ i64               │
             ╞═════════════════╪═══════════════════╡
             │ 1               ┆ 2                 │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ 2               ┆ 4                 │
-            ├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
             │ 3               ┆ 6                 │
             └─────────────────┴───────────────────┘
         """
@@ -1624,7 +1592,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as a, 2 as b")
+            >>> relation = pt.duckdb.Relation("select 1 as a, 2 as b")
             >>> relation.rename(b="c").to_df().select(["a", "c"])
             shape: (1, 2)
             ┌─────┬─────┐
@@ -1666,8 +1634,8 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> relation_1 = pt.Relation("select 1 as a, 2 as b")
-            >>> relation_2 = pt.Relation("select 1 as a, 3 as c")
+            >>> relation_1 = pt.duckdb.Relation("select 1 as a, 2 as b")
+            >>> relation_2 = pt.duckdb.Relation("select 1 as a, 3 as c")
             >>> relation_1.set_alias("x").inner_join(
             ...     relation_2.set_alias("y"),
             ...     on="x.a = y.a",
@@ -1691,9 +1659,9 @@ class Relation(Generic[ModelType]):
         Associate a give Patito model with the relation.
 
         The returned relation has an associated ``.model`` attribute which can in turn
-        be used by several methods such as :ref:`Relation.get()<Relation.get>`,
-        :ref:`Relation.create_table()<Relation.create_table>`, and
-        :ref:`Relation.__iter__<Relation.__iter__>`.
+        be used by several methods such as :ref:`Relation.get()<duckdb.Relation.get>`,
+        :ref:`Relation.create_table()<duckdb.Relation.create_table>`, and
+        :ref:`Relation.__iter__<duckdb.Relation.__iter__>`.
 
         Args:
             model: A Patito Model class specifying the intended schema of the relation.
@@ -1708,16 +1676,18 @@ class Relation(Generic[ModelType]):
             ...     float_column: float
             ...     enum_column: Literal["A", "B", "C"]
             ...
-            >>> relation = pt.Relation("select 1 as float_column, 'A' as enum_column")
+            >>> relation = pt.duckdb.Relation(
+            ...     "select 1 as float_column, 'A' as enum_column"
+            ... )
             >>> relation.get()
             query_relation(float_column=1, enum_column='A')
             >>> relation.set_model(MySchema).get()
             MySchema(float_column=1.0, enum_column='A')
             >>> relation.create_table("unmodeled_table").types
-            {'float_column': 'INTEGER', 'enum_column': 'VARCHAR'}
+            {'float_column': INTEGER, 'enum_column': VARCHAR}
             >>> relation.set_model(MySchema).create_table("modeled_table").types
-            {'float_column': 'DOUBLE',
-             'enum_column': 'enum__7ba49365cc1b0fd57e61088b3bc9aa25'}
+            {'float_column': DOUBLE,
+             'enum_column': enum__7ba49365cc1b0fd57e61088b3bc9aa25}
         """
         # We are not able to annotate the generic instance of type(self)[type(model)]
         # due to the lack of higher-kinded generics in python as of this writing.
@@ -1733,7 +1703,7 @@ class Relation(Generic[ModelType]):
         )
 
     @property
-    def types(self) -> Dict[str, DuckDBSQLType]:
+    def types(self):  # type: ignore[no-untyped-def]  # noqa
         """
         Return the SQL types of all the columns of the given relation.
 
@@ -1743,8 +1713,8 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> pt.Relation("select 1 as a, 'my_value' as b").types
-            {'a': 'INTEGER', 'b': 'VARCHAR'}
+            >>> pt.duckdb.Relation("select 1 as a, 'my_value' as b").types
+            {'a': INTEGER, 'b': VARCHAR}
         """
         return dict(zip(self.columns, self._relation.types))
 
@@ -1756,8 +1726,10 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> pt.Relation("select 1 as column union select 2 as column").to_pandas()
-               column
+            >>> pt.duckdb.Relation("select 1 as column union select 2 as column").order(
+            ...     by="1"
+            ... ).to_pandas()
+                  column
                0       1
                1       2
         """
@@ -1771,7 +1743,9 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> pt.Relation("select 1 as column union select 2 as column").to_df()
+            >>> pt.duckdb.Relation("select 1 as column union select 2 as column").order(
+            ...     by="1"
+            ... ).to_df()
             shape: (2, 1)
             ┌────────┐
             │ column │
@@ -1779,7 +1753,6 @@ class Relation(Generic[ModelType]):
             │ i64    │
             ╞════════╡
             │ 1      │
-            ├╌╌╌╌╌╌╌╌┤
             │ 2      │
             └────────┘
         """
@@ -1791,10 +1764,10 @@ class Relation(Generic[ModelType]):
             # because polars is much more eager to store integer Series as 64-bit
             # integers. Otherwise there must be done a lot of manual casting whenever
             # you cross the boundary between DuckDB and polars.
-            return DataFrame._from_arrow(arrow_table).with_column(
+            return DataFrame._from_arrow(arrow_table).with_columns(
                 pl.col(pl.Int32).cast(pl.Int64)
             )
-        except pa.ArrowInvalid:  # pragma: no cover
+        except (pa.ArrowInvalid, pl.ArrowError):  # pragma: no cover
             # Empty relations with enum columns can sometimes produce errors.
             # As a last-ditch effort, we convert such columns to VARCHAR.
             casted_columns = [
@@ -1805,7 +1778,7 @@ class Relation(Generic[ModelType]):
             ]
             non_enum_relation = self._relation.project(", ".join(casted_columns))
             arrow_table = non_enum_relation.to_arrow_table()
-            return DataFrame._from_arrow(arrow_table).with_column(
+            return DataFrame._from_arrow(arrow_table).with_columns(
                 pl.col(pl.Int32).cast(pl.Int64)
             )
 
@@ -1820,8 +1793,8 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as a union select 2 as a")
-            >>> relation.to_series()
+            >>> relation = pt.duckdb.Relation("select 1 as a union select 2 as a")
+            >>> relation.order(by="a").to_series()
             shape: (2,)
             Series: 'a' [i32]
             [
@@ -1850,8 +1823,9 @@ class Relation(Generic[ModelType]):
         Duplicates are `not` dropped.
 
         Args:
-            other: A ``patito.Relation`` object or something that can be `casted` to
-                ``patito.Relation``. See :ref:`Relation<Relation.__init__>`.
+            other: A ``patito.duckdb.Relation`` object or something that can be
+                *casted* to ``patito.duckdb.Relation``.
+                See :ref:`Relation<duckdb.Relation.__init__>`.
 
         Returns:
             New relation containing the rows of both ``self`` and ``other``.
@@ -1861,8 +1835,8 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> relation_1 = pt.Relation("select 1 as a")
-            >>> relation_2 = pt.Relation("select 2 as a")
+            >>> relation_1 = pt.duckdb.Relation("select 1 as a")
+            >>> relation_2 = pt.duckdb.Relation("select 2 as a")
             >>> relation_1.union(relation_2).to_df()
             shape: (2, 1)
             ┌─────┐
@@ -1871,7 +1845,6 @@ class Relation(Generic[ModelType]):
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 2   │
             └─────┘
 
@@ -1883,7 +1856,6 @@ class Relation(Generic[ModelType]):
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 2   │
             └─────┘
         """
@@ -1924,7 +1896,7 @@ class Relation(Generic[ModelType]):
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.to_relation("select 1 as a, 2 as b")
             >>> relation.with_columns(c="a + b").to_df()
             shape: (1, 3)
@@ -1946,8 +1918,8 @@ class Relation(Generic[ModelType]):
         """
         Add missing defaultable columns filled with the default values of correct type.
 
-        Make sure to invoke :ref:`Relation.set_model()<Relation.set_model>` with the
-        correct model schema before executing
+        Make sure to invoke :ref:`Relation.set_model()<duckdb.Relation.set_model>` with
+        the correct model schema before executing
         ``Relation.with_missing_default_columns()``.
 
         Args:
@@ -1968,7 +1940,7 @@ class Relation(Generic[ModelType]):
             ...     default_column: int = 42
             ...     another_default_column: int = 42
             ...
-            >>> relation = pt.Relation(
+            >>> relation = pt.duckdb.Relation(
             ...     "select 1 as non_default_column, 2 as default_column"
             ... )
             >>> relation.to_df()
@@ -2036,8 +2008,8 @@ class Relation(Generic[ModelType]):
         """
         Add missing nullable columns filled with correctly typed nulls.
 
-        Make sure to invoke :ref:`Relation.set_model()<Relation.set_model>` with the
-        correct model schema before executing
+        Make sure to invoke :ref:`Relation.set_model()<duckdb.Relation.set_model>` with
+        the correct model schema before executing
         ``Relation.with_missing_nullable_columns()``.
 
         Args:
@@ -2058,7 +2030,7 @@ class Relation(Generic[ModelType]):
             ...     nullable_column: Optional[int]
             ...     another_nullable_column: Optional[int]
             ...
-            >>> relation = pt.Relation("select 1 as nullable_column")
+            >>> relation = pt.duckdb.Relation("select 1 as nullable_column")
             >>> relation.to_df()
             shape: (1, 1)
             ┌─────────────────┐
@@ -2118,7 +2090,7 @@ class Relation(Generic[ModelType]):
         """
         Execute ``self.union(other)``.
 
-        See :ref:`Relation.union()<Relation.union>` for full documentation.
+        See :ref:`Relation.union()<duckdb.Relation.union>` for full documentation.
         """
         return self.union(other)
 
@@ -2135,7 +2107,7 @@ class Relation(Generic[ModelType]):
         """
         Return Relation with selected columns.
 
-        Uses :ref:`Relation.select()<Relation.select>` under-the-hood in order to
+        Uses :ref:`Relation.select()<duckdb.Relation.select>` under-the-hood in order to
         perform the selection. Can technically be used to rename columns,
         define derived columns, and so on, but prefer the use of Relation.select() for
         such use cases.
@@ -2149,7 +2121,7 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> relation = pt.Relation("select 1 as a, 2 as b, 3 as c")
+            >>> relation = pt.duckdb.Relation("select 1 as a, 2 as b, 3 as c")
             >>> relation.to_df()
             shape: (1, 3)
             ┌─────┬─────┬─────┐
@@ -2188,9 +2160,9 @@ class Relation(Generic[ModelType]):
         """
         Iterate over rows in relation.
 
-        If :ref:`Relation.set_model()<Relation.set_model>` has been invoked first, the
-        given model will be used to deserialize each row. Otherwise a Patito model
-        is dynamically constructed which fits the schema of the relation.
+        If :ref:`Relation.set_model()<duckdb.Relation.set_model>` has been invoked
+        first, the given model will be used to deserialize each row. Otherwise a Patito
+        model is dynamically constructed which fits the schema of the relation.
 
         Returns:
             Iterator[Model]: An iterator of patito Model objects representing each row.
@@ -2199,7 +2171,7 @@ class Relation(Generic[ModelType]):
             >>> from typing import Literal
             >>> import patito as pt
             >>> df = pt.DataFrame({"float_column": [1, 2], "enum_column": ["A", "B"]})
-            >>> relation = pt.Relation(df).set_alias("my_relation")
+            >>> relation = pt.duckdb.Relation(df).set_alias("my_relation")
             >>> for row in relation:
             ...     print(row)
             ...
@@ -2235,7 +2207,7 @@ class Relation(Generic[ModelType]):
         """
         Return the number of rows in the relation.
 
-        See :ref:`Relation.count()<Relation.count>` for full documentation.
+        See :ref:`Relation.count()<duckdb.Relation.count>` for full documentation.
         """
         return self.count()
 
@@ -2247,7 +2219,7 @@ class Relation(Generic[ModelType]):
 
         Example:
             >>> import patito as pt
-            >>> products = pt.Relation(
+            >>> products = pt.duckdb.Relation(
             ...     pt.DataFrame(
             ...         {
             ...             "product_name": ["apple", "red_apple", "banana", "oranges"],
@@ -2278,7 +2250,7 @@ class Relation(Generic[ModelType]):
             banana  1
             oranges 3
 
-            >>> suppliers = pt.Relation(
+            >>> suppliers = pt.duckdb.Relation(
             ...     pt.DataFrame(
             ...         {
             ...             "id": [1, 2],
@@ -2366,7 +2338,7 @@ class Database:
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.to_relation("select 1 as a, 2 as b").create_table("my_table")
             >>> db.query("select * from my_table").to_df()
             shape: (1, 2)
@@ -2394,12 +2366,12 @@ class Database:
         Return the default DuckDB database.
 
         Returns:
-            A patito :ref:`Database<Database>` object wrapping around the given
+            A patito :ref:`Database<duckdb.Database>` object wrapping around the given
             connection.
 
         Example:
             >>> import patito as pt
-            >>> db = pt.Database.default()
+            >>> db = pt.duckdb.Database.default()
             >>> db.query("select 1 as a, 2 as b").to_df()
             shape: (1, 2)
             ┌─────┬─────┐
@@ -2424,13 +2396,14 @@ class Database:
                 ``duckdb.connect()``.
 
         Returns:
-            A :ref:`Database<Database>` object wrapping around the given connection.
+            A :ref:`Database<duckdb.Database>` object wrapping around the given
+            connection.
 
         Example:
             >>> import duckdb
             >>> import patito as pt
             >>> connection = duckdb.connect()
-            >>> database = pt.Database.from_connection(connection)
+            >>> database = pt.duckdb.Database.from_connection(connection)
         """
         obj = cls.__new__(cls)
         obj.connection = connection
@@ -2455,7 +2428,7 @@ class Database:
 
         Example:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.to_relation("select 1 as a, 2 as b").to_df()
             shape: (1, 2)
             ┌─────┬─────┐
@@ -2473,7 +2446,6 @@ class Database:
             │ i64 ┆ str │
             ╞═════╪═════╡
             │ 3   ┆ 5   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┤
             │ 4   ┆ 6   │
             └─────┴─────┘
         """
@@ -2499,7 +2471,7 @@ class Database:
 
         Example:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.execute("create table my_table (x bigint);")
             >>> db.execute("insert into my_table values (1), (2), (3)")
             >>> db.table("my_table").to_df()
@@ -2510,9 +2482,7 @@ class Database:
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 2   │
-            ├╌╌╌╌╌┤
             │ 3   │
             └─────┘
 
@@ -2527,7 +2497,6 @@ class Database:
             │ i64 │
             ╞═════╡
             │ 1   │
-            ├╌╌╌╌╌┤
             │ 3   │
             └─────┘
 
@@ -2582,7 +2551,7 @@ class Database:
 
         Example:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.query("select 1 as a, 2 as b, 3 as c")
             >>> relation.to_df()
             shape: (1, 3)
@@ -2624,7 +2593,7 @@ class Database:
             ...     string_column: str
             ...     bool_column: bool
             ...
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> empty_relation = db.empty_relation(Schema)
             >>> empty_relation.to_df()
             shape: (0, 2)
@@ -2659,7 +2628,7 @@ class Database:
         Example:
             >>> import patito as pt
             >>> df = pt.DataFrame({"a": [1, 2], "b": [3, 4]})
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.to_relation(df)
             >>> relation.create_table(name="my_table")
             >>> db.table("my_table").to_df()
@@ -2670,7 +2639,6 @@ class Database:
             │ i64 ┆ i64 │
             ╞═════╪═════╡
             │ 1   ┆ 3   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┤
             │ 2   ┆ 4   │
             └─────┴─────┘
         """
@@ -2689,7 +2657,7 @@ class Database:
         Example:
             >>> import patito as pt
             >>> df = pt.DataFrame({"a": [1, 2], "b": [3, 4]})
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> relation = db.to_relation(df)
             >>> relation.create_view(name="my_view")
             >>> db.view("my_view").to_df()
@@ -2700,7 +2668,6 @@ class Database:
             │ i64 ┆ i64 │
             ╞═════╪═════╡
             │ 1   ┆ 3   │
-            ├╌╌╌╌╌┼╌╌╌╌╌┤
             │ 2   ┆ 4   │
             └─────┴─────┘
         """
@@ -2717,11 +2684,11 @@ class Database:
         """
         Create table with schema matching the provided Patito model.
 
-        See :ref:`Relation.insert_into()<Relation.insert_into>` for how to insert data
-        into the table after creation.
-        The :ref:`Relation.create_table()<Relation.create_table>` method can also be
-        used to create a table from a given relation `and` insert the data at the same
-        time.
+        See :ref:`Relation.insert_into()<duckdb.Relation.insert_into>` for how to insert
+        data into the table after creation.
+        The :ref:`Relation.create_table()<duckdb.Relation.create_table>` method can also
+        be used to create a table from a given relation `and` insert the data at the
+        same time.
 
         Args:
             name: Name of new database table.
@@ -2737,10 +2704,10 @@ class Database:
             ...     str_column: str
             ...     nullable_string_column: Optional[str]
             ...
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.create_table(name="my_table", model=MyModel)
             >>> db.table("my_table").types
-            {'str_column': 'VARCHAR', 'nullable_string_column': 'VARCHAR'}
+            {'str_column': VARCHAR, 'nullable_string_column': VARCHAR}
         """
         self.create_enum_types(model=model)
         schema = model.schema()
@@ -2768,7 +2735,7 @@ class Database:
             >>> class EnumModel(pt.Model):
             ...     enum_column: Literal["A", "B", "C"]
             ...
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> db.create_enum_types(EnumModel)
             >>> db.enum_types
             {'enum__7ba49365cc1b0fd57e61088b3bc9aa25'}
@@ -2812,7 +2779,7 @@ class Database:
 
         Examples:
             >>> import patito as pt
-            >>> db = pt.Database()
+            >>> db = pt.duckdb.Database()
             >>> "my_table" in db
             False
             >>> db.to_relation("select 1 as a, 2 as b").create_table(name="my_table")