SEARCH_IP

Recherches d’adresses IPv4 valides dans des colonnes de chaînes de caractères spécifiées à partir d’une ou plusieurs tables, y compris des champs dans des colonnes VARIANT, OBJECT et ARRAY. La recherche est basée sur une seule adresse IP ou une plage d’adresses IP que vous spécifiez. Si cette adresse IP correspond à une adresse IP dans la colonne ou le champ spécifié, la fonction renvoie TRUE.

Pour plus d’informations sur l’utilisation de ces fonctions, voir Utilisation de la recherche en texte intégral.

Syntaxe

SEARCH_IP( <search_data>, <search_string> )
Copy

Arguments

search_data

Les données que vous souhaitez rechercher, exprimées sous la forme d’une liste délimitée par des virgules de littéraux de chaîne, de noms de colonnes ou chemins vers les champs dans les colonnes VARIANT. Les données de recherche peuvent également être une chaîne littérale unique, ce qui peut être utile lorsque vous testez la fonction.

Vous pouvez spécifier le caractère générique (*), où * s’étend à toutes les colonnes éligibles dans toutes les tables concernées par la fonction. Les colonnes éligibles sont celles qui ont les types de données VARCHAR (texte), VARIANT, ARRAY et OBJECT. Les données VARIANT, ARRAY et OBJECT sont converties en texte pour la recherche. Vous pouvez également utiliser les mots-clés ILIKE et EXCLUDE pour le filtrage.

Pour plus d’informations sur cet argument, voir la search_data description de la fonction SEARCH.

search_string

Une chaîne VARCHAR contenant l’un des éléments suivants :

  • Une adresse IP complète et valide au format standard IPv4, par exemple 192.0.2.1.

  • Une adresse IP valide au format standard IPv4 avec une plage Classless Inter-Domain Routing (CIDR), par exemple 192.0.2.1/24.

  • Une adresse IP valide au format standard IPv4 avec des zéros non significatifs, par exemple 192.000.002.001 (et non pas 192.0.2.1). La fonction accepte jusqu’à trois chiffres pour chaque partie de l’adresse IP.

Cet argument doit être une chaîne littérale ; les noms de colonnes ne sont pas pris en charge. Spécifiez une paire de guillemets simples autour de la chaîne.

Vous ne pouvez pas spécifier plus d’une adresse IP. Vous ne pouvez pas spécifier une adresse IPv6 ou une adresse IPv4 partielle.

Renvoie

Renvoie un BOOLEAN.

  • Renvoie TRUE si une adresse IP valide est spécifiée dans search_string et une adresse IP correspondante se trouve dans search_data.

  • Renvoie TRUE si une adresse IP valide avec une plage CIDR la plage est spécifiée dans search_string et une adresse IP dans la plage spécifiée est trouvée dans search_data.

  • Renvoie TRUE si search_string est vide et qu’aucune adresse IP valide ne se trouve dans search_data.

  • Renvoie NULL si l’un de ces arguments est NULL.

  • Sinon, renvoie FALSE.

Notes sur l’utilisation

  • La fonction SEARCH_IP fonctionne uniquement sur les données VARCHAR, VARIANT, ARRAY et OBJECT. La fonction renvoie une erreur si l’argument search_data ne contient pas de données de ces types de données. Lorsque l’argument search_data inclut des données des types de données pris en charge et des types de données non pris en charge, la fonction recherche les données des types de données pris en charge et ignore silencieusement les données des types de données non pris en charge. Pour des exemples, voir Exemples de cas d’erreur prévus.

  • La fonction SEARCH_IP fonctionne uniquement sur les données VARCHAR, VARIANT, ARRAY et OBJECT. La fonction renvoie une erreur si vous essayez de rechercher d’autres types de données. Pour des exemples, voir Exemples de cas d’erreur prévus.

  • Vous pouvez ajouter une optimisation FULL_TEXT de la recherche sur les colonnes qui sont la cible d’appels de fonction SEARCH_IP à l’aide d’une commande ALTER TABLE qui spécifie ENTITY_ANALYZER. Par exemple :

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

    Pour plus d’informations, voir activer l’optimisation de la recherche FULL_TEXT.

