Bump columnar to 0.8.0 (#620)

antiguru · web-flow · commit 55f5d68fb053 · 2025-07-08T17:30:48.000+02:00
* Bump columnar to 0.8.0

Signed-off-by: Moritz Hoffmann &lt;antiguru@gmail.com&gt;

* Update example to columnar 0.8.0

Signed-off-by: Moritz Hoffmann &lt;antiguru@gmail.com&gt;

---------

Signed-off-by: Moritz Hoffmann &lt;antiguru@gmail.com&gt;
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,7 @@ resolver = "2"
 [workspace.dependencies]
 differential-dataflow = { path = "differential-dataflow", default-features = false, version = "0.15.3" }
 timely = { version = "0.21", default-features = false }
+columnar = { version = "0.8", default-features = false }
 #timely = { path = "../timely-dataflow/timely/", default-features = false }
 
 [profile.release]
diff --git a/differential-dataflow/Cargo.toml b/differential-dataflow/Cargo.toml
@@ -23,7 +23,7 @@ graph_map = "0.1"
 bytemuck = "1.18.0"
 
 [dependencies]
-columnar = "0.6"
+columnar = { workspace = true }
 columnation = "0.1.0"
 fnv="1.0.2"
 paste = "1.0"
diff --git a/differential-dataflow/examples/columnar.rs b/differential-dataflow/examples/columnar.rs
@@ -156,15 +156,17 @@ mod container {
     use columnar::bytes::{EncodeDecode, Indexed};
     use columnar::common::IterOwn;
 
+    type BorrowedOf<'a, C> = <<C as Columnar>::Container as columnar::Container>::Borrowed<'a>;
+
     impl<C: Columnar> Column<C> {
-        pub fn borrow(&self) -> <C::Container as columnar::Container<C>>::Borrowed<'_> {
+        pub fn borrow(&self) -> BorrowedOf<C> {
             match self {
                 Column::Typed(t) => t.borrow(),
-                Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))),
-                Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(a)),
+                Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))),
+                Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)),
             }
         }
-        pub fn get(&self, index: usize) -> C::Ref<'_> {
+        pub fn get(&self, index: usize) -> columnar::Ref<C> {
             self.borrow().get(index)
         }
     }
@@ -174,8 +176,8 @@ mod container {
         fn len(&self) -> usize {
             match self {
                 Column::Typed(t) => t.len(),
-                Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).len(),
-                Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(a)).len(),
+                Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).len(),
+                Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).len(),
             }
         }
         // This sets the `Bytes` variant to be an empty `Typed` variant, appropriate for pushing into.
@@ -187,23 +189,23 @@ mod container {
             }
         }
 
-        type ItemRef<'a> = C::Ref<'a>;
-        type Iter<'a> = IterOwn<<C::Container as columnar::Container<C>>::Borrowed<'a>>;
+        type ItemRef<'a> = columnar::Ref<'a, C>;
+        type Iter<'a> = IterOwn<BorrowedOf<'a, C>>;
         fn iter<'a>(&'a self) -> Self::Iter<'a> {
             match self {
                 Column::Typed(t) => t.borrow().into_index_iter(),
-                Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),
-                Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),
+                Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),
+                Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),
             }
         }
 
-        type Item<'a> = C::Ref<'a>;
-        type DrainIter<'a> = IterOwn<<C::Container as columnar::Container<C>>::Borrowed<'a>>;
+        type Item<'a> = columnar::Ref<'a, C>;
+        type DrainIter<'a> = IterOwn<BorrowedOf<'a, C>>;
         fn drain<'a>(&'a mut self) -> Self::DrainIter<'a> {
             match self {
                 Column::Typed(t) => t.borrow().into_index_iter(),
-                Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),
-                Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),
+                Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),
+                Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),
             }
         }
     }
