No mappings matched table

Error message

No mappings matched table '{}' in this writer. The writer will be a no-op: rows are acknowledged without writing to HugeGraph.

What it means

This warning is emitted by HugeGraphSinkWriter.buildMappingEntries() when, in single-table mode (no mapping sets source_table), none of the configured mappings matched any fields of the current table path. The writer therefore has no mapping entries and becomes a no-op: incoming rows are acknowledged but never written to HugeGraph. It is logged rather than failed because a legitimate use case is sinking only a subset of fields/tables.

Solutions

Inspect the job's table path and row type; confirm the mapping property source names exactly match SeaTunnel column names.
If the intent was multi-table routing, set source_table on the relevant mappings so they are selected for this table.
If the no-op is unintended, fix the mappings; if it is intentional (subset-of-fields sink), suppress/ignore the warning knowingly.

Example fix

// before (no matching fields)
mappings = [{type = "VERTEX", label = "person", properties = {nm = "name"}}] // table has no 'name'
// after
mappings = [{type = "VERTEX", label = "person", properties = {name = "user_name"}}] // matches actual column

Defensive patterns

Strategy: validation

Validate before calling

def rowColumns = tablePathColumns[tablePath]
def matched = mappings.findAll { m ->
    (m.source_table == null || m.source_table == tablePath) &&
    m.properties.values().every { rowColumns.contains(it) }
}
assert !matched.isEmpty() : "No mappings match table ${tablePath}; writer will be a no-op"

Prevention

Verify mapping property source names exactly match SeaTunnel column names
Set source_table on mappings when running multi-table jobs
Re-check mappings after upstream schema changes
Run a tiny test job and confirm rows actually land in HugeGraph before production

When it happens

Trigger: Writer initialization with mappings that reference fields not present in the row type of the incoming table (or mappings keyed to a different table path while none sets source_table); buildMappingEntries() finds zero entries for the tablePath and logs this message.

Common situations: Column name mismatches between the SeaTunnel row type and the mapping properties; upstream schema changes that renamed/dropped fields; users expecting mappings to apply globally but whose row type carries none of the mapped fields; typos in mapping property source names.

Related errors

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

Appendix: source

Thrown at seatunnel-connectors-v2/connector-hugegraph/src/main/java/org/apache/seatunnel/connectors/seatunnel/hugegraph/sink/HugeGraphSinkWriter.java:264

                                .filter(t -> t != null && !t.isEmpty())
                                .distinct()
                                .collect(Collectors.toList());
                throw new HugeGraphConnectorException(
                        HugeGraphConnectorErrorCode.ILLEGAL_CONFIG_ARGUMENT,
                        String.format(
                                "No mapping matched writer table '%s'. The configured "
                                        + "source_table value(s) are %s. Verify that each "
                                        + "source_table matches the CatalogTable.getTablePath() "
                                        + "produced by the upstream Source (in read-all mode this "
                                        + "is the HugeGraph label name).",
                                tablePath, configuredTables));
            }

            // Single-table mode (no source_table set on any mapping): no entries means the
            // row type carries no fields the mappings can use. This is unusual but not
            // necessarily a config error — a downstream project may legitimately sink only a
            // subset of fields. Log and continue as a no-op.
            LOG.warn(
                    "No mappings matched table '{}' in this writer. The writer will be a no-op: "
                            + "rows are acknowledged without writing to HugeGraph.",
                    tablePath);
        }
        return entries;
    }

    private Map<String, Integer> resolveLegacyFieldsIndex(
            Map<String, Integer> originalFieldsIndex) {
        if (sinkConfig.getSchemaConfig() == null) {
            return originalFieldsIndex;
        }

        List<String> selectedFields = sinkConfig.getSelectedFields();
        if (selectedFields != null && !selectedFields.isEmpty()) {
            Map<String, Integer> selected = new LinkedHashMap<>();
            for (String field : selectedFields) {
                Integer index = originalFieldsIndex.get(field);

View on GitHub (pinned to cf67b549a7)