Where clause problem in a subquery

Question

I'll try to explain as detailed as possible.
Given the following set of data and the parameters passed the query must only return one row;
If the structure_chain is like the parameter passed, then select that row
If not then strip out the first number in both the parameter and the column,
e.i., '2.35364194.34889485' becomes '35364194.34889485'
The select is what is currently in the code and so far I've not been able to get the (new) desired results - customer changed/enhanced requirements
with TT as
    (select 1 row_no, 22794978 old_child_id, 51755902 new_child_id, '1.35364194' structure_chain from dual union all
     select 2, 22794978, 51755899, '1.23576950' from dual union all
     select 3, 17872962, 51755893, '1.23576950' from dual union all
     select 4, 17872962, 51756065, '1.35364194.34880851' from dual union all
     select 5, 17872962, 51759249, '2.35364194.34880851' from dual union all
     select 6, 17872962, 51759248, '1.23576950.22795468' from dual union all
     select 7, 17872962, 51759250, '2.23576950.22795468' from dual )
select * from tt
where old_child_id = &1
and   &2 like structure_chain ||'%'
17872962 '2.35364194.34880851'   -- Return row_no 5 
17872962 '1.23576950.22795468'   -- Return row_no 6 - this returns more than one
17872962 '1.35364194.34880851'   -- Return row_no 4
17872962 '2.23576950.22795468'   -- Return row_no 7
22794978 '2.35364194.34889485'   -- Return row_no 1 - does not return anything
22794978 '1.35364194.34889485'   -- Return row_no 1

Answer 1

Hi,
I'm not sure what you're asking.
It would help if you posted the results you want as clearly as you posted the sample data. For each set of parametes, post the desired result set.
I think you want to do two kinds of pattern matches, and return the results of the strictest one that has results.
That is, if there is a match on all parts of structure_chain, then return the rows that match all parts.
But if there is no match on all parts of structure_chain, then return the rows (if any) that match if we ignore the sub-atring before the first dot.
That's an example of a Top-N Query , and here's one way to do it:
WITH     got_r_num AS
     SELECT  tt.*
     ,     DENSE_RANK () OVER (ORDER BY  CASE
                                            WHEN  '&2'        LIKE structure_chain || '%'
                                THEN  1
                                ELSE  2
                                        END
                       ) AS r_num
     FROM     tt
     WHERE      old_child_id     = &1
     AND        SUBSTR ( '&2'
                 , INSTR ('&2', '.')
                 )                LIKE SUBSTR ( structure_chain
                                              , INSTR (structure_chain, '.')
                                  ) || '%'
SELECT     row_no, old_child_id, new_child_id, structure_chain
FROM     got_r_num
WHERE     r_num     = 1
;With parameters &1=17872962 and &2=1.23576950.22795468, the query above produces this output:
`   ROW_NO OLD_CHILD_ID NEW_CHILD_ID STRUCTURE_CHAIN
         3     17872962     51755893 1.23576950
         6     17872962     51759248 1.23576950.22795468because both rows matched the given &2, including the '1.' at the beginning. (The query you posted gave the same results in this case.)
With parameters &1=22794978 and &2=2.35364194.34889485, the query above produces:
    ROW_NO OLD_CHILD_ID NEW_CHILD_ID STRUCTURE_CHAIN
         1     22794978     51755902 1.35364194because there was no match when considering the '2.' at the beginning of &2, but the row shown does match when we ignore the '2.'.
The WHERE clause in the sub-query narrows the result set down to rows that meet at least the looser match reuirement.
The CASE expression ranks each row as 1 if it meets the stricter requirement, and 2 if it only met the looser one.
DENSE_RANK returns 1 for the lower of those numbers that was actually found.