SEARCH_IP

Sucht nach gültigen IPv4-Adressen in angegebenen Zeichenfolgen aus einer oder mehreren Tabellen, einschließlich Feldern in den Spalten VARIANT, OBJECT und ARRAY. Die Suche basiert auf einer einzelnen IP-Adresse oder einem Bereich von IP-Adressen, die Sie angeben. Wenn diese IP-Adresse mit einer IP-Adresse in der angegebenen Spalte oder im angegebenen Feld übereinstimmt, gibt die Funktion TRUE zurück.

Weitere Informationen zur Verwendung dieser Funktion finden Sie unter Verwenden der Volltextsuche.

Syntax

SEARCH_IP( <search_data>, <search_string> )
Copy

Argumente

search_data

Die Daten, die Sie suchen möchten, ausgedrückt als durch Kommas getrennte Listen von Zeichenfolgen, Spaltennamen oder Pfaden zu Feldern in VARIANT-Spalten. Die Suchdaten können auch aus einer einzelnen literalen Zeichenfolge bestehen, was nützlich für das Testen der Funktion sein kann.

Sie können das Platzhalterzeichen (*) angeben, wobei sich * auf alle qualifizierten Spalten in allen Tabellen ausdehnt, die sich im Bereich der Funktion befinden. Qualifizierte Spalten sind diejenigen, die die Datentypen VARCHAR (Text), VARIANT, ARRAY und OBJECT haben. VARIANT-, ARRAY- und OBJECT-Daten werden für die Suche in Text umgewandelt. Sie können auch die Schlüsselwörter ILIKE und EXCLUDE zum Filtern verwenden.

Weitere Informationen zu diesem Argument finden Sie in der Beschreibung search_data der SEARCH Funktion.

search_string

Eine VARCHAR-Zeichenfolge, die eine der folgenden Angaben enthält:

  • Eine vollständige und gültige IP-Adresse im Standardformat IPv4, z. B. 192.0.2.1.

  • Eine gültige IP-Adresse im Standardformat IPv4 mit einem Classless Inter-Domain Routing-Bereich (CIDR) Bereich, wie z. B. 192.0.2.1/24.

  • Eine gültige IP Adresse im Standardformat IPv4 mit führenden Nullen, z. B. 192.000.002.001 (anstelle von 192.0.2.1). Die Funktion akzeptiert bis zu drei Ziffern für jeden Teil der IP-Adresse.

Dieses Argument muss eine literale Zeichenfolge sein. Geben Sie ein Paar einfache Anführungszeichen um die Zeichenfolge an.

Die folgenden Arten von Argumenten werden nicht unterstützt:

  • Spaltennamen

  • Leere Zeichenfolgen

  • Mehr als eine IP-Adresse

  • Partielle IPv4-Adressen

  • IPv6-Adressen

Rückgabewerte

Gibt einen BOOLEAN-Wert zurück.

  • Gibt TRUE zurück, wenn eine gültige IP-Adresse in search_string angegeben ist und eine passende IP-Adresse in search_data gefunden wird.

  • Gibt TRUE zurück, wenn in search_string eine gültige IP-Adresse mit einem CIDR-Bereich angegeben ist und in search_data eine IP-Adresse in dem angegebenen Bereich gefunden wird.

  • Gibt NULL zurück, wenn eines dieser Argumente NULL ist.

  • Andernfalls wird FALSE zurückgegeben.

