SQL Besoin d'une requête qui retourne chaque champ qui contient une lettre spécifiée

J'ai une table SQL avec 11000 mots clés en elle.

Je veux une requête qui peut trouver des champs qui contiennent un certian lettre.

Donc, si je comprend "a" et "b", la requête permet de sélectionner tous les champs qui contiennent la lettre "a" et la lettre "b" quelque part dans le champ.

Vous êtes à la recherche uniquement pour en minuscules ou en majuscules?

OriginalL'auteur Erik | 2009-10-16

sql

5
```
select *
from table
where keyword like '%a%'
and keyword like '%b%'
```
ps, Ce sera super lent. Vous souhaitez peut-être enquêter sur l'indexation du texte intégral des solutions.

L'indexation de texte intégral n'y a généralement pas de l'aide pour la recherche de mots plus courts que 3-4 personnages.
Comme ce sera lent de toute façon, vous pourriez jeter dans un lower(keyword) si il n'est pas nécessaire de différencier les majuscules et minuscules.

OriginalL'auteur Tom Ritter
2

essayer cette
```
Select * From Table
Where field like '%' + ltrValue1 + '%'
  And field like '%' + ltrValue2 + '%'
... etc.
```
et être préparé pour une analyse de table que cette fonctionnalité ne peut pas utiliser n'importe quel indices

OriginalL'auteur Charles Bretana
2

J'avais utilisez les caractères génériques de la recherche.
```
where <field> like '%[ab]%'
```
Il n'est pas regex, mais il fait un bon travail.
Vous pouvez aussi faire des variantes comme <field> like 'sim[oa]ns' -- qui va correspondre à simons, et simans...

Depnding sur votre classement, vous peut ou peut ne pas inclure les données de cas, like '%[aAbB]%'

Comme mentionné ailleurs être préparé pour une attente comme les indices sont hors de question, quand vous êtes en train de faire contient de la recherche.

Kris

OriginalL'auteur KSimons
1

Toutes les réponses données à l'aide de LIKEsont totalement valables, mais que chacun d'entre eux a noté la lenteur. Donc, si vous avez beaucoup de questions et pas trop de changements dans la liste de mots-clés, il est utile de construire une structure qui permet d'accélérer les requêtes.

Voici quelques idées:

Si tout ce que vous cherchez est les lettres de a à z et vous ne vous souciez pas des majuscules/minuscules, vous pouvez ajouter des colonnes containsA .. containsZ et de pré-remplir les colonnes:
```
UPDATE table
SET containsA = 'X' 
WHERE UPEPR(your_field) Like '%A%';
```
(et ainsi de suite pour toutes les colonnes).

L'indice, puis l'contient.. colonnes et votre requête serait
```
SELECT 
FROM your_table
WHERE containsA = 'X'
AND containsB = 'X'
```
Cela peut être normalisée dans un "index de la table" iTable avec les colonnes your_table_key, lettre, l'indice de la lettre de la colonne et de votre requête devient quelque chose comme
```
SELECT
FROM your_table 
WHERE <key> in (select a.key
    From iTable a join iTable b and a.key = b.key
    Where a.letter = 'a'
    AND b.letter = 'b');
```
Toutes ces opérations nécessitent certains de prétraitement (peut-être dans un déclencheur ou de faire), mais la question doit être beaucoup plus rapide.

Yep, si c'est une commune de la requête, prefilling peut être le meilleur pari. La première remplir prendra un certain temps, mais les insertions et mises à jour de passer après ça devrait aller assez vite dans un écrit correctement déclencher comme vous affecte seulement un très petit nombre de lignes en général.

OriginalL'auteur Thorsten

where somefield like '%a%' or somefield like '%b%'

OriginalL'auteur longneck

0
```
select * from your_table where your_field like '%a%b%'
```
et être prêt à attendre un certain temps...

Edit: notez que ce modèle à la recherche d'un "a", suivi par un 'b' (éventuellement avec d'autres "trucs" entre les deux) - en relisant ta question, qui peut ne pas être ce que tu voulais...

En fait, cela ne fonctionnera pas si le contenu du champ est quelque chose comme "bddddatttt'
Oui, au départ, j'avais mal lu sa question en disant: "...et puis la lettre "b"," au lieu de "...et la lettre "b""

