Feedback

Creating synergies and interactions among the analysts and the “producers” of data. See details.

Reuse these data in your code

Query, endpoint and code for reusing the same data
https://query.wikidata.org/sparql
PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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).
Howto write a query SPARQL? (in French)
{{#sparql:PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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).
| endpoint = https://query.wikidata.org/sparql
| chart=bordercloud.visualization.DataTable
| options=
| log=2
}}
Howto install LinkedWiki in my wiki? Howto insert this graph in my wiki?
Test this script in a new tab.
<html>
    <head>
        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"  async></script>
    </head>
    <body onload="testQuery();">
        <script>
function testQuery(){
    var endpoint = "https://query.wikidata.org/sparql";
    var query = "PREFIX bd: <http://www.bigdata.com/rdf#> \n\
\n\
PREFIX wdt: <http://www.wikidata.org/prop/direct/> \n\
PREFIX wikibase: <http://wikiba.se/ontology#> \n\
#added before 2016-10\n\
\n\
# Each composer’s most used tonality, with number of works in that tonality.\n\
# (If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.)\n\
#\n\
# The SPARQL for this is an evil perversion of three subqueries (one of them nested in another).\n\
# To understand it, you have to go inside out… follow the numbers.\n\
\n\
SELECT ?composerLabel ?tonalityLabel ?count\n\
WHERE\n\
{\n\
  {\n\
    # 4. Group again, this time just by the composer.\n\
    #    We also select the highest count of a tonality.\n\
    #    Notice that we don’t know what tonality this count is associated with – we’ll get to that.\n\
    #    So now we have each composer, along with how often they used whatever tonality they used most.\n\
    SELECT ?composer (MAX(?count) AS ?count)\n\
    WHERE\n\
    {\n\
      {\n\
        # 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.\n\
        SELECT ?composer ?tonality (COUNT(?composition) AS ?count)\n\
        WHERE\n\
        {\n\
          # 1. Extremely straightforward the ?composition has the composer ?composer and the tonality ?tonality.\n\
          #    (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.)\n\
          ?composition wdt:P86 ?composer;\n\
                       wdt:P826 ?tonality.\n\
        }\n\
        GROUP BY ?composer ?tonality\n\
        HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”.\n\
      }\n\
    }\n\
    GROUP BY ?composer\n\
  }\n\
  {\n\
    # 6. Identical to 2.\n\
    SELECT ?composer ?tonality (COUNT(?composition) AS ?count)\n\
    WHERE\n\
    {\n\
      # 5. Identical to 1.\n\
      ?composition wdt:P86 ?composer;\n\
                   wdt:P826 ?tonality.\n\
    }\n\
    GROUP BY ?composer ?tonality\n\
    HAVING(?count > 1) # 7. Identical to 3.\n\
  }\n\
  # 8. That’s it. Wait, what?\n\
  #    From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most.\n\
  #    From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality.\n\
  #    The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined,\n\
  #    we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 –\n\
  #    that is, where this tonality was used as often as the composer’s most-used tonality.\n\
  #    In other words, this must *be* the composer’s most-used tonality (except when there are multiple tonalities with the same count).\n\
  SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\
}\n\
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)."

   // $('#bodyContentResearch').append(queryDataset);
    $.ajax({
                url: endpoint,
                dataType: 'json',
                data: {
                    queryLn: 'SPARQL',
                    query: query ,
                    limit: 'none',
                    infer: 'true',
                    Accept: 'application/sparql-results+json'
                },
                success: displayResult,
                error: displayError
        });
}

function displayError(xhr, textStatus, errorThrown) {
    console.log(textStatus);
    console.log(errorThrown);
}

function displayResult(data) {
    $.each(data.results.bindings, function(index, bs) {
        console.log(bs);
        $("body").append(JSON.stringify(bs) + "<hr/>");
    });
}

        </script>
    </body>
</html>
Test this script in a new tab (Careful, several charts need a API key).
Howto insert this graph in my html page?
<html>
    <head>
     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">

     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.9.0/css/all.min.css">

     <script
            src="https://code.jquery.com/jquery-3.4.1.min.js"
            integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
            crossorigin="anonymous"> </script>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js" integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous"> </script>
     <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js" integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous"> </script>

     <script type="text/javascript" src="https://bordercloud.github.io/sgvizler2/sgvizler2/sgvizler2.js" defer> </script>
     <script type="text/javascript" src="https://io.datascience-paris-saclay.fr/js/initExampleHTML.js"  defer > </script>
    </head>
<body style="margin:0;">
<div id="sgvzl_example_query"
   data-sgvizler-endpoint="https://query.wikidata.org/sparql"
   data-sgvizler-query="PREFIX bd: &lt;http://www.bigdata.com/rdf#&gt; 

PREFIX wdt: &lt;http://www.wikidata.org/prop/direct/&gt; 
PREFIX wikibase: &lt;http://wikiba.se/ontology#&gt; 
#added before 2016-10