Nutzungshinweise

  • Die SEARCH_IP-Funktion arbeitet nur mit VARCHAR-, VARIANT-, ARRAY- und OBJECT-Daten. Die Funktion gibt einen Fehler zurück, wenn das Argument search_data keine Daten dieser Datentypen enthält. Wenn das Argument search_data sowohl Daten von unterstützten als auch von nicht unterstützten Datentypen enthält, sucht die Funktion die Daten der unterstützten Datentypen und ignoriert die Daten der nicht unterstützten Datentypen. Weitere Beispiele finden Sie unter Beispiele für erwartete Fehlerfälle.

  • Die Funktion gibt einen Fehler zurück, wenn das Argument search_string keine gültige IP-Adresse ist. Weitere Beispiele finden Sie unter Beispiele für erwartete Fehlerfälle.

  • Sie können eine Optimierung der FULL_TEXT-Suche für Spalten hinzufügen, die das Ziel von SEARCH_IP-Funktionsaufrufen sind, indem Sie den Befehl ALTER TABLE verwenden, der die ENTITY_ANALYZER angibt. Beispiel:

    ALTER TABLE ipt ADD SEARCH OPTIMIZATION ON FULL_TEXT(
  ip1,
  ANALYZER => 'ENTITY_ANALYZER');
    Copy

    Der ENTITY_ANALYZER erkennt nur die Entitäten (z. B. IP-Adressen). Daher ist der Suchzugriffspfad in der Regel viel kleiner als die FULL_TEXT-Suchoptimierung mit einem anderen Analysator.

    Weitere Informationen finden Sie unter Aktivieren der FULL_TEXT-Suchoptimierung.

Beispiele

Die folgenden Beispiele verwenden die Funktion SEARCH_IP.

Suche nach passenden IP-Adressen in VARCHAR-Spalten

Die folgenden Beispiele zeigen, wie Sie die Funktion SEARCH_IP verwenden, um VARCHAR-Spalten abzufragen.

Erstellen Sie eine Tabelle mit dem Namen ipt und fügen Sie zwei Zeilen ein:

CREATE OR REPLACE TABLE ipt(id INT, ip1 VARCHAR(20), ip2 VARCHAR(20));
INSERT INTO ipt VALUES(1, '192.0.2.146', '203.0.113.5');
INSERT INTO ipt VALUES(2, '192.0.2.111', '192.000.002.146');
Copy

Führen Sie die folgenden Suchabfragen aus. Die erste Abfrage verwendet die Funktion SEARCH_IP in der SELECT-Liste und durchsucht die beiden VARCHAR-Spalten in der Tabelle:

SELECT ip1,
       ip2,
       SEARCH_IP((ip1, ip2), '192.0.2.146')
  FROM ipt
  ORDER BY ip1;
Copy
+-------------+-----------------+--------------------------------------+
| IP1         | IP2             | SEARCH_IP((IP1, IP2), '192.0.2.146') |
|-------------+-----------------+--------------------------------------|
| 192.0.2.111 | 192.000.002.146 | True                                 |
| 192.0.2.146 | 203.0.113.5     | True                                 |
+-------------+-----------------+--------------------------------------+

Beachten Sie, dass search_data 192.000.002.146 eine Übereinstimmung mit search_string 192.0.2.146 ist, obwohl 192.000.002.146 führende Nullen enthält.

Diese Abfrage zeigt eine search_string mit einem CIDR-Bereich:

SELECT ip1,
       ip2,
       SEARCH_IP((ip1, ip2), '192.0.2.1/20')
  FROM ipt
  ORDER BY ip1;
Copy
+-------------+-----------------+---------------------------------------+
| IP1         | IP2             | SEARCH_IP((IP1, IP2), '192.0.2.1/20') |
|-------------+-----------------+---------------------------------------|
| 192.0.2.111 | 192.000.002.146 | True                                  |
| 192.0.2.146 | 203.0.113.5     | True                                  |
+-------------+-----------------+---------------------------------------+

Diese Abfrage zeigt, dass eine search_string mit führenden Nullen True für IP-Adressen liefert, bei denen die führenden Nullen weggelassen wurden:

SELECT ip1,
       ip2,
       SEARCH_IP((ip1, ip2), '203.000.113.005')
  FROM ipt
  ORDER BY ip1;
Copy
+-------------+-----------------+------------------------------------------+
| IP1         | IP2             | SEARCH_IP((IP1, IP2), '203.000.113.005') |
|-------------+-----------------+------------------------------------------|
| 192.0.2.111 | 192.000.002.146 | False                                    |
| 192.0.2.146 | 203.0.113.5     | True                                     |
+-------------+-----------------+------------------------------------------+

Diese Abfrage verwendet die Funktion in der WHERE-Klausel und sucht nur in der Spalte ip2.

SELECT ip1,
       ip2
  FROM ipt
  WHERE SEARCH_IP(ip2, '203.0.113.5')
  ORDER BY ip1;
