I have two tables, Category and Member:
Category: Member:
+--Id--+--Name--+ +--Id--+--Name--+--CategoryId--+
| 1 | Cat1 | | 1 | Mem1 | 2 |
| 2 | Cat2 | | 2 | Mem2 | 2 |
| 3 | Cat3 | | 3 | Mem3 | 1 |
+------+--------+ | 4 | Mem4 | 3 |
| 5 | Mem5 | 1 |
| 6 | Mem6 | 3 |
+------+--------+--------------+
I would like to have a query that gives the following output:
Combined:
+--Name--+--IsCategory--+
| Cat1 | True |
| Mem3 | False |
| Mem5 | False |
| Cat2 | True |
| Mem1 | False |
| Mem2 | False |
| Cat3 | True |
| Mem4 | False |
| Mem6 | False |
+--------+--------------+
I know how to use JOIN to output every Member with its Category name in one row and how to use UNION to list all Categories and Members in one output. Can I use a combination of these two commands to achieve the desired output? Or do I need to perform a FOR EACH loop somehow? Is it even possible to get what I want?
EDIT:
The order Cat1, Mem3, Mem5, Cat2, Mem1, Mem2,... is important for me.
JUST i tried like this can u check it
CREATE TABLE #Category
([Id] int, [Name] varchar(4))
INSERT INTO #Category
([Id], [Name])
VALUES
(1, 'Cat1'),
(2, 'Cat2'),
(3, 'Cat3')
CREATE TABLE #Member
([Id] int, [Name] varchar(4), [CategoryId] int)
;
INSERT INTO #Member
([Id], [Name], [CategoryId])
VALUES
(1, 'Mem1', 2),
(2, 'Mem2', 2),
(3, 'Mem3', 1),
(4, 'Mem4', 3),
(5, 'Mem5', 1),
(6, 'Mem6', 3)
SELECT NAME , CASE WHEN NAME LIKE'%CAT%' THEN 'TRUE' ELSE 'FALSE' END AS IS_CATEGORY FROM (SELECT * FROM #MEMBER UNION ALL
SELECT *,NULL AS COLUMN1 FROM #CATEGORY )A
output
NAME IS_CATEGORY
Mem1 FALSE
Mem2 FALSE
Mem3 FALSE
Mem4 FALSE
Mem5 FALSE
Mem6 FALSE
Cat1 TRUE
Cat2 TRUE
Cat3 TRUE
You can use union for this:
SELECT name, 0 as IsCategory
FROM member
UNION ALL
SELECT name, 1
FROM category
Based on the answers of #Chanukya and #Zohar Peled I found the following solution:
SELECT Name, IsCategory FROM
(SELECT Name as Name, 1 as IsCategory, id * 10000 as OrderNumber
FROM Category
UNION ALL
SELECT m.Name as Name, 0, c.id * 10000 + m.id as OrderNumber
FROM Members b JOIN Category c ON m.CategoryId = c.Id
) AS temp
ORDER BY OrderNumber;
This assumes that there are no more than 10000 members per category, which is fine for my current use case. However, I appreciate any suggestions for a more elegant and correct way.
Related
Let's say I have a table I want to update based on multiple conditions. Each of these conditions is an equal-sized array, and the only valid cases are the ones which match the same index in the arrays.
That is, if we use the following SQL clause
UPDATE Foo
SET bar = 1
WHERE a IN ( 1, 2, 3, 4, 5)
AND b IN ( 6, 7, 8, 9, 0)
AND c IN ('a', 'b', 'c', 'd', 'e')
bar will be set to 1 for any row which has, for example, a = 1, b = 8, c = 'e'.
That is not what I want.
I need a clause where only a = 1, b = 6, c = 'a' or a = 2, b = 7, c = 'b' (etc.) works.
Obviously I could rewrite the clause as
UPDATE Foo
SET bar = 1
WHERE (a = 1 AND b = 6 AND c = 'a')
OR (a = 2 AND b = 7 AND c = 'b')
OR ...
This would work, but it's hardly extensible. Given the values of the conditions are variable and obtained programmatically, it'd be far better if I could set each array in one place instead of having to build a string-building loop to get that WHERE call right.
So, is there a better, more elegant way to have the same behavior as this last block?
Use the Table Values Constructor :
UPDATE f
SET bar = 1
WHERE EXISTS (
SELECT * FROM (VALUES (1,6,'a'),(2,7,'b'),(3,8,'c')) AS Trios(a,b,c)
WHERE Trios.a = f.a AND Trios.b = f.b AND Trios.c = f.c
)
You can use values() and join:
UPDATE f
SET bar = 1
FROM Foo f JOIN
(VALUES (1, 6, 'a'),
(2, 7, 'b'),
. . .
) v(a, b, c)
ON f.a = v.a AND f.b = v.b AND f.c = v.c;
Try this might work
DECLARE #Temp AS Table ( a int, b int, c varchar(50))
INSERT INTO #Temp(a,b,c)
VALUES(1, 6, 'a'),
(2, 7, 'b'),
(3, 8, 'c'),
(4, 9, 'd'),
(5, 0, 'e')
UPDATE F
SET bar = 1
FROM FOO F INNER JOIN #Temp T
ON F.a = T.a AND F.b = T.b AND F.c = T.c
When you read the data don't save it as separated values but as a single string and then use the following:
update foo
set bar = 1
where concat(a,b,c) in ('16a','27b','38c','49d','50e')
it may not be the most elegant way but it is very practical and simple.
I could be entirely off the mark here--I'm not sure if you're passing in a set of values or what-have-you--but my first thought is using a series of CTEs.
I'm making considerable assumptions about your data, but here's an example you can run in SSMS based on my thoughts of your question.
-- Create #Data and insert some, er... data ---
DECLARE #Data TABLE ( id INT IDENTITY(100,1) PRIMARY KEY, a VARCHAR(1), b VARCHAR(1), c VARCHAR(1) );
INSERT INTO #Data ( a ) VALUES ('1'), ('2'), ('3'), ('4'), ('5');
INSERT INTO #Data ( b ) VALUES ('6'), ('7'), ('8'), ('9'), ('0');
INSERT INTO #Data ( c ) VALUES ('a'), ('b'), ('c'), ('d'), ('e');
So let's assume this is your data. I've kept it simple to make it easier to understand.
+-----+---+---+---+
| id | a | b | c |
+-----+---+---+---+
| 100 | 1 | | |
| 101 | 2 | | |
| 102 | 3 | | |
| 103 | 4 | | |
| 104 | 5 | | |
| 105 | | 6 | |
| 106 | | 7 | |
| 107 | | 8 | |
| 108 | | 9 | |
| 109 | | 0 | |
| 110 | | | a |
| 111 | | | b |
| 112 | | | c |
| 113 | | | d |
| 114 | | | e |
+-----+---+---+---+
Query the data with aligned "array" indexes:
;WITH CTE_A AS (
SELECT
id,
ROW_NUMBER() OVER ( ORDER BY id ) AS a_row_id,
a
FROM #Data WHERE a IS NOT NULL
)
, CTE_B AS (
SELECT
id,
ROW_NUMBER() OVER ( ORDER BY id ) AS b_row_id,
b
FROM #Data WHERE b IS NOT NULL
)
, CTE_C AS (
SELECT
id,
ROW_NUMBER() OVER ( ORDER BY id ) AS c_row_id,
c
FROM #Data WHERE c IS NOT NULL
)
SELECT
CTE_A.id, CTE_A.a_row_id, CTE_A.a
, CTE_B.id, CTE_B.b_row_id, CTE_B.b
, CTE_C.id, CTE_C.c_row_id, CTE_C.c
FROM CTE_A
JOIN CTE_B ON CTE_A.a_row_id = CTE_B.b_row_id
JOIN CTE_C ON CTE_A.a_row_id = CTE_C.c_row_id;
Which returns:
+-----+----------+---+-----+----------+---+-----+----------+---+
| id | a_row_id | a | id | b_row_id | b | id | c_row_id | c |
+-----+----------+---+-----+----------+---+-----+----------+---+
| 100 | 1 | 1 | 105 | 1 | 6 | 110 | 1 | a |
| 101 | 2 | 2 | 106 | 2 | 7 | 111 | 2 | b |
| 102 | 3 | 3 | 107 | 3 | 8 | 112 | 3 | c |
| 103 | 4 | 4 | 108 | 4 | 9 | 113 | 4 | d |
| 104 | 5 | 5 | 109 | 5 | 0 | 114 | 5 | e |
+-----+----------+---+-----+----------+---+-----+----------+---+
Again, assumptions made on your data (in particular an id exists that can be sorted), but this basically pivots it by linking the a, b and c values on their relative "index" (ROW_NUMBER). By using ROW_NUMBER in this way, we can create a makeshift array index value ( a_row_id, b_row_id, c_row_id ) that can be used to join the resulting values.
This example can easily be changed to an UPDATE statement.
Does this address your question?
I have a schema as below
Test
--------------------
| Id | Name |
--------------------
| 1 | A001 |
| 2 | B001 |
| 3 | C001 |
--------------------
RelatedTest
---------------------------------
| Id | Name | TestId |
---------------------------------
| 1 | Jack | NULL |
| 2 | Joe | 2 |
| 3 | Jane | 3 |
| 4 | Julia | 3 |
---------------------------------
To briefly explain this schema RelatedTest has a nullable FK to Test and the FKId can appear either 0 or 1 or 2 times but never more than 2 times.
I am after a t-SQL query that reports the data in Test in the following format
TestReport
---------------------------------------------------------------------------
| TestId | TestName | RelatedTestName1 | RelatedTestName2 |
---------------------------------------------------------------------------
| 1 | A001 | NULL | NULL |
| 2 | B001 | Joe | NULL |
| 3 | C001 | Jane | Julia |
I can safely assume that TestReport will not need any more than two columns for RelatedTestName.
The schema is beyond my control and I am just looking to query it for some reporting.
I've been trying to utilise the Pivot function but I'm not entirely sure how I can use it so that RelatedTestName1 and RelatedTestName1 can be NULL in the case where there is no RelatedTest records. And also since RelatedTestName is a varchar I'm not sure how to apply an appropriate aggregate if that's what is needed.
Preparing Data:
DROP TABLE IF EXISTS Test
GO
CREATE TABLE Test (Id INT PRIMARY KEY, Name VARCHAR(10)) ON [PRIMARY]
GO
INSERT INTO Test Values
(1, 'A001')
,(2, 'B001')
,(3, 'C001')
GO
DROP TABLE IF EXISTS RelatedTest
GO
CREATE TABLE RelatedTest (
Id INT,
Name VARCHAR(10),
TestId INT FOREIGN KEY REFERENCES Test (Id)
) ON [PRIMARY]
GO
INSERT INTO RelatedTest Values
(1, 'Jack', NULL)
,(2, 'Joe', 2)
,(3, 'Jane', 3)
,(3, 'Julia', 3)
GO
Query:
;WITH CTE AS
(
SELECT TestId = T.Id
,TestName = T.Name
,RelatedTestName = RT.Name
,RN = ROW_NUMBER() OVER(PARTITION BY T.Id ORDER BY RT.Id ASC)
FROM Test T
LEFT JOIN RelatedTest RT
ON T.Id = RT.TestId
)
SELECT DISTINCT
C.TestId
,C.TestName
,RelatedTestName1 = (SELECT RelatedTestName FROM CTE A WHERE A.TestId = C.TestId AND A.RN = 1)
,RelatedTestName2 = (SELECT RelatedTestName FROM CTE A WHERE A.TestId = C.TestId AND A.RN = 2)
FROM CTE C;
I know this is a much asked question and I've had a look through whats already available but I believe my case is slightly unique (and if it's not please point me in the right direction).
I am trying to find the latest occurrence of a row associated to a user a currently across two tables and several columns.
table: statusUpdate
+-------+-----------+-----------+-------------------+
| id | name | status | date_change |
+-------+-----------+-----------+-------------------+
| 1 | Matt | 0 | 01-01-2001 |
| 2 | Jeff | 1 | 01-01-2001 |
| 3 | Jeff | 2 | 01-01-2002 |
| 4 | Bill | 2 | 01-01-2001 |
| 5 | Bill | 3 | 01-01-2004 |
+-------+-----------+-----------+-------------------+
table: relationship
+-------+-----------+--------------+
| id | userID |stautsUpdateID|
+-------+-----------+--------------+
| 1 | 22 | 1 |
| 2 | 33 | 2 |
| 3 | 33 | 3 |
| 4 | 44 | 4 |
| 5 | 44 | 5 |
+-------+-----------+--------------+
There is a third table which links userID to its own table but these sample tables should be good enough to get my question over.
I am looking to get the latest status change by date. The problem currently is that it returns all instances of a status change.
Current results:
+-------+---------+-----------+-------------------+
|userID |statusID | status | date_change |
+-------+---------+-----------+-------------------+
| 33 | 2 | 1 | 01-01-2001 |
| 33 | 3 | 2 | 01-01-2002 |
| 44 | 4 | 2 | 01-01-2001 |
| 44 | 5 | 3 | 01-01-2004 |
+-------+---------+-----------+-------------------+
Expected results:
+-------+-----------+-----------+-------------------+
|userID |statusID | status | date_change |
+-------+-----------+-----------+-------------------+
| 33 | 3 | 2 | 01-01-2002 |
| 44 | 5 | 3 | 01-01-2004 |
+-------+-----------+-----------+-------------------+
I hope this all makes sense, please ask for more information otherwise.
Just to reiterate I just want to return the latest instance of a users status change by date.
Sample code of one of my attempts:
select
st.ID, st.status, st.date_change, r.userID
from statusUpdate st
inner join Relationship r on st.ID = r.statusUpdateID
inner join (select ID, max(date_change) as recent from statusUpdate
group by ID) as y on r.stausUpdateID = y.ID and st.date_change =
y.recent
Hope someone can point me in the right direction.
use row_number() to get the last row by user
select *
from
(
select st.ID, st.status, st.date_change, r.userID,
rn = row_number() over (partition by r.userID order by st.date_change desc)
from statusUpdate st
inner join Relationship r on st.ID = r.statusUpdateID
) as d
where rn = 1
I ADDED MAX condition to your answer
CREATE TABLE #Table1
([id] int, [name] varchar(4), [status] int, [date_change] datetime)
;
INSERT INTO #Table1
([id], [name], [status], [date_change])
VALUES
(1, 'Matt', 0, '2001-01-01 00:00:00'),
(2, 'Jeff', 1, '2001-01-01 00:00:00'),
(3, 'Jeff', 2, '2002-01-01 00:00:00'),
(4, 'Bill', 2, '2001-01-01 00:00:00'),
(5, 'Bill', 3, '2004-01-01 00:00:00')
;
CREATE TABLE #Table2
([id] int, [userID] int, [stautsUpdateID] int)
;
INSERT INTO #Table2
([id], [userID], [stautsUpdateID])
VALUES
(1, 22, 1),
(2, 33, 2),
(3, 33, 3),
(4, 44, 4),
(5, 44, 5)
select
max(st.ID) id , max(st.status) status , max(st.date_change) date_change, r.userID
from #Table1 st
inner join #Table2 r on st.ID = r.stautsUpdateID
inner join (select ID, max(date_change) as recent from #Table1
group by ID) as y on r.stautsUpdateID = y.ID and st.date_change =
y.recent
group by r.userID
output
id status date_change userID
1 0 2001-01-01 00:00:00.000 22
3 2 2002-01-01 00:00:00.000 33
5 3 2004-01-01 00:00:00.000 44
I have this schema
Item:
| ItemId | Name | Price |
|--------|-------|-------|
| 1 | Item1| 5.00 |
| 2 | Item2| 2.00 |
OrderHeader:
| OrderId| OrderNum| OrderDate |
|--------|---------|------------|
| 1 | ORD1 | 2017-05-10 |
| 2 | ORD2 | 2017-05-12 |
OrderDetails:
|OrderId| ItemId | Total |
--------|--------|---------
| 1 | 1 | 3 |
| 2 | 1 | 2 |
How can I get this result:
|ItemId | OrderId | Paid | Debt |
--------|-----------|----------------
| 1 | 1 | 3 | 2 |
| 1 | 2 | 5 | 0 |
In the result set, the column paid must contains the total of previous payments and plus the new one.
How can I use a Common table expression for example to solve this?
This, you should have provided us:
DECLARE #Item TABLE (Id int, [Name] varchar(15), Price int)
DECLARE #OrderDetails TABLE (OrderId int, ItemId int, Total int)
INSERT INTO #ITEM VALUES (1, 'ITEM1', 5), (2, 'ITEM2', 2)
INSERT INTO #OrderDetails VALUES (1, 1, 3), (2, 1, 2)
This, seems to work, and I think it still has room for improvement:
SELECT OrderId, ItemId, [SUM1], R.Price - [SUM1]
FROM #OrderDetails AS A
LEFT JOIN #Item AS R ON A.ItemId = R.Id
OUTER APPLY (
SELECT SUM(SUB1.TOTAL) AS [SUM1]
FROM #OrderDetails AS SUB1
WHERE SUB1.ItemId = A.ItemId AND SUB1.OrderId <= A.OrderId
) AS B
I want to compare two tables, source and target, and get similar rows.
Compare source and target on Id one by one and:
If matched and it's two or more on Target => select All matched from Target
If matched and it's two or more on Source =>
for first matched if it doesn't selected before
select Matched From target
else (IF it have selected before)
check for next one matched
I think need a recursive expression to check source and target one by one
Source
x------x---------x
| Id | Name |
x------x---------x
| 1 | a |
| 2 | b |
| 2 | c |
| 3 | d |
| 3 | e |
| 4 | x |
x------x---------x
Target
x------x---------x
| Id | Name |
x------x---------x
| 1 | f |
| 1 | g |
| 2 | h |
| 3 | i |
| 3 | j |
| 5 | y |
x------x---------x
Result
x------x---------x
| Id | Name |
x------x---------x
| 1 | f |
| 1 | g |
| 2 | h |
| 3 | i |
| 3 | j |
x------x---------x
Test data
declare #s table(Id int, name varchar(20))
DECLARE #t table( Id int, name varchar(20))
INSERT #s values(1, 'a'), (2, 'b'), (2, 'c'), (3, 'd'), (3, 'e')
INSERT #t values(1, 'f'), (1, 'g'), (2, 'h'), (3, 'i'), (3, 'j')
I think you just need Exists operator to do this.
select * from #t t
where exists (select 1 from #s s where t.id=s.id)
SQLFIDDLE DEMO
SELECT DISTINCT
t.Id,
t.name
FROM SOURCE s
INNER JOIN target t ON s.id=t.Id
WHERE s.Id IN (SELECT Id FROM target)