diff --git a/python/cuspatial/cuspatial/_lib/distance.pyx b/python/cuspatial/cuspatial/_lib/distance.pyx
index 6b4b6073f..4a21cfb81 100644
--- a/python/cuspatial/cuspatial/_lib/distance.pyx
+++ b/python/cuspatial/cuspatial/_lib/distance.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport make_shared, shared_ptr, unique_ptr
 from libcpp.utility cimport move, pair
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -26,7 +25,7 @@ from cuspatial._lib.cpp.types cimport collection_type_id, geometry_type_id
 from cuspatial._lib.types cimport collection_type_py_to_c
 
 
-cpdef haversine_distance(
+cpdef plc_Column haversine_distance(
     plc_Column x1,
     plc_Column y1,
     plc_Column x2,
@@ -42,7 +41,7 @@ cpdef haversine_distance(
     with nogil:
         c_result = move(cpp_haversine_distance(c_x1, c_y1, c_x2, c_y2))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def directed_hausdorff_distance(
@@ -65,17 +64,14 @@ def directed_hausdorff_distance(
             )
         )
 
-    owner_col = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(result.first)),
-        data_ptr_exposed=True
-    )
+    cdef plc_Column owner_col = plc_Column.from_libcudf(move(result.first))
     cdef plc_Table plc_owner_table = plc_Table(
-        [owner_col.to_pylibcudf(mode="read")] * result.second.num_columns()
+        [owner_col] * result.second.num_columns()
     )
     cdef plc_Table plc_result_table = plc_Table.from_table_view(
         result.second, plc_owner_table
     )
-    return [Column.from_pylibcudf(col) for col in plc_result_table.columns()]
+    return plc_result_table.columns()
 
 
 def pairwise_point_distance(
@@ -108,7 +104,7 @@ def pairwise_point_distance(
             c_multipoints_lhs.get()[0],
             c_multipoints_rhs.get()[0],
         ))
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def pairwise_linestring_distance(
@@ -134,7 +130,7 @@ def pairwise_linestring_distance(
             c_multilinestring_rhs.get()[0],
         ))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def pairwise_point_linestring_distance(
@@ -164,7 +160,7 @@ def pairwise_point_linestring_distance(
             c_multilinestrings.get()[0],
         ))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def pairwise_point_polygon_distance(
@@ -195,7 +191,7 @@ def pairwise_point_polygon_distance(
             c_multipoints.get()[0], c_multipolygons.get()[0]
         ))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def pairwise_linestring_polygon_distance(
@@ -221,7 +217,7 @@ def pairwise_linestring_polygon_distance(
             c_multilinestrings.get()[0], c_multipolygons.get()[0]
         ))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
 
 
 def pairwise_polygon_distance(plc_Column lhs, plc_Column rhs):
@@ -244,4 +240,4 @@ def pairwise_polygon_distance(plc_Column lhs, plc_Column rhs):
             c_lhs.get()[0], c_rhs.get()[0]
         ))
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(c_result)))
+    return plc_Column.from_libcudf(move(c_result))
diff --git a/python/cuspatial/cuspatial/_lib/intersection.pyx b/python/cuspatial/cuspatial/_lib/intersection.pyx
index 9b99cb46a..9935f548c 100644
--- a/python/cuspatial/cuspatial/_lib/intersection.pyx
+++ b/python/cuspatial/cuspatial/_lib/intersection.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport make_shared, shared_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 
 from cuspatial._lib.types import CollectionType, GeometryType
@@ -26,8 +25,6 @@ def pairwise_linestring_intersection(plc_Column lhs, plc_Column rhs):
     """
     Compute the intersection of two (multi)linestrings.
     """
-    from cuspatial.core._column.geometa import Feature_Enum
-
     cdef linestring_intersection_column_result c_result
     cdef collection_type_id multi_type = <collection_type_id>(
         <underlying_collection_type_id_t>(CollectionType.MULTI.value)
@@ -52,39 +49,21 @@ def pairwise_linestring_intersection(plc_Column lhs, plc_Column rhs):
             c_lhs.get()[0], c_rhs.get()[0]
         ))
 
-    geometry_collection_offset = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.geometry_collection_offset))
-    )
-
-    types_buffer = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.types_buffer))
-    )
-    offset_buffer = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.offset_buffer))
-    )
-    points = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.points))
+    geometry_collection_offset = plc_Column.from_libcudf(
+        move(c_result.geometry_collection_offset)
     )
-    segments = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.segments))
+    types_buffer = plc_Column.from_libcudf(move(c_result.types_buffer))
+    offset_buffer = plc_Column.from_libcudf(move(c_result.offset_buffer))
+    points = plc_Column.from_libcudf(move(c_result.points))
+    segments = plc_Column.from_libcudf(move(c_result.segments))
+    lhs_linestring_id = plc_Column.from_libcudf(
+        move(c_result.lhs_linestring_id)
     )
