Analyzing the Eurovision Song Contest With Graphs
Tags: algorithms, graphdatabse, database, memgraph
Published: 2023-06-09 15:04:08


### Introduction 

After the 2020 Eurovision Song Contest was canceled, we are excited about this year's finals more than ever, but geeks among us can't just wait around doing nothing! 
Every year Eurovision brings us a fantastic mash-up of extravagant outfits, catchy songs, and bold dance moves. Underneath the surface of glitter and rainbows, there is a complicated story of geopolitics, rivalry, and tactics hidden in the collection of interconnected data. 

We will try to untangle strategic voting, neighbor preferences, and political rivalries with the help of graph analytics. 


## Data model


Our dataset is quite simple. There are 51 `Country` nodes with the following properties: `name`, `capital`, `lat`, `lng` and `flag`. The properties `lat` and `lng` represent the coordinates of a country's capital city and will be important for visualizing the data on a map. The same is true for the `flag` property.

Each year's winner and runner-up are connected to `Winner` and `RunnerUp` nodes, respectively, with an edge `IS` that contains the properties `year` and `points`.

The `Country` nodes are connected with the `BORDERS` edge if they are neighboring countries.`VOTE_JURY` and `VOTE_TELEVOTE` edges have properties `year` and `points`. `VOTE_JURY` edges represent a number of points given by each country's professional jury, and `VOTE_TELEVOTE` edges represent the general public's vote that has been introduced in 1997. The voting system has been changed a few times so far but since 2009 the winner is determined by votes of the jury and public in an equal split.

