SPARQling Pig –Processing Linked Data with Pig Latin
Ste an Hagedorn1 Kat a Hose2 Kai-Uwe Sattler1
1 Te nis e Universitat¨ Ilmenau Ilmenau Germany {first.last}@tu-ilmenau.de 2 Aal orgUniversity Aal org Denmark [email protected]
Abstract: In re ent years data owlanguages su as Pig Latin ave emerged as exi le and power ul tools or andling omplexanalysis tasks on ig data. T ese languages support s ema exi ility as well as ommon programming patterns su as iteration. T eyo er extensi ility t roug user-de ned un tions w ile running on top o s ala le distri uted plat orms. In doing so t ese languages ena le analyti al tasks w ile avoiding t e limitations o lassi al query languages su as SQL and SPARQL. However t e tuple-oriented viewo general-purpose languages likePig does not mat very well t e spe i s o modern datasets availa le on t e We w i o ten use t e RDF data model. Grap patterns or instan e are one o t e ore on- epts o SPARQL ut aveto e ormulated as expli it oins w i urdens t e user wit t e details o e ient query pro essing strategies. In t is paper weaddress t is pro lem y proposing extensions to Pig t at deal wit linked data in RDF to ridge t e gap etween Pig and SPARQL or analyti s. T ese extensions are realized y aset o user-de ned un tions and rewriting rules still allowing to ompile t e en an ed Pig s ripts to plain MapRedu e programs. Forall proposed extensions we dis uss possi le rewriting strategies and present results rom an experimental evaluation.
1Introduction Pro essing and analyzing RDF [W C0 ] data and parti ularly Linked (Open) Data [BL06] o ten requires operations going eyond t e apa ilities o lassi query languages su as SPARQL [W C08]. Alt oug t e most re ent W C re ommendations or SPARQL support ederated queries and aggregate un tions typi al data preparation and leaning steps as well as more advan ed analyti al tasks annot easily e implemented dire tly in SPARQL or anysimilar query language. Consider or example auser w o wants to o tain in ormation a out events in all availa le ategories ( estival azz or estra ro k et .) t at takepla e in t e ve iggest ities in t e world. Even i t e user as ull a ess to t e event dataset determining w i 5 ities are t e iggest in t e world requires a ess to anot er remote dataset. Answering su a query urt er requires expensive grouping and an t ere ore easily e ome expensive to evaluate in atriple store. Furt ermore integrating non-RDF sour es e.g. CSV les or omplextasks su as lustering t e events on t eir geograp i lo ation or data leaning tasks are not possi le in SPARQL engines. On t e ot er and wit t e wide a eptan e o t e MapRedu e plat orm [DG08] de lara- tive data owlanguages su as Pig [ORS+08] or Jaql [BEG+ ] ave gained mu atten-
79 tion. T eyprovide ari set o data pro essing operations transparent parallelization to exploit data parallelism an deal wit exi le s emas and are easy to learn even or non- spe ialists. Furt ermore t ese languages an easily e extended y user-de ned un tions ena ling ustom pro essing. Finally ytargeting MapRedu e as exe ution environment data ows ripts are deploya le to large-s ale lusters or analyzing ig datasets. Alt oug Pig supports anested data model w i is ased on ags o tuples t at in turn an ontain ags atuple-oriented viewresults in several limitations and s ort omings: W ile SPARQL provides asi grap patterns (BGP) as a ore on ept o query or- mulation su query patterns ave to e expressed as sel oins in atuple-oriented language. Un ortunately t is is aquite expensive operation; rst e ause it is im- plemented in Pig y aso- alled COGROUP operator representing ageneralized orm o oin and grouping t at is mapped to a om ination o map and redu e tasks. T e se ond reason is t at sel oins in Pig require to load t e data twi e i.e. on e or ea ran o a oin. Furt ermore t e user is responsi le or ormulating e ient s ripts e.g. in terms o oin order or oin implementation. Pig is targeting t e MapRedu e plat orm and t ere ore works est i t e data an e loaded rom HDFS [Fou09]. However pro essing Linked Data o ten requires to a ess and retrieve data rom remote (SPARQL) endpoints ±w i is usually ad- dressed y ederated SPARQL engines. Depending on t e size o t e remote dataset t e apa ilities o t e endpoint and t e requen yo s ript exe ution it mig t e use ul to download and materialize t e dataset e ore running t e Pig s ript or to et (and a e) t e remote data on demand. In ot ases t is as to e expli itly implemented in t e s ripts. Pig provides a exi le nested data model t at o ers several alternatives or repre- senting groups o triples or RDF statements. T is in ludes not only t e representa- tion w ile pro essing t e data utalso t e storage ormat in HDFS les. However t e oi e o t e most e ient ormat also depends on t e workload and is en e again t e responsi ility o t e user. To over ome t ese limitations t is paper presents Pig language extensions adding SPARQL-like eatures t at are parti ularly use ul or implementing analyti al pro ess- ing tasks overLinked Data. T e main goal o our work is to provide operators on alevel o a stra tion t at li ts t e urden o oosing t e most e ient strategy and operator implementations rom t e user.T ese extensions in lude e ient support o BGPs and FILTERsaswell as transparent a ess to remote Linked Open Data. Our ontri ution is two old: We present aset o language extensions or making Pig alanguage suita le or analyti al Linked Data pro essing. We dis uss possi le strategies or implementing t ese extensions in Pig. We report results rom an experimental evaluation o t e di erent strategies. In la k o a ost model and ost- ased Pig ompilers t ese results an e used as a ounda- tion to implement rewriting euristi s in Pig.
T e work des ri ed in t is paper is em edded in alarger vision o aplat orm or (Linked) Open Data analyti s (LODHu [HS ]) t at allows to pu lis s are and analyze Linked Datasets. In t is ontext Pig is used ±under t e ood o avisual data owdesigner ±as t e data pro essing language. T e remainder o t e paper is stru tured as ollows. A ter adis ussion o related work in Se t. 2 we rie y des ri e t e ontext o our work in Se t. and derive requirements on Pig suita le extensions or Linked Data pro essing. T e proposed extensions are t en presented in Se t. ollowed y adis ussion o t e ne essary data owplanning and ompiling steps in Se t. 5. Results o t e experimental evaluation o t e implementation and rewriting strategies are reported in Se t. 6. Finally Se t. 7 on ludes t is paper and outlines uture work.
2Related Work
Wit t e ontinuous growt o RDF datasets we experien e s ala ility issues w en us- ing asingle server to pro ess SPARQL queries. Despite e ient entralized SPARQL engines or asingle server installation su as RDF- X [NW08] literature as proposed several systems [KM ] t at use parallel pro essing in a luster o ma ines. T e ar- ite tures used or t is purpose di er etween or estrating multiple entralized RDF stores [GHS ] using key-value stores [ W+ ] or uilding upon distri uted le sys- tems [SP L CTW ]. Espe ially systems using adistri uted lesystem makeuse o MapRedu e [DG08] to pro- ess oins [HMM+ PKT+ ]. One o t e key onsiderations is to minimize t e num er o MapRedu e y les w ile still omputing t e omplete answer to t e query.Instead o dire tly mapping SPARQL queries to MapRedu e programs Pig Latin [ORS+08] an e used as an intermediary step i.e. SPARQL queries are mapped to Pig Latin w i in turn is ompiled into MapRedu e. One o t e rst approa es o t is lass waspresented in [SP L ] w ere t e translation o SPARQL queries into Pig Latin s ripts is dis ussed. In t is work RDF data is represented as plain tuples o t ree elds and t e operators o t e SPARQL alge ra are mapped to sequen es o Pig Latin ommands. In ontrast to t is approa our work aims at integrating SPARQL elements su as BGPs into Pig keep- ing t e data owlanguage as t e primary language or spe i ying data analyti s pipelines. Furt ermore we support multiple RDF datasets and SPARQL endpoints wit in asingle s ript. In addition we dis uss and exploit di erent (intermediate) data representation or- mats or RDF data toget er wit possi le optimization strategies depending on t ese data representations. An alternative line o optimization te niques makeuse o alge rai optimiza- tion [RKA ] to minimize t e num er o MapRedu e y les on asystem ased on Pig in om ination wit an alge ra [KRA ] t at onsiders triple groups e.g. all triples wit t e same su e t are onsidered agroup. In our work we ollowasimilar idea o represent- ing RDF triples utgeneralize t e approa and onsider it as only one alternative strategy or deriving e ient MapRedu e programs. In omparison to pro essing o standard SPARQL queries analyti al queries pose ad- ditional allenges due to t eir spe ial ara teristi s su as omplexity evaluation on
typi ally very large datasets and long runtime [ADE+ CGMR ]. Data u es wit dimensions and measures overRDF data an e de ned using RDF ompliant stan- dards [EV 2 W C ]. On t is asis analyti al queries an e ormulated evaluated and optimized. Kotoulas et al. [KUBM 2] propose an approa or query optimization t at interleavesquery exe ution and optimization and SPARQL queries are translated to Pig Latin. In summary existing systems ave o used on RDF data organized in asingle dataset t at t e user as omplete ontrol over. In ontrast t is paper proposes asystem t at targets a roader perspe tive y onsidering analyti al queries and Linked Data organized in multiple datasets and even remote sour es t at t e user w o issues t e query does not ave any ontrol over.
Use Case: The LODHub Platform
T e goal o LODHu [HS ] is to om ine t e un tionalities o rameworks or Open Data management wit in rastru ture or storing and pro essing large sets o Linked (Open) Data. An elasti server in rastru ture e.g. osted y IaaS (In rastru ture as a Servi e) providers su as Amazon EC2 will allowtostart ma ines automati ally as workload peaks o ur.Queries and datasets an t en e distri uted among t ese ma ines transparently to t e user. LODHu is designed to en ourage users to s are t eir data wit ot er users and t us on- tri ute to t e idea o Open Data. Still users an also oose to keep t eir datasets private. Additionally asusers o ten tend to work in teams t e plat orm will allowtoasso iate user a ounts wit organizations and to organize users in teams. W en s aring datasets wit ot er users or reating anew version o an existing dataset provenan e in ormation will e kept to tra k t e original aut or. Data exploration eatures will elp users to dis overnew knowledge y automati ally extending t eir query results wit in ormation ound not only in ot er availa le datasets wit in LODHu utalso rom remote sour es on t e We . T e integration o Pig [ORS+08] ena les users to per orm analyti al tasks t at are not pos- si le wit apure SPARQL approa . Su tasks in lude data trans ormation om ining di erent sour es wit di erent ormats and ot er omplextasks or w i no equivalent SPARQL operations exist. To let users work wit t eir data LODHu provides an easy-to-use and intuitive grap i al editor to reate Pig s ripts. Wit t is editor auser an an drag and drop operators and edit t eir parameters. Operators ave ports or input and output and y onne ting t e output port o one operator to t e input port o anot er operator adata owis reated. Conne ting all needed operators results in adata owgrap w i must ontain one or more LOAD operators and at least one DUMP or STORE operator to s owt e results on s reen or to save t em as anew dataset respe tively.Between t ose twotypes o operators users an add as manyoperators as needed. T e s reens ot in Fig. s ows t e grap i al Pig editor as well as t e Pig s ript ompiled rom t e operator grap .
Figure : LODHu ’svisual data owdesigner or Pig s ripts
In its urrent implementation LODHu eatures almost all operators t at Pig provides. Some o t ese operators owever were modi ed to meet t e allenges t at arise w en working wit RDF data. Note t at LODHu is a le to work not only wit RDF data ut wit any ormat or w i aload un tion e.g. as aUDF exists. T e ollowing s enario illustrates an example s enario and an analyti al task t at is sup- ported y LODHu .Assume t ere exists an RDF dataset wit in ormation a out events. T ese events may e on erts sport events et . or even some sensor readings t at ave een logged into a le. Among ot er in ormation ea event is des ri ed y atitle a des ription o t e event or sensor reading a ategory (i.e. ”sport” ”musi ” or ”tempera- ture”) and aposition o t e event in t e orm o lat/long oordinates. Consider t e ollowing ex erpt rom adataset (in total a. 6.5 million events and more t an 5 million statements) t at were extra ted rom t e we site http://eventful.com and trans ormed into RDF ( or simpli ity wea reviate namespa es and event IDs):
Assume auser wants to nd t e num er o events in ea ategory or ea o t e ve iggest ities in t e world. To answer t is question we rst need to nd ve iggest ities.
T is in ormation ould or instan e e extra ted rom t e remote DBpedia [ABK+07] dataset w i ontains in ormation a out ities in luding name lo ation and population. T e next step is to nd out w i event took pla e in w i ity.Ast e event dataset ontains t e oordinates in twoseparate RDF statements (longitude and latitude) a self- join is required to o tain t e ull oordinate. Now using t ese oordinates we an use an external webservice su as GeoNames [Wi ] to o tain t e name o t e ity t at an event is lo ated in. On e we ave identi ed t e orresponding ity or ea event we an oin t e results o tained rom t e DBpedia dataset wit our events dataset on t e ities. T is produ es t e events lo ated in t e 5 iggest ities. T is intermediate result now as to e oined again wit our original eventdataset to o tain t e event ategory.We an group t is oin result on ity and event ategory and t en ount t e requen ies to produ e t e answer to t e user’squery. Based on t is example s enario we identi y several allenges to Pig operators: Loading datasets. First t e dataset loader must e a le to e iently load datasets rom t e le system (HDFS [Fou09] in our ramework). It s ould ide URIs and le names rom t e user as users s ould not e ot ered wit details su as t e internal le lo ations. Furt ermore t e dataset loader must andle t e spe ial data ormat t at is optimized or Pig on RDF data (see Se t. or details). Basic Graph Pattern. SPARQL uses BGPs t at are mat ed against t e underlying dataset. Pig owever does not support t ese BGPs natively.Toallowusers to easily work wit RDF data t e Pig operators must e a le to e iently interpret BGPs w i may range rom single statements to omplexgrap patterns involving multiple oins. Self joins. RDF data is ased on t e on ept o triples de ning arelations ip (property) etween asu e t and an o e t. T ere ore pro essing SPARQL queries requires to eval- uate manysel oins to pro ess t e BGPs de ned in SPARQL queries. In ontrast to triples stores Pig (and Hadoop) wasnot designed or RDF data and assumes only very ew oins wit in aquery.T is makes plain Pig and Hadoop very ine ient on RDF data e ause per orming sel oins requires to load t e same dataset twi e. As an example onsider t e previous s enario: to onstru t t e oordinate pair or t e events t e dataset as to e loaded twi e in order to per orm t e sel oin. And later to add t e ategory in ormation we again ave to per orm a oin wit t e original event dataset. Remote joins. One o t e ene ts o RDF is its distri uted nature. In ormation an e distri uted overmanyservers and t roug t e links wit in t e datasets t ese datasets are inter- onne ted. T is means t at pro essing aquery mig t in lude per orming a oin wit adataset on aremote server.Asdatasets an e large alot o in ormation mig t ave to e downloaded. To assure reasona le response times query strategies or su remote oins ave to implemented. In our s enario we need to ompute a oin wit t e DBpedia dataset. Su a oin an e per ormed in di erent ways depending on t e remote dataset’ssize and t e data needed to answer t e query: t e datasets an eit er e downloaded ompletely (i possi le) or i aSPARQL endpoint is availa le aSPARQL query an e sent to retrieve only relevant parts o t e dataset w i pro a ly results in only asmall amount o data to download.
Pig Extensions forLinked Data Processing
In order to address t e requirements dis ussed in Se t. we ave developed several exten- sions to t e Pig Latin language w i we introdu e in t e ollowing. T ese extensions par- ti ularly deal wit eatures or pro essing RDF data as well as de ning analyti al pipelines and an e lassi ed into t e ollowing groups: onversion etween RDF triples and t e Pig data model or e ient pro essing a essing linked (RDF) datasets supporting asi grap patterns or users more amiliar wit t e SPARQL style o query ormulation.
TUPLIFY –Tuple construction. Alt oug t e asi triple stru ture o RDF data in t e orm o su e t s predi ate p and o e t o is very exi le and allows to represent ar itrary stru tured data in luding grap s it is not t e optimal oi e or e ient ana- lyti s. T e main reason is t at re onstru ting omplexo e ts rom multiple triples re- quires (sel ) oins w i are very expensive parti ularly in MapRedu e- ased exe ution models su as t e model underlying Pig. On t e ot er and arigid relational stru ture wit aprede ned s ema w ere aset o triples wit t e same su e t is represented y (s,o1,o2,...,on) or t e s ema (s,p1,p2,...pn) iso ten not exi le enoug or RDF data. Fortunately Pig provides a exi le nested data model wit tuples ags and maps. T us tuple onstru tion is an important operation ne essary to pro ess RDF data in Pig e iently.
A rst possi le representation is to use maps or t e predi ate-o e t pairs i.e. (s, {p1 → o1,p2 → o2,...}).However t is pro i its t e use o t e same predi ate multi- ple times or agiven tuple. T ere ore an alternative approa uses ags instead o maps or t e predi ate-o e t pairs i.e. as ema {subject:bytearray, stmts: {(predicate:bytearray, object:bytearray)}}.T is an urt er e generalized y allowing to group triples on anyo t e t ree omponents e.g. on t e predi- ate so t at we o tain {predicate:bytearray, stmts:{(subject:bytearray, object:bytearray)}}.W i o t ese representations is t e est oi edepends on t e operations t at s all e applied on t e data. T e details o tuple re onstru tion are idden y a TUPLIFY operator w i is mapped to di erent implementations. I t e input is aplain ag o triples it simply groups t em as ollows: triple_groups =FOREACH (GROUP triples BY subject) GENERATE group as subject, triples.(predicate, object) AS stmts;
RDFLoad –Accessing datasets. Fora essing linked datasetswe avetodistinguis etween lo al and remote a ess. T e most straig t orward wayo lo al a ess is to load textual les in t e Notation (N ) ormat rom HDFS w i is natively supported y Pig’s LOAD operator.Amore e ient storage s eme ot in terms o spa e onsumption and read osts is to leverage triple groups y using ad a en ylists i.e. aset o triples
5 {(s1,p1,o1),(s1,p2,o2),...,(s1,pn,on)}is represented y (s1, {(p1,o1),...,(pn,on)}.Be- ause t e Pig data model supports ags maps and nested tuples textual les representing t is stru ture an e loaded dire tly into Pig s ripts. In addition y using auser-de ned un tion (UDF) or LOAD t is prin iple an also e extended to lo k-oriented inary les using di tionary and/or run-lengt en oding o t e s p and o values. Currently wesupport t e ollowing strategies or a essing RDF data rom HDFS: using Pig’snative LOAD operator or N les. Be ause RDF literals an ontain w itespa es aUDF (RDFize) or tokenizing text lines ontaining triples into RDF omponents is used as part o ama ro:
REGISTER sparklingpig.jar; DEFINE RDFFileLoad(file) RETURNS T { lines =LOAD ’$file’ AS (txt: chararray); $T =FOREACH lines GENERATE FLATTEN(pig.RDFize(txt)) AS (subject, predicate, object); } triples =RDFFileLoad(’rdf-data.nt’):
using Pig’s LOAD operator wit t e BinStorage un tion or triple groups:
rdf_tuples =LOAD ’rdf-data.dat’ USING BinStorage() AS (subject: bytearray, stmts: (predicate: bytearray, object:bytearray));
In addition RDF datasets may also e retrieved rom remote SPARQL endpoints. Fort is purpose we provide aUDF alled SPARQLLoader t at sends agiven SPARQL query to t e endpoint and trans orms t e result data (usually en oded in XML or JSON) into Pig tuples: REGISTER sparklingpig.jar; raw =LOAD ’http://endpoint.org:8080/sparql’ USING SPARQLLoader(’SELECT * WHERE { ?s ?p ?o }’) AS (subject, predicate, object); Note t at t e latter opens up newoptions to deal wit t e retrieveddata: depending on t e size o t e dataset it ould e use ul to download and materialize t e data in HDFS or reuse e ore starting t e a tual pro essing. Te keep t e load at pu li SPARQL endpoints low it is o ourse advisa le to download data ase dumps w en availa le and manually store t em in HDFS. Furt ermore depending on t e user query we an oose not to download all triples o t e remote endpoint utonly t ose triples t at are ne essary to answer t e user’squery.For instan e givenaFILTER expression on t e population in auser query t en t e ollowing s ript retrievesonly triples en oding t e population o ities: REGISTER sparklingpig.jar; raw =LOAD ’http://endpoint.org:8080/sparql’ USING SPARQLLoader( ’CONSTRUCT {?s dbpedia:populationTotal ?pop } WHERE {?s rdf:type dbpedia:City . ?s dbpedia:populationTotal ?pop}’) AS (subject, predicate, object);
6 I metadata is availa le t at des ri es t e storage ormat o t e data and indi ates w et er data rom remote endpoints ave already een downloaded t en t e details o t ese di - erent strategies an e en apsulated y ageneri RDFLoad operator.
FILTER –Basic Graph Pattern. BGPs are sets o triple patterns t at are used not only or simple ltering utalso or oins. Translating BGPs in t e style o relational query pro essing results in anum er o expensive oins. Furt ermore t e exa t ormulation de- pends on t e triple/tuple layout o t e data; or example i triples are used t en we need a JOIN w ereas or ag- ased tuple stru tures nested FOREACH/FILTER operations an e used. Consider t e ollowing simple BGP as an example: { ?s
Based on atriple s ema in Pig i.e. {subject:bytearray, predicate:bytearray, object:bytearray } t e BGP ould e implemented y: triples1 =RDFLoader(’rdf-data.nt’); triples2 =RDFLoader(’rdf-data.nt’); result =JOIN triples1 BY (subject), triples2 BY (subject); Note t at or sel oins Pig requires to load t e data twi e as in t e example a ove.O ourse t is would not e ne essary i t e se ond pattern stemmed rom anot er dataset. In ontrast i we ave onstru ted RDF tuples using t e s ema {subject:bytearray, stmts:{(predicate: bytearray,object: bytearray)}} e ore i.e. reating a ag o pairs (predi ate o e t) elonging to asu e t t en we an implement t e BGP y: tmp =FOREACH rdf tuples { r1 =FILTER stmts BY (predicate == ’
5Pig Planning and Compiling
In t e previous se tion we des ri ed several extensions to Pig Latin to pro ess Linked Data. To exe ute s ripts involving t ese extensions we need to trans orm t em into plain Pig s ripts. T is trans ormation is implemented as at ree aspe ts: planning rewriting and UDFs. T e remainder o t is se tion dis usses t ese aspe ts in more detail. 7 Planning. Givenauser query we an o ten use metadata to rewrite t e query into amore e ient version. Sin e our extended Pig or instan e allows a ess to lo al as well as remote datasets aquery mig t ontain LOAD operations on aremote SPARQL endpoint. Givent e in ormation t at t e dataset wasalready downloaded and materialized w ile exe uting anot er query we an rewrite t e original query into one t at uses alo al dataset instead. To identi y t ese ases we need to olle t metadata and statisti s e.g. amapping (URL, query) → HDFS path t at we an use to de ide w et er aremote dataset is already availa le lo ally.Asanexample onsider t e LOAD operation rom Se t. : raw =LOAD ’http://endpoint.org:8080/sparql’ USING SPARQLLoader(’SELECT * WHERE { ?s ?p ?o }’) AS (subject, predicate, object);
I amapping (http://endpoint.org:8080/sparql SELECT * WHERE {?s ?p ?o}) → hdfs:///rdf-data.nt exists t en we an rewrite t e expression as raw =RDFFileLoad(’hdfs:///rdf-data.nt’); w i an o viously e exe uted more e iently y avoiding expensive data ex ange overt e We . Note t at t is annot e a ievedinapure Pig environment e ause o t e missing option to generate and store meta in ormation. A ramework likeLODHu owever ould easily store su in ormation and reuse data a ross user queries. In addition to t e a ove mentioned mappings LODHu ould also store in ormation a out t e le ormat i.e. i t e ontent o a le is stru tured as plain triples or as triple groups as well as additional statisti s (e.g. VoID [W C 0] statisti s) a out t e downloaded datasets w i will allow or urt er optimization. Rewriting. T oug UDFs provide a exi le me anism to extend Pig wit additional un tionality wede ided not to implement all extensions as UDFs e ause trans orming t e extended Pig expressions to plain Pig allows us to use all optimizations t at Pig already omes wit . Instead we de ided to implement BGP support via rewriting rules i.e. e ore exe ution t e Pig s ript is passed to arewriter t at analyzes t e ode and uses rewriting rules to trans orm extended Pig statements into plain Pig statements. T ese rules over various input ormats BGPs and operations. An example or su arewriting wasalready giveninSe t. or t e extended lter operation. T e input ormat de nes t e stru ture o t e data stream i.e. i t eyare plain tuples rom an N le or an external SPARQL endpoint or i t e stream is already in atriple group representation as introdu ed in Se t. . In t e ollowing we present and dis uss t ese rewriting rules in detail. (schema) We use t e notation aliasformat to des ri e t e ara teristi s o t e input and out- put datao anoperator.T e alias is t e Pig alias o t e input or output data format de- s ri es t e ormat o t e data i.e. i it is plain triples or triple groups. In t e ormer ase we write plain and in t e latter ase we write group.T e schema denotes t e s ema o t e data e.g. (subject, predicate, object) or plain triples or (subject, {(predicate, object)}) or triple groups. Forease o presentation t e ollowing rules use t e su e t (s) as ade ault to denote grouping ±nevert eless t e rules old or ot er groupings as well.
(T ) I t e data is availa le as plain triples it an e tupli ed using t e TUPLIFY opera- tor.Itist e task o t e optimizer to de ide w et er or not to apply t is rule in order to reate triple groups or agiven input. (s,p,o) aliasplain ⇒ (s,{(p,o)}) outgroup =TUPLIFY(alias) =FOREACH (GROUP alias BY s) GENERATE group as s, alias.(p, o) AS stmts;
(R ) I t e RDFLoad operator is used wit are eren e to aremote endpoint (uri.protocol = ′http′) repla e t e operator wit t e UDF SPARQLLoader as introdu ed in Se t. . out =RDFLoad(’uri’) AS (schema); ⇒ (schema) outplain =LOAD ’uri’ USING pig.SPARQLLoader( ’SELECT * WHERE { ?s ?p ?o }’) AS (schema); (R2) As already outlined in Se t. we an use arestri tive query to redu e t e amount o triples et ed rom t e SPARQL endpoints. T e ne essary knowledge an e drawn rom FILTER operations t at use BGPs. out =RDFLoad(’uri’) AS (schema);
out2 =FILTER out BY {BGP1 . BGP2}; ⇒ (schema) outplain =LOAD ’uri’ USING pig.SPARQLLoader( ’CONSTRUCT * WHERE { BGP1 }’) AS (schema); (schema) (schema) out2plain =FILTER outplain BY { BGP2 };
BGP1 and BGP2 represent asi grap patterns e.g. star oins. T e (su )set o t e BGP t at restri ts t e remote data an e used to de ne t e query t at is sent to t e SPARQL endpoint. O ten t e FILTER’s BGP annot ompletely e used in t e query.Int is ase t e remaining part o t e BGP still as to e applied in a FILTER.Note t at t e LOAD does not ave to e dire tly ollowed y t e FILTER to mat t is rule. Rat er t e output o t e LOAD as to e passed as input to t e FILTER transitively. (L ) To load alo al dataset t e URI uses t e hdfs proto ol (uri.protocol =’hdfs’). In t is ase t e RDFLoad operation an e repla ed y t e RDFFileLoad ma ro. I t e dataset as een savedasplain triples t e output o t e loader are plain triples too. out =RDFLoad(’uri’); ⇒ (s,p,o) outplain =RDFFileLoad(’uri’);
(L2) Loading lo al datasets t at ave een savedint e triple group ormat produ es an output wit t e triple group s ema. Consider t e output wasgrouped y su e t (s) t e RDFLoad operation will e rewritten as:
9 out =RDFLoad(’uri’); ⇒ (s,{(p,o)}) outgroup =LOAD ’uri’USING BinStorage() AS (s:chararray, stmts:bag{ t:(p:chararray,o:chararray) });
T e resulting s ema depends on w i omponent (su e t predi ate or o e t) wasused or grouping. T is in ormation an e stored in t e meta data or ea dataset. (F ) Asinge triple pattern may use only un ound varia les. I su atriple pattern is used in a FILTER it an e omitted sin e it as no e e t: out(schema1) =FILTER in(schema1) BY { ?s ?p ?o }; out2(schema2) = any operator out(schema1); ⇒ out2(schema2) = any operator in(schema1);
Note t at in t is ase t e ormat o t e aliases does not matter. (F2) Filter operators t at use asingle triple pattern wit only one ound varia le an e rewritten as asimple FILTER wit one predi ate. (s,p,o) (s,p,o) outplain =FILTER inplain BY { ?s ?p ’value’ }; ⇒ (s,p,o) (s,p,o) outplain =FILTER inplain BY o==’value’; Rewriting rules or one ound varia le in t e ot er two omponents (subject or predicate)are o viously analogously de ned. Hen e we omit t em ere.
(F ) I t e triple pattern o a lter ontains two(ore more) ound varia les it is rewritten as a lter operation t at onne ts ot predi ates y AND. (s,p,o) (s,p,o) outplain =FILTER inplain BY { ?s ’value1’’value2’ }; ⇒ (s,p,o) (s,p,o) outplain =FILTER inplain BY p==’value1’AND o==’value2’;
As in rule (F2) a ove t ere are analogous rules or t e ound varia les in ot er (or all t ree) omponents. (F ) I t e input alias o t e FILTER operator is in t e triple group ormat and i t e one ound varia le is t e grouping olumn e.g. s t e ollowing rule applies: (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { ’value’?p?o}; ⇒ (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY s==’value’;
(F5) I t e ound varia le o t e lter triple pattern is not t e grouping olumn e.g. o t en t e lter operation e omes more omplex:
9 (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { ?s ?p ’value’ };
⇒ (s,{(p,o)},cnt) (s,{(p,o)}) tmpgroup =FOREACH ingroup { t=FILTER stms BY o==’value’; GENERATE *,COUNT(t) AS cnt; }; (s,{(p,o)},cnt) (s,{(p,o)},cnt) outgroup =FILTER tmpgroup BY cnt >0;
(F6) I t e triple pattern ontains two ound varia les and neit er o t em is t e grouping olumn t en ot predi ates an e onne ted y AND. (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { ?s ’v1’’v2’ };
⇒ (s,{(p,o)},cnt) (s,{(p,o)}) tmpgroup =FOREACH ingroup { t=FILTER stms BY p==’v1’AND o==’v2’; GENERATE *,COUNT(t) AS cnt; }; (s,{(p,o)},cnt) (s,{(p,o)},cnt) outgroup =FILTER tmpgroup BY cnt >0;
(F7) I t e triple pattern ontains two ound varia les and one is t e grouping olumn it will e split into two lter operations. T ese an t en urt er e pro essed y rules (F ) and (F5). (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { ’v1’?p’v2’ };
⇒ (s,{(p,o)}) (s,{(p,o)}) tmpgroup =FILTER ingroup BY { ’v1’ ?p ?o }; (s,{(p,o)},cnt) (s,{(p,o)}) outgroup =FILTER tmpgroup BY { ?s ?p ’v2’ }; (F8) Analogously to rule (F7) i t e input is in t e triple group ormat and a lter triple pattern ontains only ound varia les it will e repla ed y two lter operations w i in turn an urt er e pro essed y rules (F ) and (F6). (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { ’v1’’v2’’v3’ };
⇒ (s,{(p,o)}) (s,{(p,o)}) tmpgroup =FILTER ingroup BY { ’v1’ ?p ?o }; (s,{(p,o)},cnt) (s,{(p,o)}) outgroup =FILTER tmpgroup BY { ?s ’v2’ ’v3’ };
(F9) I a lter ontains more t an one triple pattern (TP1,..., TPN) i.e. aBGP and t ey do not orm a oin t ey an e evaluated one a ter t e ot er as an impli it AND.We leave it to t e Pig engine to optimize t e sequen e o lters. In t is ase t e ormat o t e respe tive aliases again do not matter. (schema) (schema) out =FILTER in BY { TP1 ... TPN }; ⇒ (schema) (schema) f1 =FILTER in BY { TP1 }; ... (schema) (schema) fN =FILTER f(N-1) BY { TPN }; out(schema) =fN; (J ) I t e data is availa le in plain triple ormat and i t e BGP o a lter expression orms astar oin (i.e. t e triple pattern TP1,..., TPN s are t e same varia le in t e same position e.g. on su e t) t e dataset as to e loaded or ea BGP parti i- pating in t e oin. Su oins may ontain ound varia les. Hen e we rst lter t e input or t ese ound varia les.
9 (s,p,o) inplain =RDFLoad(’uri’); (s,p,o) (s,p,o) outplain =FILTER inplain BY { TP1 ... TPN };
⇒ (s,p,o) in1plain =RDFLoad(’uri’); (s,p,o) (s,p,o) f1plain =FILTER in1plain BY { TP1 }; ... (s,p,o) inN plain =RDFLoad(’uri’); (s,p,o) (s,p,o) fN plain =FILTER inN plain BY { TPN }; (s,p,o) (s,p,o) (s,p,o) outplain =JOIN f1plain BY (s), ..., fNplain BY (s); Ea lter operation an t en e urt er pro essed y rules (F ) -(F ). (J2) As already stated in previous se tions t e star oin an easily e realized using FILTER operators i t e input is already in t e triple group ormat. I t e triple pat- tern ontains ound varia les e.g. in t e predi ate position wit values p1,..., pN a lter as to e applied. (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { TP1 ... TPN }; ⇒ (s,{(p,o)},cnt1,...,cntN) (s,{(p,o)}) tmpgroup =FOREACH ingroup { t1 =FILTER stms BY p==’p1’; ... tN =FILTER stms BY p==’pN’; GENERATE *,COUNT(t1) AS cnt1, ..., COUNT(tN) as cntN; }; (s,{(p,o)},cnt1,...,cntN) (s,{(p,o)},cnt1,...,cntN) outgroup =FILTER tmpgroup BY cnt1 >0AND ... AND cntN >0;
(J ) Apat oin is ara terized y t e a t t at t e oin varia les are not on t e same positions in all triple pattern e.g. t e o e t o TPi is oined wit t e su e t o TPi+1.I atriple pattern ontains a onstant t at an e used as a lter t ose lters an e pus ed down. (s,p,o) inplain =RDFLoad(’uri’); (s,p,o) (s,p,o) outplain =FILTER inplain BY { TP1 ... TPN }; ⇒ (s,p,o) in1plain =RDFLoad(’uri’); (s,p,o) (s,p,o) filter1plain =FILTER inplain BY { TP1 }; ... (s,p,o) inN plain =RDFLoad(’uri’); (s,p,o) (s,p,o) filterNplain =FILTER inN plain BY { TPN }; (schemafilter1,schemafilter2) (s,p,o) out1plain =JOIN filter1plain BY (o), (s,p,o) filter2plain BY (s); ... (schemaouti-1,schemafilteri+1) (schemaouti-1) outiplain =JOIN outi-1plain BY (o), (s,p,o) filteri+1plain BY (s); ... (schemaoutN-1,schemafilterN) (schemaoutN-1) outplain =JOIN outN-1plain BY (o), (s,p,o) filterN plain BY (s);
9 T e lter operations on ea triple pattern an e pro essed y rules (F )-(F ) (J ) In ase t e input is loaded as triple groups and apat oin needs to e evaluated we ave to atten t e stru ture and pass t e at triples to t e oin as in rule (J ) a ove.
(s,{(p,o)}) ingroup =RDFLoad(’uri’); (s,{(p,o)}) (s,{(p,o)}) outgroup =FILTER ingroup BY { TP1 ... TPN }; ⇒ (s,{(p,o)}) in1group =RDFLoad(’uri’); (s,{(p,o)}) (s,{(p,o)}) filter1group =FILTER ingroup BY { TP1 }; (s,p,o) (s,{(p,o)}) flat1plain =FOREACH filter1group GENERATE s, FLATTEN(stmts); ... (s,{(p,o)}) inN group =RDFLoad(’uri’); (s,{(p,o)}) (s,{(p,o)}) filterNgroup =FILTER inN group BY { TPN }; (s,p,o) (s,{(p,o)}) flatNplain =FOREACH filterNgroup GENERATE s, FLATTEN(stmts); (schemaflat1,schemaflat2) (s,p,o) (s,p,o) out1plain =JOIN flat1plain BY (o), flat2plain BY (s); ... (schemaouti-1,schemaflati+1) (schemaouti-1) outiplain =JOIN outi-1plain BY (o), (s,p,o) flati+1plain BY (s); ... (schemaoutN-1,schemaflatN) (schemaoutN-1) outplain =JOIN outN-1plain BY (o), (s,p,o) flatN plain BY (s);
UDFs and Compiling. We implemented a ew UDFs to load and pro ess linked datasets. We use t e SPARQLLoader t at a epts aURL o aSPARQL endpoint and aquery to retrieve data rom t at endpoint. Furt ermore t ere is a RDFize UDF t at is used to read and parse statements in N les. For ompiling and optimizing t e resulting s ript we ompletely rely on t e Pig ompiler to generate t e MapRedu e programs.
6Evaluation
In t is se tion we s owt at t e per orman e o t e s ripts depends on w i rules are applied to trans orm t e extended Pig s ript into plain Pig. To do so we ompare t e exe ution times or s ripts t at were generated y di erent rules. T ese experiments s ow t at t ere is aneed or an optimizer t at as a ess to various statisti s in order to de ide w i rule to oose. In our experiments we used aHadoop luster o eig t nodes onsisting o one name node and sevendata nodes. Ea node as an Intel Core i5- 70S CPU wit our ores running at 2.9 GHz and 6 GB RAM. T e luster is managed y Cloudera CDH 5.2 running Hadoop 2.5 and Pig 0. 2. We imported an 8GBdataset w i we introdu ed in Se t. t at ontains ∼5 million statements. In t e experiments we manually trans ormed t e extended Pig statements into plain Pig or typi al operations on RDF data su as ltering on BGP and sel oins. T ere are
9 twos enarios or input data: (i) t e input data are plainN triples ( ased on w i triple groups mig t e generated on-t e- y) and (ii) t e input data is in triple group ormat. T e t ird ase w ere data is et ed rom aremote SPARQL endpoint is not onsidered in t is evaluation as t e delays aused y remote ommuni ation will not lead to additional insig ts. Fort ese s enarios we rst ompared t e exe ution times o asel oin. T e task is to ompute t e latitude and longitude or ea event. We started wit aPig s ript t at uses extended Pig eatures or loading and evaluating aBGP: raw =RDFLoad(’hdfs:///eventful.nt’) res =FILTER raw BY { ?s
T e s ript in ludes one LOAD and one FILTER operator.For LOAD we ave t e two s enarios mentioned a ove.Depending on t e osen rewriting or LOAD we avetwo s enarios or t e BGP pro essing: on plain triples or on triple groups. Fort e latter ase t e triple groups are eit er read dire tly rom t e input le or generated on-t e- y.T is results in (t eoreti ally) our exe ution s enarios: (i) data is loaded as plain triples and t e lter is evaluated on plain triples (ii) data is loaded as plain triples and t e lter is evalu- ated on triple groups (t is requires generating t e groups on-t e- y) (iii) data is loaded as triple groups and evaluation is on plain triples and (iv) input is loaded as triple groups and lter is evaluated on t ese groups. We do not onsider ase (iii) in t is evaluation e ause onverting t e ompa t orm to t e ver ose N ormat will o viously not e ene ial. For s enario (iv) t e triple groups were generated e ore and using t e ode s own in Se t. . T e result wassaved to HDFS using Pig’s BinStorage. Fors enario (i) t e a ove extended Pig s ript an e rewritten using rule (L ) or t e load operation and (J ) or t e BGPs: raw1 =RDFFileLoad(’hdfs:///eventful.nt’); f1 =FILTER triples1 BY predicate == ’
To rewrite t e input s enario (ii) we used rules (L ) or t e LOAD and (T ) to reate t e triple groups. To rewrite t e BGP in t e lter expression rule (J2) wasused. Fors enario (iv) t e rules (L2) and (J2) were applied. T e exe ution times o t e di erent rewriting results are s own in Fig. 2. Forea s ript we used one to eig t partitions per input dataset. One partition is t en pro essed y one mapper.For s enario (i) t is means t at e ause we need to load t e dataset twi e to per orm t e oin we a tually ave twi e as manymappers as partitions. For ot s enarios (ii) and (iv) we only need to load t e dataset on e. As we an see in t e gure working wit triple groups is learly aster t an working wit plain triples. Alt oug t ese gaps de rease w en in reasing t e num er o partitions
9 450 on-the-fly 400 plain triple groups 350
300
250 econds]
[s 200 me
ti 150
100
50
0 1 2 3 4 5 6 7 8 partitions
Figure 2: Exe utiontimes or sel oin operation wit di erent num ers o partitions. Le t: s enario (ii) middle: s enario (i) and rig t: s enario (iv). note t at or plain triples t ere are a tually twi e as manymappers as or t e ot er two s enarios i.e. t is s enario onsumes mu more resour es. However i t e triple groups ave to e generated on-t e- y rst t ere is asigni ant per orman e over ead and t e pro essing takes signi antly longer as or t e s enario w ere t e groups were loaded rom a le. As expe ted t e results suggest t at it may e ene ial to materialize su intermediate results sin e t is would allowot er operators in omplexs ripts to reuse t ese results. I t e materialized results are stored permanently t e optimizer an make use o it in ot er s ripts too. Furt er we an see t e impa t o t e num er o mappers used or exe ution. W en in- reasing t e num er o partitions Pig an makeuse o more mappers to pro ess t e data in parallel w i redu es t e overall pro essing time.
450 on-the-fly 400 plain triple groups 350
300
250 econds]
[s 200 me
ti 150
100
50
0 1 2 3 4 5 6 7 8 partitions
Figure : Exe utiontimes or aBGP lter on anon-grouping omponent (o e t) wit di erent num ers o partitions. Le t: s enario (ii) middle: s enario (i) and rig t: s enario (iv).
Next we measured t e per orman e or a lter on t e o e t omponent o atriple. T e extended Pig s ript is similar to t e one a ove despite t e lter ontains only one triple pattern:
95 raw =RDFLoad(’hdfs:///eventful.nt’); res =FILTER raw BY { ?s ?p ’Metallica’. }; Similar to t e sel oin s ript a ove weevaluated t ree rewriting s enarios. Fors enario (i) t e load operation is also rewrittenusing rule (L ) and t e ler using rule (F2). In s enario (ii) we applied t e rules (L ) (T ) and (F5). And in s enario (iv) t e rules (L2) and (F5) were used. As an example we s owt e rewriting result or s enario (ii): raw =RDFFileLoad(’hdfs:///eventful.nt’); out =TUPLIFY(raw); tmp =FOREACH out { t=FILTER stmts BY (object == ’Metallica’); GENERATE *,COUNT(t) as cnt; }; res =FILTER tmp BY cnt >0; T e exe ution times or t e t ree input s enarios are s own in Fig. . Here t e di eren es etween t e s enarios are even greater.Sin e ltering is not as ex- pensive as a oin operation t e over ead o reating t e triple groups on-t e- y auses agreater gapin omparison to t e ot er twos enarios. However we an learly see t at t e triple groups (w en loaded dire tly rom le) are still aster t an ltering plain triples. Sin e t e lter wasont e o e t t e lter operation ad to pro ess ea tuple in t e ag or ea su e t w i leads to inspe ting ust as manytriples as w en evaluation plain triples. In t is ase t e advantage omes rom t e ewer data t at as to e read rom disk sin e t e su e t is stored only on e. Hen e w en t e dataset e omes larger t e di eren es will in rease to t e advantage o t e triple groups. Also i t e lter as to e evaluated on t e omponent on w i t e triple groups are grouped t e di eren e etween ltering triple groups and plain triples e omes even greater e ause t e lter predi ate as to e evaluated only on e per grouped entity (e.g. su e t) see Fig. . In ontrast or plain triples t e lter is evaluated or ea statement t at elongs to an entity leading to signi antly more lter operations.
450 on-the-fly 400 plain triple groups 350
300
250 econds]
[s 200 me
ti 150
100
50
0 1 2 3 4 5 6 7 8 partitions
Figure : Exe utiontimes or aBGP lter on agrouping omponent (su e t) wit di erent num ers o partitions. Le t: s enario (ii) middle: s enario (i) and rig t: s enario (iv).
One an see t at t e num er o mappers also as an impa t on t e exe ution time. In our small setup t ese di eren es do not seem to e ig enoug to e signi ant. However
96 i t ere is adi eren e in su asmall setup t e di eren e will e even greater w en t e num er o nodes in t e luster t at an parti ipate in t e omputation or t e size o t e dataset to pro ess in reases. In t is evaluation we orgo experiments wit apat oin e ause our rule set trans orms triple groups to plain triples and t en relies on Pig oin. Hen e an evaluation o t is oper- ation will not reveal newinsig ts.
7Conclusion
In t is paper weextended t e Pig language wit support o SPARQL-like eatures su as ltering and oins on BGPs w i are parti ularly use ul to per orm analyti al tasks on linked datasets. T e extensions were introdu ed at t ree levels o implementation: as strategies or query planning and data a ess as rewriting rules to trans orm t e Pig ex- tensions to plain Pig and as UDFs t at implement new un tionality.Indoing so we are a le to use t e Pig ompiler to ompile and optimize t e s ripts or exe ution. T e ur- rent implementation o our system ontains t e UDFs and ma ros to load RDF data eit er rom HDFS or rom remote sour es via SPARQL endpoints. T e implementation is also apa le o generating loading pro essing and storing data in t e triple group ormat. T e results o our experiments s owt at per orman e depends on w i rules are used or in t e rewriting step. To s owt is e e t t e s ripts were generated manually using aset o rewriting rules. To support ar itrary queries we plan to implement arewriter in our uture work t at om ines t e planning and rewriting steps into one optimization step. T e optimizer will use euristi s to automati ally de ide w i rules to use or rewriting extended Pig and to de ide w et er intermediate results s ould e materialized. To a il- itate t ese de isions statisti s and metadata a out t e datasets will e o tained rom t e LODHu plat orm w i provides t e ontext or our work.
Acknowledgements
T is work waspartially unded y t e German Resear Foundation (DFG) under grant no. SA782/22
References [ABK+07] S. Auer C.Bizer G.Ko ilarov J. Le mann R. Cyganiak and . G. Ives. DBpedia: ANu leus or aWe o Open Data. In ISWC 2007. [ADE+ ] A. A ello ´ J. Darmont L. Et everry M.Gol arelli J. Mazon ´ F. Naumann T. B. Pedersen S. Rizzi J. Tru illo P. Vassiliadis and G. Vossen. Fusion Cu es: Towards Sel -Servi e Business Intelligen e. IJDWM 9(2):66±88 20 . [BEG+ ] K. S. Beyer V.Er egova R. Gemulla A. Balmin M. Elta ak C.-C. Kanne F. Oz- an and E. JS ekita. Jaql: As ripting language or large s ale semistru tured data analysis. In PVLDB’11 20 . [BL06] T. Berners-Lee. Linked Data. W C Design Issues. http://www.w3.org/ DesignIssues/LinkedData.html 2006.
97 [CGMR ] D. Colazzo F. Goasdoue ´ I. Manoles u and A. Roatis. RDF analyti s: lenses over semanti grap s. In WWW’14 pages 67± 78 20 . [DG08] J. Dean and S. G emawat. MapRedu e: simpli ed data pro essing on large lusters. Communications of the ACM 5 ( ): 07± 2008. [EV 2] L. Et everry and A. A. Vaisman. QB OLAP: AVo a ulary or OLAP Cu es on t e Semanti We . In COLD’12 20 2. [Fou09] T e Apa e So tware Foundation. Hadoop. http://hadoop.apache.org/ core/ 2009. [GHS ] L. Galarraga ´ K. Hose and R. S enkel. Partout: ADistri uted Engine or E ient RDF Pro essing. In WWW’14 pages 267±268 20 . [HMM+ ] M. Husain J. M Glot lin M. MMasud L. K an and B. T uraising am. Heuristi s- ased query pro essing or large rd grap s using loud omputing. IEEE Transactions on Knowledgeand Data Engineering 2 (9): 2± 27 20 . [HS ] S. Hagedorn and K.-U. Sattler.LODHu -APlat orm or S aring and Analyzing large-s ale Linked Open Data. In Proc. of ISWC 2014 demo track volume 272 pages 8 ± 8 O to er 20 . [KM ] . Kaoudi and I. Manoles u. RDF in t e louds: asurvey. The VLDB Journal pages ±25 20 . [KRA ] H. Kim P. Ravindra and K. Anyanwu. From SPARQL to MapRedu e: T e Journey Using aNested TripleGroup Alge ra. PVLDB ( 2): 26± 29 20 . [KUBM 2] S. Kotoulas J. Ur ani P. Bon z and P. Mika. Ro ust Runtime Optimization and Skew-Resistant Exe ution o Analyti al SPARQL Queries on Pig. In ISWC’12 pages 2 7±262. 20 2. [NW08] T. Neumann and G. Weikum. RDF- X: aRISC-style engine or RDF. PVLDB ( ):6 7±659 2008. [ORS+08] C. Olston B. Reed U. Srivastava R.Kumar and A. Tomkins. Pig latin: anot-so- oreign language or data pro essing. In SIGMOD’08 pages 099± 0 2008. [PKT+ ] N. Papailiou I. Konstantinou D. Tsoumakos P. Karras and N. Koziris. H2RDF+: Hig -per orman e distri uted oins overlarge-s ale RDF grap s. In IEEE Interna- tional Conference on Big Data pages 255±26 20 . [RKA ] P. Ravindra H. Kim and K. Anyanwu. An Intermediate Alge ra or Optimizing RDF Grap Pattern Mat ing on MapRedu e. In ESWC’11 pages 6±6 20 . [SP L ] A. S atzle ¨ M. Przy a iel- a lo ki and G. Lausen. PigSPARQL: Mapping SPARQL to Pig Latin. In SWIM’11 pages : ± :8 20 . [W C0 ] W C. RDF Primer (W C Re ommendation 200 -02- 0). http://www.w3.org/ TR/rdf-primer/ 200 . [W C08] W C. SPARQL Query Language or RDF (W C Re ommendation 2008-0 - 5). http://www.w3.org/TR/rdf-sparql-query/ 2008. [W C 0] W C. Des ri ing Linked Datasets wit t e VoID Vo a ulary. http://www.w3. org/TR/void/ 20 0. [W C ] W C. T e RDF Data Cu e Vo a ulary. http://www.w3.org/TR/2013/ CR-vocab-data-cube-20130625/ 20 . [Wi ] Mar Wi k. GeoNames. http://www.geonames.org/. [ CTW ] X. ang L. C en . Tong and M. Wang. EAGRE: Towards s ala le I/O e ient SPARQL query evaluation on t e loud. In ICDE’13 pages 565±576 20 . [ W+ ] K. eng J. ang H. Wang B. S ao and . Wang. Adistri uted grap engine or we s ale RDF data. In PVLDB’13 pages 265±276 20 .
9