Oracle requête pour trouver toutes les occurrences d'un charcter dans une chaîne de caractères

Je dois écrire un Oracle de la requête en crapaud pour trouver toutes les occurrences d'un caractère dans une chaîne. Par exemple, si je suis à la recherche de R dans la chaîne SSSRNNSRSSR, il doit retourner les positions 4, 8 et 11.

Je suis nouveau à l'Oracle et j'ai essayé cette.

select instr(mtr_ctrl_flags, 'R', pos + 1, 1) as pos1 
  from mer_trans_reject  
 where pos in ( select instr(mtr_ctrl_flags, 'R', 1, 1) as pos 
                  from mer_trans_reject
                       );

où mtr_ctrl_flags est le nom de la colonne. J'obtiens un message d'erreur indiquant que pos est un identifiant invalide.

Défi intéressant. Ce serait un très étrange requête, ou vous aurez à écrire une procédure stockée. Ou il y a toujours ce dernier, malheureux possibilité qu'il existe une fonction très pratique je ne sais pas de...
(Auto-écrite) fonction pourrait être plus efficace que l'utilisation de tout type de requête récursive.
Il pourrait être, mais ne sous-estimez pas la surcharge d'appels de fonctions. Il serait intéressant de tester, si, mais actuellement, je n'ai que sqlfiddle, et je doute si c'est fiable plate-forme d'analyse comparative.

InformationsquelleAutor Rajeena Safeer | 2013-07-28

oracle sql

13

L'extension de GolezTrol de réponse, vous pouvez utiliser des expressions régulières pour réduire de façon significative le nombre de requêtes récursives vous n':
```
 select instr('SSSRNNSRSSR','R', 1, level)
   from dual
connect by level <= regexp_count('SSSRNNSRSSR', 'R')
```
REGEXP_COUNT() renvoie le nombre de fois que le motif correspond, dans ce cas, le nombre de fois R existe dans SSSRNNSRSSR. Cela limite le niveau de récursion le nombre exact que vous en avez besoin.

INSTR() simplement des recherches pour l'indice de R dans votre chaîne. level est la profondeur de la récursivité, mais dans ce cas c'est aussi le niveau th occurrence de la chaîne que nous avons limité le nombre d'analyse requis.

Si la chaîne que vous êtes désireux de choisir est plus compliqué que vous pourriez aller pour les expressions régulières sna REGEXP_INSTR() plutôt INSTR (), mais il sera plus lent (pas de beaucoup) et il n'est pas nécessaire sauf si requis.

Simple indice de référence demandés:

