Comment scinder une chaîne de valeur basée sur un délimiteur dans DB2

Réponse courte:

Vous avez besoin de trouver la position de l'
séparateur, puis une sous-chaîne à utiliser comme point de départ, et une longueur calculée.

SELECT 
    SUBSTR('CHG-FFH', 1, LOCATE('-','CHG-FFH')-1) as FIRST_PART
  , SUBSTR('CHG-FFH', LOCATE('-','CHG-FFH')+1)   as SECOND_PART
FROM SYSIBM.SYSDUMMY1;

BONUS! Si vous faites cela souvent, créer une fonction définie par l'utilisateur pour le faire de façon dynamique. Voici un exemple dans une base de violon.

CREATE FUNCTION SPLITTER (input VARCHAR(4000), delimiter CHAR, part_number INTEGER)
      RETURNS VARCHAR(4000)
      LANGUAGE SQL
      READS SQL DATA
      NO EXTERNAL ACTION
      DETERMINISTIC
      RETURN 

with pos_info (first_pos, length) as (
select 
  case when part_number = 1 then 0
       else LOCATE_IN_STRING(input, delimiter,1, part_number-1, OCTETS)  
  end as first_pos, 

  case when part_number = 1 then LOCATE_IN_STRING(input, delimiter,1, part_number, OCTETS) - 1 
       when LOCATE_IN_STRING(input, delimiter,1, part_number, OCTETS) = 0
        and  LOCATE_IN_STRING(input, delimiter,1, part_number-1, OCTETS) = 0
       then 0
       when LOCATE_IN_STRING(input, delimiter,1, part_number, OCTETS) = 0
       then length(input) -  LOCATE_IN_STRING(input, '-',1, part_number - 1,    OCTETS)
       else LOCATE_IN_STRING(input, delimiter,1, part_number, OCTETS) -    LOCATE_IN_STRING(input, delimiter,1, part_number-1, OCTETS) - 1
  end as length
from sysibm.sysdummy1
)

select    
    substr(input, first_pos+1,length) as part
from pos_info;

Sinon, vous pouvez voir une approche différente ici, à cette réponse: Diviser un VARCHAR dans DB2 pour récupérer une valeur à l'intérieur.

---

Réponse longue:

DB2, avec d'autres bases de données relationnelles ne fournissent pas une seule fonction pour accomplir cette tâche.

La raison en est probablement que ce n'est pas implicitement une fonction scalaire. Si votre chaîne avait plus d'un tiret, voulez-vous de le diviser en trois parties? Quatre? Donc, la première étape est à noter que si vos données est déterminée, - si il y a un certain nombre de composants que vous souhaitez vous séparer. Dans votre exemple, vous avez les deux, alors je vais commencer avec cette hypothèse, et puis par la suite des commentaires sur la façon de traiter les autres situations.

Scénario: Une chaîne de valeur avec deux composants séparés par un délimiteur

Avec seulement deux pièces, vous devez trouver la position du séparateur, puis sous-chaîne de caractères avant et après à l'aide de la position avant et après les avoir dans une fonction de sous-chaîne.

1. RECHERCHEZ l'index de votre délimiteur.

LOCATE('-','CHG-FFH')

REMARQUE: DB2 fournit deux fonctions qui peuvent être utilisées pour cela: POSITION (ou POSSTR), et LOCALISER (ou LOCATE_IN_STRING). RECHERCHEZ est un peu plus puissante, car elle permet de définir la position de départ, ce qui serait utile si vous avez eu plus d'un délimiteur.

1. SUBSTR en utilisant le délimiteur de l'index.

Pour la première partie, démarrez votre sous-chaîne à la position 1, vers le caractère avant le délimiteur (délimiteur de position - 1):

SUBSTR('CHG-FFH', 1,LOCATE('-','CHG-FFH')-1) as FIRST_PART

Pour la deuxième partie, démarrez votre sous-chaîne à la position après le délimiteur index (délimiteur de position + 1), et obtenir le reste de la Chaîne:

 SUBSTR('CHG-FFH', LOCATE('-','CHG-FFH')+1) as SECOND_PART

Résultat Final:

SELECT 
    SUBSTR('CHG-FFH', 1,LOCATE('-','CHG-FFH')-1) as FIRST_PART
  , SUBSTR('CHG-FFH', LOCATE('-','CHG-FFH')+1) as SECOND_PART
FROM SYSIBM.SYSDUMMY1;

Scénario: Une chaîne de valeur avec trois composants séparés par un délimiteur

