SQL查询找到匹配项

Question

I have written a query to provide matches with the same DB and it's giving me expected results except that I don't get few part of it. Below is the query :

select f.name, f.id, f.industry, d.name, d.id, d.industry
from product_table f, product_table d
where (f.name like '%' || d.name || '%') and 
(f.industrylike '%' || d.industry|| '%') and

I know by providing this it's actually looking for matches between the 2 columns :

(..... like '%' || ..... || '%')

But what does each part of it do exactly and what does it mean?

Answer 1

This query is executing a self-join (here, a cross self-join) in which we query two instances of the same table for some purpose. In this case it looks like some form of data quality exercise, where we suspect we might have almost duplicate records. That is, we think we have records for the same combination of (product name and industry). The use of wild cards will identify records where the value of one column is wholly embedded in another column: for instance '%STACK%' matches 'META STACKOVERFLOW' .

The posted version has a potential flaw, in that if there are two records with an exact match you will get two hits (one for F:D, one for D:F). You can finagle that by adding a filter on id

select f.name, f.id, f.industry, 
       d.name, d.id, d.industry
from product_table f, product_table d
where (f.name like '%' || d.name || '%') 
and (f.industrylike '%' || d.industry|| '%') 
and  ( ( f.name = d.name 
        and f.industry = d.industry 
        and f.id < d.id )
    or f.name != d.name 
    or f.industry != d.industry 
    )

---

The double vertical bar (more commonly known as a pipe) is the concatenation operator. It is used for joining strings together. (Many programming languages use + but Oracle reserves that strictly for arithmetic on numbers.)

not so much clear on why we put it before and after only the second column : f.name like '%' || d.name || '%'

In this case, the query is concatenating a wild card. Given this value for f.name = 'XYZ' , we would get matches for '%' || d.name || '%' '%' || d.name || '%' '%' || d.name || '%' on:

• '1XYZ1'
• '11XYZ11'
• '11XYZ'
• 'XYZ1'
• 'XYZ' <---- matching same record

We don't need to wrap f.name in wildcard operators because the query is a self-join so all the values of name will appear on the left hand side of the filter. When f.name = '1XYZ1' it match for '%' || d.name || '%' '%' || d.name || '%' '%' || d.name || '%' on:

• '1XYZ1' <---- matching same record
• 'XYZ1'
• 'XYZ'

So you're going to get multiple hits already. Embedding both sides of the filter in wildcards will only generate more noisy duplicates.