J'essaie de créer une requête en utilisant un db sur OpenOffice où une chaîne est entrée dans la requête, et toutes les permutations de la chaîne sont recherchées dans la base de données et les correspondances sont affichées. Ma base de données contient des champs pour un mot et sa définition, donc si je cherche GOOD, j'obtiendrai sa définition ainsi que la définition de DOG.Requête SQL - Permutations de chaîne
Fondamentalement, vous ne pouvez pas facilement faire des permutations dans une seule instruction SQL. Vous pouvez facilement les faire dans une autre langue, par exemple, voici comment le faire en C#: http://msdn.microsoft.com/en-us/magazine/cc163513.aspx
Vous aurez également besoin d'une troisième colonne. Dans cette colonne, vous aurez le mot - mais avec les lettres triées par ordre alphabétique. Par exemple, vous aurez le mot APPLE et dans la colonne suivante le mot AELPP. Vous triaient le mot que vous cherchez - et exécuter un certain code SQL comme
WHERE sorted_words = 'my_sorted_word'
pour la pomme de mot, vous obtiendrez quelque chose comme ceci:
unsorted sorted
AELPP APPLE
AELPP PEPLA
AELPP APPELMaintenant, vous avez aussi voulu - corrigez-moi si je me trompe, mais vous voulez tous les mots qui peuvent être faits avec ** n'importe quelle combinaison ** des lettres, ce qui signifie que APPLE renvoie aussi des mots comme LEAP et PEA.
Pour ce faire, vous devez utiliser un langage de programmation - vous devez écrire une fonction qui préformées ci-dessus récursive, par exemple - pour le mot AELLP vous avez
O k, version corrigée qui, je pense, gère toutes les situations. Cela fonctionnera dans MS SQL Server, donc vous devrez peut-être l'ajuster pour votre SGBDR jusqu'à l'utilisation de la table locale et de la fonction REPLICATE. Il suppose un paramètre passé appelé @search_string. En outre, comme il utilise VARCHAR au lieu de NVARCHAR, si vous utilisez des caractères étendus, veillez à le modifier.
Un dernier point auquel je pense juste maintenant ... il permettra la duplication de lettres. Par exemple, "GOOD" trouverait "DODO" même s'il n'y a qu'un "D" dans "GOOD". Cependant, il ne trouvera pas de mots de plus grande longueur que votre mot d'origine. En d'autres termes, alors qu'il trouverait "DODO", il ne trouverait pas "DODODO". Peut-être que cela vous donnera un point de départ à partir de travailler en fonction de vos besoins précis.
DECLARE @search_table TABLE (search_string VARCHAR(4000))
DECLARE @i INT
SET @i = 1
WHILE (@i <= LEN(@search_string))
BEGIN
INSERT INTO @search_table (search_string)
VALUES (REPLICATE('[' + @search_string + ']', @i)
SET @i = @i + 1
END
SELECT
word,
definition
FROM
My_Words
INNER JOIN @search_table ST ON W.word LIKE ST.search_string
La requête originale avant mon édition, juste pour avoir ici:
SELECT
word,
definition
FROM
My_Words
WHERE
word LIKE REPLICATE('[' + @search_string + ']', LEN(@search_string))
Supposons que vous ayez une table de nombres auxiliaires avec des nombres entiers.
DECLARE @s VARCHAR(5);
SET @s = 'ABCDE';
WITH Subsets AS (
SELECT CAST(SUBSTRING(@s, Number, 1) AS VARCHAR(5)) AS Token,
CAST('.'+CAST(Number AS CHAR(1))+'.' AS VARCHAR(11)) AS Permutation,
CAST(1 AS INT) AS Iteration
FROM dbo.Numbers WHERE Number BETWEEN 1 AND 5
UNION ALL
SELECT CAST(Token+SUBSTRING(@s, Number, 1) AS VARCHAR(5)) AS Token,
CAST(Permutation+CAST(Number AS CHAR(1))+'.' AS VARCHAR(11)) AS
Permutation,
s.Iteration + 1 AS Iteration
FROM Subsets s JOIN dbo.Numbers n ON s.Permutation NOT LIKE
'%.'+CAST(Number AS CHAR(1))+'.%' AND s.Iteration < 5 AND Number
BETWEEN 1 AND 5
--AND s.Iteration = (SELECT MAX(Iteration) FROM Subsets)
)
SELECT * FROM Subsets
WHERE Iteration = 5
ORDER BY Permutation
Token Permutation Iteration
----- ----------- -----------
ABCDE .1.2.3.4.5. 5
ABCED .1.2.3.5.4. 5
ABDCE .1.2.4.3.5. 5
(snip)
EDBCA .5.4.2.3.1. 5
EDCAB .5.4.3.1.2. 5
EDCBA .5.4.3.2.1. 5
(120 row(s) affected)