```
{% endcode %}
#### Example PARSE\_JSON object
The following `PARSE_JSON` example synthesizes given name values, and redacts values for the Speaker Initials custom entity type:
{% code overflow="wrap" %}
```
PARSE_JSON('{
"generatorConfig":{
"CUSTOM_MY_ENTITY_TYPE":"Redaction",
"NAME_GIVEN":"Synthesis"
},
"customPiiEntityIds":["CUSTOM_MY_ENTITY_TYPE|org1|entity1|model1"]
}')
```
{% endcode %}
### Example: Redacting text
The following example sends a text string to the app:
```sql
SELECT TONIC_TEXTUAL.APP_PUBLIC.TEXTUAL_REDACT('My name is Jane Doe');
```
This returns the redacted text, which looks similar to the following:
```sql
My name is [NAME_GIVEN_abc789] [NAME_FAMILY_xyz123].
```
Because we did not specify the handling for any of the entity types, both the first name Jane and last name Doe are redacted.
### Example: Customizing the redaction
In this example, when a first name (`NAME_GIVEN`) is detected, it is synthesized instead of redacted.
SELECT TONIC_TEXTUAL.APP_PUBLIC.TEXTUAL_REDACT('My name is Jane Doe',
PARSE_JSON('{
"generatorConfig": {
"NAME_GIVEN": "Synthesis"
}
}'));
This returns output similar to the following. The first name Jane is replaced with a realistic value (synthesized), and the last name Doe is redacted.
```sql
My name is Shirley [NAME_FAMILY_xyz123].
```
## Using the TEXTUAL\_PARSE function
You use the `TEXTUAL_PARSE` function to transform files in an external or internal stage into Markdown-based content that you can use to populate LLM systems.
The output includes metadata about the file, including sensitive values that were detected.
### Granting access to the stage
To be able to parse the files, Textual must have access to the stage where the files are located.
Your role must be able to grant the `USAGE` and `READ` permissions.
To grant Textual access to the stage, run the following commands:
{% code overflow="wrap" %}
```sql
GRANT USAGE ON DATABASE TO APPLICATION TONIC_TEXTUAL;
GRANT USAGE ON SCHEMA . TO APPLICATION TONIC_TEXTUAL;
GRANT READ, USAGE ON STAGE .. TO APPLICATION TONIC_TEXTUAL;
```
{% endcode %}
### Sending a request for a single file
To send a parse request for a single file, run the following:
{% code overflow="wrap" %}
```sql
SELECT TONIC_TEXTUAL.APP_PUBLIC.TEXTUAL_PARSE('', '', '');
```
{% endcode %}
Where:
* `` is the fully qualified name of the stage, in the format `..`. For example, `database1.schema1.stage1`.
* `` is the name of the file.
* `` is the MD5 sum version of the file content.
### Sending a request for multiple files
To parse a large number of files:
1. List the stage files to parse. For example, you might use `PATTERN` to limit the files based on file type.
2. Run the parse request command on the list.
For example:
{% code overflow="wrap" %}
```sql
LIST @ PATTERN='.*(txt|xlsx|docx)';
SELECT TONIC_TEXTUAL.APP_PUBLIC.TEXTUAL_PARSE('', "name","md5") FROM table(result_scan(last_query_id()));
```
{% endcode %}
### About the results
The app writes the results to the `TEXTUAL_RESULTS` table.
For each request, the entry in `TEXTUAL_RESULTS` includes the request status and the request results.
The status is one of the following values:
* `QUEUED` - The parse request was received and is waiting to be processed.
* `RUNNING` - The parse request is currently being processed.
* `SKIPPED` - The parse request was skipped because the file did not change since the previous time it was parsed. Whether a file is changed is determined by its MD5 checksum.
* `FAILURE_` - The parse request failed for the provided reason.
The `result` column is a `VARIANT` type that contains the parsed data.
### Querying the results
You can query the parse results in the same way as you would any other Snowflake `VARIANT` column.
For example, the following command retrieves the parsed documents, which are in a converted Markdown representation.
```sql
SELECT result["Content"]["ContentAsMarkdown"] FROM TEXTUAL_RESULTS;
```
To retrieve the entities that were identified in the document:
```sql
SELECT result["Content"]["nerResults"] FROM TEXTUAL_RESULTS;
```
Because the `result` column is a simple variant, you can use flattening operations to perform more complex analysis. For example, you can extract all entities of a certain type or value across the documents, or find all documents that contain a specific type of entity.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://docs.tonic.ai/textual/textual-integrations/snowflake-native-app-and-spcs/snowflake-app-use.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.