0
votes

Comment éliminer l'élément plus long dans chaque groupe dans SQL?

J'ai une table: xxx pré>

Je veux supprimer plus longtemps nom2 code> pour chaque groupe de nom1 code>. Plus spécifiquement, pour chaque groupe de Name1 code>, les deux premiers caractères du plus court nom2 code> doivent être identiques à la plus longue. De plus, le nombre de lignes de chaque groupe devrait être 2, c'est-à-dire que des groupes avec des rangées de plus de 2 ne sont pas pris en compte. P>

Voici la sortie attendue: (Seul def est supprimé) P>

name1 name2
abc   de
xy    cdf
xy    che
mnp   qpr
mnp   qprt
mnp   qp

sql sql-server

3 commentaires

Pourquoi vous n'élevez pas "MNP QPRT" et "MNP QPR"

@Psk car il y a 3 lignes de mnp .


                                        
                                                                            @John . . . "De plus, le nombre de lignes de chaque groupe devrait être 2, c'est-à-dire que des groupes avec des lignes de plus de 2 ne sont pas pris en compte." Vos résultats n'ont pas de sens.



                                    
                    4 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Utiliser  dense_rank ()  et  Union Tout   xxx  
 sortie   xxx                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vous pouvez essayer comme suit. 
+-------+-------+
| name1 | name2 |
+-------+-------+
| abc   | de    |
+-------+-------+
| mnp   | qp    |
+-------+-------+
| mnp   | qpr   |
+-------+-------+
| mnp   | qprt  |
+-------+-------+
| xy    | cdf   |
+-------+-------+
| xy    | che   |
+-------+-------+

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Pouvez-vous expliquer votre réponse?                                                
                                                
                                                                                            
                                                    Merci pour votre solution et votre démo, PSK.                                                
                                                
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Quelque chose comme ça devrait fonctionner:  xxx  
   démo ici    
 Explication:  

  comptez (*) sur (partition par nom1)  compte la population de chaque  nom1  groupe d'enregistrements 
  externe s'applique  est utilisé pour vérifier les enregistrements ayant le même  nom1  et  similaire   nom2 . Similaire ici signifie même que l'autre mais plus court. 
  Vous pouvez facilement ajuster la vérification de la similarité par tripdling avec le  où  clause de la  externe s'applique  sous-requête.                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Vous pouvez utiliser une telle instruction SELECT: 
with t(name1, name2) as
(
 select 'abc','def'  union all 
 select 'abc','de'   union all
 select 'xy','cdf'   union all
 select 'xy','che'   union all
 select 'mnp','qpr'  union all
 select 'mnp','qprt' union all
 select 'mnp','qp' 
), t2 as
( 
select name1, max(name2) as name2
  from t 
 group by name1, substring(name2,1,2)
 having count(*) = 2
)  
select * from t except 
select * from t2;

name1   name2
-----   -----
abc     de
xy      cdf
xy      che
mnp     qpr
mnp     qprt
mnp     qp

                                

                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Erreur:  'substr' n'est pas un nom de fonction intégré reconnu.

Articles qui pourrait vous intéresser : Ordre des requêtes de syntaxe SQL par Problème de jointure sql, impossible de récupérer les enregistrements de la table a qui correspondent à une condition de la table b et les enregistrements restants de la table a Interroger les données de PostgreSQL à partir de deux tables Comment identifier les lignes par groupe avant un certain écart de valeur?