Merge vs Append vs Union in GIS

Merge, Append, and Union can all bring data from multiple vector layers into one result, but they do very different things. Use Merge when you want to combine features from several compatible datasets into a new dataset. Use Append when you want to add features to a dataset that already exists. Use Union, in the common polygon-overlay sense, when the spatial relationships between layers matter and you want the output geometry divided according to their overlapping boundaries.

The crucial distinction is that Merge and Append are primarily data-combination operations. They put features together without analysing where those features overlap. Union is a spatial overlay operation: geometry is compared, split, and reconstructed according to spatial relationships.

If two road datasets overlap, merging or appending them normally preserves both road features as they are. A polygon Union, by contrast, can split overlapping polygons into new pieces.

Merge, Append, and Union at a glance

• Operation: Merge; Main purpose: Combine features from several datasets; Creates a new dataset?: Usually yes; Existing target required?: No; Uses spatial overlap to construct geometry?: No

• Operation: Append; Main purpose: Add features to an existing dataset; Creates a new dataset?: No; Existing target required?: Yes; Uses spatial overlap to construct geometry?: No

• Operation: Union; Main purpose: Combine polygon layers through spatial overlay; Creates a new dataset?: Yes; Existing target required?: No; Uses spatial overlap to construct geometry?: Yes

A fourth question is often even more useful:

Should the input features remain geometrically unchanged?

With Merge and Append, usually yes. With Union, not necessarily. Overlapping boundaries can divide features into new geometric pieces.

Merge combines datasets into a new dataset

Suppose you have three road layers:

• roads_north

• roads_centre

• roads_south

They contain the same general kind of feature but were produced or stored separately.

If you want a new layer containing all of those roads, Merge is the natural operation.

Conceptually:

roads_north ──┐
roads_centre ─┼──> roads_all
roads_south ──┘

The output contains features from all three inputs.

Importantly, Merge does not normally ask whether one road overlaps another, whether polygons intersect, or whether boundaries should be removed. It is combining collections of features, not analysing their geographic relationships.

The QGIS Merge vector layers documentation describes this directly: multiple vector layers of the same geometry type are combined into a single output layer, with fields from the inputs represented in the resulting attribute table.

That means two overlapping polygons can remain two overlapping polygons after a Merge.

Nothing about the operation inherently resolves the overlap.

Append adds data to an existing target

Append answers a similar but operationally different question.

Suppose roads_all already exists and is the dataset your organisation maintains. A new road survey arrives as roads_august.

You do not necessarily need another new dataset containing both.

Instead, you may want:

roads_august
      │
      ▼
roads_all

where the new records are added to the existing target.

That is the core idea behind Append.

The difference from Merge can therefore be expressed simply:

Merge produces a combined output. Append writes additional data into an existing target.

ArcGIS Pro makes this distinction particularly explicit. Its Append documentation defines Append around an existing target dataset and directs users to Merge when they instead want a new output dataset.

This distinction matters because Append can modify something you already rely on.

If a Merge produces the wrong result, the original inputs still exist independently. If an Append writes unwanted records to a production dataset, correcting the result may require deleting or restoring data.

For that reason, the existing target and its schema deserve careful attention before an append operation.

Merge and Append usually preserve the input geometry

Imagine two polygon datasets:

Layer A

+---------+
|    A    |
|      +--+--
+------+  |
       | B|

Layer B overlaps A.

If you Merge them, the output can simply contain polygon A and polygon B as two features. Their overlap remains an overlap.

Appending B into a dataset already containing A can produce essentially the same feature arrangement.

Neither operation inherently asks:

Where do A and B overlap, and what new geometric pieces does that overlap create?

That is where Union becomes different.

Union uses the spatial relationship between layers

A polygon-overlay Union analyses how the input geometries overlap.

Suppose polygon A partially overlaps polygon B.

Instead of merely storing A and B together, an overlay Union can create separate output pieces for:

• the part belonging only to A;

• the part belonging to both A and B;

• the part belonging only to B.

Attributes from the inputs can then describe which source polygons contributed to each piece.

This is why the output of Union may contain more features than either input.

QGIS documents its Union overlay operation as retaining the overlapping and non-overlapping portions of the processed layers while splitting features where their geometries overlap.

