Gibt es eine Kombination von "LIKE" und "IN" in SQL?

Question

In SQL muss ich (leider) oft "LIKE"-Bedingungen verwenden, aufgrund von Datenbanken, die nahezu alle Regeln der Normalisierung verletzen. Das kann ich im Moment nicht ändern. Aber das ist irrelevant für die Frage.

Weiterhin verwende ich oft Bedingungen wie WHERE etwas in (1,1,2,3,5,8,13,21) für bessere Lesbarkeit und Flexibilität meiner SQL-Anweisungen.

Gibt es eine mögliche Möglichkeit, diese beiden Dinge ohne das Schreiben von komplizierten Unterabfragen zu kombinieren?

Ich möchte etwas so Einfaches wie WHERE etwas LIKE ('bla%', '%foo%', 'batz%') anstelle von diesem:

WHERE something LIKE 'bla%'
OR something LIKE '%foo%'
OR something LIKE 'batz%'

Ich arbeite hier mit SQL Server und Oracle, aber ich bin interessiert, ob dies überhaupt in einem RDBMS möglich ist.

Answer 1

Es gibt keine Kombination von LIKE & IN in SQL, schon gar nicht in TSQL (SQL Server) oder PLSQL (Oracle). Ein Teil des Grundes dafür ist, dass die Volltextsuche (FTS) die empfohlene Alternative ist.

Sowohl Oracle als auch SQL Server FTS-Implementierungen unterstützen das Schlüsselwort CONTAINS, aber die Syntax ist immer noch leicht unterschiedlich:

Oracle:

WHERE CONTAINS(t.something, 'bla OR foo OR batz', 1) > 0

SQL Server:

WHERE CONTAINS(t.something, '"bla*" OR "foo*" OR "batz*"')

Die Spalte, die Sie abfragen, muss volltextindiziert sein.

Referenz:

• Erstellen von Volltextsuche-Anwendungen mit Oracle Text
• Verständnis von SQL Server Volltext

Answer 2

Wenn Sie Ihre Aussage leicht lesbar machen möchten, können Sie REGEXP_LIKE verwenden (verfügbar ab Oracle-Version 10).

Ein Beispiel für eine Tabelle:

SQL> create table mytable (something)
  2  as
  3  select 'blabla' from dual union all
  4  select 'notbla' from dual union all
  5  select 'ofooof' from dual union all
  6  select 'ofofof' from dual union all
  7  select 'batzzz' from dual
  8  /

Tabelle erstellt.

Die originale Syntax:

SQL> select something
  2    from mytable
  3   where something like 'bla%'
  4      or something like '%foo%'
  5      or something like 'batz%'
  6  /

SOMETH
------
blabla
ofooof
batzzz

3 Zeilen ausgewählt.

Und eine einfach aussehende Abfrage mit REGEXP_LIKE

SQL> select something
  2    from mytable
  3   where regexp_like (something,'^bla|foo|^batz')
  4  /

SOMETH
------
blabla
ofooof
batzzz

3 Zeilen ausgewählt.

ABER ...

Ich würde es aufgrund der nicht besonders guten Leistung nicht empfehlen. Ich würde bei mehreren LIKE-Prädikaten bleiben. Also waren die Beispiele nur zum Spaß.

Answer 3

Sie sind stecken geblieben mit dem

WHERE something LIKE 'bla%'
OR something LIKE '%foo%'
OR something LIKE 'batz%'

es sei denn, Sie füllen eine Temporäre Tabelle (inklusive der Wildcards mit den Daten) und verbinden es auf diese Weise:

FROM IhreTabelle                y
    INNER JOIN IhreTemporäreTabelle  t On y.something LIKE t.something

Probieren Sie es aus (verwenden Sie die SQL Server Syntax):

declare @x table (x varchar(10))
declare @y table (y varchar(10))

insert @x values ('abcdefg')
insert @x values ('abc')
insert @x values ('mnop')

insert @y values ('%abc%')
insert @y values ('%b%')

select distinct *
FROM @x x
WHERE x.x LIKE '%abc%' 
   or x.x LIKE '%b%'

select distinct x.*  
FROM @x             x
    INNER JOIN  @y  y On x.x LIKE y.y

AUSGABE:

x
----------
abcdefg
abc

(2 row(s) affected)

x
----------
abc
abcdefg

(2 row(s) affected)

Answer 4

Mit PostgreSQL gibt es die ANY oder ALL Form:

WHERE col LIKE ANY( subselect )

oder

WHERE col LIKE ALL( subselect )

wo die subselect genau eine Datenspalte zurückgibt.

Answer 5

Eine weitere Lösung, die auf allen RDBMS funktionieren sollte:

WHERE EXISTS (SELECT 1
                FROM (SELECT 'bla%' pattern FROM dual UNION ALL
                      SELECT '%foo%'        FROM dual UNION ALL
                      SELECT 'batz%'        FROM dual)
               WHERE something LIKE pattern)

Das innere SELECT kann durch eine andere Quelle von Mustern wie einer Tabelle (oder einer Ansicht) ersetzt werden, auf diese Weise:

WHERE EXISTS (SELECT 1
                FROM table_of_patterns t
               WHERE something LIKE t.pattern)

table_of_patterns sollte mindestens eine Spalte pattern enthalten und kann wie folgt befüllt werden:

INSERT INTO table_of_patterns(pattern) VALUES ('bla%');
INSERT INTO table_of_patterns(pattern) VALUES ('%foo%');
INSERT INTO table_of_patterns(pattern) VALUES ('batz%');