SPLIT_TEXT_RECURSIVE_CHARACTER (SNOWFLAKE.CORTEX)

La fonction SPLIT_TEXT_RECURSIVE_CHARACTER divise une chaîne en chaînes plus courtes, de manière récursive, pour utiliser le texte de prétraitement avec des fonctions d’intégration de texte ou d’indexation de recherche. La fonction renvoie un tableau de fragments de texte, les fragments étant dérivés du texte original sur la base des paramètres d’entrée fournis.

L’algorithme de fractionnement tente de fragmenter le texte sur les séparateurs dans l’ordre où ils sont fournis, soit implicitement par défaut en fonction du format, soit explicitement dans l’argument separators. Le fractionnement est ensuite appliqué à chaque fragment dont la longueur est supérieure à la longueur chunk_size spécifiée, de manière récursive, jusqu’à ce que tous les fragments soient inférieurs à la longueur chunk_size spécifiée.

Par exemple, si le format est défini sur 'none', l’algorithme commence par fractionner les séquences « \n\n », qui représentent les sauts de paragraphe dans la plupart des formats. Dans tout fragment résultant dont la longueur est toujours supérieure à chunk_size caractères, la fonction fractionne les caractères « \n », qui représentent les sauts de ligne. Ce processus se répète jusqu’à ce que chacun des fragments soit inférieur à chunk_size caractères.

Syntaxe

SNOWFLAKE.CORTEX.SPLIT_TEXT_RECURSIVE_CHARACTER (
  '<text_to_split>',
  '<format>',
  <chunk_size>,
  [ <overlap> ],
  [ <separators> ]
)
Copy

Arguments

Obligatoire :

'text_to_split'

Texte à fractionner.

'format'

Format de votre texte d’entrée, qui détermine les séparateurs par défaut dans l’algorithme de fractionnement. Il doit s’agir de l’un des éléments suivants :

  • none : pas de séparateur propre au format. Seuls les séparateurs du champ separators sont utilisés pour le fractionnement.

  • markdown : sépare au niveau des en-têtes, des blocs de code et des tables, en plus de tout séparateur dans le champ des séparateurs.

chunk_size

Nombre entier spécifiant le nombre maximum de caractères dans chaque fragment. La valeur doit être supérieure à zéro.

Facultatif :

overlap

Nombre entier spécifiant le nombre de caractères de chevauchement entre des fragments consécutifs. Par défaut, les fragments ne se chevauchent pas. Si overlap est spécifié, il doit être plus petit que l’argument chunk_size.

Le chevauchement est utile pour s’assurer que chaque fragment dispose d’un certain contexte par rapport au fragment précédent. Cela peut contribuer à améliorer la qualité des résultats de recherche ou d’autres traitements.

separators

Liste ordonnée de séquences de caractères à utiliser comme limites pour déterminer où fractionner le texte, en plus de tout séparateur dicté par le paramètre format. Le dernier élément de cette liste doit être un séparateur général, tel qu’une chaîne vide (qui permet d’effectuer un fractionnement entre deux caractères), de sorte que l’algorithme peut fractionner le texte en fragments de la taille souhaitée.

Par défaut : [ »\n\n », « \n », «  « , « « ], c’est-à-dire un saut de paragraphe, un saut de ligne, un espace et entre deux caractères quelconques (la chaîne vide).

Renvoie

Renvoie un tableau de chaînes contenant des fragments de texte extraits de la chaîne d’entrée.

Limitations connues

Pour cet aperçu, les messages d’erreur peuvent être énigmatiques. La plupart des messages d’erreur sont liés à l’échec de la validation des arguments. La première étape du débogage consiste à s’assurer que tous vos arguments ont des valeurs valides.

Exemples

Utilisation simple

L’exemple suivant appelle directement la fonction SPLIT_TEXT_RECURSIVE_CHARACTER avec le texte d’entrée hello world are you here. La fonction fractionne le texte en fragments de 15 caractères chacun, avec un chevauchement de 10 caractères entre les fragments.

SELECT SNOWFLAKE.CORTEX.SPLIT_TEXT_RECURSIVE_CHARACTER (
   'hello world are you here',
   'none',
   15,
   10
);
Copy
['hello world are', 'world are you', 'are you here']

Exemple de formatage Markdown et d’aplatissement de tableaux de fragments en lignes

L’exemple suivant crée une table sample_documents contenant un court document Markdown dans chaque ligne, puis appelle la fonction SPLIT_TEXT_RECURSIVE_CHARACTER pour fractionner chaque document. La fonction fractionne le texte en fragments de 25 caractères chacun, avec un chevauchement de 10 caractères entre les fragments.

-- Create sample markdown data table
CREATE OR REPLACE TABLE sample_documents (
   doc_id INT AUTOINCREMENT, -- Monotonically increasing integer
   document STRING
);

-- Insert sample data
INSERT INTO sample_documents (document)
VALUES
   ('### Heading 1\\nThis is a sample markdown document. It contains a list:\\n- Item 1\\n- Item 2\\n- Item 3\\n'),
   ('## Subheading\\nThis markdown contains a link [example](http://example.com) and some \**bold*\* text.'),
   ('### Heading 2\\nHere is a code snippet:\\n```\\ncode_block_here()\\n```\\nAnd some more regular text.'),
   ('## Another Subheading\\nMarkdown example with \_italic\_ text and a [second link](http://example.com).'),
   ('### Heading 3\\nText with an ordered list:\\n1. First item\\n2. Second item\\n3. Third item\\nMore text follows here.');

-- split text
SELECT
   doc_id,
   c.value
FROM
   sample_documents,
   LATERAL FLATTEN( input => SNOWFLAKE.CORTEX.SPLIT_TEXT_RECURSIVE_CHARACTER (
      document,
      'markdown',
      25,
      10
   )) c;
Copy
Langage: Français