Ytukyg

I need to solve the following problem.

Let's suppose I have a table with 4 fields called a, b, c, d.

I have the following records:

-------------------------------------

   a   |    b    |    c    |    d  

-------------------------------------

   1   |    2    |         |             row 1 

   1   |    2    |    3    |    4        row 2 

   1   |    2    |         |    4        row 3

   1   |    2    |    3    |             row 4  

As it's possible to observe, rows 1,3,4 are "sub-records" of row 2.

What I would like to do is, to extract only 2nd row.

Could you help me please?

Thanks in advance for the answer

EDIT: I need to be more specific.

I could have also the cases:

-------------------------------------

   a   |    b    |    c    |    d  

-------------------------------------

   1   |    2    |         |             row 1 

   1   |    2    |         |    4        row 2 

   1   |         |         |    4        row 3

where I need to extract the 2nd row,

-------------------------------------

   a   |    b    |    c    |    d  

-------------------------------------

   1   |    2    |         |             row 1 

   1   |    2    |    3    |             row 2 

   1   |         |    3    |             row 3

and again I need to extract the 2nd row.

Same for couples,

   a   |    b    |    c    |    d  

-------------------------------------

   1   |         |         |             row 1 

   1   |         |    3    |             row 2 

       |         |    3    |             row 3

and so on for the other examples.

(Of course, it's now always 2nd row)

Using a NOT EXISTS the records that have a better duplicate can be filtered out.

create table abcd (

 a int,

 b int,

 c int,

 d int

);

insert into abcd (a, b, c, d) values

 (1, 2, null, null)

,(1, 2, 3, 4)

,(1, 2, null, 4)

,(1, 2, 3, null)



,(2, 3, null,null)

,(2, 3, null, 5)

,(2, null, null, 5) 



,(3, null, null, null)

,(3, null, 5, null)

,(null, null, 5, null)

SELECT *  

FROM abcd AS t 

WHERE NOT EXISTS 

(

   select 1

   from abcd as d  

   where (t.a is null or d.a = t.a)

     and (t.b is null or d.b = t.b)

     and (t.c is null or d.c = t.c)

     and (t.d is null or d.d = t.d)

     and (case when t.a is null then 0 else 1 end +

          case when t.b is null then 0 else 1 end +

          case when t.c is null then 0 else 1 end +

          case when t.d is null then 0 else 1 end) < 

         (case when d.a is null then 0 else 1 end +

          case when d.b is null then 0 else 1 end +

          case when d.c is null then 0 else 1 end +

          case when d.d is null then 0 else 1 end)

);

 a |    b |    c |    d

-: | ---: | ---: | ---:

 1 |    2 |    3 |    4

 2 |    3 | null |    5

 3 | null |    5 | null

db<>fiddle here

You will need to compute a "completion index" for each row. In the example you provided, you might use something along the lines of:

   (CASE WHEN a IS NULL THEN 0 ELSE 1) +

   (CASE WHEN b IS NULL THEN 0 ELSE 1) +

   (CASE WHEN c IS NULL THEN 0 ELSE 1) +

   (CASE WHEN d IS NULL THEN 0 ELSE 1) AS CompletionIndex

Then SELECT the top 1 ordered by CompletionIndex in descending order.

This is obviously not very scalable across a large number of columns. But if you have a large number of sparsely populated columns you might consider a row-based rather than column-based structure for your data. That design would make it much easier to count the number of non-NULL values for each entity.

Most complete rows, by your definition, are the ones with the least null columns:

SELECT * FROM tablename

WHERE (

    (CASE WHEN a IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN b IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN c IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN d IS NULL THEN 0 ELSE 1 END)

) =

(SELECT MAX(

    (CASE WHEN a IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN b IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN c IS NULL THEN 0 ELSE 1 END) + 

    (CASE WHEN d IS NULL THEN 0 ELSE 1 END)) 

FROM tablename)

Hmmm . . . I think you can use not exists:

with t as (

      select t.*, row_number() over (order by a) as id

      from t

     )

select t.*

from t

where not exists (select 1

                  from t t2

                  where ((t2.a is not distinct from t.a or t2.a is not null and t.a is null) and

                         (t2.b is not distinct from  t.b or t2.b is not null and t.b is null) and

                         (t2.c is not distinct from  t.c or t2.c is not null and t.c is null) and

                         (t2.d is not distinct from  t.d or t2.d is not null and t.d is null)

                        ) and

                        t2.id <> t.id

                 );

The logic is that no more specific row exists, where the values match

Here is a db<>fiddle.

As mentioned by Gordon Linoff, we do have to use something like not exists too,

Edit Using EXCEPT helps

This might work...

SELECT * from table1 

EXCEPT

(

SELECT t1.*

FROM table1 t1

JOIN table1 t2

ON  COALESCE(t1.a, t2.a, -1) = COALESCE(t2.a, -1)

AND COALESCE(t1.b, t2.b, -1) = COALESCE(t2.b, -1)

AND COALESCE(t1.c, t2.c, -1) = COALESCE(t2.c, -1)

AND COALESCE(t1.d, t2.d, -1) = COALESCE(t2.d, -1)

)

Here, t1 is every subset row.

Note: We are assuming value -1 as sentinel value and it does not occur in any column.