SPLIT_TEXT_RECURSIVE_CHARACTER (SNOWFLAKE.CORTEX)

Die Funktion SPLIT_TEXT_RECURSIVE_CHARACTER teilt eine Zeichenfolge rekursiv in kürzere Zeichenfolgen auf, um den Text für die Verwendung mit Funktionen zur Texteinbettung oder Suchindizierung vorzuverarbeiten. Die Funktion gibt ein Array von Textblöcken zurück, wobei die Blöcke auf der Grundlage der angegebenen Eingabeparameter aus dem Originaltext abgeleitet werden.

Der Aufteilungsalgorithmus versucht, den Text an den Trennzeichen in der Reihenfolge aufzuteilen, in der sie bereitgestellt werden, entweder implizit als Standardwerte basierend auf dem Format oder explizit im Argument separators. Die Aufteilung wird dann rekursiv auf jeden Block angewendet, der länger als die angegebene chunk_size ist, bis alle Blöcke nicht mehr länger als die angegebene chunk_size sind.

Wenn zum Beispiel das Format auf 'none' eingestellt ist, teilt der Algorithmus zuerst an den Sequenzen „\n\n“ auf, die in den meisten Formaten Absatzumbrüche darstellen. Innerhalb eines resultierenden Blocks, der immer noch länger als chunk_size ist, trennt die Funktion an den „\n“-Zeichen, die für Zeilenumbrüche stehen. Dieser Vorgang wird so lange wiederholt, bis jeder der Blöcke weniger als chunk_size Zeichen enthält.

Syntax

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

Argumente

Benötigt:

'text_to_split'

Der zu teilende Text.

'format'

Das Format Ihres Eingabetextes, das die Standardtrennzeichen im Aufteilungsalgorithmus bestimmt. Muss einer der folgenden sein:

  • none: Keine formatspezifischen Trennzeichen. Nur die Trennzeichen im Feld separators werden für die Aufteilung verwendet.

  • markdown: Trennt in Kopfzeilen, Codeblöcken und Tabellen, zusätzlich zu allen Trennzeichen im Feld „Trennzeichen“.

chunk_size

Eine Ganzzahl, die die maximale Anzahl von Zeichen in jedem Block angibt. Der Wert muss größer als Null sein.

Optional:

overlap

Eine Ganzzahl, die die Anzahl der Zeichen angibt, die zwischen aufeinanderfolgenden Blöcken überlappen sollen. Standardmäßig haben Blöcke keine Überschneidungen. Wenn overlap angegeben wird, muss es kleiner sein als das Argument chunk_size.

Überschneidungen sind nützlich, um sicherzustellen, dass jeder Block einen gewissen Kontext zum vorherigen Block hat. Dies kann dazu beitragen, die Qualität der Suchergebnisse oder anderer Verarbeitungen zu verbessern.

separators

Eine geordnete Liste von Zeichenfolgen, die als Begrenzungen verwendet werden sollen, wenn bestimmt wird, wo der Text geteilt werden soll, zusätzlich zu allen Trennzeichen, die durch den Parameter format vorgegeben werden. Das letzte Element in dieser Liste sollte ein allgemeines Trennzeichen sein, z. B. eine leere Zeichenfolge (die eine Aufteilung zwischen zwei beliebigen Zeichen ermöglicht), sodass der Algorithmus garantiert in der Lage ist, den Text in Blöcke der gewünschten Größe aufzuteilen.

Standard: [“\n\n“, „\n“, „ „, „“], d. h. ein Absatzumbruch, ein Zeilenumbruch, ein Leerzeichen und zwischen zwei beliebigen Zeichen (die leere Zeichenfolge).

Rückgabewerte

Gibt ein Array von Zeichenfolgen zurück, das Textblöcke enthält, die aus der Eingabezeichenfolge extrahiert wurden.

Bekannte Einschränkungen

Bei dieser Vorschau können die Fehlermeldungen kryptisch sein. Die meisten Fehlermeldungen beziehen sich auf eine fehlgeschlagene Argumentvalidierung. Als ersten Schritt der Fehlersuche sollten Sie sicherstellen, dass alle Ihre Argumente gültige Werte haben.

Beispiele

Einfache Nutzung

Das folgende Beispiel ruft direkt die Funktion SPLIT_TEXT_RECURSIVE_CHARACTER mit dem Eingabetext hello world are you here auf. Die Funktion teilt den Text in Blöcke von je 15 Zeichen auf, mit einer Überlappung von 10 Zeichen zwischen den Blöcken.

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']

Beispiel mit Markdown-Formatierung und Vereinfachung von Blöcken in Zeilen

Im folgenden Beispiel wird eine Tabelle sample_documents erstellt, die in jeder Zeile ein kurzes Markdown-Dokument enthält, und dann die Funktion SPLIT_TEXT_RECURSIVE_CHARACTER aufgerufen, um jedes Dokument zu teilen. Die Funktion teilt den Text in Blöcke von je 25 Zeichen auf, mit einer Überlappung von 10 Zeichen zwischen den Blöcken.

-- 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
Sprache: Deutsch