![](https://i.imgur.com/XR5n3GN.png)


## Visualizing the Graph With Memgraph Lab

You can find the Eurovision song contest dataset in Memgraph Lab and on [Memgraph Playground](https://playground.memgraph.com/) online. 
Memgraph Lab is an integrated development environment used to import data, develop, debug and profile database queries and visualize query results. Just go to the **Datasets tab** and load the *Eurovision voting results* dataset.

Visualizing data in Memgraph is pretty simple. Memgraph Lab automatically detects nodes that have numerical `lat` and `lng` properties and displays them on a map. 
You can style the map to your liking by using the Style editor in Memgraph Lab. To find out more about the style editor, take a look at [this tutorial](https://memgraph.com/blog/how-to-style-your-graphs-in-memgraph-lab).
Each country node also has a `flag` property which is used to display an image. You can use the following styling script to display the flags on a map:


```
@NodeStyle {
  size: 100
  border-width: 2
  border-color: #ffffff
  shadow-color: #bab8bb
  shadow-size: 6
}

@NodeStyle Greater(Size(Labels(node)), 0) {
  label: Format(":{}", Join(Labels(node), " :"))
}

@NodeStyle HasLabel(node, "Country") {
  color: #dd2222
  color-hover: Darker(#dd2222)
  color-selected: #dd2222
}

@NodeStyle HasProperty(node, "name") {
  label: AsText(Property(node, "name"))
}

@EdgeStyle {
  width: 10
  label: Type(edge)
  color: gray
}

@NodeStyle {
  image-url: Property(node, "flag")
}
```
To get your graph, run the following Cypher query:

```cypher
MATCH (c:Country) 
RETURN c;
```
If everything works properly, you should get a visualization similar to the one below.

![](https://i.imgur.com/Jw6ARGq.png)

## Data analysis

Some countries have been more successful than others in producing good music (or keeping strong relationships with their neighbors). Let's check which country was the most victorious since 1975:

```cypher
MATCH (c:Country)-[i:IS]-(w:Winner) 
RETURN c.name AS Country, count(i) AS Wins 
ORDER BY Wins DESC;
```

Interestingly, Ireland and Sweden stay on top despite our dataset being incomplete.

![](https://i.imgur.com/dMxcq6a.png)

Coming in second on Eurovision is like nearly winning a medal at the Olympics. Let's check the biggest runner-ups of Eurovision:

```cypher
MATCH (c:Country)-[i:IS]-(r:RunnerUp) 
RETURN c.name AS Country, count(i) AS RunnerUp
ORDER BY RunnerUp DESC;
```

It seems that the UK is the most notable runner-up in history.

![](https://i.imgur.com/3aMmvxl.png)

But it's not all about winning! There is a special satisfaction in supporting your favorite song and casting a vote. 

Some countries were better than others in predicting a winner, or is it just that some have better taste? Let's check which countries gave the most points to the winners throughout history:

```cypher
MATCH (c:Country)-[vote:VOTE_JURY]->(: Country)-[i:IS]->(w:Winner)
WHERE vote.points = 12 AND vote.year = i.year
WITH c, COUNT(vote.points) AS points
RETURN c.name AS Country, points
ORDER BY points DESC 
LIMIT 10;
```

![](https://i.imgur.com/AJGSV3Y.png)

But it turns out that it isn't a matter of good or bad taste. When we take a look at the list of countries that didn't give any points to winners over the years: 

```cypher
MATCH (c:Country)-[v:VOTE_JURY]->(:Country)-[i:IS]->(w:Winner)
WHERE v.points = 0 AND v.year=i.year
RETURN c.name AS Country, count(v) AS WasWrong
ORDER BY WasWrong DESC
LIMIT 10;
```

The UK is again at the top of our list.

![](https://i.imgur.com/AiHvIwN.png)


So what's Eurovision voting really about?  Is having a catchy song really what it takes to win, or is there more to it? Maybe similar languages or familiar cultures play a role. 
Let's check who fancies who by looking into which countries exchange the most points between each other:

```cypher
MATCH (c1:Country)-[v1:VOTE_JURY]->(c2:Country), (c1: Country)<-[v2:VOTE_JURY]-(c2:Country)  
WHERE v1.year = v2.year
WITH c1.name AS Country1, c2.name AS Country2, SUM(v1.points) + sum(v2.points) AS Points
RETURN Country1, Points, Country2
ORDER BY Points DESC;

```
Relationships are symmetrical, so for every pair, there are two results. The number of points calculated is identical in both results, but countries switch places.
It's not surprising that most love is exchanged between neighbors!

![](https://i.imgur.com/Jlya3lu.png)

Let's check how number of points from neighbors influenced the choice of winners over the years:

```cypher
MATCH (w: Winner)-[i:IS]-(c1: Country)-[b:BORDERS]-(c2: Country), 
      (c1: Country)<-[v:VOTE_JURY]-(c2: Country)
WHERE i.year = v.year
WITH c1.name AS Country, sum(v.points) AS neighbour_points, i.points AS total_points
RETURN Country, round(1.0 * neighbour_points/total_points * 100) as Percent_of_neighbour_votes 
ORDER BY Percent_of_neighbour_votes DESC;
```

Looks like France has amazing relationships with its neighbors. But is it about quality or quantity?

![](https://i.imgur.com/69FFzP7.png)

First, let's find out who has the most neighbors participating in the competition:

```cypher
MATCH (c1:Country)-[:BORDERS]-(c2:Country)
WITH DISTINCT c2.name AS Neighbor, c1.name as Country
RETURN Country, COUNT(Neighbor) AS Number_of_neighbors
ORDER BY Number_of_neighbors DESC LIMIT 10;
```
Seems like quantity wins in this case. France, Russia, and Germany have the largest number of neighbors and the most significant influence on their victories.

![](https://i.imgur.com/8hniEDy.png)

Let's finish with a specific example of how much geographical location influences the vote. Russia was the winner in 2008, but how many points would it get if voting for neighbors were forbidden?
```cypher
MATCH (c1:Country)-[b:BORDERS]-(c2:Country {name: 'Russia'}),
      (c1:Country)-[v:VOTE_JURY {year: 2008}]->(c2:Country)
WITH sum(v.points) AS border_vote, c2.name AS name
MATCH (:Country)-[v:VOTE_JURY {year: 2008}]->(c:Country {name: 'Russia'})
RETURN c.name AS Country, sum(v.points) AS Points, sum(v.points)-border_vote AS Points_without_neighbours;
```
That's a significant difference! 

![](https://i.imgur.com/krAq9E9.png)


## Conclusion



There is a lot more to untangle and explore, but as the 2021 Grand Final is approaching, it's time to stop analyzing. After we find out this year's winner, we'll update the dataset and come back next year with new and more exciting analysis. 
Until then, for more interesting examples of how to use graph analytics to analyze network data, visit [Memgraph Playground](https://playground.memgraph.com/) and check out one of the available tutorials. You can also download[ Memgraph Lab](https://memgraph.com/download) and try it out locally.

Now relax and enjoy all things Eurovision!
*"Good night, Europe! And Good morning, Australia!"*