fix: correct SQLite div_i formula for small dividends

[queelius]

Summary

• Fixes the SQLite div_i formula which produced wrong results (e.g., -1 instead of 0) when |dividend| < |divisor|
• Replaces ROUND(ABS(l/r) - 0.5) with CAST(ABS(l * 1.0 / r) AS INTEGER) for correct truncation-towards-zero semantics
• Adds a regression test for this case

Fixes #5735

Root Cause

The old SQLite formula ROUND(ABS({l} / {r}) - 0.5) * SIGN({l}) * SIGN({r}) broke when both operands were integers and |l| < |r|:

1. SQLite integer division: 1 / 2 = 0
2. ABS(0) - 0.5 = -0.5
3. ROUND(-0.5) = -1 (SQLite rounds away from zero)
4. Result: -1 instead of expected 0

Verified with actual SQLite: the old formula gave wrong results for 1//2, -1//2, 3//7, -3//7, etc.

Fix

Force float division with * 1.0, then use CAST(... AS INTEGER) which truncates towards zero in SQLite -- exactly matching integer division semantics.

Test plan

• Verified fix produces correct results for all test cases in actual SQLite
• Added test_sqlite_integer_division regression test
• All 449 existing prqlc tests pass
• Updated compileall snapshot for arithmetic test

Generated with Claude Code

[Copilot]

Pull request overview

This PR fixes PRQL’s SQLite implementation of integer division (//) to correctly return 0 when |dividend| < |divisor|, and updates integration snapshots/tests to prevent regressions.

Changes:

• Update SQLite div_i translation in std.sql.prql to use CAST(... AS INTEGER) truncation semantics.
• Add an integration regression test covering a // b compilation for SQLite.
• Refresh the compileall arithmetic snapshot to reflect updated SQLite integer-division SQL.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 1 comment.

File	Description
prqlc/prqlc/src/sql/std.sql.prql	Updates SQLite div_i SQL formula used to compile the // operator.
prqlc/prqlc/tests/integration/sql.rs	Adds a regression test snapshot for the SQLite a // b compilation output.
prqlc/prqlc/tests/integration/snapshots/integration__queries__compileall__arithmetic.snap	Updates the arithmetic compileall snapshot to match new SQLite integer-division output.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

div_i forces floating-point division via * 1.0. In SQLite that can introduce precision loss for large 64-bit integers (e.g., values > 2^53), producing an off-by-one quotient after CAST(... AS INTEGER) even when the exact integer-division result would fit exactly. Since CAST(... AS INTEGER) already truncates toward zero, consider removing the float coercion and casting the / result directly (or casting ABS(l / r)), so integer operands keep exact integer arithmetic while floats still truncate correctly.

Suggested change

	let div_i = l r -> s"CAST(ABS({l:11} * 1.0 / {r:12}) AS INTEGER) * SIGN({l:0}) * SIGN({r:0})"
	let div_i = l r -> s"CAST(ABS({l:11} / {r:12}) AS INTEGER) * SIGN({l:0}) * SIGN({r:0})"

[max-sixty]

thanks @queelius !