So although Merge and Union can both take several layers and produce one output layer, the similarities largely end there.

Merge combines their records.

Union combines their spatial coverage.

For the broader overlay distinction, Clip vs Intersect vs Union explains what Union preserves relative to Clip and Intersect.

An example makes the difference clearer

Suppose two organisations maintain land-management polygons.

Dataset A contains:

• ID: A1; Type: Forest

• ID: A2; Type: Grassland

Dataset B contains:

• ID: B1; Status: Protected

• ID: B2; Status: Unprotected

If you Merge them

The output contains the features from A followed by the features from B.

Conceptually:

• Source: A; ID: A1; Type: Forest; Status: null

• Source: A; ID: A2; Type: Grassland; Status: null

• Source: B; ID: B1; Type: null; Status: Protected

• Source: B; ID: B2; Type: null; Status: Unprotected

The operation has not determined which forest area is protected. It has simply put records from both datasets into one layer.

That may itself be an awkward result if the layers describe fundamentally different kinds of features. The fact that two layers share a geometry type does not mean that merging them is semantically sensible.

If you Append B to A

The result may look similar geometrically, but Dataset A—or another designated target—is being modified.

Whether B's Status field can be retained depends on how its schema maps into the target.

If you Union A and B

The output is spatially subdivided where their polygons overlap.

A resulting feature might represent:

Forest and Protected

while another represents:

Forest and Unprotected.

That is new spatial information derived from the relationship between the two layers.

Union is therefore appropriate when the overlay itself is the question.

Schema differences matter for Merge and Append

Geometry is only one part of a vector dataset. Its attribute structure matters too.

Suppose one road layer contains:

while another contains:

They may represent the same kind of geographic object, but their schemas do not align automatically.

Merge can construct an output schema

A Merge operation can often create a new output containing the fields encountered across the inputs.

Depending on the software, fields may be mapped, renamed, converted, or filled with null values when an input does not contain them.

Because a new dataset is being created, the operation has some freedom to construct an output schema.

Append must respect an existing schema

Append has a stronger constraint: the target already exists.

Its fields, types, domains, identifiers, and other rules may already be established.

Input fields therefore need to map meaningfully into that target.

A source attribute called road_name might need to map to target field name. An input field with nowhere to go may be ignored or require explicit field mapping. A value incompatible with a constrained target field may fail validation or become null, depending on the implementation.

This is one reason Append should not be understood as simply “Merge without creating a new file”.

It is a data-loading operation into an existing structure.

Append can be more consequential than Merge

Because Append modifies a target, it raises practical questions that Merge often avoids.

Before appending, it is worth knowing:

• whether the target contains existing records that must remain untouched;

• whether identifiers need to remain unique;

• whether input fields correspond correctly to target fields;

• whether duplicates are possible;

• whether coordinate reference systems will be transformed correctly;

• whether field domains or constraints apply;

• whether the operation can be reversed if something goes wrong.

Some Append implementations can also perform update-like behaviour when input records match existing target records. That makes the exact software semantics especially important.

The conceptual definition remains useful—add data to an existing target—but production workflows should always verify what a particular Append tool does before modifying important data.

Merge does not remove duplicate features

Another common assumption is that Merge will somehow reconcile duplicated or overlapping records.

Usually it will not.

If Dataset A contains a road feature and Dataset B contains the same road feature, merging the layers can leave both copies in the output.

The resulting dataset may therefore contain duplicate geometry, duplicate identifiers, or several observations representing the same real-world object.

Whether those records are actually duplicates is a separate data-quality question.

Likewise, Merge does not automatically:

• snap nearby boundaries;

• remove overlaps;

• dissolve matching polygons;

• choose the newest version of a feature;

• reconcile conflicting attributes;

• determine whether two records represent the same object.

Those tasks require additional rules or operations.

Union can create new features rather than merely collect them

This is perhaps the most fundamental difference.

With Merge:

Input feature A normally remains feature A.

With Append:

Input feature A normally becomes another feature in the target.

With Union:

Input feature A may be divided into several output features because other boundaries cross it.

Suppose one municipality polygon crosses three land-cover polygons. A Union can split the municipality according to those land-cover boundaries.

The output records now represent spatial combinations that did not exist as separate records in either original dataset.