-    lhs_linestring_id = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.lhs_linestring_id))
-    )
-    lhs_segment_id = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.lhs_segment_id))
-    )
-    rhs_linestring_id = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.rhs_linestring_id))
-    )
-    rhs_segment_id = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.rhs_segment_id))
-    )
-
-    # Map linestring type codes from libcuspatial to cuspatial
-    types_buffer[types_buffer == GeometryType.LINESTRING.value] = (
-        Feature_Enum.LINESTRING.value
+    lhs_segment_id = plc_Column.from_libcudf(move(c_result.lhs_segment_id))
+    rhs_linestring_id = plc_Column.from_libcudf(
+        move(c_result.rhs_linestring_id)
     )
+    rhs_segment_id = plc_Column.from_libcudf(move(c_result.rhs_segment_id))
 
     return ((geometry_collection_offset,
             types_buffer,
diff --git a/python/cuspatial/cuspatial/_lib/linestring_bounding_boxes.pyx b/python/cuspatial/cuspatial/_lib/linestring_bounding_boxes.pyx
index e5bc8e983..d63714019 100644
--- a/python/cuspatial/cuspatial/_lib/linestring_bounding_boxes.pyx
+++ b/python/cuspatial/cuspatial/_lib/linestring_bounding_boxes.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column_view cimport column_view
 from pylibcudf.libcudf.table.table cimport table
@@ -13,9 +12,12 @@ from cuspatial._lib.cpp.linestring_bounding_boxes cimport (
 )
 
 
-cpdef linestring_bounding_boxes(plc_Column poly_offsets,
-                                plc_Column x, plc_Column y,
-                                double R):
+cpdef list linestring_bounding_boxes(
+    plc_Column poly_offsets,
+    plc_Column x,
+    plc_Column y,
+    double R
+):
     cdef column_view c_poly_offsets = poly_offsets.view()
     cdef column_view c_x = x.view()
     cdef column_view c_y = y.view()
@@ -25,7 +27,4 @@ cpdef linestring_bounding_boxes(plc_Column poly_offsets,
             c_poly_offsets, c_x, c_y, R
         ))
     cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return [
-        Column.from_pylibcudf(col)
-        for col in plc_table.columns()
-    ]
+    return plc_table.columns()
diff --git a/python/cuspatial/cuspatial/_lib/nearest_points.pyx b/python/cuspatial/cuspatial/_lib/nearest_points.pyx
index 82f3931c5..a8b7423ac 100644
--- a/python/cuspatial/cuspatial/_lib/nearest_points.pyx
+++ b/python/cuspatial/cuspatial/_lib/nearest_points.pyx
@@ -2,7 +2,6 @@
 
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 from pylibcudf.libcudf.column.column_view cimport column_view
 
@@ -42,22 +41,18 @@ def pairwise_point_linestring_nearest_points(
 
     multipoint_geometry_id = None
     if multipoint_geometry_offset is not None:
-        multipoint_geometry_id = Column.from_pylibcudf(plc_Column.from_libcudf(
-            move(c_result.nearest_point_geometry_id.value())))
+        multipoint_geometry_id = plc_Column.from_libcudf(
+            move(c_result.nearest_point_geometry_id.value()))
 
     multilinestring_geometry_id = None
     if multilinestring_geometry_offset is not None:
-        multilinestring_geometry_id = Column.from_pylibcudf(
-            plc_Column.from_libcudf(
-                move(c_result.nearest_linestring_geometry_id.value())
-            )
+        multilinestring_geometry_id = plc_Column.from_libcudf(
+            move(c_result.nearest_linestring_geometry_id.value())
         )
 
-    segment_id = Column.from_pylibcudf(
-        plc_Column.from_libcudf(move(c_result.nearest_segment_id))
-    )
-    point_on_linestring_xy = Column.from_pylibcudf(plc_Column.from_libcudf(
-        move(c_result.nearest_point_on_linestring_xy)))
+    segment_id = plc_Column.from_libcudf(move(c_result.nearest_segment_id))
+    point_on_linestring_xy = plc_Column.from_libcudf(
+        move(c_result.nearest_point_on_linestring_xy))
 
     return (
         multipoint_geometry_id,
diff --git a/python/cuspatial/cuspatial/_lib/pairwise_multipoint_equals_count.pyx b/python/cuspatial/cuspatial/_lib/pairwise_multipoint_equals_count.pyx
index b23eab808..f20be58ed 100644
--- a/python/cuspatial/cuspatial/_lib/pairwise_multipoint_equals_count.pyx
+++ b/python/cuspatial/cuspatial/_lib/pairwise_multipoint_equals_count.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport make_shared, shared_ptr, unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 from pylibcudf.libcudf.column.column cimport column
 
@@ -42,4 +41,4 @@ def pairwise_multipoint_equals_count(
             )
         )
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(result)))
+    return plc_Column.from_libcudf(move(result))
diff --git a/python/cuspatial/cuspatial/_lib/pairwise_point_in_polygon.pyx b/python/cuspatial/cuspatial/_lib/pairwise_point_in_polygon.pyx
index 2d8941692..a5456e69b 100644
--- a/python/cuspatial/cuspatial/_lib/pairwise_point_in_polygon.pyx
+++ b/python/cuspatial/cuspatial/_lib/pairwise_point_in_polygon.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -42,4 +41,4 @@ def pairwise_point_in_polygon(
             )
         )
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(result)))
+    return plc_Column.from_libcudf(move(result))
diff --git a/python/cuspatial/cuspatial/_lib/point_in_polygon.pyx b/python/cuspatial/cuspatial/_lib/point_in_polygon.pyx
index 52e89d1e3..790c7e1c8 100644
--- a/python/cuspatial/cuspatial/_lib/point_in_polygon.pyx
+++ b/python/cuspatial/cuspatial/_lib/point_in_polygon.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -42,4 +41,4 @@ def point_in_polygon(
             )
         )
 
-    return Column.from_pylibcudf(plc_Column.from_libcudf(move(result)))
+    return plc_Column.from_libcudf(move(result))
diff --git a/python/cuspatial/cuspatial/_lib/points_in_range.pyx b/python/cuspatial/cuspatial/_lib/points_in_range.pyx
index 181525eae..e9d4a504b 100644
--- a/python/cuspatial/cuspatial/_lib/points_in_range.pyx
+++ b/python/cuspatial/cuspatial/_lib/points_in_range.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column_view cimport column_view
 from pylibcudf.libcudf.table.table cimport table
@@ -13,7 +12,7 @@ from cuspatial._lib.cpp.points_in_range cimport (
 )
 
 
