query-9efc7ae38c81161960b357edcee31665
Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement). Each composer’s most used tonality, with number of works in that tonality.
(If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count WHERE { { # 4. Group again, this time just by the composer. # We also select the highest count of a tonality. # Notice that we don’t know what tonality this count is associated with – we’ll get to that. # So now we have each composer, along with how often they used whatever tonality they used most. SELECT ?composer (MAX(?count) AS ?count_) WHERE { { # 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality. # (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. } } GROUP BY ?composer } { # 6. Identical to 2. SELECT ?composer ?tonality (COUNT(?composition) AS ?count) WHERE { # 5. Identical to 1. ?composition wdt:P86 ?composer; wdt:P826 ?tonality. } GROUP BY ?composer ?tonality HAVING(?count > 1) # 7. Identical to 3. } # 8. That’s it. Wait, what? # From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. # From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. # The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, # we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – # that is, where this tonality was used as often as the composer’s most-used tonality. # In other words, this must be the composer’s most-used tonality (except when there are multiple tonalities with the same count). SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } } ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement).
Use at
- https://query.wikidata.org/sparql
PREFIX wikibase: <http://wikiba.se/ontology#>
PREFIX wdt: <http://www.wikidata.org/prop/direct/>
PREFIX bd: <http://www.bigdata.com/rdf#>
# Each composer’s most used tonality, with number of works in that tonality.
# (If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)
#
# The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).
# To understand it, you have to go inside out… follow the numbers.
SELECT ?composerLabel ?tonalityLabel ?count
WHERE
{
{
# 4. Group again, this time just by the composer.
# We also select the highest count of a tonality.
# Notice that we don’t know what tonality this count is associated with – we’ll get to that.
# So now we have each composer, along with how often they used whatever tonality they used most.
SELECT ?composer (MAX(?count) AS ?count_)
WHERE
{
{
# 2. Group by composer and tonality, so that for each composer and tonality, we get a count of how often the composer used this tonality.
SELECT ?composer ?tonality (COUNT(?composition) AS ?count)
WHERE
{
# 1. Extremely straightforward: the ?composition has the composer ?composer and the tonality ?tonality.
# (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.)
?composition wdt:P86 ?composer;
wdt:P826 ?tonality.
}
GROUP BY ?composer ?tonality
HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”.
}
}
GROUP BY ?composer
}
{
# 6. Identical to 2.
SELECT ?composer ?tonality (COUNT(?composition) AS ?count)
WHERE
{
# 5. Identical to 1.
?composition wdt:P86 ?composer;
wdt:P826 ?tonality.
}
GROUP BY ?composer ?tonality
HAVING(?count > 1) # 7. Identical to 3.
}
# 8. That’s it. Wait, what?
# From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most.
# From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality.
# The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined,
# we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 –
# that is, where this tonality was used as often as the composer’s most-used tonality.
# In other words, this must *be* the composer’s most-used tonality (except when there are multiple tonalities with the same count).
SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
}
ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn’t very meaningful for low counts (many compositions aren’t on Wikidata or don’t have a tonality statement).
Query found at
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ar
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/be-tarask
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ca
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/cs
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/da
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/de
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/en
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/en-gb
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/eo
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/es
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/eu
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/fr
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/he
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/hy
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/id
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/it
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ja
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ko
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/lb
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/lt
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ms
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/nl
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/pl
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/pt-br
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ro
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/ru
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/si
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/sv
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/th
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/tr
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/uk
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/vec
- https://www.wikidata.org/wiki/Wikidata:SPARQL_query_service/queries/examples/zh