@@ -406,10 +408,13 @@ pub mod batcher {
 
     impl<'a, D, T, R, C2> PushInto<&'a mut Column<(D, T, R)>> for Chunker<C2>
     where
-        D: for<'b> Columnar<Ref<'b>: Ord>,
-        T: for<'b> Columnar<Ref<'b>: Ord>,
-        R: for<'b> Columnar<Ref<'b>: Ord> + for<'b> Semigroup<R::Ref<'b>>,
-        C2: Container + for<'b, 'c> PushInto<(D::Ref<'b>, T::Ref<'b>, &'c R)>,
+        D: for<'b> Columnar,
+        for<'b> columnar::Ref<'b, D>: Ord,
+        T: for<'b> Columnar,
+        for<'b> columnar::Ref<'b, T>: Ord,
+        R: for<'b> Columnar + for<'b> Semigroup<columnar::Ref<'b, R>>,
+        for<'b> columnar::Ref<'b, R>: Ord,
+        C2: Container + for<'b, 'c> PushInto<(columnar::Ref<'b, D>, columnar::Ref<'b, T>, &'c R)>,
     {
         fn push_into(&mut self, container: &'a mut Column<(D, T, R)>) {
 
@@ -482,11 +487,13 @@ pub mod batcher {
 
         impl<D, T, R> ContainerQueue<Column<(D, T, R)>> for ColumnQueue<(D, T, R)>
         where
-            D: for<'a> Columnar<Ref<'a>: Ord>,
-            T: for<'a> Columnar<Ref<'a>: Ord>,
+            D: for<'a> Columnar,
+            for<'b> columnar::Ref<'b, D>: Ord,
+            T: for<'a> Columnar,
+            for<'b> columnar::Ref<'b, T>: Ord,
             R: Columnar,
         {
-            fn next_or_alloc(&mut self) -> Result<<(D, T, R) as Columnar>::Ref<'_>, Column<(D, T, R)>> {
+            fn next_or_alloc(&mut self) -> Result<columnar::Ref<(D, T, R)>, Column<(D, T, R)>> {
                 if self.is_empty() {
                     Err(std::mem::take(&mut self.list))
                 }
@@ -510,12 +517,12 @@ pub mod batcher {
         }
 
         impl<T: Columnar> ColumnQueue<T> {
-            fn pop(&mut self) -> T::Ref<'_> {
+            fn pop(&mut self) -> columnar::Ref<T> {
                 self.head += 1;
                 self.list.get(self.head - 1)
             }
 
-            fn peek(&self) -> T::Ref<'_> {
+            fn peek(&self) -> columnar::Ref<T> {
                 self.list.get(self.head)
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -156,15 +156,17 @@ mod container {`
`156`	`156`	`use columnar::bytes::{EncodeDecode, Indexed};`
`157`	`157`	`use columnar::common::IterOwn;`
`158`	`158`
	`159`	`+ type BorrowedOf<'a, C> = <<C as Columnar>::Container as columnar::Container>::Borrowed<'a>;`
	`160`	`+`
`159`	`161`	`impl<C: Columnar> Column<C> {`
`160`		`- pub fn borrow(&self) -> <C::Container as columnar::Container<C>>::Borrowed<'_> {`
	`162`	`+ pub fn borrow(&self) -> BorrowedOf<C> {`
`161`	`163`	`match self {`
`162`	`164`	`Column::Typed(t) => t.borrow(),`
`163`		`- Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))),`
`164`		`- Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(a)),`
	`165`	`+ Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))),`
	`166`	`+ Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)),`
`165`	`167`	`}`
`166`	`168`	`}`
`167`		`- pub fn get(&self, index: usize) -> C::Ref<'_> {`
	`169`	`+ pub fn get(&self, index: usize) -> columnar::Ref<C> {`
`168`	`170`	`self.borrow().get(index)`
`169`	`171`	`}`
`170`	`172`	`}`
`@@ -174,8 +176,8 @@ mod container {`
`174`	`176`	`fn len(&self) -> usize {`
`175`	`177`	`match self {`
`176`	`178`	`Column::Typed(t) => t.len(),`
`177`		`- Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).len(),`
`178`		`- Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'_> as FromBytes>::from_bytes(&mut Indexed::decode(a)).len(),`
	`179`	`+ Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).len(),`
	`180`	`+ Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).len(),`
`179`	`181`	`}`
`180`	`182`	`}`
`181`	`183`	// This sets the `Bytes` variant to be an empty `Typed` variant, appropriate for pushing into.
`@@ -187,23 +189,23 @@ mod container {`
`187`	`189`	`}`
`188`	`190`	`}`
`189`	`191`
`190`		`- type ItemRef<'a> = C::Ref<'a>;`
`191`		`- type Iter<'a> = IterOwn<<C::Container as columnar::Container<C>>::Borrowed<'a>>;`
	`192`	`+ type ItemRef<'a> = columnar::Ref<'a, C>;`
	`193`	`+ type Iter<'a> = IterOwn<BorrowedOf<'a, C>>;`
`192`	`194`	`fn iter<'a>(&'a self) -> Self::Iter<'a> {`
`193`	`195`	`match self {`
`194`	`196`	`Column::Typed(t) => t.borrow().into_index_iter(),`
`195`		`- Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),`
`196`		`- Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),`
	`197`	`+ Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),`
	`198`	`+ Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),`
`197`	`199`	`}`
`198`	`200`	`}`
`199`	`201`
`200`		`- type Item<'a> = C::Ref<'a>;`
`201`		`- type DrainIter<'a> = IterOwn<<C::Container as columnar::Container<C>>::Borrowed<'a>>;`
	`202`	`+ type Item<'a> = columnar::Ref<'a, C>;`
	`203`	`+ type DrainIter<'a> = IterOwn<BorrowedOf<'a, C>>;`
`202`	`204`	`fn drain<'a>(&'a mut self) -> Self::DrainIter<'a> {`
`203`	`205`	`match self {`
`204`	`206`	`Column::Typed(t) => t.borrow().into_index_iter(),`
`205`		`- Column::Bytes(b) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),`
`206`		`- Column::Align(a) => <<C::Container as columnar::Container<C>>::Borrowed<'a> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),`
	`207`	`+ Column::Bytes(b) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(bytemuck::cast_slice(b))).into_index_iter(),`
	`208`	`+ Column::Align(a) => <BorrowedOf<C> as FromBytes>::from_bytes(&mut Indexed::decode(a)).into_index_iter(),`
`207`	`209`	`}`
`208`	`210`	`}`
`209`	`211`	`}`
`@@ -406,10 +408,13 @@ pub mod batcher {`
`406`	`408`
`407`	`409`	`impl<'a, D, T, R, C2> PushInto<&'a mut Column<(D, T, R)>> for Chunker<C2>`
`408`	`410`	`where`
`409`		`- D: for<'b> Columnar<Ref<'b>: Ord>,`
`410`		`- T: for<'b> Columnar<Ref<'b>: Ord>,`
`411`		`- R: for<'b> Columnar<Ref<'b>: Ord> + for<'b> Semigroup<R::Ref<'b>>,`
`412`		`- C2: Container + for<'b, 'c> PushInto<(D::Ref<'b>, T::Ref<'b>, &'c R)>,`
	`411`	`+ D: for<'b> Columnar,`
	`412`	`+ for<'b> columnar::Ref<'b, D>: Ord,`
	`413`	`+ T: for<'b> Columnar,`
	`414`	`+ for<'b> columnar::Ref<'b, T>: Ord,`
	`415`	`+ R: for<'b> Columnar + for<'b> Semigroup<columnar::Ref<'b, R>>,`
	`416`	`+ for<'b> columnar::Ref<'b, R>: Ord,`
	`417`	`+ C2: Container + for<'b, 'c> PushInto<(columnar::Ref<'b, D>, columnar::Ref<'b, T>, &'c R)>,`
`413`	`418`	`{`
`414`	`419`	`fn push_into(&mut self, container: &'a mut Column<(D, T, R)>) {`
`415`	`420`
`@@ -482,11 +487,13 @@ pub mod batcher {`
`482`	`487`
`483`	`488`	`impl<D, T, R> ContainerQueue<Column<(D, T, R)>> for ColumnQueue<(D, T, R)>`
`484`	`489`	`where`
`485`		`- D: for<'a> Columnar<Ref<'a>: Ord>,`
`486`		`- T: for<'a> Columnar<Ref<'a>: Ord>,`
	`490`	`+ D: for<'a> Columnar,`
	`491`	`+ for<'b> columnar::Ref<'b, D>: Ord,`
	`492`	`+ T: for<'a> Columnar,`
	`493`	`+ for<'b> columnar::Ref<'b, T>: Ord,`
`487`	`494`	`R: Columnar,`
`488`	`495`	`{`
`489`		`- fn next_or_alloc(&mut self) -> Result<<(D, T, R) as Columnar>::Ref<'_>, Column<(D, T, R)>> {`
	`496`	`+ fn next_or_alloc(&mut self) -> Result<columnar::Ref<(D, T, R)>, Column<(D, T, R)>> {`
`490`	`497`	`if self.is_empty() {`
`491`	`498`	`Err(std::mem::take(&mut self.list))`
`492`	`499`	`}`
`@@ -510,12 +517,12 @@ pub mod batcher {`
`510`	`517`	`}`
`511`	`518`
`512`	`519`	`impl<T: Columnar> ColumnQueue<T> {`
`513`		`- fn pop(&mut self) -> T::Ref<'_> {`
	`520`	`+ fn pop(&mut self) -> columnar::Ref<T> {`
`514`	`521`	`self.head += 1;`
`515`	`522`	`self.list.get(self.head - 1)`
`516`	`523`	`}`
`517`	`524`
`518`		`- fn peek(&self) -> T::Ref<'_> {`
	`525`	`+ fn peek(&self) -> columnar::Ref<T> {`
`519`	`526`	`self.list.get(self.head)`
`520`	`527`	`}`
`521`	`528`	`}`