Use PiecewiseSequence indices for FSL take

[danking]

Summary

Ports the TakeSlices-style optimization to Take(elements, PiecewiseSequenceArray) instead of introducing a value-wrapper API.

• FSL take now builds one start per selected list, a constant list length, and a constant multiplier of 1, then calls elements.take(piecewise_indices).
• Primitive, bool, decimal, VarBinView, and VarBin take paths detect PiecewiseSequenceArray indices and gather contiguous ranges only when multipliers is a constant unsigned 1; non-unit multipliers fall back through normal materialized-index take.
• Shared PiecewiseSequence execution handles general start + j * multiplier sequences, while the current optimized consumers stay explicitly contiguous.

Validation

• cargo fmt -p vortex-array
• cargo test -p vortex-array piecewise_sequence
• cargo check -p vortex-array
• cargo check -p vortex-array --benches
• git diff --check

[codspeed-hq]

Merging this PR will regress 2 benchmarks

⚠️ Different runtime environments detected

Some benchmarks with significant performance changes were compared across different runtime environments,
which may affect the accuracy of the results.

Open the report in CodSpeed to investigate

⚡ 19 improved benchmarks
❌ 2 regressed benchmarks
✅ 1649 untouched benchmarks
🆕 128 new benchmarks
⏩ 52 skipped benchmarks¹

Warning

Please fix the performance issues or acknowledge them on CodSpeed.

Performance Changes

	Mode	Benchmark	BASE	HEAD	Efficiency
❌	Simulation	decode_varbin[(1000, 4)]	26.1 µs	34.1 µs	-23.32%
❌	Simulation	true_count_vortex_buffer[128]	522.2 ns	580.6 ns	-10.05%
⚡	Simulation	take_fsl_random[1024, 1000]	15.2 ms	6 ms	×2.5
⚡	Simulation	take_fsl_nullable_random[1024, 1000]	14.8 ms	6 ms	×2.5
⚡	Simulation	take_fsl_random[256, 1000]	3.5 ms	1.6 ms	×2.2
⚡	Simulation	take_fsl_nullable_random[256, 1000]	3.4 ms	1.6 ms	×2.1
⚡	Simulation	take_fsl_random[1024, 100]	1,567.8 µs	799.3 µs	+96.14%
⚡	Simulation	take_fsl_nullable_random[1024, 100]	1,535.6 µs	811.9 µs	+89.12%
⚡	Simulation	copy_nullable[65536]	1,027.9 µs	573.6 µs	+79.2%
⚡	Simulation	take_fsl_random[256, 100]	418.1 µs	239 µs	+74.92%
⚡	Simulation	take_fsl_random[64, 1000]	815.6 µs	466.6 µs	+74.79%
⚡	Simulation	take_fsl_nullable_random[64, 1000]	811.9 µs	477.3 µs	+70.11%
⚡	Simulation	take_fsl_nullable_random[256, 100]	415.5 µs	252.1 µs	+64.82%
⚡	Simulation	take_fsl_nullable_random[16, 1000]	257.6 µs	199.3 µs	+29.28%
⚡	Simulation	take_fsl_random[16, 1000]	237.7 µs	189.4 µs	+25.55%
⚡	Simulation	take_fsl_random[4096, 1000]	67.3 ms	54.2 ms	+24.16%
⚡	Simulation	take_fsl_random[64, 100]	123 µs	99.3 µs	+23.8%
⚡	Simulation	take_fsl_nullable_random[4096, 1000]	65.6 ms	54.3 ms	+20.89%
⚡	Simulation	take_fsl_nullable_random[64, 100]	131.5 µs	111.9 µs	+17.51%
⚡	Simulation	copy_non_nullable[65536]	908.7 µs	794.3 µs	+14.4%
...	...	...	...	...	...

ℹ️ Only the first 20 benchmarks are displayed. Go to the app to view all benchmarks.

Tip

Investigate this regression by commenting @codspeedbot fix this regression on this PR, or directly use the CodSpeed MCP with your agent.

---

_{Comparing codex/piecewise-sequential-take (d694338) with codex/piecewise-sequential-array (2b6fa3e)}

Footnotes

1. 52 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

[robert3005]

the slice will validate them

[robert3005]

eh, we need my refactor pr to extract the ref from view

[robert3005]

this is already validated by the result slice

[robert3005]

so imho you either keep this and convert the loop below all into unsafe accesses or remove this and use the optional getters on slice

[robert3005]

I think this would be better if you had the mutable result and then wrote directly into the next available range result[curr..][..length]

[robert3005]

I think validity take already handles this

[robert3005]

I think we have to audit the validation from the compute and verify that we do not do the work twice. We have to audit exactly but ideally we'd not validate and figure out how to make operations safe by default even given bad input.