T_SQL query extreme value - sql

Question

There is a table T, with a random value in id, How with one select we can get extreme value of id in input .
example :
T.id =
12
34
76
89
1234
1254
6789
3456
For input we give select id=1254, as output we have to get two values 1234 and 6789

Answer 1

You can do It in following:
SAMPLE DATE
CREATE TABLE #Test (ID INT)
INSERT INTO #Test VALUES (12),(34),(76),(89),(1234),(1254),(6789),(3456)
INPUT
DECLARE #var INT = 1234
QUERY
;WITH cte AS
(
SELECT Id,
ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) rn1
FROM #Test t
)
SELECT PrevId, NextId
FROM cte
LEFT JOIN (
SELECT Id PrevId,
ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) rn
FROM #Test t1
) previd ON cte.rn1 = previd.rn +1
LEFT JOIN (
SELECT Id NextId,
ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) rn
FROM #Test t1
) nextid ON cte.rn1 = nextid.rn -1
WHERE cte.Id = #var
OUTPUT
PrevId NextId
89 1254
DEMO
You can test It at SQL FIDDLE

Answer 2

You can use conditional aggregation:
select max(case when id < 1254 then id end) as prev,
min(case when id > 1254 then id end) as next
from t;
A similar approach produces two rows but is more efficient if you have indexes:
select 'prev', max(id)
from t
where id < 1254
union all
select 'next', min(id)
from t
where id > 1254;
EDIT:
I seem to have missed that the ids are out of order. In that case, you need to assume that there is a column that specifies the ordering of the data. SQL tables represent unordered sets, so there is no next or previous value. You can handle this using window functions if you have a column for ordering:
with n as (
select t.*, row_number() over (order by <ordering column goes here>) as seqnum
from t
)
select max(case when seqnum = theseqnum - 1 then id end) as prev_id,
max(case when seqnum = theseqnum + 1 then id end) as next_id
from (select n.*,
max(case when id = 1254 then seqnum end) as theseqnum
from n
) n
where seqnum = theseqnum - 1 or seqnum = thesequm + 1;

Answer 3

You did not mention which SQL Server version you're using. If it's 2012+ you can use LAG() and LEAD() functions to achieve that quite fast:
LAG:
Accesses data from a previous row in the same result set without the
use of a self-join in SQL Server 2012+. LAG provides access to a row
at a given physical offset that comes before the current row. Use this
analytic function in a SELECT statement to compare values in the
current row with values in a previous row.
LEAD:
Accesses data from a subsequent row in the same result set without the
use of a self-join in SQL Server 2012+. LEAD provides access to a row
at a given physical offset that follows the current row. Use this
analytic function in a SELECT statement to compare values in the
current row with values in a following row.
Here's an example:
DECLARE #Test TABLE
(
ID INT
);
INSERT INTO #Test
VALUES (12)
, (34)
, (76)
, (89)
, (1234)
, (1254)
, (6789)
, (3456);
;WITH CTE (ID, Prev, Next, Extreme)
AS (
SELECT ID
, LAG(ID) OVER (ORDER BY (SELECT NULL))
, LEAD(ID) OVER (ORDER BY (SELECT NULL))
, MAX(ID) OVER ()
FROM #Test
)
SELECT *
FROM CTE
WHERE ID = 1234;
This query returns
╔══════╦══════╦══════╦═════════╗
║ ID ║ Prev ║ Next ║ Extreme ║
╠══════╬══════╬══════╬═════════╣
║ 1234 ║ 89 ║ 1254 ║ 6789 ║
╚══════╩══════╩══════╩═════════╝
As stated by lad2025, this and as well answered query will break if sql server optimizer decides to use parallelism.
Using OPTION(MAXDOP 1) hint might solve it. It tells sql server not to use parallelism. Only correct way would be having column, that you could give stable order for your data set.