apache/seatunnel · error · MilvusConnectorException

NOT_SUPPORT_TYPE

NOT_SUPPORT_TYPE

Error message

NOT_SUPPORT_TYPE

What it means

MilvusSinkConverter.convertBySeaTunnelType throws NOT_SUPPORT_TYPE when a SeaTunnelColumn value has an SqlType the converter cannot serialize to a Milvus JSON field. The default branch catches every type outside the explicitly handled cases (e.g. certain DATE/TIME/NULL/complex variants) and rejects them, naming the offending SqlType.

Source

Thrown at seatunnel-connectors-v2/connector-milvus/src/main/java/org/apache/seatunnel/connectors/seatunnel/milvus/utils/sink/MilvusSinkConverter.java:132

                        Integer[] intArray = (Integer[]) value;
                        return Arrays.asList(intArray);
                    case BIGINT:
                        Long[] longArray = (Long[]) value;
                        return Arrays.asList(longArray);
                    case FLOAT:
                        Float[] floatArray = (Float[]) value;
                        return Arrays.asList(floatArray);
                    case DOUBLE:
                        Double[] doubleArray = (Double[]) value;
                        return Arrays.asList(doubleArray);
                }
            case ROW:
                SeaTunnelRow row = (SeaTunnelRow) value;
                return JsonUtils.toJsonString(row.getFields());
            case MAP:
                return JsonUtils.toJsonString(value);
            default:
                throw new MilvusConnectorException(
                        MilvusConnectionErrorCode.NOT_SUPPORT_TYPE, sqlType.name());
        }
    }

    public static FieldType convertToFieldType(
            Column column,
            PrimaryKey primaryKey,
            String partitionKeyField,
            Boolean autoId,
            Boolean enableNullableField) {
        SeaTunnelDataType<?> seaTunnelDataType = column.getDataType();
        DataType milvusDataType;
        if (column.getSinkType() != null) {
            milvusDataType = DataType.valueOf(column.getSinkType());
        } else {
            milvusDataType = convertSqlTypeToDataType(seaTunnelDataType.getSqlType());
        }
        FieldType.Builder build =

View on GitHub (pinned to cf67b549a7)

Solutions

1. Read sqlType.name() in the message to identify the unsupported type and transform that column upstream (e.g. via a FieldMapper/SQL transform casting to STRING)
2. Cast unsupported columns to supported types (STRING/INT/ARRAY/FLOAT/etc.) before the Milvus sink
3. Drop unnecessary columns via transform so they never reach the sink
4. Upgrade SeaTunnel if a newer version added support for that SqlType
5. File/track a connector enhancement if the type is essential to your pipeline

Example fix

// before: TIMESTAMP column passed straight to Milvus sink
transform = Sql {
  source_table = "src"
  result_table_name = "t"
}
// after: cast the unsupported column to STRING
transform = Sql {
  source_table = "src"
  result_table_name = "t"
  query = "SELECT CAST(event_time AS STRING) AS event_time, id, embedding FROM src"
}

// Pre-validate upstream schema contains only sink-supported SqlTypes
Set<SqlType> supported = Set.of(SqlType.STRING, SqlType.INT, SqlType.BIGINT,
    SqlType.FLOAT, SqlType.DOUBLE, SqlType.BOOLEAN, SqlType.ARRAY, SqlType.ROW, SqlType.MAP);
for (CatalogTable table : tables)
  for (Column c : table.getTableSchema().getColumns())
    if (!supported.contains(c.getSqlType()))
      throw new IllegalStateException("Cast or drop column before Milvus sink: " + c.getName());

try {
  sink.write(rows);
} catch (MilvusConnectorException e) {
  if (e.getErrorCode() == MilvusConnectionErrorCode.NOT_SUPPORT_TYPE) {
    logger.error("Unsupported SqlType reaching Milvus sink: {}", e.getMessage());
  } else { throw e; }
}

When it happens

Trigger: A sink row contains a column whose SqlType (sqlType.name() is included in the message) falls through the switch in convertBySeaTunnelType — e.g. unsupported structured or temporal types — during conversion of row data into Milvus JsonObject payloads.

Common situations: Source tables containing column types Milvus/JSON conversion does not handle (e.g. TIMESTAMP/NULL/ARRAY variants depending on connector version), schemas drifting after an upgrade, or reading from sources that emit types the Milvus sink never anticipated.

Related errors

• Not support convert to milvus type, sqlType is %s
• COMMON-19
• COMMON-19
• UNSUPPORTED_DATA_TYPE
• UNSUPPORTED_DATA_TYPE

AI-assisted analysis of apache/seatunnel@cf67b549a7 (2026-09-10). Data as JSON: /api/errors/45882e0ce7fbb259. Report an issue: GitHub.