# Contains either test

Learn how to check if a collection contains one or more elements.

This test checks whether one collection contains at least one of the elements of another. It is the opposite of the [`contains neither`](/reference/cql/expressions/tests/collection/contains-neither) test.

This operation corresponds to the mathematical concepts of [intersection](https://en.wikipedia.org/wiki/Intersection_\(set_theory\)) and [disjoint sets](https://en.wikipedia.org/wiki/Disjoint_sets). Specifically, it checks whether the intersection of the collection 𝐴 and 𝐵 is not empty (𝐴 ∩ 𝐵 ≠ ∅) or, conversely, whether 𝐴 and 𝐵 are not disjoint (𝐴 ∩ 𝐵 ≠ ∅).

Note that the result is always false if the second collection is empty because the [empty set is disjoint from every set](https://en.wikipedia.org/wiki/Empty_set#properties).

Also, keep in mind that neither the order nor duplicate elements affect the result since collections are treated as [sets](/reference/cql/data-types/core/collection#set).

## Syntax \[#contains-either-syntax]

This test has the following syntax:

```cql
/*<collection>*/ contains either /*<collection>*/
```

Alternatively, you can use the following syntax:

```cql
/*<collection>*/ includes either /*<collection>*/
```

Both forms have the same semantics. You can use whichever makes your query more expressive and easier to read.

You can negate the test to verify the contrary:

```cql
/*<collection>*/ does not contain either /*<collection>*/
```

The same applies to the alternative syntax:

```cql
/*<collection>*/ does not include either /*<collection>*/
```

However, consider using the [`contains neither`](/reference/cql/expressions/tests/collection/contains-neither) test instead of negating, as it is more expressive and easier to understand.

## Parameters \[#contains-either-parameters]

These are the supported parameters:

- `collection`: `collection`

  The collection to check.

- `subset`: `collection`

  The collection whose elements must be contained in the other collection.

## Examples \[#contains-either-examples]

Here is an example of a collection that contains at least one of the elements of another collection:

```cql
["a", "b", "c"] contains either ["a", "d", "e"] // true
```

And here is a counterexample:

```cql
["a", "b", "c"] contains either ["d", "e", "f"] // false
```

To negate the test, you can write:

```cql
["a", "b", "c"] does not contain either ["a", "d", "e"] // false
```

If the second collection is empty, the result is always `false`:

```cql
["a", "b", "c"] contains either [] // false
```