OriginalL'auteur Jerry Coffin
0

Je vais supposer que vous vouliez dire plus ou moins ce que vous avez dit, et vous souhaitez trouver des mots-clés dans votre table qui contient la lettre " a "et la lettre "b"." Certaines des solutions proposées ici ne donnent la réponse à une autre question.

Pour obtenir des mots-clés qui contiennent les deux les lettres " a " et " b " (par opposition à celles qui contiennent soit lettre), vous pouvez utiliser 'ab', comme dans la requête ci-dessous:
```
select
  keyword
from myTable
where not exists (
  select Nums26.i from Nums26
  where Nums26.i <= len(<matchsetstring>) -- or your dialect's equivalent for LEN()
  and keyword not like '%'+substring(<matchsetstring>,Nums26.i,1)+'%' -- adapt SUBSTRING to your dialect
);
```
La table nommée "Nums26" doit contenir une colonne "i" (indexé pour l'efficacité) qui contient chacune des valeurs de 1 à 26 (ou plus si vous pouvez essayer de faire correspondre plus que des lettres). Voir ci-dessous. Les conseils donnés par d'autres en ce qui concerne les majuscules et les minuscules. Si votre classement est sensible à la casse, cependant, vous ne pouvez simplement spécifier "aAbB" ici comme le votre , parce que cela demande des mots-clés qui contiennent chacun des quatre personnages a, A, b et B. Vous pouvez utiliser des majuscules et match "AB", peut-être.
```
create table nums26 (
  i int primary key
);
insert into nums26 values (1);
insert into nums26 select 1+i from nums26;
insert into nums26 select 2+i from nums26;
insert into nums26 select 4+i from nums26;
insert into nums26 select 8+i from nums26;
insert into nums26 select 16+i from nums26;
```
OriginalL'auteur Steve Kass

Vous pouvez utiliser un curseur et de la table temporaire approche de sorte que vous ne faites pas des full table scan à chaque fois. Ce que cela ferait de remplissage de la table temporaire avec l'ensemble de vos mots-clés, puis chaque chaîne dans le @letters XML, il serait de supprimer tous les enregistrements de la table temporaire. À la fin, vous n'avez enregistrements dans une table temporaire qui ont chacun de votre choix chaînes.

declare @letters xml

SET @letters = '&lt;letters&gt;
            &lt;letter&gt;a&lt;/letter&gt;
            &lt;letter&gt;b&lt;/letter&gt;
        &lt;/letters&gt;'

-- SELECTING LETTERS FROM THE XML
SELECT Letters.l.value('.', 'nvarchar(50)') AS letter
FROM @letters.nodes('/letters/letter') AS Letters(l)

-- CREATE A TEMP TABLE WE CAN DELETE FROM IF A RECORD DOESN'T HAVE THE LETTER
CREATE TABLE #TempResults (keywordID int not null, keyWord nvarchar(50) not null)
INSERT INTO #TempResults (keywordID, keyWord)
SELECT employeeID, firstName FROM Employee

-- CREATE A CURSOR, SO WE CAN LOOP THROUGH OUR LETTERS AND REMOVE KEYWORDS THAT DON'T MATCH
DECLARE Cursor_Letters CURSOR READ_ONLY
FOR 
    SELECT Letters.l.value('.', 'nvarchar(50)') AS letter
    FROM @letters.nodes('/letters/letter') AS Letters(l)

DECLARE @letter varchar(50)
OPEN Cursor_Letters

FETCH NEXT FROM Cursor_Letters INTO @letter
WHILE (@@fetch_status <> -1)
BEGIN
    IF (@@fetch_status <> -2)
    BEGIN
        DELETE FROM #TempResults 
        WHERE  keywordID NOT IN 
        (SELECT keywordID FROM #TempResults WHERE keyWord LIKE '%' + @letter + '%')
    END
    FETCH NEXT FROM Cursor_Letters INTO @letter
END

CLOSE Cursor_Letters
DEALLOCATE Cursor_Letters

SELECT * FROM #TempResults

DROP Table #TempResults
GO

OriginalL'auteur Greg Andora

Vous devez vous connecter pour publier un commentaire.