SQL, Oracle11g: Trouver les enregistrements correspondants ensemble particulier d'ID de

Question

S'il vous plaît se référer SQL Oracle : how to find records maching a particular id in the column

Maintenant, ma requête est sur les lignes similaires: Ma table a les données suivantes:

maintenant je veux trouver les dossiers qui ont asso_entity_id comme une combinaison de 3 valeurs. Par exemple: - Si je sélectionne asso_entities de ma jsp comme 30000, 30001 et 80002 (dans n'importe quel ordre), je devrais obtenir le premier enregistrement du tableau ci-dessus.

Answer 1

S'il vous plaît vérifier la requête ... Bit long ... va essayer de le raccourcir.

with test as (
    select * from YOURTABLE 
) 
SELECT distinct DATASETNAME FROM(
    select x.*, COUNT(*) OVER (partition by DATASETNAME ORDER BY DATASETNAME) CNT From(
    select DATASETNAME, regexp_substr (ASSO_ENTITY_ID, '[^|]+', 1, row_number() OVER (partition by DATASETNAME ORDER BY DATASETNAME)) split 
    from test 
    connect by level <= length (regexp_replace (ASSO_ENTITY_ID, '[^|]+')) + 1 
)x where SPLIT IS NOT NULL 
)xx 
    WHERE SPLIT IN ('300000', '300001', '800002') AND 
    CNT =3; 

Answer 2

Faisant suite à ma réponse à votre question précédente, et de continuer à l'utiliser comme un exemple becuase je peux voir la requête sous-jacente qui est fait le listagg ... vous pouvez faire correspondre à plusieurs valeurs, combien vous comptez appariés, et appliquer un autre filtre pour vous assurer de correspondre à tous. Quelque chose comme:

select distinct role_id, role_name, active, companyName, permission_id, 
    permission_name, rn, total_rows, roleCreated 
from (
    select t.*, 
     count(raw_permission_id) over (partition by role_id) as cnt 
    from (
     select r.role_id, 
      r.role_name, 
      r.active, 
      decode(r.entity_type_id, 1000, m.name, 3000, cour.name, 
       4000, 'Ensenda') companyName, 
      p.permission_id as raw_permission_id, 
      listagg(p.permission_id, ' | ') 
       within group (order by p.permission_id) 
        over (partition by r.role_id) permission_id, 
      listagg(p.permission_name, ' | ') 
       within group (order by p.permission_id) 
        over (partition by r.role_id) permission_name, 
      dense_rank() over (order by r.created_ts desc) as rn, 
      count(distinct r.role_id) over() as total_rows, 
      r.created_ts roleCreated 
     from t_role r 
     left join t_role_permission rp ON r.role_id = rp.role_id 
     left join t_permission p ON rp.permission_id = p.permission_id 
     left join merchant m on r.entity_id = m.merchantkey 
     left join courier cour on r.entity_id = cour.courierkey 
    ) t 
    where raw_permission_id in (301446, 301445) 
) 
where cnt = 2 
and rn between 1 and 100 
order by roleCreated desc; 

La seule différence par rapport à la réponse précédente est les deux couches extérieures de la requête:

select ... 
from (
    select t.*, 
     count(raw_permission_id) over (partition by role_id) as cnt 
    from (
    ... -- no changes here 
    ) t 
    where raw_permission_id in (301446, 301445) 
) 
where cnt = 2 
... 

Il cherche maintenant deux autorisations possibles, et comptage - analytiquement, donc pour chaque rôle - combien ont été appariés. La requête externe vérifie que le nombre correspondant est égal à 2, ce que vous devrez évidemment ajuster en fonction du nombre d'options que vous essayez de faire correspondre.

Pour cette question, il ajouterait quelque chose comme:

 count(raw_asso_entity_id) over (partition by <some_id>) as cnt 
    ... 
    where raw_asso_id in (30000, 30001 and 80002) 
... 
where cnt = 3 

Answer 3

Un peu version simplifiée de l'exemple de techdo:

C'est la structure de la table de test:

ID DATASET_NAME DATASET_VAL 
------------------------------------------ 
1 DATASET1  3000 | 30001 | 80002 
2 DATASET1  3000 | 80002 
3 DATASET1  3000 | 80002 


SELECT LISTAGG(str, ' | ') WITHIN GROUP (ORDER BY str) asso_ety_id 
    FROM 
    (
    SELECT DISTINCT id, dataset_name 
     , TRIM(REGEXP_SUBSTR (dataset_val, '[^|]+', 1, LEVEL)) str 
    FROM your_tab 
    CONNECT BY LEVEL <= LENGTH(REGEXP_REPLACE(dataset_val, '[^|]+')) + 1 
) 
    WHERE str IN ('80002', '30001', '3000') -- in any order -- 
    -- AND id = 1 -- optional -- 
/

Sortie:

3000 | 30001 | 80002