feat(rust/sedona-functions): Implement ST_Affine(), ST_Rotate(), and ST_Scale() #504

yutannihilation · 2026-01-11T03:23:58Z

This pull request implements ST_Affine(), ST_Rotate and ST_Scale using the glam crate. I chose glam because

while affine transformation is probably not very hard to implement, I might make some silly mistakes
glam is widely used
glam doesn't require any additional dependency by default

but I don't have strong opinion. If it is desirable to implement from scratch, I can do so.

> SELECT ST_Affine(ST_GeomFromText('POLYGON ZM ((1 0 1 1, 1 1 1 1, 2 2 2 1, 1 0 1 1))'), 10, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0);
┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ st_affine(st_geomfromtext(Utf8("POLYGON ZM ((1 0 1 1, 1 1 1 1, 2 2 2 1, 1 0 1 1))")),Int64(10),Int64(0),Int64(0),Int64(0),Int64(10),Int64(0),Int64(0),Int64(0),Int64(10),Int64(0),Int64(0),Int64(0)) │
│                                                                                               geometry                                                                                               │
╞══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╡
│ POLYGON ZM((10 0 10 1,10 10 10 1,20 20 20 1,10 0 10 1))                                                                                                                                              │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

yutannihilation · 2026-01-11T09:20:35Z

I was hoping to add the variants with origin of rotation or scaling, but, since this pull request is already a bit lengthy, I think it's probably better to address in a separate pull request.

paleolimbot

Thank you! This has to be the most arguments I have ever seen in a SQL function and managing all of them is a pain that you've nicely abstracted here.

using the glam crate.

I think this is OK. We sort of have this for 2D already but I'm not sure that will simplify this PR given the 3D support. If we do inline this we should do it in sedona-geometry and add the appropriate tests.

I was hoping to add the variants with origin of rotation or scaling, but, since this pull request is already a bit lengthy, I think it's probably better to address in a separate pull request.

Great!

paleolimbot · 2026-01-12T15:29:58Z

rust/sedona-functions/src/st_affine.rs

+        let executor = WkbExecutor::new(arg_types, args);
+        let mut builder = BinaryBuilder::with_capacity(
+            executor.num_iterations(),
+            WKB_MIN_PROBABLE_BYTES * executor.num_iterations(),


No need to do this here because I think we need a helper for it to be compact, but in this particular case we know the output will have the exact number of bytes as the input)

Ah, true. Thanks for catching.

paleolimbot · 2026-01-12T15:47:16Z

rust/sedona-functions/src/st_affine_helpers.rs

