issue_comments

I add the example from https://github.com/pydata/xarray/pull/4753#discussion_r631399543 here. I am not 100% if that is the same problem or not:

```python def combine_by_coords_problem(name, join="override"):

ds0 = xr.Dataset(coords={"x1": [1, 2, 3], name: [10, 20, 30]})
ds1 = xr.Dataset(coords={"x1": [4, 5, 6], name: [40, 50, 60]})

return xr.combine_by_coords([ds0, ds1], join=join)

combine_by_coords_problem("x0") # concatenates 1, 2, 3, 4, 5, 6 combine_by_coords_problem("x2") # concatenates 10, 20, 30, 40, 50, 60 ```

with join= - "exact": error - "left", "right", "inner", "override": ambiguous result - "outer": sensible result

But then it also overrides when it should concatenate...

```python import numpy as np import xarray as xr

data = np.arange(5).reshape(1, 5) x = np.arange(5) x_name = "lat"

da0 = xr.DataArray(data, dims=("t", x_name), coords={"t": [1], x_name: x}).to_dataset(name="a") x = x + 5 da1 = xr.DataArray(data, dims=("t", x_name), coords={"t": [2], x_name: x}).to_dataset(name="a") ds = xr.combine_by_coords((da0, da1), join="override")

outpython <xarray.Dataset> Dimensions: (lat: 5, t: 2) Coordinates: * lat (lat) int64 0 1 2 3 4 * t (t) int64 1 2 Data variables: a (t, lat) int64 0 1 2 3 4 0 1 2 3 4 ```

Again if we set x_name = "y" the following is returned:

```python <xarray.Dataset> Dimensions: (t: 1, y: 10) Coordinates: * t (t) int64 1 * y (y) int64 0 1 2 3 4 5 6 7 8 9 Data variables: a (t, y) int64 0 1 2 3 4 0 1 2 3 4

```

Thanks for the thorough answer! Thus, we need to figure out if there is a "bug" in merge or if this has to be soved in combine_by_coords.

Disallowing "ragged hypercubes" certainly makes the problem much easier. Then we can say: "if two coords have the same start they need to be equal" (I think).

combine_by_coords does a merge and a concat (in the _combine_1d function). The order of these operations makes a difference to the result. See details.

Yes I think I'd be interested to fix this...

One question on the scope of combine_by_coords - consider the following example with 4 arrays ("a" through "d") arranged as follows:

aabbb cccdd

Or as Dataset:

```python ds_a = xr.Dataset({"data": (("y", "x"), [[1, 2]]), "x": [0, 1], "y": [0]}) ds_b = xr.Dataset({"data": (("y", "x"), [[3, 4, 5]]), "x": [2, 3, 4], "y": [0]})

ds_c = xr.Dataset({"data": (("y", "x"), [[11, 12, 14]]), "x": [0, 1, 2], "y": [1]}) ds_d = xr.Dataset({"data": (("y", "x"), [[14, 15]]), "x": [3, 4], "y": [1]})

xr.combine_by_coords([ds_a, ds_b, ds_c, ds_d]).data ```

Should that work or not?

Current behaviour

Currently it yields the following:

python <xarray.DataArray 'data' (y: 2, x: 5)> array([[ 1, 2, 3, 4, 5], [11, 12, 14, 14, 15]]) Coordinates: * x (x) int64 0 1 2 3 4 * y (y) int64 0 1

However, if "x" is renamed to "z" it fails ("resulting coords not monotonic").