This is why Union belongs with operations such as Intersect and Difference rather than with data-management tools such as Merge and Append.

The Common GIS Vector Operations Explained pillar places these operations within their broader processing families.

Union is also an overloaded term

As with the earlier overlay comparison, Union does not mean exactly the same thing in every geospatial API or tool.

The comparison in this article uses Union in the familiar layer-overlay sense: inputs are spatially combined and boundaries can split features into overlapping and non-overlapping pieces.

A geometry library or spatial database may instead use union for a mathematical geometric operation that combines occupied space and removes internal overlaps.

So if a software package offers a button or function called Union, check what level it operates at before assuming that it performs the layer-overlay workflow described here.

The important distinction for this article is that neither meaning is equivalent to merely stacking the records of several datasets.

Merge is not Dissolve either

Merge and Dissolve can also appear superficially similar because both can reduce the number of datasets being managed.

Their feature behaviour is very different.

Suppose three polygon layers contain 100 features each.

A Merge may create a new layer containing roughly 300 features.

A Dissolve could potentially reduce many of those features into a much smaller number by combining geometry according to a grouping rule.

As What Does Dissolve Do in GIS? explains, Dissolve changes which boundaries and feature distinctions survive. Merge normally does not.

This gives us another useful distinction:

Merge combines datasets without intentionally combining their features.

Dissolve combines features according to a grouping rule.

Which one should you use?

Start with what should happen to the destination.

Use Merge when:

“I have several compatible datasets and want a new dataset containing their features.”

Examples include:

• combining separately downloaded road layers;

• assembling several regional point datasets into one national dataset;

• combining annual survey files before later processing;

• bringing several same-purpose layers into a common output.

Use Append when:

“I already have the target dataset and want to add new data to it.”

Examples include:

• loading this month's field observations into an existing database;

• adding another region to a maintained national layer;

• importing newly collected features into an established feature class.

Because the target is modified, schema compatibility and data governance matter.

Use Union when:

“I need the output to represent how polygon layers overlap.”

Examples include:

• combining zoning and flood-zone polygons so each output area records both classifications;

• comparing two polygon systems while retaining both overlapping and non-overlapping areas;

• creating a complete subdivision from boundaries contributed by several layers.

In that case, simply putting all the records into one dataset would not answer the question.

A decision table

• Question: Do I need a new combined dataset?; Merge: ✓; Append: ; Union: ✓

• Question: Do I need to modify an existing target?; Merge: ; Append: ✓; Union:

• Question: Should input features generally retain their geometry?; Merge: ✓; Append: ✓; Union:

• Question: Does spatial overlap determine the result?; Merge: ; Append: ; Union: ✓

• Question: Can overlapping input features simply remain overlapping?; Merge: ✓; Append: ✓; Union: No, not in the normal overlay result

• Question: Can features be split into new pieces?; Merge: Normally no; Append: Normally no; Union: ✓

• Question: Is target schema compatibility especially important?; Merge: Sometimes; Append: ✓; Union: Different concern

• Question: Am I primarily combining records?; Merge: ✓; Append: ✓; Union:

• Question: Am I constructing new spatial relationships?; Merge: ; Append: ; Union: ✓

The simplest distinction is about what is being combined

Merge, Append, and Union become much easier to distinguish once you stop asking whether they all “combine layers”.

They do—but at different levels.

Merge combines datasets into a new dataset.

Append combines incoming data with an existing target.

Union combines geography according to spatial overlap.

If you merely need features from several compatible files in one place, spatial overlay is unnecessary. If you already have the destination and want to add records to it, creating another merged dataset may also be unnecessary. And if the question is about how boundaries overlap, neither Merge nor Append will create the spatial subdivisions you need.

Before choosing the tool, decide whether you are combining datasets, records, or geography.

That usually makes the correct operation clear.

References

1. QGIS Documentation — Merge vector layers. Documents QGIS's Merge operation as combining multiple compatible vector layers into a new output layer containing their features and attributes.

2. ArcGIS Pro Documentation — Append. Defines Append around adding input data to an existing target dataset, including schema matching and field-mapping behaviour, and distinguishes it from creating a new output with Merge.

3. QGIS Documentation — Union. Documents polygon-overlay Union as splitting features according to overlap and retaining overlapping and non-overlapping portions with attributes from the contributing layers.