T-SQL : how to disable overflow checks on integer operations? - tsql

Question

In C# we have unchecked to disable overflow checks on integer operations
int int1;
unchecked
{
int1 = 2147483647 + 10;
}
The integer arithmetic result will wrap to -2,147,483,639
But in T-SQL I can't find a way to disable bounds checks
DECLARE #INT1 INT
SET #INT1 = 2147483647 + 10
Results in error:
Msg 8115, Level 16, State 2, Line 2
Arithmetic overflow error converting expression to data type int.

Answer 1

Not that I think this is necessarily a great idea, but you could wrap it in a try/catch.
declare #int int;
begin try
set #int = 2147483647 + 10
end try
begin catch
if ERROR_NUMBER() = 8115
set #int = 2147483647
else
select
ERROR_NUMBER() AS ErrorNumber
,ERROR_MESSAGE() AS ErrorMessage;
end catch
select #int
Result:
2147483647

Answer 2

It's not possible to perform that operation (2147483647 + 10) since the INT data type ranges from -2,147,483,648 to 2,147,483,647, according to the Microsoft specification.
Instead, you can use the BIGINT data type, like this:
DECLARE #number BIGINT;
SET #number = CAST(2147483647 AS BIGINT) + 10;
SELECT #number;
-- Output: 2147483657, as expected

Answer 3

You can cast the int values to bigint, perform the addition and then handle the overflow while converting back to an int using a case expression thusly:
declare #MaxInt as BigInt = Power( Cast( 2 as BigInt ), 31 ) - 1;
declare #Foo as Int = 2147483647;
declare #Bar as Int = 10;
declare #BigSum as BigInt;
set #BigSum = #Foo + Cast( 10 as BigInt );
select #MaxInt as MaxInt, #Foo as Foo, #Bar as Bar, #BigSum as BigSum,
case when #BigSum <= #MaxInt then Cast( #BigSum as Int ) else
Cast( #BigSum - Power( Cast( 2 as BigInt ), 32 ) as Int ) end as Unsigned;
Update: A tidier example showing how to take a BigInt result (from prior calculations) and convert it to an Int without overflow:
declare #Samples as Table ( Value BigInt );
insert into #Samples ( Value ) values
-- NB: At least one literal value needs to be cast as a BigInt to get BigInt values. No, really.
( Cast( 0x0 as BigInt ) ), ( 0x1 ), ( 0x7FFFFFFF ), ( 0x80000000 ), ( 0x80000001 ), ( 0xFFFFFFFF ),
( -1 ), ( 0x4200000001 ), ( 0x7080000000 ); -- Some BigInt values beyond 32 bits.
select Value, Cast( Value as Binary(8) ) as ValueHex,
Value & 0xFFFFFFFF as LSB32, Cast( Value & 0xFFFFFFFF as Binary(8) ) as LSB32Hex,
Cast( case when Value & 0x80000000 = 0 then Value & 0xFFFFFFFF else
( Value & 0x7FFFFFFF ) - Cast( 0x80000000 as BigInt ) end as Int ) as IntResult
from #Samples;
The conversion could be bundled off into a UDF, though the performance may suffer.

Answer 4

I've not found a way to allow integer operations to overflow.
As others have said you just have to do the operation on the value converted to BIGINT instead.
You can (if you want) then convert the result of the operation back to an INT - as though it was an unchecked int operation - and the key to that is to just take the result MOD 2^32 (in SQL Server "%" is the MOD operation)
Heres a little function I've written to convert a BIGINT to an INT unchecked (ie allowing overflow) that will also handle negative values
CREATE FUNCTION dbo.BigIntToUncheckedInt(#input BIGINT)
RETURNS INT AS
BEGIN
-- select the result MOD 2^32 (the max of an unsigned int)
-- this will give a result < 4294967296 (if +ve input), or > -4294967296 (if -ve input)
SELECT #input = #input % 4294967296
-- if we have the result > INT MaxVal - do one final subtraction of 2^32 (resulting in a valid negative INT)
IF #input > 2147483647 BEGIN SELECT #input = #input - 4294967296 END
-- if we have the result < INT MinVal - do one final addition of 2^32 (resulting in a valid positive INT)
IF #input < -2147483648 BEGIN SELECT #input = #input + 4294967296 END
RETURN CAST(#input AS INT)
END
GO
You can then do whatever operation you want and convert it back to an INT (unchecked) with this function, eg:
DECLARE #INT1 BIGINT
SET #INT1 = CAST(2147483647 AS BIGINT) + 10
SELECT dbo.BigIntToUncheckedInt(#INT1)
-- result = -2147483639