# Each composer&rsquo;s most used tonality, with number of works in that tonality.
# (If this is ambiguous &ndash; multiple tonalities with the same number &ndash; 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&hellip; 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&rsquo;t know what tonality this count is associated with &ndash; we&rsquo;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&rsquo;m not bothering with any &ldquo;instance of&rdquo; 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 &gt; 1) # 3. Limit that to counts &gt; 1, because using a tonality once is hardly &ldquo;most used&rdquo;.
      }
    }
    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 &gt; 1) # 7. Identical to 3.
  }
  # 8. That&rsquo;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 &ndash;
  #    that is, where this tonality was used as often as the composer&rsquo;s most-used tonality.
  #    In other words, this must *be* the composer&rsquo;s most-used tonality (except when there are multiple tonalities with the same count).
  SERVICE wikibase:label { bd:serviceParam wikibase:language &quot;en&quot;. }
}
ORDER BY DESC(?count) # 9. Order by count (highest first), because the result isn&rsquo;t very meaningful for low counts (many compositions aren&rsquo;t on Wikidata or don&rsquo;t have a tonality statement)."
    data-sgvizler-chart='bordercloud.visualization.DataTable'
    data-sgvizler-chart-options=''
    data-sgvizler-endpoint_output_format='json'
    data-sgvizler-log='2'
    style='width:100%; height:auto;'  />

<script>
/*$(function() {
   sgvizler2.containerDrawAll({
       // Google Api key
       googleApiKey : "GOOGLE_MAP_API_KEY",
       // OpenStreetMap Access Token
       //  https://www.mapbox.com/api-documentation/#access-tokens
       osmAccessToken : "OSM_MAP_API_KEY"
     });
});*/
</script>

</body>
</html>
from SPARQLWrapper import SPARQLWrapper, JSON

sparql = SPARQLWrapper("https://query.wikidata.org/sparql")
sparql.setQuery("""
    PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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).""")
sparql.setReturnFormat(JSON)
results = sparql.query().convert()

for result in results["results"]["bindings"]:
    print(result)
    #print(result["label"]["value"])
Howto use SPARQL with Python ?
library(SPARQL) # SPARQL querying package
library(ggplot2)

# Step 1 - Set up preliminaries and define query
# Define the data.gov endpoint
    endpoint <- "https://query.wikidata.org/sparql"
# create query statement
    query <- "PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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)."
# Step 2 - Use SPARQL package to submit query and save results to a data frame
qd <- SPARQL(endpoint,query)
df <- qd$results
SPARQL with R in less than 5 minutes
#!/usr/bin/env ruby
#
# Install sparql for Ruby
#   gem update --system
#   gem install sparql
#
require 'sparql/client'

endpoint = "https://query.wikidata.org/sparql"
sparql = <<-EOT
PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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).
EOT

#For Wikidata, the method get is required
#For other SPARQL endpoints, the method post is prefered
client = SPARQL::Client.new(endpoint, :method => :get)
rows = client.query(sparql)

puts "Number of rows: #{rows.size}"
for row in rows
  for key,val in row do
    # print "#{key.to_s.ljust(10)}: #{val}\t"
    print "#{key}: #{val}\t"
  end
  print "\n"
end
Doc Ruby for SPARQL 1.1
endpoint = 'https://query.wikidata.org/sparql';

query = ['PREFIX bd: <http://www.bigdata.com/rdf#>  '...
' '...
'PREFIX wdt: <http://www.wikidata.org/prop/direct/>  '...
'PREFIX wikibase: <http://wikiba.se/ontology#>  '...
'#added before 2016-10 '...
' '...
'# 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). '];

url_head = strcat(endpoint,'?query=');
url_query = urlencode(query);
format = 'text/tab-separated-values';
url_tail = strcat('&format=', format);

url = strcat(url_head, url_query, url_tail);

% get the data from the endpoint
query_results = urlread(url);

% write the data to a file so that tdfread can parse it
fid = fopen('query_results.txt','w');
if fid>=0
    fprintf(fid, '%s\n', query_results)
    fclose(fid)
end

% this reads the tsv file into a struct
sparql_data = tdfread('query_results.txt')
Project Github MatlabSPARQL
<?php
require __DIR__ . '/../vendor/autoload.php';
use BorderCloud\SPARQL\SparqlClient;

$endpoint ="https://query.wikidata.org/sparql";
$sp_readonly = new SparqlClient();
$sp_readonly->setEndpointRead($endpoint);
$q = <<<EOD
PREFIX bd: <http://www.bigdata.com/rdf#> 

PREFIX wdt: <http://www.wikidata.org/prop/direct/> 
PREFIX wikibase: <http://wikiba.se/ontology#> 
#added before 2016-10

# 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).EOD;
$rows = $sp_readonly->query($q, 'rows');
$err = $sp_readonly->getErrors();
if ($err) {
      print_r($err);
      throw new Exception(print_r($err,true));
}

foreach($rows["result"]["variables"] as $variable){
        printf("%-20.20s",$variable);
        echo '|';
 }
 echo "\n";

foreach ($rows["result"]["rows"] as $row){
        foreach($rows["result"]["variables"] as $variable){
                printf("%-20.20s",$row[$variable]);
        echo '|';
        }
        echo "\n";
 }
 ?>