Utiliser les mêmes concepts que le premier scénario, mais vous devez déterminer l'indice de la deuxième séparateur. Utiliser l'index du premier caractère de séparation utilisé pour spécifier un point de départ: à Noter que RECHERCHEZ permet de spécifier une position de départ:

>>-LOCATE(search-string,source-string-+--------+-+--------------------+-)-><
                                      '-,start-' '-,--+-CODEUNITS16-+-'     
                                                      +-CODEUNITS32-+       
                                                      '-OCTETS------' 

Trouver le second délimiteur:

D'utiliser la position du premier délimiteur comme le point de départ pour trouver le second délimiteur.

LOCATE('-','CHG-FFH-EEE', LOCATE('-','CHG-FFH-EEE')+1)

De l'utiliser comme un SUBSTR point pour les deuxième et troisième valeurs, et vous êtes tous ensemble. Remarque: Pour la deuxième valeur, vous devez utiliser à la fois du séparateur de lieux à sous-chaîne de la valeur.

Résultat Final:

SELECT 
    SUBSTR('CHG-FFH-EEE', 1,LOCATE('-','CHG-FFH-EEE')-1) as FIRST_PART
  , SUBSTR('CHG-FFH-EEE', LOCATE('-','CHG-FFH-EEE')+1, LOCATE('-','CHG-FFH-EEE', LOCATE('-','CHG-FFH-EEE'))-1) as SECOND_PART
  , SUBSTR('CHG-FFH-EEE', LOCATE('-','CHG-FFH-EEE', LOCATE('-','CHG-FFH-EEE')+1)+1) as THIRD_PART
FROM SYSIBM.SYSDUMMY1;

Vous pouvez le voir, cette stratégie permettrait de sortir de la main pour un plus grand nombre de séparateurs dans votre Chaîne.

Scénario: durée Indéterminée nombre de séparateurs

C'est un problème délicat qui est le mieux approché avec une Procédure Stockée. Pensez à travers des choses comme: Comment voulez-vous que l'analyse des données de l'algorithme, comment allez-vous pour accéder aux données? Les tableaux ne sont pas un type natif, en SQL, mais ils sont dans des Procédures Stockées, de sorte qu'allez-vous faire avec le tableau lorsque vous avez analysé toutes les pièces de votre Chaîne?

Une manière d'aborder ce scénario est la réponse ici:

Diviser un VARCHAR dans DB2 pour récupérer une valeur à l'intérieur

OriginalL'auteur Josh Hull

Essayer cette déclaration:

select substr(your_value, 1,3), substr(your_value, 4, 3) from your_table

OriginalL'auteur Peter Miehle

J'avais besoin d'utiliser l'instrument, substr, garniture, et sali avec localiser aussi bien.. mais instr, et substr sont tous pris en charge. Vous pouvez trouver un patron. J'ai dû passer par un varchar split avec " - " et nécessaires pour trouver la fin et revenir en arrière à partir de là.

           select  itn, 
           substr(Message, 1 , locate(' - ', Message)) FIRST_SSR,  
           SUBSTR(Message , instr( message, ' - ', octets)+1, (instr( 
            message, '(Ref', octets)+1)) SECOND_STR ,
           Message
              from
         (
   select p.itn itn, 
          substr(p.msg,  instr( p.msg, ' - ' , octets)+21) Message
    from itnpad p
    where p.msg like '%MR - Multiple Requests%'

       ) A 

OriginalL'auteur David Isser

Dans DB2

SELECT
'11,222,33,444' AS THE_F_STRING
SUBSTR('11,222,33,444', 1, LOCATE_IN_STRING('11,222,33,444',',',1,1)-1) AS AA
SUBSTR('11,222,33,444', LOCATE_IN_STRING('11,222,33,444',',',1,1)+1, LOCATE_IN_STRING('11,222,33,444',',',1,2)-LOCATE_IN_STRING('11,222,33,444',',',1,1)-1) AS BB 
SUBSTR('11,222,33,444', LOCATE_IN_STRING('11,222,33,444',',',1,2)+1, LOCATE_IN_STRING('11,222,33,444',',',1,3)-LOCATE_IN_STRING('11,222,33,444',',',1,2)-1) AS CC
SUBSTR('11,222,33,444', LOCATE_IN_STRING('11,222,33,444',',',1,3)+1, LENGTH('11,222,33,444')-LOCATE_IN_STRING('11,222,33,444',',',1,3)) AS DD
FROM SYSIBM.SYSDUMMY1;

Garder d'extrapoler...profitez-en...

OriginalL'auteur Vikram Vedha