-cpdef points_in_range(
+cpdef plc_Table points_in_range(
     double range_min_x,
     double range_max_x,
     double range_min_y,
@@ -37,12 +36,4 @@ cpdef points_in_range(
                 y_v
             )
         )
-
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(c_result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(["x", "y"], plc_table.columns())
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(c_result))
diff --git a/python/cuspatial/cuspatial/_lib/polygon_bounding_boxes.pyx b/python/cuspatial/cuspatial/_lib/polygon_bounding_boxes.pyx
index d3bdf3422..c3923e00e 100644
--- a/python/cuspatial/cuspatial/_lib/polygon_bounding_boxes.pyx
+++ b/python/cuspatial/cuspatial/_lib/polygon_bounding_boxes.pyx
@@ -3,7 +3,6 @@
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column_view cimport column_view
 from pylibcudf.libcudf.table.table cimport table
@@ -13,9 +12,12 @@ from cuspatial._lib.cpp.polygon_bounding_boxes cimport (
 )
 
 
-cpdef polygon_bounding_boxes(plc_Column poly_offsets,
-                             plc_Column ring_offsets,
-                             plc_Column x, plc_Column y):
+cpdef list polygon_bounding_boxes(
+    plc_Column poly_offsets,
+    plc_Column ring_offsets,
+    plc_Column x,
+    plc_Column y,
+):
     cdef column_view c_poly_offsets = poly_offsets.view()
     cdef column_view c_ring_offsets = ring_offsets.view()
     cdef column_view c_x = x.view()
@@ -26,7 +28,4 @@ cpdef polygon_bounding_boxes(plc_Column poly_offsets,
             c_poly_offsets, c_ring_offsets, c_x, c_y
         ))
     cdef plc_Table table_result = plc_Table.from_libcudf(move(result))
-    return [
-        Column.from_pylibcudf(col)
-        for col in table_result.columns()
-    ]
+    return table_result.columns()
diff --git a/python/cuspatial/cuspatial/_lib/quadtree.pyx b/python/cuspatial/cuspatial/_lib/quadtree.pyx
index 0fd6e9da4..d9d84d66b 100644
--- a/python/cuspatial/cuspatial/_lib/quadtree.pyx
+++ b/python/cuspatial/cuspatial/_lib/quadtree.pyx
@@ -5,7 +5,6 @@ from libcpp.memory cimport unique_ptr
 from libcpp.pair cimport pair
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -17,12 +16,17 @@ from cuspatial._lib.cpp.quadtree cimport (
 )
 
 
-cpdef quadtree_on_points(plc_Column x, plc_Column y,
-                         double x_min, double x_max,
-                         double y_min, double y_max,
-                         double scale,
-                         int8_t max_depth,
-                         size_type min_size):
+cpdef tuple quadtree_on_points(
+    plc_Column x,
+    plc_Column y,
+    double x_min,
+    double x_max,
+    double y_min,
+    double y_max,
+    double scale,
+    int8_t max_depth,
+    size_type min_size,
+):
     cdef column_view c_x = x.view()
     cdef column_view c_y = y.view()
     cdef pair[unique_ptr[column], unique_ptr[table]] result
