o i@sPddlmZ ddlZddlZddlZddlZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZddlmZddlmZmZmZmZmZmZddlmZmZddlmZdd l m!Z!m"Z"dd l#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,dddZ-dddZ.dddZ/dddZ0dddZ1dd"d#Z2 ddd&d'Z3dd(d)Z4dd+d,Z5dd0d1Z6dd4d5Z7dd8d9Z8ddd;d<Z9ddDdEZ:ddIdJZ;ddMd$ZeddYdWZ>dd\dWZ>dd_d`Z?ddcddZ@ddfdgZAddhdiZBddjdkZCddldmZDGdndodoeEZFdpdqdrdqfddwdxZGdydqfdd|d}ZHd~dqddqdfdddZIdddZJdddZKdddZLdddZMddddZNdddZOdddZPdddZQdddZRdddZSdddZdddZT  ddddZUdddZVdddZW  ddddZX  ddddZYGdddeEZZGdddZ[dddńZ\dddDŽZ]dS)) annotationsN)reduce) AnyCallable DefaultDictDictIterableListMappingOptionalSetTupleoverload) ParseResults)AlternativePathInvPathMulPath NegatedPathPath SequencePath) TrueFilterand_)simplify) CompValueExpr)PrologueQueryUpdate)BNode IdentifierLiteralURIRefVariableprexprList[CompValue]returncCtd||dS)NOrderByr#r$rr)r+X/var/www/edux/Edux_v2/venv/lib/python3.10/site-packages/rdflib/plugins/sparql/algebra.pyr(1r(2typing.Union[List[Dict[Variable, str]], CompValue]cC td|dS)N ToMultiSetr#r*r1r+r+r,r05 r0p1p2cCr')NUnionr3r4r*r6r+r+r,r59r-r5Optional[CompValue]cCr')NJoinr6r*r6r+r+r,r8=r-r8cCr')NMinusr6r*r6r+r+r,r9Ar-r9termrgraphcCr')NGraph)r:r#r*)r:r;r+r+r,r<Er-r<triples9Optional[List[Tuple[Identifier, Identifier, Identifier]]]cCstd|pgdS)NBGPr=r*r@r+r+r,r?Ir?cCtd|||dS)NLeftJoinr3r4r$r*rDr+r+r,rCOsrCrcCr')NFilterr$r#r*rFr+r+r,rESr-rEtyping.Union[Identifier, Expr]varr"cCrB)NExtendr#r$rHr*rJr+r+r,rIWrArIresList[Dict[Variable, str]]cCr/)NvaluesrKr*rNr+r+r,Values]r2rOPVList[Variable]cCr')NProjectr#rPr*rSr+r+r,rRar-rROptional[List[Variable]]cCr')NGroupr)r*r)r+r+r,rUer-rUtriple)Tuple[Identifier, Identifier, Identifier] varsknown"Set[typing.Union[BNode, Variable]] varscountDict[Identifier, int]Tuple[int, int, bool]cs<tfdd|Dtfdd|D t|dt fS)Ncs&g|]}|vrt|ttfr|qSr+) isinstancer"r.0x)rXr+r, ps z_knownTerms..c3s|] }|dVqdS)rN)getr^)rZr+r, vz_knownTerms..)lensumr]r )rVrXrZr+rZrXr, _knownTermsis ril_3Iterable[Tuple[Identifier, Identifier, Identifier]]/List[Tuple[Identifier, Identifier, Identifier]]csDddd}dd|D}ttt|D]}|d D]}t|ttfr-|d 7<qqd }|t|krtfd d ||d D||d <||d d }d }||t|kr|||d d |kr|||d D]}||qq|d 7}||t|kr|||d d |ksi|d 7}|t|ks7dd|DS)zZ Reorder triple patterns so that we execute the ones with most bindings first r:strrX"Set[typing.Union[Variable, BNode]]cSs t|ttfr||dSdSN)r]r"radd)r:rXr+r+r,_addvarszreorderTriples.._addvarcSsg|]}d|fqSror+r^r+r+r,raz"reorderTriples..rc3s(|]}t|d|dfVqdS)rsN)rir^rhr+r,rcs&z!reorderTriples..NcSsg|]}|dqS)rsr+r^r+r+r,rarr)r:rmrXrn) set collections defaultdictintr]r"rrfsorted)rjrqtcijr+rhr,reorderTriples{s.    (( ( r}lUtyping.Union[List[List[Identifier]], List[Tuple[Identifier, Identifier, Identifier]]]csHtddtddkrtdtfddtdtdDS)NcSs||Sror+)r`yr+r+r,sztriples..rzthese aint triplesc3s.|]}||d|dfVqdS)rsreNr+r^r~r+r,rcs,ztriples..)rrf Exceptionr}rangerr+rr,r=s"typing.Union[CompValue, str]prologuerOptional[Identifier]cCs^t|tr#|jdkr||S|jdkr!t|j|j||jdSdSt|tr-||SdS)z' Expand prefixed/relative URIs pnameliteral)langdatatypeN) r]rname absolutizer stringrrr!)r#rr+r+r,translatePNames      rr!NonecCdSror+r1r+r+r, translatePathr'Path'cCrror+r1r+r+r,rrtyping.Union[CompValue, URIRef]Optional['Path']cCs4t|tr|jdkrt|jdkr|jdSt|jS|jdkr1t|jdkr,|jdSt|jS|jdkr]|js<|jSt|jtrVt|jdkrMt dt |jd|jSt |j|jS|jdkrt|jtrzt|jdkrst dt |jdSt |jS|jdkrt|jtrt t|jSt |jSd Sd S) z, Translate PropertyPath expressions PathAlternativersr PathSequencePathEltz Denkfehler!PathEltOrInversePathNegatedPropertySetN) r]rrrfpartrrmodlistrrrrr1r+r+r,rs:               !e-typing.Union[Expr, Literal, Variable, URIRef]cCsdd}t||d}|S)z Translate the graph pattern used by EXISTS and NOT EXISTS http://www.w3.org/TR/sparql11-query/#sparqlCollectFilters cSsDt|tr|jdvrt|j|_|jjdkr d|j_dSdSdSdS)N)Builtin_EXISTSBuiltin_NOTEXISTSrET)r]rrtranslateGroupGraphPatternr;no_isolated_scopenr+r+r,_cs     ztranslateExists.._c visitPost)traverse)rrr+r+r,translateExistss rpartsOptional[Expr]cCsfg}d}|t|kr+||}|jdkr!|t|j||n|d7}|t|ks |r1t|SdS)z FILTER expressions apply to the whole group graph pattern in which they appear. http://www.w3.org/TR/sparql11-query/#sparqlCollectFilters rrErsN)rfrappendrr$popr)rfiltersr{r#r+r+r,collectAndRemoveFilterss     r graphPatterncCs0d}|jD]}t|}|s|}qt||}q|Sro)r;rr5)rAgr+r+r,!translateGroupOrUnionGraphPattern8s  rcCst|jt|jSro)r<r:rr;rr+r+r,translateGraphGraphPatternDsrcCs tt|Sro)r0translateValuesrr+r+r,translateInlineDataHr2rcCs|jdkr tt|dS|jsg|_t|j}g}|jD])}|jdkrA|r-|djdks3|t|ddt|j7<q||qt}|D]}|jdkrmt|j }|jdkrft ||j |j }qLt ||t }qL|jd kr|t|t|j d }qL|jd krt|t|d }qL|jd krt|t|d }qL|jd krt|t|d }qL|jdkrt||d }qL|jdvrt||d }qL|jdkrt|t|j |j}qLtdt||jf|rt||d}|S)zB http://www.w3.org/TR/sparql11-query/#convertGraphPattern SubSelectr TriplesBlockr?r=OptionalGraphPatternrEMinusGraphPatternr6GroupOrUnionGraphPatternGraphGraphPattern InlineDataServiceGraphPattern)r?rIBindz*Unknown part in GroupGraphPattern: %s - %srF)rr0 translaterrrr?r=rr;rCr#r$rr9r8rrrrIrrHrtyperE)rrrr#Grr+r+r,rLsN                 rc@seZdZdddZdS) StopTraversalrvboolcCs ||_dSro)r)selfrr+r+r,__init__s zStopTraversal.__init__N)rr)__name__ __module__ __qualname__rr+r+r+r,rsrcCrror+rr+r+r,rrcCrror+rr+r+r,rrrvisitPreCallable[[Any], Any]rcs|}|dur |S|durdSt|ttfr!fdd|DSt|tr2tfdd|DSt|trH|D] \}}t|||<q;|}|durR|S|S)m Traverse a parse-tree, visit each node if visit functions return a value, replace current node Ncg|]}t|qSr+ _traverser^rrr+r,raz_traverse..crr+rr^rr+r,rar)r]rrtupleritemsr)rrr_ekvalr+rr,rs    rcCrror+)rvr+r+r,rrvisitorCallable[[Any, Any], Any]csfg}t|tttfrfdd|D}nt|tr.|D]\}}|dur-|t|q||S)rcsg|]}t|qSr+) _traverseAggr^rr+r,raz _traverseAgg..N)r]rrrrrrr)rrrKrrr+rr,rs  rcCrror+rr+r+r,rrcCrror+rr+r+r,rrcompleteOptional[bool]c CsLzt|||}|dur|WS|WSty%}z |jWYd}~Sd}~ww)z Traverse tree, visit each node with visit function visit function may raise StopTraversal to stop traversal if complete!=None, it is returned on complete traversal, otherwise the transformed tree is returned N)rrr)treerrrrstr+r+r,rs rcCs&t|tr|jdrtddSdS)zL Traverse parse(sub)Tree return true if any aggregates are used Aggregate_TN)r]rr startswithr)r`r+r+r, _hasAggregates  rOptional[Variable]cCsDt|tr|jdr ||tdt|}||d<|SdSdS)zR Collect Aggregates in A replaces aggregates with variable references r __agg_%d__rKN)r]rrrrr"rf)rraggvarr+r+r,_aggss  r Set[Variable]cCsjt|tr ||t|tr1|jdkr||j|S|jdkr3|jr/|dd|jD|SdSdS)z& Find all variables in a tree rrcs|] }|jp |jVqdSrorHevarr_rr+r+r,rcrdz_findVars..N)r]r"rprrrH projectionupdate)r`rKr+r+r, _findVarss      rchildrenList[Set[Variable]]cCst|tr t|gSt|tra|jdkrt|d<|dS|jdkr8ttjddt||Dt|d<|dStttj|t|d<|jdkr]|j rXtdd|j D}|St}|S|dSttj|tS) zE find which variables may be bound by this part of the query RelationalExpression_varsrIcSsg|] \}}|dkr|qS)r$r+)r_childrr+r+r,rasz_addVars..rcsrrorrr+r+r,rc rdz_addVars..) r]r"rtrrroperatoror_zipr)r`rsr+r+r,_addVars s,       r>typing.Union[CompValue, List[Expr], Expr, List[str], Variable]rcCs@t|tr |jdr |St|tr||krtd|dSdSdS)zO For each unaggregated variable V in expr Replace V with Sample(V) rAggregate_SamplevarsN)r]rrrr")rrr+r+r,_sample,s  rcCst|tr t|SdSro)r]rsimplifyFilters)rr+r+r,_simplifyFilters7s rqM1Tuple[CompValue, List[Tuple[Variable, Variable]]]cCsg}g}|jr)|jD]}|jr(t|jtjt|jd|_t|jtjt|d|_q t|jt ddrCt|jt|_t|jtjt|dt|j t ddr]t|j t|_ t|j tjt|d|jr|jD]"}|j rt dt |d}|td|j |d |||j fqctd ||d |fS) N)r)rTrFrrsr)rrK AggregateJoin)rr#)rrrr$ functoolspartialrrhavingrorderbyrHr"rfrr)r r Errrr+r+r,translateAggregates<s,  rcCszg}|js|S|js |St|jdts(|jD] }||jd|iqt|S|jD] }|tt|j|q+t|S)Nr)rHvaluer]rrdictrrO)rrKrvalsr+r+r,r`s  r*Tuple[Optional[CompValue], List[Variable]]cCst|tt|jtd|_t}|jdkr)t|j}|jdur%dt|fSd|_ n t|jt j t |dt |j}d}|jrjg}|jjD]}t|tr[|jdkr[t||j|j}|j}||qDt||d}d }n#t|jtdd st|jtdd std d |jpgDrt|d }d }|rt||\}}ng}|D] \}}t|||}q|jrtt|jj|d}|jrt|t t!|jd}|jst"|D] } |t| j#O}qt|} nCt} t} |jD]+} | jr| | vr| | jq| j$r| | vr| | j$| | j| j$fqt%d| D] \} } t|| | }q|jr*t&|dd|jjD}t'|| }|j rL|j dkr@td|d }n |j dkrLtd|d }|j(r}d}|j(j)dur_|j(j)*}|j(j+durvtd|||j(j+*d}|| fStd||d}|| fS)z= http://www.w3.org/TR/sparql11-query/#convertSolMod r DescribeQueryNDISTINCTrNFGroupAsr)Tr css&|]}|jrt|jtddVqdS)Fr N)rrr$rr^r+r+r,rcs ztranslate..r1rFr6zI expected a var or evar here!cSsg|] }td|j|jdqS)OrderCondition)r$order)rr$r)r_rzr+r+r,rasztranslate..DistinctREDUCEDReducedrSlice)r#startlength)r#r!),rrrwhererrtrrHrmodifierrrrrgroupby conditionr]rrIr$rrUrrranyrrrEr valuesClauser8r0r_find_first_child_projectionsrPrrr(rR limitoffsetoffsettoPythonlimit)r VSr  aggregate conditionsrzaggregateAliasesaliasrHchild_projectionrPrrrr+r+r+r,rus                      rIterable[CompValue]ccsD|D]}t|tr|jdkr|Vqt|D]}|VqqdS)z Recursively find the first child instance of a Projection operation in each of the branches of the query execution plan/tree. rRN)rMr]rrr))r child_opr3r+r+r,r)s    r)rcCst|tr>|jdkr0|jjdkrt|jjdkr|jS|jjdkr,t|jjdkr.|jSdSdS|jdkr@t|j|d<|SdSdS)zRemove joins to empty BGPsr8r?rr=N)r]rrr3rfr=r4r}rr+r+r,rs   rrcCs>t|tr|jdkrt||d<dS|jdvrdSt|SdS)z Some things can be lazily joined. This propegates whether they can up the tree and sets lazy flags for all joins r8lazyF)r rT)r]rrall)rrr+r+r,analyses    r8rbase Optional[str]initNsOptional[Mapping[str, Any]]Optional[Prologue]cCs|dur t}d|_|r||_|r |D] \}}|||q|D]}|jdkr.|j|_q"|jdkr>||j||jq"|S)NBase PrefixDecl)rr9rbindririprefixr)r#r9r;rrrr`r+r+r,translatePrologue1s   rDquadsyTuple[List[Tuple[Identifier, Identifier, Identifier]], DefaultDict[str, List[Tuple[Identifier, Identifier, Identifier]]]]cCsX|jr t|j}ng}tt}|jr(|jD]}|jr'||jt|j7<q||fSro)r=rurvrquadsNotTriplesr:)rE alltriplesallquadsr r+r+r,translateQuadsJs  rJucCs|jdvrnV|jdvr nP|jdvr't|j\}}||d<||d<|jdvr& n5|jdkrV|jr=t|jj\|jd<|jd<|jrNt|jj\|jd<|jd<t|j|d<ntd |||_|S) N)LoadClearDropCreate)AddMoveCopy) InsertData DeleteData DeleteWhererEr=)rUrTModifyr#z$Unknown type of update operation: %s) rrJrEdeleteinsertrr#rr)rKrryr r+r+r,translateUpdate1as(      rYrcCs~g}d}|js |St|j|jD])\}}t||||}t|tjt|dd}t|t }t|t d}| t ||qt ||S)z= Returns a list of SPARQL Update Algebra expressions Nrr)requestrrrDrrrrrrrrrYr)r r9r;rKrr#rKr+r+r,translateUpdateys    r\rc Cst|d||}t|dtjt|dd|d<t|d\}}|dj}|djdkrE|djr7t |djnd}t |dj|||d}n t |dj|||d}t|t d}t |t d t |tt||S) z| Translate a query-parsetree to a SPARQL Algebra Expression Return a rdflib.plugins.sparql.sparql.Query object rrsrZrConstructQueryN)r#template datasetClause)r#r_rPr)rDrrrrrr_rr^r=rrrr8rr) r r9r;rPrPr_r^rKr+r+r,translateQuerys       rac@s eZdZdS)ExpressionNotCoveredExceptionN)rrrr+r+r+r,rbsrbc@sHeZdZdZdddZ   ddddZdddZddZdddZdS)_AlgebraTranslatora Translator of a Query's algebra to its equivalent SPARQL (string). Coded as a class to support storage of state during the translation process, without use of a file. Anticipated Usage: .. code-block:: python translated_query = _AlgebraTranslator(query).translateAlgebra() An external convenience function which wraps the above call, `translateAlgebra`, is supplied, so this class does not need to be referenced by client code at all in normal use. query_algebrarcCs||_tt|_d|_dS)Nr>)rdrurvr aggr_vars_alg_translation)rrdr+r+r,rs z_AlgebraTranslator.__init__Nrsoldrmnewsearch_from_matchsearch_from_match_occurrencerwcountc Cshdd}|r)|r)||j||}|jd|}|j|d|||} || |_dS|j||||_dS)NcSsR||}|dkr'|dkr'|||t|}|d8}|dkr'|dks|S)Nrrs)lowerfindrf)haystackneedlerr!r+r+r,find_nths z-_AlgebraTranslator._replace..find_nth)rfreplace) rrgrhrirjrkrpposition filedata_pre filedata_postr+r+r,_replacesz_AlgebraTranslator._replacenode_arg.typing.Union[Identifier, CompValue, Expr, str]r&cCst|tr||jvr|j|d}|S|St|tr(d|jdSt|tr4d|jdSt|t r;|St d |)Nr{},The expression {0} might not be covered yet.) r]rrekeysrn3rrrrmrbformat)rrvgrp_varr+r+r,convert_node_args    z#_AlgebraTranslator.convert_node_argc' st|t rY|jdkrd|jjd_dES|jdkrFddd|jD}d|jd d d d jd dd d jddd d dES|jdkr_dd|jjd|j jddES|jdkrxdd|jjd|j jddES|jdkrt|j tr|j j}nt d|jr|jjdkrdd|jjddd|ddESdd|d|jjddESdd|ddES|jdkrd d!|jjd"|j jddES|jd#krd$|j d%|jjd}d&|dES|jd'kr:j}|d(}j|j d)|j d*|j d+d(|d,d-d|jjddES|jd.krVd|jjd/|j jd}d0|dES|jd1krg}|j r|j D]}t|trv|| qet dd2d|jjdd d3d4|d4dESd2d|jjddES|jdkr-d5d|jjd|jD]r}t|jtr|j } nt dj|j|j|jd6d7} d} |jr|jd4} | d8kr| d9| |j d:|j d+n| | d)| |jd+d;|j|jqdES|jd|jDdES|jd?kratd@dAddBd|jDdES|jdCkrkt d|jdDkrg} |j D]*} t| j tr| j }| jdEur| jd)|d+}n|}| |qvt ddFd|jjddGd4| d4dES|jdHkrg}|j D]}t|tr|| qt dd}|jjdDkrdI}dJd4|d!|jjdd |ddES|jdKkrdLdM|jjddES|jdNkr&dOdP|jjddES|jdQkrJdRt!|j"dSt!|j#}dTd|jjd|dES|jdUkru|jjdVkredWd!|jjddESdWdX|jjdddES|jdYkr|j }|j$}tt%t&|j'rd)dZfd[d|j'Dd+}n|j'}d\j|||d]}d^|dES|jd_krd`fdad>|j'D}db|j d`|dES|jdckrddfded>|j'D}dfd)|j dd|d+dES|jdgkr0|j }|}t(|j$D]\}}||d4|j'|d47}qdh|dES|jdikra|j }|}t(|j$D]\}}||d4|j'|d47}qCdj|dES|jdkkrudldm|j dES|j)dnr|j*}dodp|d+dES|j)dqr|j+}|j,}dr|j-jds|dZ|d+}dt|dES|j)dur׈dvdwdZfdxd|j*Dd+dES|j)dyrdzd{|j.jdt/|j.j0d||j.S|j)d}rt|j.jd~d|j.jdt/|j.j0d||j.S|j)dr8dd|j-dZ|j+d+dES|j)drOdd|j*d+dES|j)drfdd|j*d+dES|j)dr}dd|j*d+dES|j)drdd|j*d+dES|j)drdd|j*d+dES|j)drˆdd|j*d+dES|j)drوdd|j*d+dES|j)drdd|j*d+dES|j)drdd|j*d+dES|j)dr&dd|j-dZ|j+d+dES|j)drEdd|j-dZ|j+d+dES|j)drTdddES|j)drcdddES|j)drzdd|j*d+dES|j)dr|j*|j"g}|j#r||j#ddZ|d+}d|dES|j)drdd|j*d+dES|j)drӈdd|j*d+dES|j)drdd|j-dZ|j+d+dES|j)drdd|j-dZ|j+d+dES|j)dr0dd|j-dZ|j+d+dES|j)drOdd|j-dZ|j+d+dES|j)d¡rnddĈ|j-dZ|j+d+dES|j)dšrddLj|j*d+dES|j)dȡrdjdZfdd|j*Ddˍ}d|dES|j)d͡rĈddψ|j-dZ|j+d+dES|j)dСr|j1|j2g}ddZ|d+}d|dES|j)dӡrddՈ|j*dZ|j2dZ|j3d+dES|jdkr%dd؈|j*d+dES|jdkr;ddۈ|j*d+dES|jdkrQddވ|j*d+dES|jdkrgdd|j*d+dES|jdkrudddES|jdkrdddES|jdkrdd|j*d+dES|jdkrdd|j*d+dES|jdkrňdd|j*d+dES|jdkrۈdd|j*d+dES|jdkrdd|j*d+dES|jdk rdd|j*d+dES|jdk rdd|j*d+dES|jdk r3dd|j*d+dES|jdk rLdd|j*d+dES|jdk redd|j*d+dES|jdk r~dd|j*d+dES|jd k rd d |j*d+dES|jd k rd d|j*d+dES|jdVk r1g} |jd4D]}!t|!t r| |!  qt d|!dd4| d+}"d}#|jD]:}$g}%|$5D]%}&t|&t r|%|&  qt|&t! r|%|& qt d|&|#d)d4|%d+7}# qdV|"d|#ddES|jdk r[dd|j d|j.jdt/|j.j0d||j.SdESdES(zl https://www.w3.org/TR/sparql11-query/#sparqlSyntax :param node: :return: SelectQueryz-*-SELECT-*- {ryr?r>cs@|]}|dd|dd|ddVqdSr rsre.Nr|r_rVr+r+r,rcs . z7_AlgebraTranslator.sparql_query_text..z{BGP}z -*-SELECT-*-SELECTr)rkz {GroupBy}z{Having}r8z{Join}rxz}{rCz {LeftJoin}z }OPTIONAL{{z}}rEz)This expression might not be covered yet.r z{Filter}zHAVING({z})zFILTER({z}) {r5z{Union}z{{z }}UNION{{r<zGRAPH z {{z{Graph}rIz -*-select-*-(z as ))rirjz{Extend}r9z}MINUS{{z{Minus}rUz{Group}z GROUP BY rz{AggregateJoin}_rs GroupConcatz GROUP_CONCAT(z ;SEPARATOR=z(SAMPLE({0}) as {0})GroupGraphPatternSubcg|]}|qSr+r)r_patternrr+r,rarz8_AlgebraTranslator.sparql_query_text..r triplesblockz{TriplesBlock}csrrrrr+r+r,rcs    ToListr(Nz {OrderBy}z{OrderConditions}rRzORDER BY {OrderConditions}z {Project}rz {Distinct}z DISTINCT {rz {Reduced}z REDUCED {r zOFFSET z LIMIT z{Slice}r0rMz {ToMultiSet}z{-*-SELECT-*- {rz, c3|]}|VqdSrorr_r$rr+r,rcz{left} {operator} {right})leftrrightz{RelationalExpression}ConditionalAndExpressionz && crr+rrrr+r,rarz{ConditionalAndExpression}ConditionalOrExpressionz || crr+rrrr+r,rarz{ConditionalOrExpression}MultiplicativeExpressionz{MultiplicativeExpression}AdditiveExpressionz{AdditiveExpression}UnaryNotz {UnaryNot}!BOUNDz{Builtin_BOUND}zbound(IFzIF({z}, z {Builtin_IF}COALESCEz{Builtin_COALESCE}z COALESCE(c3rror)r_argrr+r,rc)rrz{Builtin_EXISTS}z EXISTS {{rrz{Builtin_NOTEXISTS}z NOT EXISTS {{sameTermz{Builtin_sameTerm}z SAMETERM( Builtin_isIRIz{Builtin_isIRI}zisIRI(Builtin_isBLANKz{Builtin_isBLANK}zisBLANK(Builtin_isLITERALz{Builtin_isLITERAL}z isLITERAL(Builtin_isNUMERICz{Builtin_isNUMERIC}z isNUMERIC( Builtin_STRz {Builtin_STR}zSTR( Builtin_LANGz{Builtin_LANG}zLANG(Builtin_DATATYPEz{Builtin_DATATYPE}z DATATYPE( Builtin_IRIz {Builtin_IRI}zIRI( Builtin_BNODEz{Builtin_BNODE}zBNODE(STRDTz{Builtin_STRDT}zSTRDT(Builtin_STRLANGz{Builtin_STRLANG}zSTRLANG( Builtin_UUIDz{Builtin_UUID}zUUID()Builtin_STRUUIDz{Builtin_STRUUID}z STRUUID()Builtin_STRLENz{Builtin_STRLEN}zSTRLEN(Builtin_SUBSTRzSUBSTR(z{Builtin_SUBSTR} Builtin_UCASEz{Builtin_UCASE}zUCASE( Builtin_LCASEz{Builtin_LCASE}zLCASE(Builtin_STRSTARTSz{Builtin_STRSTARTS}z STRSTARTS(Builtin_STRENDSz{Builtin_STRENDS}zSTRENDS(Builtin_CONTAINSz{Builtin_CONTAINS}z CONTAINS(Builtin_STRBEFOREz{Builtin_STRBEFORE}z STRBEFORE(Builtin_STRAFTERz{Builtin_STRAFTER}z STRAFTER(Builtin_ENCODE_FOR_URIz{Builtin_ENCODE_FOR_URI}zENCODE_FOR_URI(Builtin_CONCATzCONCAT({vars})c3rror)r_elemrr+r,rcrrz{Builtin_CONCAT}Builtin_LANGMATCHESz{Builtin_LANGMATCHES}z LANGMATCHES(REGEXzREGEX(z{Builtin_REGEX}REPLACEz{Builtin_REPLACE}zREPLACE( Builtin_ABSz {Builtin_ABS}zABS( Builtin_ROUNDz{Builtin_ROUND}zROUND( Builtin_CEILz{Builtin_CEIL}zCEIL( Builtin_FLOORz{Builtin_FLOOR}zFLOOR( Builtin_RANDz{Builtin_RAND}zRAND() Builtin_NOWz {Builtin_NOW}zNOW() Builtin_YEARz{Builtin_YEAR}zYEAR( Builtin_MONTHz{Builtin_MONTH}zMONTH( Builtin_DAYz {Builtin_DAY}zDAY( Builtin_HOURSz{Builtin_HOURS}zHOURS(Builtin_MINUTESz{Builtin_MINUTES}zMINUTES(Builtin_SECONDSz{Builtin_SECONDS}zSECONDS(Builtin_TIMEZONEz{Builtin_TIMEZONE}z TIMEZONE( Builtin_TZz {Builtin_TZ}zTZ( Builtin_MD5z {Builtin_MD5}zMD5( Builtin_SHA1z{Builtin_SHA1}zSHA1(Builtin_SHA256z{Builtin_SHA256}zSHA256(Builtin_SHA384z{Builtin_SHA384}zSHA384(Builtin_SHA512z{Builtin_SHA512}zSHA512(rrzzVALUES (rz{ServiceGraphPattern}zSERVICE )6r]rrr#rfjoinr=rur3r4r$rbr:r|rlrkrHrrrrrKrersplitdistinct separatorupperr}rprintrrPrmr!r"oprrother enumerateendswithrarg2arg3arg1r;rsparql_query_texttextr replacementr{rM)'rnoder=r$ query_stringselect_occurrences group_by_varsrHagg_func identifier agg_func_namerorder_conditionsrzcondproject_variablesorder_by_patternslicerrr& inner_nodes left_sidemultiplicationr{raddition bound_varrr if_expressionargscolumnskeyrMrowsrrowr:r+rr,rs                                +                                                                            `z$_AlgebraTranslator.sparql_query_textcCst|jj|jd|jS)Nr)rrdalgebrarrfrr+r+r,translateAlgebraxsz#_AlgebraTranslator.translateAlgebra)rdr)NNrs) rgrmrhrmrirmrjrwrkrw)rvrwr&rm)r&rm) rrr__doc__rrurrrr+r+r+r,rcs   vrcrdrmcCst|d}|S)z Translates a SPARQL 1.1 algebra tree into the corresponding query string. :param query_algebra: An algebra returned by `translateQuery`. :return: The query form generated from the SPARQL 1.1 algebra tree for SELECT queries. )rd)rcr)rdquery_from_algebrar+r+r,r}s rcsFdfdd z|jWdSty"|D]}|qYdSw)N csft|ts t|dStd|jf|D]}td||fdd|||dqtd|dS)Nz%s(z%s%s =r)endrz%s))r]rrr)r#indrppr+r,rs zpprintAlgebra..pp)r)rAttributeError)r r`r+rr, pprintAlgebras  r)r#rr$r%r&r)r#r.r&r)r3rr4rr&r)r3rr4r7r&r)r:rr;rr&rro)r=r>r&r)r$rr#rr&r)r#rr$rGrHr"r&r)rKrLr&r)r#rrPrQr&r)r#rr$rTr&r)rVrWrXrYrZr[r&r\)rjrkr&rl)r~rr&rl)r#rrrr&r)r#r!r&r)r#rr&r)r#rr&r)rrr&r)rr%r&r)rrr&r7)rrr&r)rrrrrr)rr)rrrrrrr&r)r&r)r&r)rKrr&r7)rrr&r)rrrrr&r7)rrr&r)r rr rr&r )rrr&r.)r rr&r)r rr&r4)rrr&r7)rrrrr&r)NN) r#rr9r:r;r<rr=r&r)rErr&rF)rKrrrr&r)r rr9r:r;r<r&r)r rr9r:r;r<r&r)rdrr&rm)^ __future__rrurrtypingrrrrrrr r r r r r pyparsingr rdflib.pathsrrrrrrrdflib.plugins.sparql.operatorsrrrr!rdflib.plugins.sparql.parserutilsrrrdflib.plugins.sparql.sparqlrrr rdflib.termrrr r!r"r(r0r5r8r9r<r?rCrErIrOrRrUrir}r=rrrrrrrrrrrrrrrrrrrrrrr)r8rDrJrYr\rarbrcrrr+r+r+r,s  4                  1     -    @ #    "  $       $ D