Project Github BorderCloud/SPARQL
import com.bordercloud.sparql.Endpoint;
import java.util.ArrayList;
import java.util.HashMap;

public class Main {

    public static void main(String[] args) {
        try {
            Endpoint sp = new Endpoint("https://query.wikidata.org/sparql";, false);

            String querySelect = 'PREFIX bd: <http://www.bigdata.com/rdf#>  \n'
                    + ' \n'
                    + 'PREFIX wdt: <http://www.wikidata.org/prop/direct/>  \n'
                    + 'PREFIX wikibase: <http://wikiba.se/ontology#>  \n'
                    + '#added before 2016-10 \n'
                    + ' \n'
                    + '# Each composer’s most used tonality, with number of works in that tonality. \n'
                    + '# (If this is ambiguous – multiple tonalities with the same number – there are multiple results for one composer.) \n'
                    + '# \n'
                    + '# The SPARQL for this is an evil perversion of three subqueries (one of them nested in another). \n'
                    + '# To understand it, you have to go inside out… follow the numbers. \n'
                    + ' \n'
                    + 'SELECT ?composerLabel ?tonalityLabel ?count \n'
                    + 'WHERE \n'
                    + '{ \n'
                    + '  { \n'
                    + '    # 4. Group again, this time just by the composer. \n'
                    + '    #    We also select the highest count of a tonality. \n'
                    + '    #    Notice that we don’t know what tonality this count is associated with – we’ll get to that. \n'
                    + '    #    So now we have each composer, along with how often they used whatever tonality they used most. \n'
                    + '    SELECT ?composer (MAX(?count) AS ?count) \n'
                    + '    WHERE \n'
                    + '    { \n'
                    + '      { \n'
                    + '        # 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. \n'
                    + '        SELECT ?composer ?tonality (COUNT(?composition) AS ?count) \n'
                    + '        WHERE \n'
                    + '        { \n'
                    + '          # 1. Extremely straightforward the ?composition has the composer ?composer and the tonality ?tonality. \n'
                    + '          #    (I’m not bothering with any “instance of” because the presence of these two properties is a sufficient indicator of ?composition being a composition.) \n'
                    + '          ?composition wdt:P86 ?composer; \n'
                    + '                       wdt:P826 ?tonality. \n'
                    + '        } \n'
                    + '        GROUP BY ?composer ?tonality \n'
                    + '        HAVING(?count > 1) # 3. Limit that to counts > 1, because using a tonality once is hardly “most used”. \n'
                    + '      } \n'
                    + '    } \n'
                    + '    GROUP BY ?composer \n'
                    + '  } \n'
                    + '  { \n'
                    + '    # 6. Identical to 2. \n'
                    + '    SELECT ?composer ?tonality (COUNT(?composition) AS ?count) \n'
                    + '    WHERE \n'
                    + '    { \n'
                    + '      # 5. Identical to 1. \n'
                    + '      ?composition wdt:P86 ?composer; \n'
                    + '                   wdt:P826 ?tonality. \n'
                    + '    } \n'
                    + '    GROUP BY ?composer ?tonality \n'
                    + '    HAVING(?count > 1) # 7. Identical to 3. \n'
                    + '  } \n'
                    + '  # 8. That’s it. Wait, what? \n'
                    + '  #    From 4, we now have ?composer, any composer, and ?count, the count of how often they used whatever tonality they used most. \n'
                    + '  #    From 6, we also have a ?composer, as well as a ?tonality, and the count of how often they used that particular tonality. \n'
                    + '  #    The trick is that ?composer and ?count are the same variable in each subquery, and so now, when the two subqueries are joined, \n'
                    + '  #    we select only that ?tonality from 6 where the ?composer and the ?count are identical to those from 4 – \n'
                    + '  #    that is, where this tonality was used as often as the composer’s most-used tonality. \n'
                    + '  #    In other words, this must *be* the composer’s most-used tonality (except when there are multiple tonalities with the same count). \n'
                    + '  SERVICE wikibase:label { bd:serviceParam wikibase:language "en". } \n'
                    + '} \n'
                    + '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). \n';

            HashMap rs = sp.query(querySelect);
            printResult(rs,30);

        }catch(EndpointException eex) {
            System.out.println(eex);
            eex.printStackTrace();
        }
    }

    public static void printResult(HashMap rs , int size) {

      for (String variable : (ArrayList) rs.get("result").get("variables")) {
        System.out.print(String.format("%-"+size+"."+size+"s", variable ) + " | ");
      }
      System.out.print("\n");
      for (HashMap value : (ArrayList>) rs.get("result").get("rows")) {
        //System.out.print(value);
        /* for (String key : value.keySet()) {
         System.out.println(value.get(key));
         }*/
        for (String variable : (ArrayList) rs.get("result").get("variables")) {
          //System.out.println(value.get(variable));
          System.out.print(String.format("%-"+size+"."+size+"s", value.get(variable)) + " | ");
        }
        System.out.print("\n");
      }
    }
}
Project Github BorderCloud/SPARQL-JAVA
Very soon !
TODO