@@ -30,21 +34,7 @@ cpdef quadtree_on_points(plc_Column x, plc_Column y,
         result = move(cpp_quadtree_on_points(
             c_x, c_y, x_min, x_max, y_min, y_max, scale, max_depth, min_size
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result.second))
-    result_names = [
-        "key",
-        "level",
-        "is_internal_node",
-        "length",
-        "offset"
-    ]
     return (
-        Column.from_pylibcudf(plc_Column.from_libcudf(move(result.first))),
-        (
-            {
-                name: Column.from_pylibcudf(col)
-                for name, col in zip(result_names, plc_table.columns())
-            },
-            None
-        )
+        plc_Column.from_libcudf(move(result.first)),
+        plc_Table.from_libcudf(move(result.second))
     )
diff --git a/python/cuspatial/cuspatial/_lib/spatial.pyx b/python/cuspatial/cuspatial/_lib/spatial.pyx
index 473d6408d..20a7fff0d 100644
--- a/python/cuspatial/cuspatial/_lib/spatial.pyx
+++ b/python/cuspatial/cuspatial/_lib/spatial.pyx
@@ -4,7 +4,6 @@ from libcpp.memory cimport unique_ptr
 from libcpp.pair cimport pair
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -36,6 +35,6 @@ def sinusoidal_projection(
         )
 
     return (
-        Column.from_pylibcudf(plc_Column.from_libcudf(move(result.first))),
-        Column.from_pylibcudf(plc_Column.from_libcudf(move(result.second)))
+        plc_Column.from_libcudf(move(result.first)),
+        plc_Column.from_libcudf(move(result.second))
     )
diff --git a/python/cuspatial/cuspatial/_lib/spatial_join.pyx b/python/cuspatial/cuspatial/_lib/spatial_join.pyx
index 61168a10b..50a0993a7 100644
--- a/python/cuspatial/cuspatial/_lib/spatial_join.pyx
+++ b/python/cuspatial/cuspatial/_lib/spatial_join.pyx
@@ -4,7 +4,6 @@ from libc.stdint cimport int8_t
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column_view cimport column_view
 from pylibcudf.libcudf.table.table cimport table, table_view
@@ -16,14 +15,16 @@ from cuspatial._lib.cpp.spatial_join cimport (
 )
 
 
-cpdef join_quadtree_and_bounding_boxes(object quadtree,
-                                       object bounding_boxes,
-                                       double x_min,
-                                       double x_max,
-                                       double y_min,
-                                       double y_max,
-                                       double scale,
-                                       int8_t max_depth):
+cpdef plc_Table join_quadtree_and_bounding_boxes(
+    object quadtree,
+    object bounding_boxes,
+    double x_min,
+    double x_max,
+    double y_min,
+    double y_max,
+    double scale,
+    int8_t max_depth
+):
     cdef plc_Table plc_quadtree = plc_Table(
         [col.to_pylibcudf(mode="read") for col in quadtree._columns]
     )
@@ -39,27 +40,20 @@ cpdef join_quadtree_and_bounding_boxes(object quadtree,
             c_bounding_boxes,
             x_min, x_max, y_min, y_max, scale, max_depth
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(
-                ["bbox_offset", "quad_offset"], plc_table.columns()
-            )
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(result))
 
 
-cpdef quadtree_point_in_polygon(object poly_quad_pairs,
-                                object quadtree,
-                                plc_Column point_indices,
-                                plc_Column points_x,
-                                plc_Column points_y,
-                                plc_Column poly_offsets,
-                                plc_Column ring_offsets,
-                                plc_Column poly_points_x,
-                                plc_Column poly_points_y):
+cpdef plc_Table quadtree_point_in_polygon(
+    object poly_quad_pairs,
+    object quadtree,
+    plc_Column point_indices,
+    plc_Column points_x,
+    plc_Column points_y,
+    plc_Column poly_offsets,
+    plc_Column ring_offsets,
+    plc_Column poly_points_x,
+    plc_Column poly_points_y
+):
     cdef plc_Table plc_poly_quad_pairs = plc_Table(
         [col.to_pylibcudf(mode="read") for col in poly_quad_pairs._columns]
     )
@@ -88,26 +82,19 @@ cpdef quadtree_point_in_polygon(object poly_quad_pairs,
             c_poly_points_x,
             c_poly_points_y
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(
-                ["polygon_index", "point_index"], plc_table.columns()
-            )
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(result))
 
 
-cpdef quadtree_point_to_nearest_linestring(object linestring_quad_pairs,
-                                           object quadtree,
-                                           plc_Column point_indices,
-                                           plc_Column points_x,
-                                           plc_Column points_y,
-                                           plc_Column linestring_offsets,
-                                           plc_Column linestring_points_x,
-                                           plc_Column linestring_points_y):
+cpdef plc_Table quadtree_point_to_nearest_linestring(
+    object linestring_quad_pairs,
+    object quadtree,
+    plc_Column point_indices,
+    plc_Column points_x,
+    plc_Column points_y,
+    plc_Column linestring_offsets,
+    plc_Column linestring_points_x,
+    plc_Column linestring_points_y
+):
     cdef plc_Table plc_quad_pairs = plc_Table(
         [
             col.to_pylibcudf(mode="read")
@@ -137,14 +124,4 @@ cpdef quadtree_point_to_nearest_linestring(object linestring_quad_pairs,
             c_linestring_points_x,
             c_linestring_points_y
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(
-                ["point_index", "linestring_index", "distance"],
-                plc_table.columns()
-            )
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(result))
diff --git a/python/cuspatial/cuspatial/_lib/trajectory.pyx b/python/cuspatial/cuspatial/_lib/trajectory.pyx
index 0b4f28ba6..0730b0c11 100644
--- a/python/cuspatial/cuspatial/_lib/trajectory.pyx
+++ b/python/cuspatial/cuspatial/_lib/trajectory.pyx
@@ -4,7 +4,6 @@ from libcpp.memory cimport unique_ptr
 from libcpp.pair cimport pair
 from libcpp.utility cimport move
 
-from cudf.core.column.column import Column
 from pylibcudf cimport Column as plc_Column, Table as plc_Table
 from pylibcudf.libcudf.column.column cimport column
 from pylibcudf.libcudf.column.column_view cimport column_view
@@ -18,8 +17,12 @@ from cuspatial._lib.cpp.trajectory cimport (
 )
 
 
-cpdef derive_trajectories(plc_Column object_id, plc_Column x,
-                          plc_Column y, plc_Column timestamp):
+cpdef tuple derive_trajectories(
+    plc_Column object_id,
+    plc_Column x,
+    plc_Column y,
+    plc_Column timestamp,
+):
     cdef column_view c_id = object_id.view()
     cdef column_view c_x = x.view()
     cdef column_view c_y = y.view()
@@ -27,23 +30,13 @@ cpdef derive_trajectories(plc_Column object_id, plc_Column x,
     cdef pair[unique_ptr[table], unique_ptr[column]] result
     with nogil:
         result = move(cpp_derive_trajectories(c_id, c_x, c_y, c_ts))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result.first))
-    first_result = (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(
-                ["object_id", "x", "y", "timestamp"], plc_table.columns()
-            )
-        },
-        None
-    )
     return (
-        first_result,
-        Column.from_pylibcudf(plc_Column.from_libcudf(move(result.second)))
+        plc_Table.from_libcudf(move(result.first)),
+        plc_Column.from_libcudf(move(result.second))
     )
 
 
-cpdef trajectory_bounding_boxes(
+cpdef plc_Table trajectory_bounding_boxes(
     size_type num_trajectories,
     plc_Column object_id,
     plc_Column x,
@@ -57,21 +50,14 @@ cpdef trajectory_bounding_boxes(
         result = move(cpp_trajectory_bounding_boxes(
             num_trajectories, c_id, c_x, c_y
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(
-                ["x_min", "y_min", "x_max", "y_max"], plc_table.columns()
-            )
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(result))
 
 
-cpdef trajectory_distances_and_speeds(size_type num_trajectories,
-                                      plc_Column object_id, plc_Column x,
-                                      plc_Column y, plc_Column timestamp):
+cpdef plc_Table trajectory_distances_and_speeds(
+    size_type num_trajectories,
+    plc_Column object_id, plc_Column x,
+    plc_Column y, plc_Column timestamp
+):
     cdef column_view c_id = object_id.view()
     cdef column_view c_x = x.view()
     cdef column_view c_y = y.view()
@@ -81,11 +67,4 @@ cpdef trajectory_distances_and_speeds(size_type num_trajectories,
         result = move(cpp_trajectory_distances_and_speeds(
             num_trajectories, c_id, c_x, c_y, c_ts
         ))
-    cdef plc_Table plc_table = plc_Table.from_libcudf(move(result))
-    return (
-        {
-            name: Column.from_pylibcudf(col)
-            for name, col in zip(["distance", "speed"], plc_table.columns())
-        },
-        None
-    )
+    return plc_Table.from_libcudf(move(result))
diff --git a/python/cuspatial/cuspatial/core/binops/distance_dispatch.py b/python/cuspatial/cuspatial/core/binops/distance_dispatch.py
index a4e9c0c17..868f7a844 100644
--- a/python/cuspatial/cuspatial/core/binops/distance_dispatch.py
+++ b/python/cuspatial/cuspatial/core/binops/distance_dispatch.py
@@ -1,7 +1,7 @@
 # Copyright (c) 2024-2025, NVIDIA CORPORATION
 
 import cudf
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial._lib.distance import (
     pairwise_linestring_distance,
@@ -205,7 +205,7 @@ def __call__(self):
             range(len(self._res_index)), dtype="int32"
         ).apply_boolean_mask(self._non_null_mask)
 
-        result[scatter_map] = dist
+        result[scatter_map] = ColumnBase.from_pylibcudf(dist)
 
         # If `align==False`, geopandas preserves lhs index.
         index = None if self._align else self._res_index
diff --git a/python/cuspatial/cuspatial/core/binops/equals_count.py b/python/cuspatial/cuspatial/core/binops/equals_count.py
index b2d2dd1cd..cb3ebbd68 100644
--- a/python/cuspatial/cuspatial/core/binops/equals_count.py
+++ b/python/cuspatial/cuspatial/core/binops/equals_count.py
@@ -1,6 +1,7 @@
 # Copyright (c) 2023-2025, NVIDIA CORPORATION.
 
 import cudf
+from cudf.core.column import ColumnBase
 
 from cuspatial._lib.pairwise_multipoint_equals_count import (
     pairwise_multipoint_equals_count as c_pairwise_multipoint_equals_count,
@@ -76,4 +77,4 @@ def pairwise_multipoint_equals_count(lhs, rhs):
     rhs_column = rhs._column.mpoints._column.to_pylibcudf(mode="read")
     result = c_pairwise_multipoint_equals_count(lhs_column, rhs_column)
 
-    return cudf.Series._from_column(result)
+    return cudf.Series._from_column(ColumnBase.from_pylibcudf(result))
diff --git a/python/cuspatial/cuspatial/core/binops/intersection.py b/python/cuspatial/cuspatial/core/binops/intersection.py
index 67e5ceed6..94dc381d0 100644
--- a/python/cuspatial/cuspatial/core/binops/intersection.py
+++ b/python/cuspatial/cuspatial/core/binops/intersection.py
@@ -3,11 +3,12 @@
 from typing import TYPE_CHECKING
 
 import cudf
-from cudf.core.column import ListColumn, as_column
+from cudf.core.column import ColumnBase, ListColumn, as_column
 
 from cuspatial._lib.intersection import (
     pairwise_linestring_intersection as c_pairwise_linestring_intersection,
 )
+from cuspatial._lib.types import GeometryType
 from cuspatial.core._column.geocolumn import GeoColumn
 from cuspatial.core._column.geometa import Feature_Enum, GeoMeta
 from cuspatial.utils.column_utils import (
@@ -83,15 +84,30 @@ def pairwise_linestring_intersection(
         points,
         segments,
     ) = geoms
+    geometry_collection_offset = ColumnBase.from_pylibcudf(
+        geometry_collection_offset
+    )
+    types_buffer = ColumnBase.from_pylibcudf(types_buffer)
+    # Map linestring type codes from libcuspatial to cuspatial
+    types_buffer[
+        types_buffer == GeometryType.LINESTRING.value
+    ] = Feature_Enum.LINESTRING.value
+    offset_buffer = ColumnBase.from_pylibcudf(offset_buffer)
+    points = ColumnBase.from_pylibcudf(points)
+    segments = ColumnBase.from_pylibcudf(segments)
 
     # Organize the look back ids into list column
-    (lhs_linestring_id, lhs_segment_id, rhs_linestring_id, rhs_segment_id,) = [
-        ListColumn(
+    def id_from_pylibcudf(id_, offset_col):
+        col = ColumnBase.from_pylibcudf(id_)
+        return ListColumn(
             data=None,
-            dtype=cudf.ListDtype(id_.dtype),
-            size=len(geometry_collection_offset) - 1,
-            children=(geometry_collection_offset, id_),
+            dtype=cudf.ListDtype(col.dtype),
+            size=len(offset_col) - 1,
+            children=(offset_col, col),
         )
+
+    lhs_linestring_id, lhs_segment_id, rhs_linestring_id, rhs_segment_id = [
+        id_from_pylibcudf(id_, geometry_collection_offset)
         for id_ in look_back_ids
     ]
 
diff --git a/python/cuspatial/cuspatial/core/binpreds/contains.py b/python/cuspatial/cuspatial/core/binpreds/contains.py
index ba330e98b..0b85e6e35 100644
--- a/python/cuspatial/cuspatial/core/binpreds/contains.py
+++ b/python/cuspatial/cuspatial/core/binpreds/contains.py
@@ -4,7 +4,7 @@
 
 import cudf
 from cudf import DataFrame, Series
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 import cuspatial
 from cuspatial._lib.pairwise_point_in_polygon import (
@@ -106,7 +106,7 @@ def _brute_force_contains_properly(points, polygons):
     )
     result = DataFrame(
         pip_bitmap_column_to_binary_array(
-            polygon_bitmap_column=pip_result,
+            polygon_bitmap_column=ColumnBase.from_pylibcudf(pip_result),
             width=len(polygons.polygons.part_offset) - 1,
         )
     )
@@ -155,7 +155,9 @@ def _pairwise_contains_properly(points, polygons):
     # point) pair where the point is contained properly by the polygon. We can
     # use this to create a dataframe with only (polygon, point) pairs that
     # satisfy the relationship.
-    pip_result = cudf.Series._from_column(result_column).astype("bool")
+    pip_result = cudf.Series._from_column(
+        ColumnBase.from_pylibcudf(result_column)
+    ).astype("bool")
     trues = pip_result[pip_result].index
     true_pairs = cudf.DataFrame(
         {
diff --git a/python/cuspatial/cuspatial/core/spatial/bounding.py b/python/cuspatial/cuspatial/core/spatial/bounding.py
index ab06bfd55..82eb77320 100644
--- a/python/cuspatial/cuspatial/core/spatial/bounding.py
+++ b/python/cuspatial/cuspatial/core/spatial/bounding.py
@@ -1,7 +1,7 @@
 # Copyright (c) 2022-2025, NVIDIA CORPORATION.
 
 from cudf import DataFrame
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial._lib.linestring_bounding_boxes import (
     linestring_bounding_boxes as cpp_linestring_bounding_boxes,
@@ -66,11 +66,14 @@ def polygon_bounding_boxes(polygons: GeoSeries):
         dict(
             zip(
                 column_names,
-                cpp_polygon_bounding_boxes(
-                    as_column(poly_offsets).to_pylibcudf(mode="read"),
-                    as_column(ring_offsets).to_pylibcudf(mode="read"),
-                    as_column(x).to_pylibcudf(mode="read"),
-                    as_column(y).to_pylibcudf(mode="read"),
+                (
+                    ColumnBase.from_pylibcudf(col)
+                    for col in cpp_polygon_bounding_boxes(
+                        as_column(poly_offsets).to_pylibcudf(mode="read"),
+                        as_column(ring_offsets).to_pylibcudf(mode="read"),
+                        as_column(x).to_pylibcudf(mode="read"),
+                        as_column(y).to_pylibcudf(mode="read"),
+                    )
                 ),
             )
         )
@@ -127,4 +130,11 @@ def linestring_bounding_boxes(linestrings: GeoSeries, expansion_radius: float):
         expansion_radius,
     )
 
-    return DataFrame._from_data(dict(zip(column_names, results)))
+    return DataFrame._from_data(
+        dict(
+            zip(
+                column_names,
+                (ColumnBase.from_pylibcudf(col) for col in results),
+            )
+        )
+    )
diff --git a/python/cuspatial/cuspatial/core/spatial/distance.py b/python/cuspatial/cuspatial/core/spatial/distance.py
index 23a74ec00..dc5864886 100644
--- a/python/cuspatial/cuspatial/core/spatial/distance.py
+++ b/python/cuspatial/cuspatial/core/spatial/distance.py
@@ -2,7 +2,7 @@
 
 import cudf
 from cudf import DataFrame, Series
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial._lib.distance import (
     directed_hausdorff_distance as cpp_directed_hausdorff_distance,
@@ -95,7 +95,9 @@ def directed_hausdorff_distance(multipoints: GeoSeries):
 
     # the column label of each column in result should be its int position
     # e.g. a dict of {0: result[0], 1, result[1], ...}
-    return DataFrame._from_data(dict(enumerate(result)))
+    return DataFrame._from_data(
+        dict(enumerate(ColumnBase.from_pylibcudf(col) for col in result))
+    )
 
 
 def haversine_distance(p1: GeoSeries, p2: GeoSeries):
@@ -152,15 +154,15 @@ def haversine_distance(p1: GeoSeries, p2: GeoSeries):
     p2_lon = p2.points.x._column
     p2_lat = p2.points.y._column
 
-    return cudf.Series._from_data(
-        {
-            "None": cpp_haversine_distance(
+    return cudf.Series._from_column(
+        ColumnBase.from_pylibcudf(
+            cpp_haversine_distance(
                 p1_lon.to_pylibcudf(mode="read"),
                 p1_lat.to_pylibcudf(mode="read"),
                 p2_lon.to_pylibcudf(mode="read"),
                 p2_lat.to_pylibcudf(mode="read"),
             )
-        }
+        )
     )
 
 
@@ -227,11 +229,13 @@ def pairwise_point_distance(points1: GeoSeries, points2: GeoSeries):
     ) = _extract_point_column_and_collection_type(points2)
 
     return Series._from_column(
-        cpp_pairwise_point_distance(
-            lhs_point_collection_type,
-            rhs_point_collection_type,
-            lhs_column.to_pylibcudf(mode="read"),
-            rhs_column.to_pylibcudf(mode="read"),
+        ColumnBase.from_pylibcudf(
+            cpp_pairwise_point_distance(
+                lhs_point_collection_type,
+                rhs_point_collection_type,
+                lhs_column.to_pylibcudf(mode="read"),
+                rhs_column.to_pylibcudf(mode="read"),
+            )
         )
     )
 
@@ -301,9 +305,11 @@ def pairwise_linestring_distance(
         return cudf.Series(dtype="float64")
 
     return Series._from_column(
-        cpp_pairwise_linestring_distance(
-            multilinestrings1.lines.column().to_pylibcudf(mode="read"),
-            multilinestrings2.lines.column().to_pylibcudf(mode="read"),
+        ColumnBase.from_pylibcudf(
+            cpp_pairwise_linestring_distance(
+                multilinestrings1.lines.column().to_pylibcudf(mode="read"),
+                multilinestrings2.lines.column().to_pylibcudf(mode="read"),
+            )
         )
     )
 
@@ -418,14 +424,14 @@ def pairwise_point_linestring_distance(
         point_collection_type,
     ) = _extract_point_column_and_collection_type(points)
 
-    return Series._from_data(
-        {
-            None: c_pairwise_point_linestring_distance(
+    return Series._from_column(
+        ColumnBase.from_pylibcudf(
+            c_pairwise_point_linestring_distance(
                 point_collection_type,
                 point_column.to_pylibcudf(mode="read"),
                 linestrings.lines.column().to_pylibcudf(mode="read"),
             )
-        }
+        )
     )
 
 
@@ -503,14 +509,14 @@ def pairwise_point_polygon_distance(points: GeoSeries, polygons: GeoSeries):
     ) = _extract_point_column_and_collection_type(points)
     polygon_column = polygons.polygons.column()
 
-    return Series._from_data(
-        {
-            None: c_pairwise_point_polygon_distance(
+    return Series._from_column(
+        ColumnBase.from_pylibcudf(
+            c_pairwise_point_polygon_distance(
                 point_collection_type,
                 points_column.to_pylibcudf(mode="read"),
                 polygon_column.to_pylibcudf(mode="read"),
             )
-        }
+        )
     )
 
 
@@ -591,7 +597,9 @@ def pairwise_linestring_polygon_distance(
     polygon_column = polygons.polygons.column().to_pylibcudf(mode="read")
 
     return Series._from_column(
-        c_pairwise_line_poly_dist(linestrings_column, polygon_column)
+        ColumnBase.from_pylibcudf(
+            c_pairwise_line_poly_dist(linestrings_column, polygon_column)
+        )
     )
 
 
@@ -663,8 +671,10 @@ def pairwise_polygon_distance(polygons1: GeoSeries, polygons2: GeoSeries):
     polygon1_column = polygons1.polygons.column().to_pylibcudf(mode="read")
     polygon2_column = polygons2.polygons.column().to_pylibcudf(mode="read")
 
-    return Series._from_data(
-        {None: c_pairwise_polygon_distance(polygon1_column, polygon2_column)}
+    return Series._from_column(
+        ColumnBase.from_pylibcudf(
+            c_pairwise_polygon_distance(polygon1_column, polygon2_column)
+        )
     )
 
 
diff --git a/python/cuspatial/cuspatial/core/spatial/filtering.py b/python/cuspatial/cuspatial/core/spatial/filtering.py
index 2e10af0ee..5e47c5eee 100644
--- a/python/cuspatial/cuspatial/core/spatial/filtering.py
+++ b/python/cuspatial/cuspatial/core/spatial/filtering.py
@@ -1,7 +1,7 @@
 # Copyright (c) 2022-2025, NVIDIA CORPORATION.
 
 from cudf import DataFrame
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial._lib import points_in_range
 from cuspatial.core.geoseries import GeoSeries
@@ -51,7 +51,13 @@ def points_in_spatial_window(points: GeoSeries, min_x, max_x, min_y, max_y):
     xs = as_column(points.points.x).to_pylibcudf(mode="read")
     ys = as_column(points.points.y).to_pylibcudf(mode="read")
 
+    plc_table = points_in_range.points_in_range(
+        min_x, max_x, min_y, max_y, xs, ys
+    )
     res_xy = DataFrame._from_data(
-        *points_in_range.points_in_range(min_x, max_x, min_y, max_y, xs, ys)
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(["x", "y"], plc_table.columns())
+        }
     ).interleave_columns()
     return GeoSeries.from_points_xy(res_xy)
diff --git a/python/cuspatial/cuspatial/core/spatial/indexing.py b/python/cuspatial/cuspatial/core/spatial/indexing.py
index 9bab115c0..199c03d49 100644
--- a/python/cuspatial/cuspatial/core/spatial/indexing.py
+++ b/python/cuspatial/cuspatial/core/spatial/indexing.py
@@ -3,7 +3,7 @@
 import warnings
 
 from cudf import DataFrame, Series
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial import GeoSeries
 from cuspatial._lib.quadtree import (
@@ -187,4 +187,13 @@ def quadtree_on_points(
         max_depth,
         max_size,
     )
-    return Series._from_column(key_to_point), DataFrame._from_data(*quadtree)
+    result_names = ["key", "level", "is_internal_node", "length", "offset"]
+    return (
+        Series._from_column(ColumnBase.from_pylibcudf(key_to_point)),
+        DataFrame._from_data(
+            {
+                name: ColumnBase.from_pylibcudf(col)
+                for name, col in zip(result_names, quadtree.columns())
+            }
+        ),
+    )
diff --git a/python/cuspatial/cuspatial/core/spatial/join.py b/python/cuspatial/cuspatial/core/spatial/join.py
index f9323d367..6353ae88b 100644
--- a/python/cuspatial/cuspatial/core/spatial/join.py
+++ b/python/cuspatial/cuspatial/core/spatial/join.py
@@ -3,7 +3,7 @@
 import warnings
 
 from cudf import DataFrame
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial import GeoSeries
 from cuspatial._lib import spatial_join
@@ -86,7 +86,8 @@ def point_in_polygon(points: GeoSeries, polygons: GeoSeries):
     )
     result = DataFrame(
         pip_bitmap_column_to_binary_array(
-            polygon_bitmap_column=result, width=len(poly_offsets) - 1
+            polygon_bitmap_column=ColumnBase.from_pylibcudf(result),
+            width=len(poly_offsets) - 1,
         )
     )
 
@@ -152,17 +153,23 @@ def join_quadtree_and_bounding_boxes(
             + "scale {}. Clamping to minimum scale".format(min_scale)
         )
 
+    plc_result = spatial_join.join_quadtree_and_bounding_boxes(
+        quadtree,
+        bounding_boxes,
+        x_min,
+        x_max,
+        y_min,
+        y_max,
+        max(scale, min_scale),
+        max_depth,
+    )
     return DataFrame._from_data(
-        *spatial_join.join_quadtree_and_bounding_boxes(
-            quadtree,
-            bounding_boxes,
-            x_min,
-            x_max,
-            y_min,
-            y_max,
-            max(scale, min_scale),
-            max_depth,
-        )
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(
+                ["bbox_offset", "quad_offset"], plc_result.columns()
+            )
+        }
     )
 
 
@@ -232,18 +239,24 @@ def quadtree_point_in_polygon(
     poly_points_x = as_column(polygon_data.x).to_pylibcudf(mode="read")
     poly_points_y = as_column(polygon_data.y).to_pylibcudf(mode="read")
 
+    plc_result = spatial_join.quadtree_point_in_polygon(
+        poly_quad_pairs,
+        quadtree,
+        point_indices._column.to_pylibcudf(mode="read"),
+        points_x,
+        points_y,
+        poly_offsets,
+        ring_offsets,
+        poly_points_x,
+        poly_points_y,
+    )
     return DataFrame._from_data(
-        *spatial_join.quadtree_point_in_polygon(
-            poly_quad_pairs,
-            quadtree,
-            point_indices._column.to_pylibcudf(mode="read"),
-            points_x,
-            points_y,
-            poly_offsets,
-            ring_offsets,
-            poly_points_x,
-            poly_points_y,
-        )
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(
+                ["polygon_index", "point_index"], plc_result.columns()
+            )
+        }
     )
 
 
@@ -315,17 +328,24 @@ def quadtree_point_to_nearest_linestring(
     )
     linestring_offsets = as_column(linestrings.lines.part_offset)
 
+    plc_result = spatial_join.quadtree_point_to_nearest_linestring(
+        linestring_quad_pairs,
+        quadtree,
+        as_column(point_indices, dtype="uint32").to_pylibcudf(mode="read"),
+        points_x,
+        points_y,
+        as_column(linestring_offsets, dtype="uint32").to_pylibcudf(
+            mode="read"
+        ),
+        linestring_points_x,
+        linestring_points_y,
+    )
     return DataFrame._from_data(
-        *spatial_join.quadtree_point_to_nearest_linestring(
-            linestring_quad_pairs,
-            quadtree,
-            as_column(point_indices, dtype="uint32").to_pylibcudf(mode="read"),
-            points_x,
-            points_y,
-            as_column(linestring_offsets, dtype="uint32").to_pylibcudf(
-                mode="read"
-            ),
-            linestring_points_x,
-            linestring_points_y,
-        )
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(
+                ["point_index", "linestring_index", "distance"],
+                plc_result.columns(),
+            )
+        }
     )
diff --git a/python/cuspatial/cuspatial/core/spatial/nearest_points.py b/python/cuspatial/cuspatial/core/spatial/nearest_points.py
index 0aaf65b25..4c72bdb08 100644
--- a/python/cuspatial/cuspatial/core/spatial/nearest_points.py
+++ b/python/cuspatial/cuspatial/core/spatial/nearest_points.py
@@ -1,7 +1,7 @@
 # Copyright (c) 2024-2025, NVIDIA CORPORATION.
 
 import cudf
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 import cuspatial._lib.nearest_points as nearest_points
 from cuspatial.core._column.geocolumn import GeoColumn
@@ -100,16 +100,20 @@ def pairwise_point_linestring_nearest_points(
     )
 
     nearest_points_on_linestring = GeoColumn._from_points_xy(
-        point_on_linestring_xy
+        ColumnBase.from_pylibcudf(point_on_linestring_xy)
     )
 
     if not point_geometry_id:
         point_geometry_id = as_column(0, length=len(points), dtype="int32")
+    else:
+        point_geometry_id = ColumnBase.from_pylibcudf(point_geometry_id)
 
     data = {
         "point_geometry_id": point_geometry_id,
-        "linestring_geometry_id": linestring_geometry_id,
-        "segment_id": segment_id,
+        "linestring_geometry_id": ColumnBase.from_pylibcudf(
+            linestring_geometry_id
+        ),
+        "segment_id": ColumnBase.from_pylibcudf(segment_id),
         "geometry": nearest_points_on_linestring,
     }
 
diff --git a/python/cuspatial/cuspatial/core/spatial/projection.py b/python/cuspatial/cuspatial/core/spatial/projection.py
index 6f3ccc595..c522720f2 100644
--- a/python/cuspatial/cuspatial/core/spatial/projection.py
+++ b/python/cuspatial/cuspatial/core/spatial/projection.py
@@ -1,6 +1,7 @@
 # Copyright (c) 2022-2025, NVIDIA CORPORATION.
 
 from cudf import DataFrame
+from cudf.core.column import ColumnBase
 
 from cuspatial._lib.spatial import (
     sinusoidal_projection as cpp_sinusoidal_projection,
@@ -55,6 +56,9 @@ def sinusoidal_projection(origin_lon, origin_lat, lonlat: GeoSeries):
         lonlat.points.y._column.to_pylibcudf(mode="read"),
     )
     lonlat_transformed = DataFrame(
-        {"x": result[0], "y": result[1]}
+        {
+            "x": ColumnBase.from_pylibcudf(result[0]),
+            "y": ColumnBase.from_pylibcudf(result[1]),
+        }
     ).interleave_columns()
     return GeoSeries.from_points_xy(lonlat_transformed)
diff --git a/python/cuspatial/cuspatial/core/trajectory.py b/python/cuspatial/cuspatial/core/trajectory.py
index cac055513..faa4f56c1 100644
--- a/python/cuspatial/cuspatial/core/trajectory.py
+++ b/python/cuspatial/cuspatial/core/trajectory.py
@@ -3,7 +3,7 @@
 import numpy as np
 
 from cudf import DataFrame, Series
-from cudf.core.column import as_column
+from cudf.core.column import ColumnBase, as_column
 
 from cuspatial import GeoSeries
 from cuspatial._lib.trajectory import (
@@ -75,7 +75,18 @@ def derive_trajectories(object_ids, points: GeoSeries, timestamps):
     objects, traj_offsets = cpp_derive_trajectories(
         object_ids, xs, ys, timestamps
     )
-    return DataFrame._from_data(*objects), Series._from_column(traj_offsets)
+    objects_df = DataFrame._from_data(
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(
+                ["object_id", "x", "y", "timestamp"], objects.columns()
+            )
+        }
+    )
+    traj_offsets_ser = Series._from_column(
+        ColumnBase.from_pylibcudf(traj_offsets)
+    )
+    return objects_df, traj_offsets_ser
 
 
 def trajectory_bounding_boxes(num_trajectories, object_ids, points: GeoSeries):
@@ -144,8 +155,16 @@ def trajectory_bounding_boxes(num_trajectories, object_ids, points: GeoSeries):
     )
     xs = as_column(points.points.x).to_pylibcudf(mode="read")
     ys = as_column(points.points.y).to_pylibcudf(mode="read")
+    plc_result = cpp_trajectory_bounding_boxes(
+        num_trajectories, object_ids, xs, ys
+    )
     return DataFrame._from_data(
-        *cpp_trajectory_bounding_boxes(num_trajectories, object_ids, xs, ys)
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(
+                ["x_min", "y_min", "x_max", "y_max"], plc_result.columns()
+            )
+        }
     )
 
 
@@ -204,10 +223,14 @@ def trajectory_distances_and_speeds(
     timestamps = normalize_timestamp_column(
         as_column(timestamps)
     ).to_pylibcudf(mode="read")
+    plc_result = cpp_trajectory_distances_and_speeds(
+        num_trajectories, object_ids, xs, ys, timestamps
+    )
     df = DataFrame._from_data(
-        *cpp_trajectory_distances_and_speeds(
-            num_trajectories, object_ids, xs, ys, timestamps
-        )
+        {
+            name: ColumnBase.from_pylibcudf(col)
+            for name, col in zip(["distance", "speed"], plc_result.columns())
+        }
     )
     df.index.name = "trajectory_id"
     return df