Famly extract string length errors

Introduction

Famly extract string length errors happen when a source value is longer than the column length defined in the destination schema. In Kleene, this usually means the generated DDL has created a column that is too restrictive for the payload being extracted. This is common with API fields that can contain long JSON, notes, booking details, or other variable-length text.

Issue description

A Famly extract failed with the following error:

String length exceeds DDL length - 1204

This means at least one extracted string value was longer than the destination column definition allowed. The extract could not complete because the target table schema did not have enough capacity to store the full value.

Signs

You may be dealing with this issue if an extract fails during load or schema application with a string length or DDL length error. The error may include the length of the value that exceeded the column limit, such as 1204.

This is especially likely when the failing field contains nested API content, JSON-like text, arrays, notes, descriptions, or booking/session data. In this case, a field such as session_bookings was a likely cause because it can contain longer-than-expected JSON or text content.

Basic troubleshooting steps

Start with the following checks to narrow down the cause of the error:

• Review the extract logs and schema output to identify the failing column.
• Check whether the error includes the string length that exceeded the DDL limit.
• Compare the source field length against the generated destination column length.
• Look for fields that may contain long JSON, arrays, descriptions, notes, or booking details.
• Check whether a field such as session_bookings contains longer-than-expected content.
• Review the destination column type and confirm whether it uses a fixed or limited length.
• Decide whether the column should be changed to an unrestricted text/string type.

Common causes and how to fix them

Source value longer than inferred schema

Automatic schema inference may create a destination column based on shorter sample values. If a later extract contains a longer value, the destination column may be too small.

How to fix it: update the destination schema so the affected column can store longer values. Avoid fixed-length or low-length string columns for fields where the payload size can vary.

Long JSON or nested API payload fields

Some Famly fields may contain structured or nested content that becomes long when stored as text. Fields like session_bookings can contain multiple values or JSON-like structures that exceed the generated DDL length.

How to fix it: store these fields in an unrestricted text/string type, or use a semi-structured type where supported by the warehouse.

Destination column type too restrictive

The destination warehouse may have a column type with a maximum length that is too small for the extracted value. This causes the load to fail when the value cannot fit.

How to fix it: change the destination column to a wider text type. Common options include:

• Snowflake: TEXT, VARCHAR, or VARIANT
• BigQuery: STRING
• SQL Server: NVARCHAR(MAX)

Schema override not applied

If the connector continues to generate the same restrictive DDL, the extract may fail repeatedly even after the cause is understood.

How to fix it: apply a manual schema override where needed so the destination column is created with a suitable type every time the extract runs.

Practical troubleshooting workflow

1. Read the extract error and confirm that it refers to string length exceeding the DDL length.
2. Check the Kleene logs and generated schema to identify the affected column.
3. Inspect likely long-text fields, especially fields containing JSON, arrays, notes, descriptions, or booking/session data.
4. Compare the longest source value with the destination column length.
5. Change the affected destination column to an unrestricted text/string type.
6. If using Snowflake, consider TEXT, VARCHAR, or VARIANT depending on whether the value should be treated as plain text or semi-structured data.
7. If using BigQuery, use STRING.
8. If using SQL Server, use NVARCHAR(MAX).
9. Apply a manual schema override if automatic inference would recreate the restrictive column.
10. Re-run the extract and confirm that the longer value loads successfully.

Best practices to avoid Famly string length extract errors

• Avoid fixed-length columns for unpredictable API payload fields.
• Treat nested, JSON-like, or long free-text fields as variable-length text.
• Review generated schemas for fields that may grow over time.
• Use manual schema overrides for known long-text fields.
• Check source field lengths before finalising destination DDL.
• Store semi-structured payloads in warehouse-native flexible types where appropriate.
• Document fields such as session_bookings if they regularly contain long content.

Additional information

For this issue, the likely cause was a Famly field such as session_bookings containing longer-than-expected JSON or text content. The recommended resolution is to identify the failing column and change the destination type to an unrestricted text/string type.

If the extract continues to fail after changing the column type, review whether the generated schema is being recreated on each run and apply a manual schema override where required.