I have a table tbl1 with two columns col1 and col2 containing strings:
col1 | col2
--------+--------
bar | foo
foo | foobar
bar1foo | bar2foo
Corresponding SQL dump:
CREATE TABLE `tbl1` (
`col1` varchar(20) COLLATE latin1_general_ci NOT NULL,
`col2` varchar(20) COLLATE latin1_general_ci NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci;
INSERT INTO `tbl1` (`col1`, `col2`) VALUES
('bar', 'foo'),
('foo', 'foobar'),
('bar1foo', 'bar2foo');
The strings of an entry share a common prefix in most cases. I need a query that strips those common prefixes. Expected result:
bar | foo
| bar
1foo | 2foo
My approach, so far:
SELECT
SUBSTR(`col1`, 1+GREATEST(LENGTH(`col1`), LENGTH(`col2`)) - CEIL(LENGTH(TRIM(TRAILING '0' FROM HEX(ABS(CONV(HEX(REVERSE(`col1`)),16,10) - CONV(HEX(REVERSE(`col2`)),16,10)))))/2)),
SUBSTR(`col2`, 1+GREATEST(LENGTH(`col1`), LENGTH(`col2`)) - CEIL(LENGTH(TRIM(TRAILING '0' FROM HEX(ABS(CONV(HEX(REVERSE(`col1`)),16,10) - CONV(HEX(REVERSE(`col2`)),16,10)))))/2))
FROM tbl1
Short explanation: The strings are reversed (REVERSE), converted into integers (HEX and CONV), subtracted from each other (- and ABS), converted into hexadecimal representation (HEX), 0's are trimmed from the end (TRIM), the length of this result is subtracted from the length of the longest string (-, LENGTH and GREATEST) and then used by SUBSTR to get the result.
Problems with my approach:
Does not work with strings longer than 64bit.
Does not work with strings containing multi-byte characters
Very lengthy and ugly
Does not have good performance.
Sadly, the most general and performance method is probably a giant case expression. However, this works only up to a certain length:
select substr(col1, prefix_length + 1),
substr(col2, prefix_length + 1)
from (select tbl1.*,
(case when left(col1, 10) = left(col2, 10) then 10
when left(col1, 9) = left(col2, 9) then 9
. . .
else 0
end) as prefix_length
from tbl1
) t;
Actually, you can do this with a recursive CTE, which is the most general approach:
with recursive cte as (
select col1, col2, 1 as lev, col1 as orig_col1, col2 as orig_col2
from tbl1
union all
select substr(col1, 2), substr(col2, 2), lev + 1, orig_col1, orig_col2
from cte
where left(col1, 1) = left(col2, 1)
)
select col1, col2
from (select cte.*,
dense_rank() over (partition by orig_col1, orig_col2 order by lev desc) as seqnum
from cte
) x
where seqnum = 1;
Although the performance will definitely be worse than your solution or the massive case expression, it is probably not that bad, and you might find it sufficient for your purposes.
Here is a db<>fiddle with both solutions.
This code works, although it's lengthy and ugly and (maybe) unperformant:
select
substring(t.col1, g.maxlen + 1) col1,
substring(t.col2, g.maxlen + 1) col2
from tbl1 t inner join (
select t.col1, t.col2,
max(case when left(col1, tt.n) = left(col2, tt.n) then tt.n else 0 end) maxlen
from tbl1 t inner join (
select 1 n union all select 2 union all select 3 union all select 4 union all
select 5 union all select 6 union all select 7 union all select 8 union all
select 9 union all select 10 union all select 11 union all select 12 union all
select 13 union all select 14 union all select 15 union all select 16 union all
select 17 union all select 18 union all select 19 union all select 20
) tt on least(length(t.col1), length(t.col2)) >= tt.n
group by t.col1, t.col2
) g on g.col1 = t.col1 and g.col2 = t.col2
See the demo.
For MySql 8.0+ you can use a recursive CTE and in this case there is no need of prior knowledge of the length of the columns:
with
recursive lengths as (
select 1 n
union all
select n + 1
from lengths
where n < (select max(least(length(col1), length(col2))) from tbl1)
),
cte as (
select t.col1, t.col2,
max(case when left(col1, l.n) = left(col2, l.n) then l.n else 0 end) maxlen
from tbl1 t inner join lengths l
on least(length(t.col1), length(t.col2)) >= l.n
group by t.col1, t.col2
)
select
substring(t.col1, c.maxlen + 1) col1,
substring(t.col2, c.maxlen + 1) col2
from tbl1 t inner join cte c
on c.col1 = t.col1 and c.col2 = t.col2
See the demo.
Results:
| col1 | col2 |
| ---- | ---- |
| | bar |
| bar | foo |
| 1foo | 2foo |
I am new to StackOverflow and have got stuck with a query to print prime numbers from 2 to 1000.
I have used the below query need input if this is the most efficient way to code it.
WITH NUM AS (
SELECT LEVEL N
FROM DUAL CONNECT BY LEVEL <= 1000
)
SELECT LISTAGG(B.N,'-') WITHIN GROUP(ORDER BY B.N) AS PRIMES
FROM (
SELECT N,
CASE WHEN EXISTS (
SELECT NULL
FROM NUM N_INNER
WHERE N_INNER .N > 1
AND N_INNER.N < NUM.N
AND MOD(NUM.N, N_INNER.N)=0
) THEN
'NO PRIME'
ELSE
'PRIME'
END IS_PRIME
FROM NUM
) B
WHERE B.IS_PRIME='PRIME'
AND B.N!=1;
I know this question has been asked multiple times and I am requesting better solution if any. More over need input on how this works with MySQL/MS SQL/PostgreSQL.
Any help will make my understanding better.
In PostgreSQL probably the most fastest query that prints prime numbers up to 1000 is:
SELECT regexp_split_to_table('2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997',E',')::int
AS x
;
It took only 16 ms on my computer.
Note: a list of prime numbers was copied from https://en.wikipedia.org/wiki/Prime_number
and pasted into this long string
If you prefer SQL, then this works
WITH x AS (
SELECT * FROM generate_series( 2, 1000 ) x
)
SELECT x.x
FROM x
WHERE NOT EXISTS (
SELECT 1 FROM x y
WHERE x.x > y.x AND x.x % y.x = 0
)
;
It's two times slower - 31 ms.
Ans an equivalent version for Oracle:
WITH x AS(
SELECT level+1 x
FROM dual
CONNECT BY LEVEL <= 999
)
SELECT x.x
FROM x
WHERE NOT EXISTS (
SELECT 1 FROM x y
WHERE x.x > y.x AND remainder( x.x, y.x) = 0
)
;
The most obvious improvement is that instead of checking from 1 to n you can check from 1 to the square root of n.
A second major optimization would be to use a temporary table to store the results and check them first. This way you can iterate incrementally from 1 to n, and only check the known primes from 1 to square root of n (recursively doing that until you have a list). If you go about things this way you would probably want to set up the prime detection in a function and then do the same with your number series generator.
That second one though means extending SQL and so I don't know if that fits your requirements.
For postgresql I would use generate_series go generate the list of numbers. I would then create functions which would then either store the list of primes in a temporary table or pass them back in and out in an ordered array and then couple them like that
MariaDB (with sequence plugin)
Similar to kordirkos algorithm:
select 2 as p union all
select n.seq
from seq_3_to_1000_step_2 n
where not exists (
select 1
from seq_3_to_32_step_2 q
where q.seq < n.seq
and n.seq mod q.seq = 0
);
Using LEFT JOIN:
select 2 as p union all
select n.seq
from seq_3_to_1000_step_2 n
left join seq_3_to_32_step_2 q
on q.seq < n.seq
and n.seq mod q.seq = 0
where q.seq is null;
MySQL
There are no sequence generating helpers in MySQL. So the sequence tables have to be created first:
drop temporary table if exists n;
create temporary table if not exists n engine=memory
select t2.c*100 + t1.c*10 + t0.c + 1 as seq from
(select 0 c union all select 1 c union all select 2 c union all select 3 c union all select 4 c union all select 5 c union all select 6 c union all select 7 c union all select 8 c union all select 9 c) t0,
(select 0 c union all select 1 c union all select 2 c union all select 3 c union all select 4 c union all select 5 c union all select 6 c union all select 7 c union all select 8 c union all select 9 c) t1,
(select 0 c union all select 1 c union all select 2 c union all select 3 c union all select 4 c union all select 5 c union all select 6 c union all select 7 c union all select 8 c union all select 9 c) t2
having seq > 2 and seq % 2 != 0;
drop temporary table if exists q;
create temporary table if not exists q engine=memory
select *
from n
where seq <= 32;
alter table q add primary key seq (seq);
Now similar queries can be used:
select 2 as p union all
select n.seq
from n
where not exists (
select 1
from q
where q.seq < n.seq
and n.seq mod q.seq = 0
);
select 2 as p union all
select n.seq
from n
left join q
on q.seq < n.seq
and n.seq mod q.seq = 0
where q.seq is null;
sqlfiddle
Oracle and without inner select in getting part:
with tmp(id)
as (
select level id from dual connect by level <= 100
) select t1.id from tmp t1
JOIN tmp t2
on MOD(t1.id, t2.id) = 0
group by t1.ID
having count(t1.id) = 2
order by t1.ID
;
/* Below is my solution */
/* Step 1: Get all the numbers till 1000 */
with tempa as
(
select level as Num
from dual
connect by level<=1000
),
/* Step 2: Get the Numbers for finding out the factors */
tempb as
(
select a.NUm,b.Num as Num_1
from tempa a , tempa b
where b.Num<=a.Num
),
/*Step 3:If a number has exactly 2 factors, then it is a prime number */
tempc as
(
select Num, sum(case when mod(num,num_1)=0 then 1 end) as Factor_COunt
from tempb
group by Num
)
select listagg(Num,'&') within group (order by Num)
from tempc
where Factor_COunt=2
;
Tested on sqlite3
WITH nums(n) AS
(
SELECT 1
UNION ALL
SELECT n + 1 FROM nums WHERE n < 100
)
SELECT n
FROM (
SELECT n FROM nums
)
WHERE n NOT IN (
SELECT n
FROM nums
JOIN ( SELECT n AS n2 FROM nums )
WHERE n <> 1
AND n2 <> 1
AND n <> n2
AND n2 < n
AND n % n2 = 0
ORDER BY n
)
AND n <> 1
Tested on Vertica 8
WITH seq AS (
SELECT ROW_NUMBER() OVER() AS n
FROM (
SELECT 1
FROM (
SELECT date(0) + INTERVAL '1 second' AS i
UNION ALL
SELECT date(0) + INTERVAL '100 seconds' AS i
) _
TIMESERIES tm AS '1 second' OVER(ORDER BY i)
) _
)
SELECT n
FROM (SELECT n FROM seq) _
WHERE n NOT IN (
SELECT n FROM (
SELECT s1.n AS n, s2.n AS n2
FROM seq AS s1
CROSS JOIN seq AS s2
ORDER BY n, n2
) _
WHERE n <> 1
AND n2 <> 1
AND n <> n2
AND n2 < n
AND n % n2 = 0
)
AND n <> 1
ORDER BY n
This is what worked for me in the SQL server. I tried to reduce the order of my nested loops.
declare #var int
declare #i int
declare #result varchar (max)
set #var = 1
select #result = '2&3&5' --first few obvious prime numbers
while #var < 1000 --the first loop
begin
set #i = 3;
while #i <= #var/2 --the second loop which I attempted to reduce the order
begin
if #var%#i = 0
break;
if #i=#var/2
begin
set #result = #result + '&' + CAST(#var AS VARCHAR)
break;
end
else
set #i = #i + 1
end
set #var = #var + 1;
end
print #result
SELECT LISTAGG(PRIME_NUMBER,'&') WITHIN GROUP (ORDER BY PRIME_NUMBER)
FROM
(
SELECT L PRIME_NUMBER FROM
(
SELECT LEVEL L FROM DUAL CONNECT BY LEVEL <= 1000 ),
(
SELECT LEVEL M FROM DUAL CONNECT BY LEVEL <= 1000
) WHERE M <= L
GROUP BY L
HAVING COUNT(CASE WHEN L/M = TRUNC(L/M) THEN 'Y' END
) = 2
ORDER BY L
);
SELECT GROUP_CONCAT(NUMB SEPARATOR '&')
FROM (
SELECT #num:=#num+1 as NUMB FROM
information_schema.tables t1,
information_schema.tables t2,
(SELECT #num:=1) tmp
) tempNum
WHERE NUMB<=1000 AND NOT EXISTS(
SELECT * FROM (
SELECT #nu:=#nu+1 as NUMA FROM
information_schema.tables t1,
information_schema.tables t2,
(SELECT #nu:=1) tmp1
LIMIT 1000
) tatata
WHERE FLOOR(NUMB/NUMA)=(NUMB/NUMA) AND NUMA<NUMB AND NUMA>1
)
MySQL Code :
DECLARE
#i INT,
#a INT,
#count INT,
#p nvarchar(max)
SET #i = 1
WHILE (#i <= 1000)
BEGIN SET #count = 0
SET #a = 1
WHILE (#a <= #i)
BEGIN IF (#i % #a = 0) SET #count = #count + 1 SET #a = #a + 1
END IF (#count = 2) SET #P = CONCAT(#P,CONCAT(#i,'&')) SET #i = #i + 1
END
PRINT LEFT(#P, LEN(#P) - 1)
The below code works to find prime numbers in SQL
Tested on SampleDB of local server
CREATE procedure sp_PrimeNumber(#number int)
as
begin
declare #i int
declare #j int
declare #isPrime int
set #isPrime=1
set #i=2
set #j=2
while(#i<=#number)
begin
while(#j<=#number)
begin
if((#i<>#j) and (#i%#j=0))
begin
set #isPrime=0
break
end
else
begin
set #j=#j+1
end
end
if(#isPrime=1)
begin
SELECT #i
end
set #isPrime=1
set #i=#i+1
set #j=2
end
end
I have created the stored procedure which has a parameter #number to find the prime numbers up to that given number
In order to get the prime numbers we can execute the below stored procedure
EXECUTE sp_PrimeNumber 100 -- gives prime numbers up to 100
If you are new to stored procedures and want to find the prime numbers in SQL we can use the below code
Tested on master DB
declare #i int
declare #j int
declare #isPrime int
set #isPrime=1
set #i=2
set #j=2
while(#i<=100)
begin
while(#j<=100)
begin
if((#i<>#j) and (#i%#j=0))
begin
set #isPrime=0
break
end
else
begin
set #j=#j+1
end
end
if(#isPrime=1)
begin
SELECT #i
end
set #isPrime=1
set #i=#i+1
set #j=2
end
This code can give the prime numbers between 1 to 100. If we want to find more prime numbers edit the #i and #j arguments in the while loop and execute
Simple query in PostgreSQL:
SELECT serA.el AS prime
FROM generate_series(2, 100) serA(el)
LEFT JOIN generate_series(2, 100) serB(el) ON serA.el >= POWER(serB.el, 2)
AND serA.el % serB.el = 0
WHERE serB.el IS NULL
Enjoy! :)
For SQL Server We can use below CTE
SET NOCOUNT ON
;WITH Prim AS
(
SELECT 2 AS Value
UNION ALL
SELECT t.Value+1 AS VAlue
FROM Prim t
WHERE t.Value < 1000
)SELECT *
FROM Prim t
WHERE NOT EXISTS( SELECT 1 FROM prim t2
WHERE t.Value % t2.Value = 0
AND t.Value != t2. Value)
OPTION (MAXRECURSION 0)
One simple one can be like this
select level id1 from dual connect by level < 2001
minus
select distinct id1 from (select level id1 from dual connect by level < 46) t1 inner join (select level id2 from dual connect by level < 11) t2
on 1=1 where t1.id1> t2.id2 and mod(id1,id2)=0 and id2<>1
Simplest method For SQL Server
DECLARE #range int = 1000, #x INT = 2, #y INT = 2
While (#y <= #range)
BEGIN
while (#x <= #y)
begin
IF ((#y%#x) =0)
BEGIN
IF (#x = #y)
PRINT #y
break
END
IF ((#y%#x)<>0)
set #x = #x+1
end
set #x = 2
set #y = #y+1
end
MySQL QUERY SOLUTION
I have solved this problem in mysql which is following:
SET #range = 1000;
SELECT GROUP_CONCAT(R2.n SEPARATOR '&')
FROM (
SELECT #ctr2:=#ctr2+1 "n"
FROM information_schema.tables R2IS1,
information_schema.tables R2IS2,
(SELECT #ctr2:=1) TI
WHERE #ctr2<#range
) R2
WHERE NOT EXISTS (
SELECT R1.n
FROM (
SELECT #ctr1:=#ctr1+1 "n"
FROM information_schema.tables R1IS1,
information_schema.tables R1IS2,
(SELECT #ctr1:=1) I1
WHERE #ctr1<#range
) R1
WHERE R2.n%R1.n=0 AND R2.n>R1.n
)
Note: No. of information_schema.tables should be increased for more range e.g. if range is 100000 so set the info tables by checking yourself.
--Create Table prime_number_t
create table prime_number_t (
integervalue_c integer not null primary key
);
--Insert Data into table prime_number_t
INSERT ALL
into prime_number_t(integervalue_c) values (1)
into prime_number_t(integervalue_c) values (2)
into prime_number_t(integervalue_c) values (3)
into prime_number_t(integervalue_c) values (4)
into prime_number_t(integervalue_c) values (5)
into prime_number_t(integervalue_c) values (6)
into prime_number_t(integervalue_c) values (7)
into prime_number_t(integervalue_c) values (8)
into prime_number_t(integervalue_c) values (9)
into prime_number_t(integervalue_c) values (10)
SELECT 1 FROM DUAL;
COMMIT;
--Write an SQL statement to determine which of the below numbers are prime numbers
--same query works for REMAINDER function also instead of MOD function
WITH cte_prime_number_t AS
(
select integervalue_c
from prime_number_t
order by integervalue_c
),
cte_maxval AS
(
select max(integervalue_c) AS maxval FROM cte_prime_number_t
),
cte_level AS
(
select LEVEL+1 as lvl
from dual,
cte_maxval
CONNECT BY LEVEL <= cte_maxval.maxval
)
SELECT DISTINCT cpnt.integervalue_c as PrimeNumbers
FROM cte_prime_number_t cpnt
inner join cte_level cl on lvl <= (SELECT maxval FROM cte_maxval)
WHERE NOT EXISTS (
SELECT 1 FROM cte_level cpn
WHERE cpnt.integervalue_c > cpn.lvl AND mod(cpnt.integervalue_c,cpn.lvl) = 0
)
order by PrimeNumbers;
For MySQL 8 or above
/* create a table with one row and that starts with 2 ends at 1000*/
SET cte_max_recursion_depth = 1001; /* works for MySQL 8.0*/
;WITH RECURSIVE sequence AS (
SELECT 1 AS l
UNION ALL
SELECT l + 1 AS value
FROM sequence
WHERE sequence.l < 1000
),
/* create a caretesian product of a number to other numbers uptil this very number
so for example if there is a value 5 in a row then it creates these rows using the table below
(5,2), (5,3), (5,4), (5,5) */
J as (
SELECT (a.l) as m , (b.l) as n
FROM sequence a, sequence b
WHERE b.l <= a.l)
,
/*take a row from column 1 then divide it with other column values but group by column 1 first,
note the completely divisible count*/
f as
( SELECT m , SUM(CASE WHEN mod(m,n) = 0 THEN 1 END) as fact
FROM J
GROUP BY m
HAVING fact = 2
ORDER BY m ASC /*this view return numbers in descending order so had to use order by*/
)
/* this is for string formatting, converting a column to a string with separator &*/
SELECT group_concat(m SEPARATOR '&') FROM f;
This worked for me in MySql:
select '2&3&5&7&11&13&17&19&23&29&31&37&41&43&47&53&59&61&67&71&73&79&83&89&97&101&103&107&109&113&127&131&137&139&149&151&157&163&167&173&179&181&191&193&197&199&211&223&227&229&233&239&241&251&257&263&269&271&277&281&283&293&307&311&313&317&331&337&347&349&353&359&367&373&379&383&389&397&401&409&419&421&431&433&439&443&449&457&461&463&467&479&487&491&499&503&509&521&523&541&547&557&563&569&571&577&587&593&599&601&607&613&617&619&631&641&643&647&653&659&661&673&677&683&691&701&709&719&727&733&739&743&751&757&761&769&773&787&797&809&811&821&823&827&829&839&853&857&859&863&877&881&883&887&907&911&919&929&937&941&947&953&967&971&977&983&991&997';
Well, I know the above one is just hardcoded and you will be able to run the problem but it's not what we should go for as a programmer so here is my solution for oracle:
SELECT LISTAGG(L1,'&') WITHIN GROUP (ORDER BY L1) FROM (Select L1 FROM (SELECT LEVEL L1 FROM DUAL CONNECT BY LEVEL<=1000) Where L1 <> 1 MINUS select L1 from (SELECT LEVEL L1 FROM DUAL CONNECT BY LEVEL<=1000) A , (SELECT LEVEL L2 FROM DUAL CONNECT BY LEVEL<=1000) B Where L2<=L1 and MOD(L1,L2)=0 AND L1<>L2 AND L2<>1);
Worked in Oracle:
SELECT LISTAGG(a,'&')
WITHIN GROUP (ORDER BY a)
FROM(WITH x AS(
SELECT level+1 x
FROM dual
CONNECT BY LEVEL <= 999
)
SELECT x.x as a
FROM x
WHERE NOT EXISTS (
SELECT 1 FROM x y
WHERE x.x > y.x AND remainder( x.x, y.x) = 0
));
SELECT GROUP_CONCAT(distinct PRIME_NUMBER SEPARATOR '&')
FROM (SELECT #prime:=#prime + 1 AS PRIME_NUMBER
FROM information_schema.tables
CROSS JOIN (SELECT #prime:=1) r
WHERE #num <1000
) p
WHERE NOT EXISTS (
SELECT * FROM
(SELECT #divisor := #divisor + 1 AS DIVISOR FROM
information_schema.tables
CROSS JOIN (SELECT #divisor:=1) r1
WHERE #divisor <=1000
) d
WHERE MOD(PRIME_NUMBER, DIVISOR) = 0 AND PRIME_NUMBER != DIVISOR) ;
enter code here
Explanation:
The two inner SELECTs (SELECT #prime and SELECT #divisor) create two lists. Both of them contain numbers from 1 to 1000. The first list is the "list of potential primes" and the second is the "list of divisors"
Then, we iterate over the list of the potential primes (the outer SELECT), and for each number from this list we look for divisors (SELECT * FROM clause) that can divide the number without a reminder and are not equal to the number (WHERE MOD... clause). If at least one such divisor exists, the number is not prime and is not selected (WHERE NOT EXISTS... clause).
I have the following SQL query which is somehow broken:
SELECT *
FROM (
SELECT ID, TEST, CHR, NUMBER
FROM Test_Table
JOIN ...
WHERE ...
) TEMP_TABLE
FROM TEMP_TABLE a
LEFT
JOIN TEMP_TABLE b
ON b.test = a.test
AND b.chr = 'x'
WHERE a.number IN (5,6)
AND b.id IS NULL
GROUP
BY a.test
HAVING COUNT(*) = 2;
From the first FROM statement I get the following temporary table:
ID , TEST, CHR , NUMBER
------------------------------
( 1 , 7 , 'C' , 5),
( 2 , 7 , 'T' , 6),
( 3 , 8 , 'C' , 4),
( 4 , 8 , 'T' , 5),
( 5 , 9 , 'A' , 4),
( 6 , 9 , 'G' , 5),
( 7 , 10 , 'T' , 4),
( 8 , 10 , 'A' , 5),
( 9 , 10 , 'X' , 6),
(10 , 14 , 'T' , 4),
(11 , 14 , 'G' , 5);
From FROM TEMP_TABLE ... I try to implement the following conditions:
For example test column 7 contains two rows, if the number column contains values 5 AND 6, AND the value is NOT X in the chr column, I would like to select select the rows with 7 in the test column.
For example test column 10 contains three rows, if the number column contains values 5 AND 6, AND the value X exists in the chr column, I would like to exclude rows with 10 in the test column.
As result it should only be test column with 7, because test column 7 have 5 and 6 in the number column and not X.
Result example:
ID | TEST | CHR | NUMBER
1 | 7 | C | 5
2 | 7 | T | 6
What did go wrong with the above SQL query?
Your query has two FROM clauses remove one and try like below
SELECT *
FROM (
SELECT ID, TEST, CHR, NUMBER
FROM Test_Table
JOIN ...
WHERE ...
) a
LEFT JOIN
(
SELECT ID, TEST, CHR, NUMBER
FROM Test_Table
JOIN ...
WHERE ...
) b
ON b.test = a.test
AND b.chr = 'x'
WHERE a.number IN (5,6)
AND b.id IS NULL
GROUP
BY a.test
HAVING COUNT(*) = 2;
A easier way to do this is to create a TEMPORARY table using TEMPORARY keyword like mentioned here
CREATE TEMPORARY TABLE TEMP_TABLE (ID int, TEST varchar(100), CHR char, NUMBER int );
INSERT INTO TEMP_TABLE
(SELECT ID, TEST, CHR, NUMBER
FROM Test_Table
JOIN ...
WHERE ...);
SELECT *
FROM TEMP_TABLE a
LEFT
JOIN TEMP_TABLE b
ON b.test = a.test
AND b.chr = 'x'
WHERE a.number IN (5,6)
AND b.id IS NULL
GROUP
BY a.test
HAVING COUNT(*) = 2;
I need to be able to do something with my column (below) that can contain multiple values. The 'HearAboutEvent' column has multiple values separated by a comma. Each one of these values corresponds to an entry in another table. So the value of 11273 will equal facebook, 11274 will mean radio, and 11275 will mean commercial.
The data I am working with looks like this:
weather ID MemberID SubscriptionID DateEntered ParticipatedBefore ParticipatedBeforeCities WeatherDependent NonRefundable TShirtSize HearAboutEvent
Yes 24 18 1 2013-12-19 0 NULL 10950 10952 10957 11273, 11274, 11275
I am able to do the proper join to resolve the value of 'weather', note it is the first column and the 8th column.
This is the query I have created so far to resolve the values of WeatherDependent:
SELECT CFS1.Name as 'weather', *
FROM FSM_CustomForm_693 t
LEFT JOIN FSM_CustomFormSelectOptions CFS1 ON CFS1.ID = t.WeatherDependent
where t.ID = 24
Ultimately I need to have the data look like this:
weather ID MemberID SubscriptionID DateEntered ParticipatedBefore ParticipatedBeforeCities WeatherDependent NonRefundable TShirtSize HearAboutEvent
Yes 24 18 1 2013-12-19 0 NULL 10950 10952 10957 Facebook, radio, commercial
Things I think you could use to accomplish this are:
A Split TVF FUNCTION - http://msdn.microsoft.com/en-us/library/ms186755.aspx
CROSS APPLY - http://technet.microsoft.com/en-us/library/ms175156.aspx
STUFF & FOR XML PATH - http://msdn.microsoft.com/en-us/library/ms188043.aspx & http://msdn.microsoft.com/en-us/library/ms190922.aspx
Going one step further, you need something like this:
Excuse my profuse use of sub queries.
CREATE FUNCTION dbo.Split (#sep char(1), #s varchar(512))
RETURNS table
AS
RETURN (
WITH Pieces(pn, start, stop) AS (
SELECT 1, 1, CHARINDEX(#sep, #s)
UNION ALL
SELECT pn + 1, stop + 1, CHARINDEX(#sep, #s, stop + 1)
FROM Pieces
WHERE stop > 0
)
SELECT pn,
SUBSTRING(#s, start, CASE WHEN stop > 0 THEN stop-start ELSE 512 END) AS s
FROM Pieces
)
GO
SELECT
O.A,O.B,O.C,O.D,O.E,O.F,O.G,O.H,O.I,O.J,O.Stuffed
FROM (
SELECT
*
,STUFF((
SELECT ', ' + Name
FROM (
SELECT
V.*
,Y.Name
FROM (
SELECT
'Yes' AS A
,24 AS B
,18 AS C
,1 AS D
,'2013-12-19' AS E
,0 AS F
,NULL AS G
,10950 AS H
,10952 AS I
,10957 AS J
,'11273, 11274, 11275' AS K
)
AS V
CROSS APPLY dbo.Split(',',REPLACE(K,' ','')) AS P
JOIN (
SELECT 11273 AS Id , 'Facebook' AS Name UNION ALL
SELECT 11274 AS Id , 'radio' AS Name UNION ALL
SELECT 11275 AS Id , 'commercial' AS Name
)Y ON y.Id = p.s) ExampleTable
FOR XML PATH('')
), 1, 1, '' )
AS [Stuffed]
FROM (
SELECT
V.*
FROM (
SELECT
'Yes' AS A
,24 AS B
,18 AS C
,1 AS D
,'2013-12-19' AS E
,0 AS F
,NULL AS G
,10950 AS H
,10952 AS I
,10957 AS J
,'11273, 11274, 11275' AS K
)
AS V
CROSS APPLY dbo.Split(',',REPLACE(K,' ','')) AS P
JOIN (
SELECT 11273 AS Id , 'Facebook' AS Name UNION ALL
SELECT 11274 AS Id , 'radio' AS Name UNION ALL
SELECT 11275 AS Id , 'commercial' AS Name
)Y ON y.Id = p.s
)Z
) O
GROUP BY O.A,O.B,O.C,O.D,O.E,O.F,O.G,O.H,O.I,O.J,O.K,O.Stuffed