+    match geom.as_type() {
+        geo_traits::GeometryType::Point(pt) => {
+            if pt.coord().is_some() {
+                write_wkb_point_header(writer, dims)
+                    .map_err(|e| DataFusionError::Execution(e.to_string()))?;
+                write_transformed_coord(writer, pt.coord().unwrap(), mat, dim)?;
+            } else {
+                write_wkb_empty_point(writer, dims)
+                    .map_err(|e| DataFusionError::Execution(e.to_string()))?;
+            }
+        }
+


If this can be written as a CrsTransform we might be able re-use some existing infrastructure:

sedona-db/rust/sedona-functions/src/st_translate.rs

Lines 123 to 135 in 9bf02f4

#[derive(Debug)]

struct Translate {

deltax: f64,

deltay: f64,

}

impl CrsTransform for Translate {

fn transform_coord(&self, coord: &mut (f64, f64)) -> Result<(), SedonaGeometryError> {

coord.0 += self.deltax;

coord.1 += self.deltay;

Ok(())

}

}

sedona-db/rust/sedona-functions/src/st_translate.rs

Lines 106 to 108 in 9bf02f4

let trans = Translate { deltax, deltay };

transform(wkb, &trans, &mut builder)

.map_err(|e| DataFusionError::External(Box::new(e)))?;

https://github.com/apache/sedona-db/blob/main/rust/sedona-geometry/src/transform.rs#L259-L263

There's a chance what you have here is faster, though (no dyn like our current transform()), and we haven't implemented non-XY support for the CrsTransform yet ( #47 ).

No need to take on any of that here (I'll just add a note to that issue that we can update this section when we do get there).

Sounds good to me. I'll try.

(As translation can also be handled by affine transformation, I was wondering if ST_Transform can also be implemented using glam. But, I guess there will be not much difference)

paleolimbot · 2026-01-12T15:53:16Z

rust/sedona-functions/src/st_affine_helpers.rs

+fn write_transformed_coords<I>(
+    writer: &mut impl Write,
+    coords: I,
+    affine: &DAffine,
+    dim: &geo_traits::Dimensions,
+) -> Result<()>
+where
+    I: DoubleEndedIterator,
+    I::Item: CoordTrait<T = f64>,
+{
+    coords
+        .into_iter()
+        .try_for_each(|coord| write_transformed_coord(writer, coord, affine, dim))
+}
+
+fn write_transformed_coord<C>(
+    writer: &mut impl Write,
+    coord: C,
+    affine: &DAffine,
+    dim: &geo_traits::Dimensions,
+) -> Result<()>


(Optional) It may be unfounded, but my intuition would be that match (dim) should be in write_transformed_coords() to avoid a match() for every coordinate. Perhaps the compiler does this anyway or the transform operation is sufficiently expensive that it doesn't matter 🙂

rust/sedona-functions/src/st_affine_helpers.rs

paleolimbot · 2026-01-12T16:19:47Z

rust/sedona-functions/src/st_affine_helpers.rs

+pub(crate) struct DAffine2Iterator<'a> {
+    index: usize,
+    a: &'a PrimitiveArray<Float64Type>,
+    b: &'a PrimitiveArray<Float64Type>,
+    d: &'a PrimitiveArray<Float64Type>,
+    e: &'a PrimitiveArray<Float64Type>,
+    x_offset: &'a PrimitiveArray<Float64Type>,
+    y_offset: &'a PrimitiveArray<Float64Type>,
+}


Do we need multiple versions of this (e.g., can the core logic be distilled to struct NumericArgs { args: Vec<&'a PrimitiveArray<Float64Type>> }? Or maybe the lifetimes make this difficult?).

My reading of these is that they don't handle nulls in any of the arguments. I am not sure if it's optimizing this but you could check ahead of time if the null_count() is >0 for any of the inputs and use the slower iterator if this is the case.

rust/sedona-functions/src/st_affine_helpers.rs

rust/sedona-functions/src/st_affine.rs

python/sedonadb/tests/functions/test_functions.py

Co-authored-by: Dewey Dunnington <[email protected]>

yutannihilation

Thanks for reviewing (and sorry for a bit massive PR)! I'll try using CrsTransform.

python/sedonadb/tests/functions/test_functions.py

yutannihilation · 2026-01-12T22:54:57Z

rust/sedona-functions/src/st_affine.rs

+        let executor = WkbExecutor::new(arg_types, args);
+        let mut builder = BinaryBuilder::with_capacity(
+            executor.num_iterations(),
+            WKB_MIN_PROBABLE_BYTES * executor.num_iterations(),


Ah, true. Thanks for catching.

rust/sedona-functions/src/st_affine.rs

yutannihilation · 2026-01-12T23:09:00Z

rust/sedona-functions/src/st_affine_helpers.rs

+    match geom.as_type() {
+        geo_traits::GeometryType::Point(pt) => {
+            if pt.coord().is_some() {
+                write_wkb_point_header(writer, dims)
+                    .map_err(|e| DataFusionError::Execution(e.to_string()))?;
+                write_transformed_coord(writer, pt.coord().unwrap(), mat, dim)?;
+            } else {
+                write_wkb_empty_point(writer, dims)
+                    .map_err(|e| DataFusionError::Execution(e.to_string()))?;
+            }
+        }
+


Sounds good to me. I'll try.

(As translation can also be handled by affine transformation, I was wondering if ST_Transform can also be implemented using glam. But, I guess there will be not much difference)

rust/sedona-geometry/src/transform.rs

yutannihilation · 2026-01-13T14:34:56Z

I think I addressed most of the comments. Thanks for the advices!

paleolimbot

I tried to get through all of this before the end of the day but I may have missed some things. Thank you for these edits...I think it is very close!

rust/sedona-geometry/src/transform.rs

rust/sedona-functions/src/st_rotate.rs

rust/sedona-functions/src/st_affine.rs

rust/sedona-functions/src/st_scale.rs

rust/sedona-functions/src/st_affine_helpers.rs

Co-authored-by: Dewey Dunnington <[email protected]>

paleolimbot

Thank you!

yutannihilation · 2026-01-14T02:29:25Z

Thanks so much for reviewing!

yutannihilation and others added 23 commits January 11, 2026 00:37

WIP

6c9da22

Implement 3D affine transformation

b9d2e25

Add 2D case

f40a866

Handle 2D cases

ef26770

Add some tests

d955709

Add 3d tests

c61a88c

Address clippy warning

3497421

Handle 2D/3D transparently

2d50588

Separate code

3c597e4

Add tests for item CRS

a397fca

Add Python tests

fb30f51

Format

06374f5

Add license header

cb6704d

Add methods for ST_Rotate and ST_Scale

5ecb2a4

Tweak

a4fe16f

Add ST_Rotate

991d891

Tweak documents

e918c01

Remove unnecessary pub(crate) and add RotateAxis

9191089

Add ST_RotateX and ST_RotateY

7b07c46

Add st_scale

f8bd92c

Refactor

95110a5

Add tests

6eb411c

Merge remote-tracking branch 'upstream/main' into feat/st_affine

427566d

yutannihilation force-pushed the feat/st_affine branch from 04322a3 to 427566d Compare January 11, 2026 09:13

yutannihilation changed the title ~~feat(rust/sedona-functions): Implement ST_Affine()~~ feat(rust/sedona-functions): Implement ST_Affine(), ST_Rotate(), and ST_Scale() Jan 11, 2026

yutannihilation marked this pull request as ready for review January 11, 2026 09:17

yutannihilation and others added 2 commits January 11, 2026 18:33

Don't run ST_Rotate Rust tests

887d9c0

Remove tests

c33effe

paleolimbot reviewed Jan 12, 2026

View reviewed changes

Apply suggestions from code review

eee527c

Co-authored-by: Dewey Dunnington <[email protected]>

yutannihilation commented Jan 12, 2026

View reviewed changes

yutannihilation marked this pull request as draft January 12, 2026 23:16

yutannihilation and others added 8 commits January 13, 2026 08:20

Import sedona_internal_err

561cc69

Improve tests

0080ebb

Move match to upper

6e15c46

Add more tests

9aeb3f0

Let CrsTransform accept 3D

0eaa255

Use CrsTransform

9bb269c

Handle NULL

77de26f

Add more tests

ce14c46

yutannihilation commented Jan 13, 2026

View reviewed changes

rust/sedona-geometry/src/transform.rs Show resolved Hide resolved

yutannihilation marked this pull request as ready for review January 13, 2026 14:34

yutannihilation added 2 commits January 14, 2026 07:27

Return early

5bb7568

any_null -> no_null

2d91b53

paleolimbot reviewed Jan 13, 2026

View reviewed changes

yutannihilation and others added 7 commits January 14, 2026 08:29

Improve test code

517983b

Co-authored-by: Dewey Dunnington <[email protected]>

Remove unused imports

e9af8c0

Tweak tests

294fbc5

Add simple Python tests for ST_RotateX and ST_RotateY

79a4bb9

Add a simple test in st_affine_helpers

f6e5c4d

Add 3D test cases for CrsTransform

d3e034e

Add more simple tests in ST_Rotate

0ade209

yutannihilation mentioned this pull request Jan 14, 2026

rust/sedona-functions: make ST_Translate accept deltaZ arg #511

Open

paleolimbot approved these changes Jan 14, 2026

View reviewed changes

paleolimbot merged commit 3f4acd0 into apache:main Jan 14, 2026
15 checks passed

yutannihilation deleted the feat/st_affine branch January 14, 2026 02:27

	#[derive(Debug)]
	struct Translate {
	deltax: f64,
	deltay: f64,
	}

	impl CrsTransform for Translate {
	fn transform_coord(&self, coord: &mut (f64, f64)) -> Result<(), SedonaGeometryError> {
	coord.0 += self.deltax;
	coord.1 += self.deltay;
	Ok(())
	}
	}

	let trans = Translate { deltax, deltay };
	transform(wkb, &trans, &mut builder)
	.map_err(\|e\| DataFusionError::External(Box::new(e)))?;

feat(rust/sedona-functions): Implement ST_Affine(), ST_Rotate(), and ST_Scale() #504

feat(rust/sedona-functions): Implement ST_Affine(), ST_Rotate(), and ST_Scale() #504

Uh oh!

Conversation

yutannihilation commented Jan 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

yutannihilation commented Jan 11, 2026

Uh oh!

paleolimbot left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

yutannihilation left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

yutannihilation commented Jan 13, 2026

Uh oh!

paleolimbot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

paleolimbot left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

yutannihilation commented Jan 14, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

yutannihilation commented Jan 11, 2026 •

edited

Loading