Les deux se connectent PAR des solutions serait d'indiquer que l'utilisation de REGEXP_COUNT est 20% plus rapide sur une chaîne de cette taille.
```
SQL> set timing on
SQL>
SQL> -- CONNECT BY with REGEX
SQL> declare
  2     type t__num is table of number index by binary_integer;
  3     t_num t__num;
  4  begin
  5    for i in 1 .. 100000 loop
  6       select instr('SSSRNNSRSSR','R', 1, level)
  7         bulk collect into t_num
  8         from dual
  9      connect by level <= regexp_count('SSSRNNSRSSR', 'R')
 10              ;
 11     end loop;
 12  end;
 13  /

PL/SQL procedure successfully completed.

Elapsed: 00:00:03.94
SQL>
SQL> -- CONNECT BY with filter
SQL> declare
  2     type t__num is table of number index by binary_integer;
  3     t_num t__num;
  4  begin
  5    for i in 1 .. 100000 loop
  6       select pos
  7         bulk collect into t_num
  8         from ( select substr('SSSRNNSRSSR', level, 1) as character
  9                     , level as pos
 10                  from dual t
 11               connect by level <= length('SSSRNNSRSSR') )
 12        where character = 'R'
 13              ;
 14     end loop;
 15  end;
 16  /

PL/SQL procedure successfully completed.

Elapsed: 00:00:04.80
```
Le pipeline fonction de table est juste un peu plus lent, mais il serait intéressant de voir comment il se comporte sur de grandes chaînes de caractères avec beaucoup de matchs.
```
SQL> -- PIPELINED TABLE FUNCTION
SQL> declare
  2     type t__num is table of number index by binary_integer;
  3     t_num t__num;
  4  begin
  5    for i in 1 .. 100000 loop
  6       select *
  7         bulk collect into t_num
  8         from table(string_indexes('SSSRNNSRSSR','R'))
  9              ;
 10     end loop;
 11  end;
 12  /

PL/SQL procedure successfully completed.

Elapsed: 00:00:06.54
```
- Solution sympa et un peu plus courte. Je pourrais être plus rapide en raison de moins de récursivité, mais d'un autre côté, la regex est plus lent que le "simple" des manipulations de chaînes. Tiens soi un indice de référence.
- Ce n'est pas que beaucoup plus lent @GolezTrol; j'ai fait un simple test et pour cette chaîne de caractères et le nombre de matches de moins de récursivité, c'est mieux... que la chaîne est plus petite, il fera moins (le cas échéant) de différence.
- Si la regex est plus rapide, au moins sur une chaîne de cette taille. Intéressant. Merci pour la référence!
- Pas de problème. Ce n'est pas seulement la taille de la chaîne, mais le nombre de correspondances qui fera la différence @GolezTrol, je dirais que l'indice de référence devrait être faite sur un "typique" de la chaîne et de l'utilisation selon l'une vient de sortir le plus rapidement de qui.
- Je ne suis pas censé utiliser les fonctions ou procédures.Mais cette requête fonctionne!.Comment puis-je concaténer que le résultat 3,8,11 dans une chaîne unique de 3$8$11?Merci pour la réponse.
- À l'aide de LISTAGG() serait l'approche traditionnelle @RajeenaSafeer, voir sqlfiddle.com/#!4/d41d8/15010
- Il fonctionne Ben.Je vous remercie beaucoup.
- quand je suis à l'ajout d'un champ id dans, sélectionnez mtr_id, instr(mtr_ctrl_flags,'R', 1, niveau) str à partir de mer_trans_reject connecter par niveau <= regexp_count(mtr_ctrl_flags, 'R');
InformationsquelleAutor Ben
8

C'est une solution:
```
select
  pos
from
  (select
    substr('SSSRNNSRSSR', level, 1) as character,
    level as pos
  from
    dual
  connect by
    level <= length(t.text))
where
  character = 'R'
```
dual est un construit dans le tableau qui ne renvoie qu'une seule ligne. Très pratique!

connect by vous permet de construire des requêtes récursives. Il est souvent utilisé pour générer des listes à partir de l'arbre de données (les relations parent/enfant). Il permet de plus ou moins répéter la requête en face d'elle. Et vous avez des domaines particuliers, comme level qui vous permet de vérifier à quel point la récursivité est allé.

Dans ce cas, je l'utilise pour diviser la chaîne de caractères et de retourner une ligne pour chaque personnage. À l'aide de level, je peux répéter la requête et obtenir un personnage jusqu'à la fin de la chaîne est atteint.

Alors c'est juste une question de retourner le pos pour toutes les lignes contenant le caractère 'R'

InformationsquelleAutor GolezTrol

À prendre a_horse_with_no_name du défi voici une autre réponse avec un pipeline fonction de table.

Un pipeline fonction renvoie un tableau, que vous pouvez interroger normalement. Je m'attends à ce que plus de chaînes avec un grand nombre de matchs, ce sera mieux que la requête récursive mais comme avec tout ce test vous-même d'abord.

create type num_array as table of number
/


create function string_indexes (
    PSource_String in varchar2
  , PSearch_String in varchar2
    ) return num_array pipelined is

begin

   for i in 1 .. length(PSource_String) loop

      if substr(PSource_String, i, 1) = PSearch_String then
         pipe row(i);
      end if;

   end loop;

   return;

end;
/

Puis dans l'ordre pour y accéder:

select *
  from table(string_indexes('SSSRNNSRSSR','R'))

SQL Violon

InformationsquelleAutor Ben

Vous devez vous connecter pour publier un commentaire.