Copy
+-------------+-------------+
| IP1         | IP2         |
|-------------+-------------|
| 192.0.2.146 | 203.0.113.5 |
+-------------+-------------+

Wenn die Funktion in der WHERE-Klausel verwendet wird und es keine Übereinstimmung gibt, werden keine Werte zurückgegeben.

SELECT ip1,
       ip2
  FROM ipt
  WHERE SEARCH_IP(ip2, '203.0.113.1')
  ORDER BY ip1;
Copy
+-----+-----+
| IP1 | IP2 |
|-----+-----|
+-----+-----+

Sie können das Zeichen * (oder table.*) als erstes Argument für die SEARCH-Funktion verwenden, wie in diesem Beispiel gezeigt. Die Operation bezieht sich auf alle qualifizierten Spalten in der Tabelle, aus der Sie auswählen.

SELECT ip1,
       ip2
  FROM ipt
  WHERE SEARCH_IP((*), '203.0.113.5')
  ORDER BY ip1;
Copy
+-------------+-------------+
| IP1         | IP2         |
|-------------+-------------|
| 192.0.2.146 | 203.0.113.5 |
+-------------+-------------+

Sie können auch die Schlüsselwörter ILIKE und EXCLUDE zum Filtern verwenden. Weitere Informationen zu diesen Schlüsselwörtern finden Sie unter SELECT.

Diese Suche verwendet das Schlüsselwort ILIKE, um nur in Spalten zu suchen, die mit der Zeichenfolge ip beginnen.

SELECT ip1,
       ip2
  FROM ipt
  WHERE SEARCH_IP(* ILIKE 'ip%', '192.0.2.111')
  ORDER BY ip1;
Copy
+-------------+-----------------+
| IP1         | IP2             |
|-------------+-----------------|
| 192.0.2.111 | 192.000.002.146 |
+-------------+-----------------+

Um die Optimierung der FULL_TEXT-Suche für die Spalten der Tabelle ipt zu aktivieren, führen Sie den folgenden ALTER TABLE Befehl aus:

ALTER TABLE ipt ADD SEARCH OPTIMIZATION ON FULL_TEXT(
  ip1,
  ip2,
  ANALYZER => 'ENTITY_ANALYZER');
Copy

Bemerkung

Die von Ihnen angegebenen Spalten müssen VARCHAR oder VARIANT-Spalten sein. Spalten mit anderen Datentypen werden nicht unterstützt.

Suche nach passenden IP-Adressen in einer VARIANT-Spalte

Die folgenden Beispiele zeigen, wie Sie die Funktion SEARCH_IP verwenden, um VARIANT-Spalten abzufragen.

Dieses Beispiel verwendet die Funktion SEARCH_IP, um einen Pfad zu einem Feld in einer VARIANT-Spalte zu suchen. Erstellen Sie eine Tabelle mit dem Namen iptv und fügen Sie zwei Zeilen ein:

CREATE OR REPLACE TABLE iptv(ip1 VARIANT);
INSERT INTO iptv(ip1)
  SELECT PARSE_JSON(' { "ipv1": "203.0.113.5", "ipv2": "203.0.113.5" } ');
INSERT INTO iptv(ip1)
  SELECT PARSE_JSON(' { "ipv1": "192.0.2.146", "ipv2": "203.0.113.5" } ');
Copy

Führen Sie die folgenden Suchabfragen aus. Die erste Abfrage durchsucht nur das Feld ipv1. Die zweite Abfrage durchsucht ipv1 und ipv2.

SELECT * FROM iptv
  WHERE SEARCH_IP((ip1:"ipv1"), '203.0.113.5');
Copy
+--------------------------+
| IP1                      |
|--------------------------|
| {                        |
|   "ipv1": "203.0.113.5", |
|   "ipv2": "203.0.113.5"  |
| }                        |
+--------------------------+

SELECT * FROM iptv
  WHERE SEARCH_IP((ip1:"ipv1",ip1:"ipv2"), '203.0.113.5');