Exemples

Ces exemples montrent comment utiliser la fonction SEARCH_IP pour interroger les colonnes VARCHAR et VARIANT.

Rechercher une adresse IP correspondante dans les colonnes VARCHAR

Créez une table nommée ipt et insérez deux lignes :

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

Exécutez les requêtes de recherche suivantes. La première requête utilise la fonction SEARCH_IP dans la liste SELECT et recherche les deux colonnes VARCHAR dans la table :

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                                 |
+-------------+-----------------+--------------------------------------+

Notez que search_data 192.000.002.146 est une correspondance pour search_string 192.0.2.146 même si 192.000.002.146 a des zéros non significatifs.

Cette requête montre une search_string avec une plage CIDR :

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                                  |
+-------------+-----------------+---------------------------------------+

Cette requête montre une search_string avec des zéros non significatifs qui renvoie True pour les adresses IP qui omettent les zéros non significatifs :

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                                     |
+-------------+-----------------+------------------------------------------+

Cette requête utilise la fonction dans la clause WHERE et recherche la colonne ip2 seulement.

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 |
+-------------+-------------+

Lorsque la fonction est utilisée dans la clause WHERE et il n’y a pas de correspondance, aucune valeur n’est renvoyée.

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

Vous pouvez utiliser le caractère * (ou table.*) comme premier argument de la fonction SEARCH, comme illustré dans cet exemple. La recherche s’effectue sur toutes les colonnes éligibles de la table que vous sélectionnez.

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 |
+-------------+-------------+

Vous pouvez également utiliser les mots-clés ILIKE et EXCLUDE pour le filtrage. Pour plus d’informations sur ces mots-clés, voir SELECT.

Cette recherche utilise le mot-clé ILIKE pour rechercher uniquement dans les colonnes commençant par la chaîne ip.

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 |
+-------------+-----------------+

Pour activer l’optimisation de la recherche FULL_TEXT pour les colonnes dans la table ipt, exécutez la commande ALTER TABLE suivante :

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

Note

Les colonnes que vous spécifiez doivent être les colonnes VARCHAR ou VARIANT. Les colonnes avec d’autres types de données ne sont pas prises en charge.

Rechercher une adresse IP correspondante dans une colonne VARIANT

Cet exemple utilise la fonction SEARCH_IP pour rechercher un chemin vers un champ dans une colonne VARIANT. Créez une table nommée iptv et insérez deux lignes :

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

Exécutez les requêtes de recherche suivantes. La première requête recherche le champ ipv1 seulement. La deuxième recherche ipv1 et 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"  |
| }                        |
+--------------------------+

Pour activer l’optimisation de la recherche FULL_TEXT pour cette colonne ip1 VARIANT et ses champs, exécutez la commande ALTER TABLE suivante :

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

Note

Les colonnes que vous spécifiez doivent être les colonnes VARCHAR ou VARIANT. Les colonnes avec d’autres types de données ne sont pas prises en charge.

Exemples de cas d’erreur prévus

Les exemples suivants montrent des requêtes qui renvoient des erreurs de syntaxe attendues.

Cet exemple échoue parce que 5 n’est pas un type de données pris en charge pour l’argument search_string.

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

Cet exemple échoue car aucune colonne d’un type de données pris en charge n’est spécifiée pour l’argument search_data.

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.

Cet exemple réussit car il existe une colonne d’un type de données pris en charge spécifié pour l’argument search_data. La fonction ignore la colonne id car ce n’est pas un type de données pris en charge

SELECT SEARCH_IP((id, ip1), '192.0.2.146') FROM ipt;
Copy
+-------------------------------------+
| SEARCH_IP((ID, IP1), '192.0.2.146') |
|-------------------------------------|
| True                                |
| False                               |
+-------------------------------------+
Langage: Français