Copy
+--------------------------+
| IP1                      |
|--------------------------|
| {                        |
|   "ipv1": "203.0.113.5", |
|   "ipv2": "203.0.113.5"  |
| }                        |
| {                        |
|   "ipv1": "192.0.2.146", |
|   "ipv2": "203.0.113.5"  |
| }                        |
+--------------------------+

Um die Optimierung der FULL_TEXT-Suche für diese ip1 VARIANT Spalte und ihre Felder zu aktivieren, führen Sie den folgenden ALTER TABLE-Befehl aus:

ALTER TABLE iptv ADD SEARCH OPTIMIZATION ON FULL_TEXT(
  ip1:"ipv1",
  ip1:"ipv2",
  ANALYZER => 'ENTITY_ANALYZER');
Copy

Bemerkung

Die von Ihnen angegebenen Spalten müssen VARCHAR oder VARIANT-Spalten sein. Spalten mit anderen Datentypen werden nicht unterstützt.

Suche nach übereinstimmenden IP-Adressen in langen Textzeichenfolgen

Erstellen einer Tabelle namens ipt_log und Einfügen von Zeilen:

CREATE OR REPLACE TABLE ipt_log(id INT, ip_request_log VARCHAR(200));
INSERT INTO ipt_log VALUES(1, 'Connection from IP address 192.0.2.146 succeeded.');
INSERT INTO ipt_log VALUES(2, 'Connection from IP address 203.0.113.5 failed.');
INSERT INTO ipt_log VALUES(3, 'Connection from IP address 192.0.2.146 dropped.');
Copy

Suchen Sie nach Protokolleinträgen in der Spalte ip_request_log, die die IP-Adresse 192.0.2.146 enthalten:

SELECT * FROM ipt_log
  WHERE SEARCH_IP(ip_request_log, '192.0.2.146')
  ORDER BY id;
Copy
+----+---------------------------------------------------+
| ID | IP_REQUEST_LOG                                    |
|----+---------------------------------------------------|
|  1 | Connection from IP address 192.0.2.146 succeeded. |
|  3 | Connection from IP address 192.0.2.146 dropped.   |
+----+---------------------------------------------------+

Beispiele für erwartete Fehlerfälle

Die folgenden Beispiele zeigen Abfragen, die erwartete Syntaxfehler zurückgeben.

Dieses Beispiel schlägt fehl, weil 5 kein unterstützter Datentyp für das Argument search_string ist.

SELECT SEARCH_IP(ip1, 5) FROM ipt;
Copy
001045 (22023): SQL compilation error:
argument needs to be a string: '1'

Dieses Beispiel schlägt fehl, weil das Argument search_string keine gültige IP-Adresse ist.

SELECT SEARCH_IP(ip1, '1925.0.2.146') FROM ipt;
Copy
000937 (22023): SQL compilation error: error line 1 at position 22
invalid argument for function [SEARCH_IP(IPT.IP1, '1925.0.2.146')] unexpected argument [1925.0.2.146] at position 1,

Dieses Beispiel schlägt fehl, weil das Argument search_string eine leere Zeichenfolge ist.

SELECT SEARCH_IP(ip1, '') FROM ipt;
Copy
000937 (22023): SQL compilation error: error line 1 at position 22
invalid argument for function [SEARCH_IP(IPT.IP1, '')] unexpected argument [] at position 1,

Dieses Beispiel schlägt fehl, weil für das Argument search_data keine Spalte eines unterstützten Datentyps angegeben ist.

SELECT SEARCH_IP(id, '192.0.2.146') FROM ipt;
Copy
001173 (22023): SQL compilation error: error line 1 at position 7: Expected non-empty set of columns supporting full-text search.

Dieses Beispiel ist erfolgreich, weil für das Argument search_data eine Spalte eines unterstützten Datentyps angegeben ist. Die Funktion ignoriert die id-Spalte, da es sich nicht um einen unterstützten Datentyp handelt

SELECT SEARCH_IP((id, ip1), '192.0.2.146') FROM ipt;
Copy
+-------------------------------------+
| SEARCH_IP((ID, IP1), '192.0.2.146') |
|-------------------------------------|
| True                                |
| False                               |
+-------------------------------------+
Sprache: Deutsch