Attean-0.033/ 000755 000765 000024 00000000000 14316377026 013033 5 ustar 00greg staff 000000 000000 Attean-0.033/inc/ 000755 000765 000024 00000000000 14316377024 013602 5 ustar 00greg staff 000000 000000 Attean-0.033/SIGNATURE 000644 000765 000024 00000046770 14316377026 014335 0 ustar 00greg staff 000000 000000 This file contains message digests of all files listed in MANIFEST,
signed via the Module::Signature module, version 0.87.
To verify the content in this distribution, first make sure you have
Module::Signature installed, then type:
% cpansign -v
It will check each file's integrity, as well as the signature's
validity. If "==> Signature verified OK! <==" is not displayed,
the distribution may already have been compromised, and you should
not run its Makefile.PL or Build.PL.
-----BEGIN PGP SIGNED MESSAGE-----
Hash: RIPEMD160
SHA256 487035f339ab736e78a76a560f4e8ad820c24bd025feeab9c494d2bd6d9445b1 CONTRIBUTING
SHA256 a1b975087da0e71ea4283ae9826ce0739b0b280e262b22f68cef00fe2c0fe119 Changes
SHA256 5b319ca2e9563c27fe433e1e88f9931f911d1c489551fce1fd3658d51177a6b2 MANIFEST
SHA256 c32c8326c9b6890cdccd256c1a20ecbea0fa0a8c557155d2506c889b039a2e27 META.yml
SHA256 055657ffee02c13b2f3c179fdd3d150a1f5fe54c18c50647c7ff4ed6760b6bfa Makefile.PL
SHA256 949d49d547f195f95b54383c8f2baff39fe4e035c3a1847416f3351f34d52de6 README.md
SHA256 0989c0007d1742b3c91f59ff267f7a8ec62543c2dba09bf447f7d44fc316a3c4 bin/attean_parse
SHA256 a44838c88265d2a3e01c11ea8eaa7ae3cf6b090aea78167b1c04a9a93e777642 bin/attean_query
SHA256 7a079f36ccbe5ca289fa7591875ff392fc35e4cb946b773d98c4efad7eba17c4 bin/canonicalize_bgp.pl
SHA256 67d139199c03b8bf8447a5a62f0d0b6dc1bd5bf6dbe04de6d21998c577823ed6 inc/Module/Install.pm
SHA256 1b5430a46a35142ef8914d8c745196fca825defc9dfa7e389299bf294613825e inc/Module/Install/AuthorTests.pm
SHA256 6ebcc53a161dd5dc0aae69e4704575f2b00181901d768a82e26722a309cfdbe4 inc/Module/Install/Base.pm
SHA256 d3f8c839d03fd21c197d05362dbb277cd7cadb15da6390d124b61e851f15146e inc/Module/Install/Can.pm
SHA256 668306ae2fad17b3049f885251b8679497c4eb8d5c4b0d13f5c95bda331d1f00 inc/Module/Install/DOAPChangeSets.pm
SHA256 e9e72e18921c10c87bc4ea4c20af83e52015b9f5775d00ac64073042403717ca inc/Module/Install/Fetch.pm
SHA256 a7a681bf2c9eee58a372cb642ffe42b0301d1200432ba8de9f7791cd1ecc9827 inc/Module/Install/Makefile.pm
SHA256 aa887fa65a5eb6bbd1805706ce298b3f3cd55b353ecfd37aa7d35ae419331a49 inc/Module/Install/Metadata.pm
SHA256 751bc4e2f98074c05c9e23d484f2406cef042099664b6c87a73d6530bbeda427 inc/Module/Install/Scripts.pm
SHA256 26b166ff62aacdb55317d1659f160aa4935097eea9810ea980e6d747206b5dc0 inc/Module/Install/Win32.pm
SHA256 5f73a6851a91ea44e65b924f918743ad6e860620ad7a38a39d0295e0c5652a9f inc/Module/Install/WriteAll.pm
SHA256 798c1cadba78b43bf856597faf35e3ec729a93e42c9562d7aed8da91a2cf714b lib/Attean.pm
SHA256 dff2a1b2013f4cd655616ef19f02adab52bcccfc5f493e9a7cc2bf797a4a622f lib/Attean/API.pm
SHA256 97476b09b00c8373ac55c6873531597b185f8b9074446e0bcfc56e050c32bf36 lib/Attean/API/AbbreviatingParser.pod
SHA256 bd26be64597b9d2401dca964c53863f14654696dcd32df7f528817d984e26512 lib/Attean/API/AbbreviatingSerializer.pod
SHA256 aa800b0089eea79e6a6a5b618756655b214ee00022db07fce31f5d4eb19e3652 lib/Attean/API/AggregateExpression.pod
SHA256 01f349c8d3dcf4697053784db754c7b9371e3db94bd7bcd15b9398451d387fa7 lib/Attean/API/AppendableSerializer.pod
SHA256 211c9588bcf3fbc7815e58e6446f69090a4b2730145db90e774e58022f81b051 lib/Attean/API/AtOnceParser.pod
SHA256 306e7597c83b4ae7bec34a4893fe80bfddfef39080fcf0be9fa355ab23685a3e lib/Attean/API/Binding.pm
SHA256 843e418421990e502be25c1b6603d7daea4d0f4bd1c861d44e458d656e8ef28c lib/Attean/API/Blank.pod
SHA256 6bd4654c592b319c85e0b15ae450d26435beec3cde29b1f7e8412e60ff30e016 lib/Attean/API/BlankOrIRI.pod
SHA256 13a22a37ac87d7387656fb9359266a2a75dfedf46124bfe88998929ee653ade2 lib/Attean/API/BulkUpdatableModel.pod
SHA256 88b4c72cf11e106fb966dfd6537361aa9183161f5e5f01804723bfe2df76498b lib/Attean/API/Expression.pm
SHA256 821d99067b7baf7096fd0effcda287c75aac08633c6a763001b52d7172adb862 lib/Attean/API/IRI.pod
SHA256 89755d25717fb3ca42ad7cab59bd93d78993d29b76a0c8825ca926ab3195516a lib/Attean/API/Iterator.pm
SHA256 81f3105fdaf1aba2a9077a5cf41cc77c95b9ba17c69c4b61bee2ff8d40ca41d5 lib/Attean/API/Literal.pod
SHA256 0dd1b0c43879995fd1d7b66960d5ed08479c83cd6c4bb6dcdeb293fd164e019e lib/Attean/API/MixedStatementParser.pod
SHA256 39c004e8e75661bc0dc33675d9f578e3f6f86ffbba2164f9c439fa2adbeb8948 lib/Attean/API/MixedStatementSerializer.pod
SHA256 a828d2424e4fb27d4966b82417503e1b1390ce7eeb60522c454c161980124fbc lib/Attean/API/Model.pm
SHA256 72d2c34e0bdd408f1224adefd0074d74775067788d7c2ecc35e2ef8550788128 lib/Attean/API/MutableModel.pod
SHA256 f06cca407cf6db572226080f1a96cf926a57a0b2942856bdf7d465248ab5e9de lib/Attean/API/MutableTripleStore.pod
SHA256 721208ff69834edfc196b674a287d96a65c3cfd2b7e39ee20d9385057ee3c868 lib/Attean/API/Parser.pm
SHA256 ad0f4a7392fd31c4eac4db11074f988890a557204a906722ea19837a213697da lib/Attean/API/Plan.pm
SHA256 2c2915edc77ba09bce2e69742d37822a2ef26866284b18b53ec917ee66845051 lib/Attean/API/PullParser.pod
SHA256 7e7289d030d509ef48c723fe8d6e43e47a1612f45ed9b3958b2a5d2e7bedb5ab lib/Attean/API/PushParser.pod
SHA256 86654fb544509f1af8e24bbc52656ad5d3436d260d9e212b3f0bb58e74c8a2b0 lib/Attean/API/Quad.pod
SHA256 eb903b43941ca2dceabeda03fdef5f4cdd2e996f542d3dfdaf419a304717474f lib/Attean/API/QuadParser.pod
SHA256 439c927fc5792ad3999f6f3e538e35b4e95564e0262eba6e4c3d3a40ea784046 lib/Attean/API/QuadPattern.pod
SHA256 06e707c341921e63744958227762ef3cdd46694a15a4f619182e0a0ffb400556 lib/Attean/API/QuadSerializer.pod
SHA256 2bcba79c6050e831c2f25c51f40b42298fbb8eedf2e6f282c591e5d1d7befc32 lib/Attean/API/Query.pm
SHA256 47e9dcf851f8a621a580a7023e8909bc4a5332280788be6bfbf3dfd248e71ab9 lib/Attean/API/QueryPlanner.pm
SHA256 7ee15856ad338db4b3ea68983a707ecb2d488e0561ce9a0dba6fb1a8c6f40d94 lib/Attean/API/RepeatableIterator.pod
SHA256 13713721879dadd0dd74db800a8a4f1408fcee50835c986e04af3e7509274847 lib/Attean/API/Result.pod
SHA256 75ff680436d8e12a710ef2e97e4090817b47d293e69ffb369ada289aa79286db lib/Attean/API/ResultParser.pod
SHA256 15deeece8b08961cad86c71eba538cae3a39d7e250733e28f04facb9c8c5959f lib/Attean/API/ResultSerializer.pod
SHA256 093bf3f37cfa868f008488e32e6e7b49a7694e9635c9c4f22f080f4eb51f7c77 lib/Attean/API/Serializer.pm
SHA256 8a1b72cc9840e771771bd5a3393dd15c18f5a36522d9368d73f9ff80c3805329 lib/Attean/API/Store.pm
SHA256 70c8b2c74111f3eb6fe5072862b6b40a50acd155c69df6172ade41419dfccfbf lib/Attean/API/Term.pm
SHA256 7c41f6e8f0bc8f29e095e169e72629968772b9ab742cb2d7ef2f488cda2bec9c lib/Attean/API/TermOrVariable.pod
SHA256 92c8067ed2755713fc13516854d0dd437f2537094f8813980d019404d2c5d8f9 lib/Attean/API/TermParser.pod
SHA256 f7482c8863726f3d2d68b946eb5cbd32f32b6da1ec83474971f4244e4c1db954 lib/Attean/API/TermSerializer.pod
SHA256 754d4e372a9c758480f670bce708c0eb94aa553eef6319f128707d7aeb34decb lib/Attean/API/Triple.pod
SHA256 040e1a80153f1bcc3a4d11b9c493fe1cdae8fece0f919fe0537c97edb36cef7c lib/Attean/API/TripleOrQuad.pod
SHA256 298e6df9afda699d5c9072f3bd4091248e6c7527f8c32fc79e0bb021f08c2b7c lib/Attean/API/TripleParser.pod
SHA256 09bac20fc01478c28a7f44ef071305a87bec2be482b9f5b0af05be9333f76b1a lib/Attean/API/TriplePattern.pod
SHA256 23f557fd9335577c7c5ebfc5c433492d635a7ba592d5fee7405b87a9c54f12f6 lib/Attean/API/TripleSerializer.pod
SHA256 2a5ea94dd218216d88eed4930d2d169ddddeb7af37b1f9f0ea80754af9c48cd7 lib/Attean/API/Variable.pod
SHA256 260e1a8b26225d6b55e1a275af41e12fbcfe6d185a383a701745e85bce6a2ea8 lib/Attean/AggregateExpression.pod
SHA256 d9fc705f69058b7995635c0a2dd639438d27a041265ed414046c6f74fdb7a54a lib/Attean/Algebra.pm
SHA256 a431c04f64149192827c3f62858ab701446339c9017803cefcd7ce107d64e03b lib/Attean/BindingEqualityTest.pm
SHA256 1ae14e2a538723734034b8741acdbdb4d9fafcd3a6391d975b03ecc50e216c70 lib/Attean/Blank.pm
SHA256 3687531b9cf68b5b00e8a0d665677a97300e78068d8467341057d13eb0c1ddae lib/Attean/CodeIterator.pm
SHA256 49e1beef13ac3f2328cf31fe0ef62bb6b9cac1685dab10abad50caf9f1037217 lib/Attean/Expression.pm
SHA256 30c35653becc8e98a892f8a399f9594da5094650a15ec2dcc48bcd860801dddb lib/Attean/IDPQueryPlanner.pm
SHA256 90467260bb931b0202023f3cd51f6945d323568fffb3287fbe626d655e3bc83a lib/Attean/IRI.pm
SHA256 55172653c9f776696e6d412e014c453f735bfea8da58936ee1ae519becdf463e lib/Attean/IteratorSequence.pm
SHA256 0450227b26bf0ece4bfdf17541db1373d58ad16cf71c91ad95bf348159fc40d7 lib/Attean/ListIterator.pm
SHA256 32f00a6a2c31f1cf6b8b3ba434a9799d800042960d02e350cc812658aec96c58 lib/Attean/Literal.pm
SHA256 4a6324e7a4fb9afe6b488fbc9ad6b7df50079e944c346fedc5075e9010817878 lib/Attean/Plan.pm
SHA256 a7f1a790bc8611fadca55a816672ecfa559f9c5a88ffc41653cfec50d3e3a587 lib/Attean/Quad.pm
SHA256 e9051ac9fa0434c7734bb6475e6356f8d261fb2112af07d962377055131d7a2c lib/Attean/QuadModel.pm
SHA256 1b7e682eb6a25aad1ea2f36dad2982265880bb625eab065251bbc5633ca3df78 lib/Attean/QueryPlanner.pm
SHA256 3e2280e72a34a23753c91cc11af7c86233dac7d6a87babf3155d40ade34127f6 lib/Attean/RDF.pm
SHA256 aad013a6a4b7e260876d47e901f242f672744e59a9c722c51a0dcad2a4257e4f lib/Attean/Result.pm
SHA256 a70d5975220c0eaae69b207aba693364d1f7e360ee69b8a161e52f8e7d8e358f lib/Attean/SPARQLClient.pm
SHA256 128c089d90bb34e49978d50f2f472f6ac5bd418733787ad406a81a26c89d5482 lib/Attean/SimpleQueryEvaluator.pm
SHA256 7a972a8d03191b423d91ddad10120934289e509b8f482241b0b243a653a4ab8f lib/Attean/TermMap.pm
SHA256 98745e86bca31add1899244fc498528070aaa8d253990da9a3b283588df81c77 lib/Attean/TreeRewriter.pm
SHA256 06173c59c0752f9dadbe481a157bd5330327bce5906d70865ca925d8c8ccba8a lib/Attean/Triple.pm
SHA256 b7231042b998a5b6999f57bf6b147adcbe082e5360fc70210df20a315a4050f8 lib/Attean/TripleModel.pm
SHA256 341c7e2a53c138cc8c8ee00497a83fa73042d799431f1bcf38d9a07c7afa0ab1 lib/Attean/Variable.pm
SHA256 80035aa48363efdf9d7285e0c5017f31bc0928744e8e8df9518f692ee6d9a6d8 lib/AtteanX/API/JoinRotatingPlanner.pm
SHA256 35f69b88b1fd6c692266b7a515be3d94b97f0e355f8bf47740d76be0789fc6df lib/AtteanX/API/Lexer.pm
SHA256 787436d22a760b562f6bc839c815ffdc367001ad7e39b8571a7301769618af5c lib/AtteanX/Parser/NQuads.pm
SHA256 fdd2edca5a963109c6086a3023d1e2df520235fdd928b842d2010980fe61a468 lib/AtteanX/Parser/NTriples.pm
SHA256 74c9661d5abfaa071a831ad3d30ad988fef05a7c46890b88b245ed0f4b723e24 lib/AtteanX/Parser/NTuples.pm
SHA256 1d08fb6145257a722d7f7d0aa6c7f6ac035600977808873755e7ae6df2c13fdd lib/AtteanX/Parser/RDFXML.pm
SHA256 406fa9d3ac5f73e87b82063c38bfa19524b326d9c9ef746e118f502973854923 lib/AtteanX/Parser/SPARQL.pm
SHA256 3ae9c8150285cdcee7b566ffb67a195315ad58ef03df7760f49e6337486751a6 lib/AtteanX/Parser/SPARQLJSON.pm
SHA256 0911056e9e2cb5d29abd206ed0226e7b5f4fea31bcfddedacc2ba368047a60bc lib/AtteanX/Parser/SPARQLLex.pm
SHA256 82503f42719d1ca203fef841471c19a52a28a2c4e3c273db106322823d603338 lib/AtteanX/Parser/SPARQLTSV.pm
SHA256 b16b901f01639e6a7922d72c9c543a595bb1ccfe8245ed6e6305b15cb376eaf7 lib/AtteanX/Parser/SPARQLXML.pm
SHA256 2b1dffe53a8bc73ee64e699f5206ac866786ca9364f40876626c0eb2f1703bf5 lib/AtteanX/Parser/SPARQLXML/SAXHandler.pm
SHA256 cd7bb41bb9571e4aa9c978cebe1a37e27085c97c7a9195fe2346cc01f7378b4b lib/AtteanX/Parser/Trig.pm
SHA256 4101fc5f42e300eaef45fa1924c032179514e1b7b5f35384f2f308afdba286a7 lib/AtteanX/Parser/Turtle.pm
SHA256 84166314a45ac4f1f4831b17ab0fbc07ff8be00b69a07554ccc550d30b3c44fc lib/AtteanX/Parser/Turtle/Constants.pm
SHA256 74742da852503b047d0024bc1647d0bc7eced85d67339bb8a04761ac61818241 lib/AtteanX/Parser/Turtle/Lexer.pm
SHA256 93426601d637a61d0822151da6d82e2f567468cdb760f686b8008a2c323574ce lib/AtteanX/Parser/Turtle/Token.pm
SHA256 2a24ff6848d8aa9749f59e5bd833149d7d64ac69f0fac61ed41d508e72f64162 lib/AtteanX/SPARQL/Constants.pm
SHA256 244f835f76999c63a7ef3d1033e214f0b2c0986f47af7510ca832e2afbeca87c lib/AtteanX/SPARQL/Token.pm
SHA256 db02af2355232ad37f89a7eb32631760e24089c79e1a354ba3fb0a71dc2fd594 lib/AtteanX/Serializer/CanonicalNTriples.pm
SHA256 08daa8882422bd75eb8a77dbba410e6c56a54a61bacaba6ff0f4fb9330902539 lib/AtteanX/Serializer/NQuads.pm
SHA256 6dee634f256a1d53af917a4f25510224ccefbc3a6fab263887480a249e2cd7a1 lib/AtteanX/Serializer/NTriples.pm
SHA256 7ea0a778a68fb8e03c2a306da155a9c0a30cc8af6bc8ecf16d60357da6067fa7 lib/AtteanX/Serializer/NTuples.pm
SHA256 780f3420f3ede4702cfb4d4fad714fd67c65e0e7e6d3ea14c909cc220ab5728d lib/AtteanX/Serializer/RDFXML.pm
SHA256 aa9af3a506e0d9b84534d02267f768f8238bd94f7c0b8012bbf7b7e8b3373f5e lib/AtteanX/Serializer/SPARQL.pm
SHA256 ed78a96c9bc5c044b66df9dabd3826481b161e4ce0ac390a6df0a92000f095ce lib/AtteanX/Serializer/SPARQLCSV.pm
SHA256 b71a3d991cf686c3533c469d43c41d89ac94af3f7184d7a4dc4cda512ed8ca7a lib/AtteanX/Serializer/SPARQLHTML.pm
SHA256 c762aa56fa3a0a22ae9a0542e399d0fd64a987b32699c3e003974852a44416df lib/AtteanX/Serializer/SPARQLJSON.pm
SHA256 608b0f628e491f36d2ca9f994c884f5eed62ca14003e8e79aee7f290c7469eea lib/AtteanX/Serializer/SPARQLTSV.pm
SHA256 7658a46ea8c882b4e7db6111919fbdfb1c4dc7717e55106e33060fe0dec7a0a2 lib/AtteanX/Serializer/SPARQLXML.pm
SHA256 668b05158aae243f6dd164b51e9014cc6c0510e291ab10c601e5bd93c13f912f lib/AtteanX/Serializer/TextTable.pm
SHA256 2d06c217937eedda198ac37d9e98de7072fd33b052420f3db35adbab20ba66bc lib/AtteanX/Serializer/Turtle.pm
SHA256 f2a7674340de9b52d89ab8ca6679ac85f71cbf83d160e69f20f834a479e84694 lib/AtteanX/Serializer/TurtleTokens.pm
SHA256 8c638b0348ed0576afa90f9ced88085bd1b0a0f4f8e85785b278ed08f1a4244a lib/AtteanX/Store/Memory.pm
SHA256 72d4290c2a03547ed7dd20e8d6324a91efd8b6c561a70b15e9e205d53f31bcaa lib/AtteanX/Store/Simple.pm
SHA256 4af42be0ee69c7a07f2e2fb292aa115d34eedf495a57a0657b0dafef8caed050 lib/AtteanX/Store/SimpleTripleStore.pm
SHA256 b9f77d0fb0a9aaad104bc869f3aeec1064ffa1d813c8aba1e7aef44e59da0519 lib/Test/Attean/ETagCacheableQuadStore.pm
SHA256 c0fac9b24dea93536f0a236140ae63d4107f068f7b8071068150460f4276f4d1 lib/Test/Attean/MutableETagCacheableQuadStore.pm
SHA256 b0e086a72b39626e27b07b84668d8a9c54d1798a419679cf1634cf98c22a6837 lib/Test/Attean/MutableQuadStore.pm
SHA256 3599fe030b21f71cbcc4f8a3f2d5f5dc55cdf5412753bfbb22f6b419da90c14f lib/Test/Attean/MutableTimeCacheableQuadStore.pm
SHA256 6aabbccaa730533bccc360db4eb61db357541e40f33eef03ef2557134aaf023d lib/Test/Attean/MutableTripleStore.pm
SHA256 6034d9d2921c11ba6f93807e01cce1fff6c2aeb02cd59a83600ebeef6ee6ad19 lib/Test/Attean/QuadStore.pm
SHA256 522ba4f22bf073f57bf36ce67da337d820b757ae50391a580b1acb3affd98092 lib/Test/Attean/SPARQLStarSuite.pm
SHA256 a70dd2655e4c0bffdc72522cfffcded665d5d1d65b7b5b3fe67492fed290add8 lib/Test/Attean/SPARQLSuite.pm
SHA256 460142176b6e3b84c3e3adf5b354ac095729aaddaced60bf631b6a1519fc4ca5 lib/Test/Attean/StoreCleanup.pm
SHA256 512a054baea037a14c67a0a2d8294ca458764f49da13868f94737073c58e8698 lib/Test/Attean/TimeCacheableQuadStore.pm
SHA256 0bea5aeeb41c69ac6b36b1737b918bae744268cdbd165dc7b2223746bbc2e3ba lib/Test/Attean/TripleStore.pm
SHA256 5c8d1212f6e9ea3a12897d52745fef42dacd503007d99a1695b0df9f244db7a9 lib/Test/Attean/W3CManifestTestSuite.pm
SHA256 ad54957de8a8a1630608e3a0af7b06ec6f909ca0c63474d9395843a679b088dc lib/Types/Attean.pm
SHA256 6cce2792b13fd8d0989a654ce4efbc1f005c351707558d9f8f26f55bd22d8bb8 meta/changes.ttl
SHA256 1dc79bb2b9cdf890004c1760ece495500ae624a3759fa24cd5fe888bec58db52 t/00.load.t
SHA256 b9478f6e0d48e753304792448c6440a7974d13ceac602b5b634ac62ce3f7d9ec t/algebra.t
SHA256 e247d21a6674074ba2620a7a804deb98893ba72b84ef0e2e6d20f356d1194430 t/binding-equality.t
SHA256 4ca870ddb09a1ff622da1e36c4ee6dc19f47cf62a7d36db8ea2f4fd006f74b76 t/binding.t
SHA256 b9fb362268d464199e9966a871fc8a43fc0e97af1dc1b7ea57851a5cf333d6ec t/convenience.t
SHA256 1a1d1ef2a8fa1836d221e47a5a6501396c5f8aa34e6442c71d0113bfd5e83e46 t/cost_planner.t
SHA256 ce9233f9d79f3c6d247850d3563093898b301fe094d4ac10528f2a38d8c40e33 t/export-functions.t
SHA256 560cc1589d84209231b9bf72ff2c1d7dcb181801da060ef3ed0d1e27d89f8ec6 t/expression.t
SHA256 50f5e2e35383ef9e6e5dfc85065bcfc8cd8820c44d209938029f6cba5b2959cf t/http-negotiation.t
SHA256 32e8eef05c67002cb124105540f18c01825e743c1fb8e3c3be5575fb5a78cc41 t/idp_planner.t
SHA256 c91d27d6a4adcf3a15a7f6deff359c0f19b7613c53a909af27ed3b646948793f t/iter.t
SHA256 5d562c2b9445f744947ecd6e0e0a5bd067b5c593ecb61307e8f7c85437c7843b t/join_rotating_planner.t
SHA256 88ff05bc7a3b3bdaeb3bb97b631ae3029dcdf320fd057471752291a4edeae425 t/model-quad.t
SHA256 78e95af88a2280528015d6dfb51c0a52e28d0ccf6b878feb74a75275e4aeac11 t/model-triple.t
SHA256 16917197261d7fee09be08b8a35b8fa29e12454aea025fa65d8b8850b8a34e71 t/naive_planner.t
SHA256 defb6bed4c81808342ff65257e9a5f5d0ef3fea2ba5d6dcc0d3d056bcf0b2df2 t/parser-nquads.t
SHA256 ac0738aa575954860f2bb7e80e28fd5f7ded05dfeadb40dc35ed2e4f936b832e t/parser-ntriples.t
SHA256 3054f885baa580cb480a89de3960de3bd7d81a7f146b0bd17657ae017d6c7dda t/parser-rdfxml.t
SHA256 6d7faba1079d1365d3c4d70c87ed935e6b77696f65678088de96c82bb3c16ed3 t/parser-sparql-star.t
SHA256 bd8c72a77f58984fc117d9a9840ab4d4e6b71d1b07ca5cec77ece90cca5ae92e t/parser-sparql.t
SHA256 cebcc5c75cf316d48df99abbc0df6c2d2a978320cb7aae0aa217a1018e1f3d8f t/parser-sparqljson.t
SHA256 884b39ca9083ef1f3fea577dc2cd57b8de60836e82dcff1bff6d21452a7303ec t/parser-sparqltsv.t
SHA256 11e5be8b14c5cb0aeb7e3256688aaa8bd27b8e241ea6ed5d104d91e4957abbd5 t/parser-sparqlxml.t
SHA256 3b3773a53599d84845383dee130c773c2b50a73ebd1309b4089ffb879cc279a6 t/parser-turtle-star.t
SHA256 2e0db8b74089fe5212a8bcacb91e2a16342ddb6370d491686e50e62930989138 t/parser-turtle.t
SHA256 49d3adff4d64a797ce302f7307d4e126690f74b3faf67911ac840ff89c746f0f t/parser.t
SHA256 dd24ebd938693f07d46f1b79989d5ee0fdd006db4b59c3688861a3cb5119ec9e t/parser_serializer_api.t
SHA256 5ac6fefb729bca37648c388a20c9e49a436e64ccc58062ae8bff4ad49fc50f11 t/plan.t
SHA256 b3c643f68881fc5e7ee89dc26d50846a99f1eb7d4d238853561dfbf55b060e1e t/plans.t
SHA256 85c1e0994d2e1a7c83e16e51cc5d9f267176a7f137b525ee8cf64a508236200e t/serializer-canonicalntriples.t
SHA256 32be8d68a6ca07edbf4cd80cc2f3cda6520459885fbc2740be770e049161711c t/serializer-nquads.t
SHA256 d497b0324e6b634636fbcc1b6c306a0e4b085aa3ab953a28aed9c7fed57a4d23 t/serializer-ntriples.t
SHA256 ebf0041a9028693861ab3050cbcce8f4399211f08a53f5291db5225d2d8c8f90 t/serializer-rdfxml.t
SHA256 0a6f28944cecbc09e8adb74e3e8c79b9867d30c676e4b803b13947e17dde9375 t/serializer-sparql.t
SHA256 776f7fcece5befff17c6bb4f3b62222d773e393a6ef35ba7be52a782a109c03d t/serializer-sparqlcsv.t
SHA256 87e3e51c20d9b2fd89c571ec4ff10ed0879cd3310c670dfcedfcc31cb41dd9c2 t/serializer-sparqlhtml.t
SHA256 4c63b97ce6b45dbc1decabc6bed0f8220a91c2855c2965fed8c0c14fe75d8504 t/serializer-sparqljson.t
SHA256 fd557f136413c2aa9fd4fb37ad98cc675b00bc9198c4c847fbaabc1c5cb5019a t/serializer-sparqltsv.t
SHA256 7c67054f8972ed39121b00232d5ec56d6c2a3aa6cb6783b111b0749455aa6754 t/serializer-sparqlxml.t
SHA256 17beabdc87423cc5f48fab93bf1e76ed86ae0c080960331f3f807583224cad67 t/serializer-turtle.t
SHA256 c612288c1607ce563d87b7e30201ae5187be830beb7a01c72aa6b7925c9b601b t/serializer.t
SHA256 15b9787049ce24c70a8184d9986c0cc8d0603cd678c193333724579e552e1bf2 t/simple-eval.t
SHA256 4c7e65106d909f992a8acd478cafa012bb96c44985e4d425a9a60b327d130e57 t/simple.t
SHA256 80c9444f53b85b70a7ca6c34c5483610dcfd8c078f3f8c13542a0fbd362217db t/store-memory.t
SHA256 b5ef5fc3e12c7f2338185d600ed70a441bdb4757877651e72a929007fe6b8f14 t/store-simple.t
SHA256 f6567e7f55c4031d6987ce33e06ecf9d08adc6ed11b8631d711a3635fddc7663 t/store-simpletriple.t
SHA256 410ab17e0316f548675ee815e00d0801eb9d7a0ca0714847ce432578c0618c72 t/term-map.t
SHA256 8d54ad4dc5f5bb60ba29fea8b1ab0a7334dfe7c624b07ba440d6259ea3fa3960 t/term.t
SHA256 09757d8fcc25b8f3c92179c2439fb7e60c61d75988fa69c1e35c6dc14f786433 t/treerewrite.t
SHA256 5cfcacd72b4d27998c3e6b0167d00c630a7f4815362c0ec346daf205a5bf228a t/types-iri.t
SHA256 3f86e69e69389283882b56db46b42ce31c135237654e01573f9d2e6c29d36799 xt/dawg11-memory.t
SHA256 738067ae3b8cb02b23ad4e29dc30034bc9d8f7ba32b1b75b8694549e07ff5fe3 xt/eval-sparql-star-memory-simpleeval.t
SHA256 c7d5660216beaca18bc60da47b897ceed2645c8e8106794ccde0e08d53da4b52 xt/eval-sparql-star-memory.t
SHA256 81dae5e652e694c2acc7d105e32ba5f69edc343b22b2e1d47f95fdef8b441cd3 xt/pod-coverage.t
SHA256 2b04b20ff767801fde2fb6435361dc8ca0a9b60dda6cb0bbd18dd52962e1c1a3 xt/pod.t
-----BEGIN PGP SIGNATURE-----
iF0EAREDAB0WIQSC+8GhU5AgVmDLxA+E8rpUyqjILQUCYzn+FQAKCRCE8rpUyqjI
Ld5zAKCKqY7nbkawrTV3WWYev2eYAqNnswCfSKPKtiVqcYoOB0EqTfn2g8lTpiY=
=U/0z
-----END PGP SIGNATURE-----
Attean-0.033/bin/ 000755 000765 000024 00000000000 14316377024 013601 5 ustar 00greg staff 000000 000000 Attean-0.033/CONTRIBUTING 000644 000765 000024 00000001501 13235706150 014653 0 ustar 00greg staff 000000 000000 # How to contribute
## Reporting Issues
* [Create an issue](https://github.com/kasei/attean/issues), assuming one does not already exist.
* Add relevant labels
## Submitting Changes
* Try to follow the existing whitespace and brace style
* [1TBS](https://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS)
* Tabs used for indentation and aligning of comments (with a tabstop width of 4-characters)
* Ensure the test suite passes (`perl Makefile.PL && make && prove -l t xt`)
* Consider using the [pre-push hook](https://gist.github.com/kasei/0819f25cee79b3597576) to prevent pushing if the test suite is failing
* Submit a Pull Request
## Getting Help
* [IRC in the #perlrdf channel on irc.perl.org](irc://irc.perl.org/perlrdf)
* [@kasei](http://twitter.com/kasei/) or [@perlrdf](http://twitter.com/perlrdf/) on Twitter
Attean-0.033/PaxHeader/Changes 000644 000765 000024 00000000460 14316377003 016272 x ustar 00greg staff 000000 000000 30 mtime=1664744963.139989985
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
85 LIBARCHIVE.xattr.com.apple.FinderInfo=VEVYVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
70 SCHILY.xattr.com.apple.FinderInfo=TEXT
Attean-0.033/Changes 000644 000765 000024 00000061526 14316377003 014333 0 ustar 00greg staff 000000 000000 Attean
======
Created: 2014-09-27
Home page:
Bug tracker:
Maintainer: Gregory Todd Williams
0.033 2022-10-02
- (Addition) Add new Attean::SPARQLClient protocol implementation.
- (Update) Fixed handling of endpoint URLs containing query parameters.
- (Update) Protocol HTTP requests can now be signed by specifying a
'request_signer'.
- (Update) Update SERVICE evaluation classes to use Attean::SPARQLClient.
0.032 2022-08-14
- (Update) Fix for bug caused by newly added TermOrVariableOrTriplePattern
role.
0.031 2022-08-04
- (Addition) Add initial implementation for TriG-star parser.
- (Addition) Add support for parsing and evaluating SPARQL-star queries.
- (Update) Improve implementation, docs, and tests for accessing parsers
and serializers by file extension.
- (Update) Update Turtle, SPARQL-XML, and SPARQL-JSON parsers to support
RDF-star.
- (Update) Update docs and add tests for handling of base URIs in parsers
(#158).
0.030 2021-02-06
- (Update) Fix bug in attean_parse for parsers that are not either pull or
push parsers.
0.029 2021-02-01
- (Addition) Add Attean::API::MutableModel->load_triples_from_io (#157).
- (Addition) Added -n CLI argument to attean_parse to allow numbering of
results.
- (Update) Fix bug in Attean::API::ResultSerializer->serialize_list_to_io.
- (Update) Update Attean get_parser and get_serializer to allow searching
file extensions and media types for 1-arg calls.
- (Update) Updated Attean::API::Serializer to require file_extensions.
- (Update) Updated AtteanX::Serializer::TextTable to print table borders
and rules.
0.027 2020-11-06
- (Addition) Add canonicalization support for xsd:negativeInteger.
- (Addition) Added TextTable SPARQL results serializer.
- (Update) Fix SPARQL lexer to accept variables using the $ sigil.
- (Update) Fix evaluation of aggregates over empty groups.
- (Update) Fix handling of utf-8 encoding in AtteanX::Parser::SPARQLXML.
- (Update) Improve Attean::API::Result->apply_map handling of unbound
variables.
- (Update) Improve Test::Attean::SPARQLSuite.
- (Update) Improve handling of XPath Constructor (casting) functions.
- (Update) Update module metadata URLs (#155 from @szabgab).
0.028 2020-11-02
- (Addition) Add uniq method on iterators over objects with an as_string
method.
- (Update) Added Attean::API::RepeatableIterator->size method (#89).
- (Update) Fix Attean::QuadModel->get_quads when called with an empty term
set in some position.
- (Update) Fix utf8 handling of syntax tests in dawg test harness.
- (Update) Improve documentation about statement projection accessors
(e.g. subjects) not being unique (#152).
- (Update) Remove AtteanX::Store::DBI which was not a real DBI store and
was accidentally checked-in (#134).
- (Update) Switch UUID dependency from Data::UUID to UUID::Tiny (#145).
0.026 2020-02-20
- (Addition) Added Attean::API::Model->evaluate convenience method (#149,
#150).
- (Update) Fix typo in Attean::Plan::Service POD (#146).
- (Update) Improve type coercions (#148 from @kjetilk).
0.025 2019-10-25
- (Update) Fix Moo::Role/Role::Tiny imports (#141, #142 from @haarg).
0.024 2019-09-22
- (Addition) Add attribute in AbbreviatingSerializer to omit base
declaration to have all relative URIs (#135 from @kjetilk).
- (Update) Added ground_blanks attribute to Attean::SimpleQueryEvaluator.
- (Update) Fixed bug in AtteanX::API::Lexer that caused infinite recursion
when finding EOF in the middle of an escape sequence.
- (Update) Updates to use namespace types, available in Types::Attean
(#129, #137 from @kjetilk).
0.024 2019-04-30
- (Addition) Add a simple factory for temporary models (#132 from
@kjetilk).
- (Update) Document how to check whether a term looks like the head of an
rdf:List (#133 from @kjetilk).
- (Update) Removed the deprecated parse_term_from_string method from
NTuples and Turtle parsers (#131).
0.022 2019-03-21
- (Addition) Add Attean::API::TermOrVariable->is_bound method (#129 from
@kjetilk).
- (Addition) Added statement matching functionality for iterators.
0.021 2019-02-12
- (Addition) Added Attean::API::Model->algebra_holds method.
0.020 2019-01-09
- (Addition) Add holds handle to Model (from @kjetilk).
- (Addition) Added bgp export function in Attean::RDF with associated
tests (#125 from @kjetilk).
- (Update) Export using Exporter::Tiny instead of Exporter.pm (#122 from
@tobyink).
- (Update) Expose count_quads_estimate method at the model level.
- (Update) Make count_quad_estimate accessible from TripleModel (#124 from
@kjetilk).
0.019 2018-02-04
- (Update) Documentation updates (#120, #121 from @kjetilk).
- (Update) Fix incorrect URI for langString (#119 from @kjetilk).
0.018 2018-01-06
- (Update) Added tests for turtle parser escape handling (#55).
- (Update) Allow UUIDs to have lowercase hex digits (#102).
- (Update) Documentation fixes (#105 from @Varadinsky).
- (Update) Fixed as_string serialization of CONSTRUCT algebras (#97).
- (Update) Improve code coverage for Attean::TermMap (#107 from
@Varadinsky).
- (Update) Improvements to HashJoin query planning (#103 from @KjetilK).
- (Update) Removed LICENSE file and updated licensing statement in
individual modules (#116).
- (Update) Updated Makefile.PL for perl 5.26.
- (Update) Updated required version of IRI (#118).
- (Update) Use Moo::Role instead of namespace::clean to cleanup namespaces
(#112 from @baby-gnu).
0.017 2016-06-09
- (Addition) Port SPARQL-JSON serializer to Attean (#20, #101 from
@cakirke).
- (Update) Add a .gitignore file (#99 from @cakirke).
- (Update) Changed use of binmode to `use open` in attean_parse and
attean_query.
- (Update) Fix Construct plan string serialization.
- (Update) Fix declared arity of various algebra classes.
- (Update) Fixed bug in handling of restricted available named graphs
during query planning.
- (Update) Fixed documentation in Attean::QueryPlanner.
- (Update) Improved handling of unexpected EOF in AtteanX::Parser::SPARQL.
- (Update) Improved test coverage.
- (Update) Improved use of Travis CI (#100 from @cakirke).
- (Update) Make parse_term_from_string deprecations noisy.
- (Update) Removed default implementation of
Attean::API::Plan->plan_as_string.
- (Update) Updated SPARQL parser to produce Attean::Algebra::Reduced
algebra objects for REDUCED queries.
- (Update) Updated required versions of Moo and Test::Modern.
0.016 2016-05-04
- (Addition) Ported RDF::Trine::Serializer::RDFXML to
AtteanX::Serializer::RDFXML (#22).
- (Update) Add serialization of SPARQL PREFIX declarations and prefixnames
when namespaces are set (#53).
- (Update) Added Test::Attean::QuadStore->cleanup_store method.
- (Update) Added Test::Attean::StoreCleanup role and added store cleanup
to store tests.
- (Update) Changed Attean::TriplePattern->as_quadpattern to delegate to
Attean::API::TriplePattern->as_quad_pattern.
- (Update) Fix overly aggressive code that attempted to turn IRIs into
prefix names during Turtle serialization.
- (Update) Fixed bug in SPARQL parsing of NIL tokens.
- (Update) Fixes to POD, test, and metadata issues reported by
jonassmedegaard (#93, #94, #95, #96).
- (Update) Improve Attean::SimpleQueryEvaluator to handle updated algebra
classes and iterator API.
- (Update) Improved test suite (includes #92 from KjetilK, #53).
- (Update) Removed AtteanX::RDFQueryTranslator (split into a new package)
and all other references to RDF::Query.
- (Update) Removed default implementation of Attean::API::Term->ebv (now
required of consumers).
- (Update) Serialize SPARQL and Turtle namespace declarations in a stable
order.
- (Update) Updated Attean::API::AbbreviatingParser->base definition to be
a consumer of Attean::API::IRI.
- (Update) Updated Attean::API::SPARQLSerializable->as_sparql to return a
unicode string, not bytes.
0.015 2016-04-09
- (Update) Fixed metadata used to generate README files.
0.014 2016-04-09
- (Addition) Add a size estimate attribute to Attean::Plan::Iterator (#90
from KjetilK).
- (Addition) Added Attean::Plan::Iterator for cases where there is too
much data for Attean::Plan::Table (#88).
- (Update) Add ability for parsers to construct lazy IRIs.
- (Update) Add type checking to serialize_iter_* methods.
- (Update) Added Attean::ListIterator->size method (#89).
- (Update) Fix cases where result iterators were constructed without a
variables list.
- (Update) Improve error message generated for some SPARQL syntax errors.
- (Update) Update Attean::FunctionExpression to canonicalize ISURI to
ISIRI.
0.013 2016-03-19
- (Addition) Added Attean::API::BulkUpdatableStore role.
- (Addition) Added Attean::API::MutableModel->load_urls_into_graph method.
- (Addition) Added Attean::API::QuadPattern->as_triple_pattern method.
- (Addition) Added Attean::API::TripleOrQuadPattern->parse and
AtteanX::Parser::SPARQL->parse_nodes methods (#82).
- (Addition) Added Attean::Algebra::Query to indicate a full query trees
and aid in serialization (#67).
- (Addition) Added AtteanX::SPARQL::Token->integer constructor.
- (Addition) Added parsing, algebra, planning, and test support for SPARQL
1.1 Updates.
- (Update) Add and use Attean::Algebra::Query->subquery flag when
appropriate and stop generating needless unary join algebras.
- (Update) Add child accessor to Attean::API::UnaryQueryTree.
- (Update) Added CONTRIBUTING file.
- (Update) Allow producing short blank node labels in attean_query
results.
- (Update) Check types of invocant and model objects in calls to
cost_for_plan planning method (#77).
- (Update) Fix Attean::API::IDPJoinPlanner->cost_for_plan to pass the
planner object in calls to the model.
- (Update) Fix Attean::Algebra::Update->blank_nodes (#70).
- (Update) Fix Attean::QueryPlanner active_graphs argument during
recursive call to plans_for_algebra.
- (Update) Fix lost in-scope variables in aggregation algebra and plans
(#78).
- (Update) Fix result iterator generation for quad patterns to keep
associated variable names.
- (Update) Fix serialization of SILENT flag on Service queries.
- (Update) Fix sparql_tokens generation for quad patterns to use SPARQL
GRAPH syntax, not N-Quads syntax.
- (Update) Fixed bug in Attean::Literal that was returning rdf:string
instead of rdf:langString for language literals.
- (Update) Improve error messages in Attean::CodeIterator and
Attean::API::Binding.
- (Update) Improve errors and logging in SPARQL parser (#84 from KjetilK).
- (Update) Improve handling of utf8 encoding in SPARQL/XML, algebra, and
plan serializations.
- (Update) Improve temporary variable names in aggregates generated during
parsing.
- (Update) Improved Attean::Plan::Union to handle plans with zero
children.
- (Update) Improved error message in query planners (#76 from KjetilK).
- (Update) Pass tree depth as argument to algebra_as_string.
- (Update) Refactored SPARQL 1.1 test harness into a testing role (#80).
- (Update) Update bin/attean_query to allow dryruns to avoid generating
query plans when appropriate.
- (Update) Updated attean_query to allow updates.
0.012 2016-02-04
- (Addition) Added Attean::API::TermOrVariable->apply_binding method.
- (Addition) Added AtteanX::Store::SimpleTripleStore.
- (Update) Die on attempts to add non-ground triples/quads to stores
(#66).
- (Update) Fixed Attean::Algebra::Table to consume
Attean::API::NullaryQueryTree instead of Attean::API::UnaryQueryTree.
- (Update) Fixed type checks performed when ATTEAN_TYPECHECK is set.
- (Update) Improve error reporting for unexpected EOF in
AtteanX::Parser::SPARQL.
- (Update) Throwing an error when Triple or Quad objects gets passed a
variable (#65 from KjetilK).
- (Update) Add planning support for DESCRIBE queries (#45).
- (Update) Add type checking to store get_triples and get_quads methods
(#61).
- (Update) Added logging in QueryPlanner and TreeRewriter (#64 from
KjetilK).
- (Update) Avoid attempting to parse empty XML documents when passed in as
a scalar (#60).
- (Update) Fix Attean::CodeIterator type checking to handle non-blessed
items properly.
- (Update) Fix AtteanX::Parser::RDFXML to properly use caller-supplied
base IRI.
- (Update) Fix algebra generation for describe queries in SPARQL parser.
- (Update) Fix bug in Attean::Plan::Aggregate handling of COUNT(*)
queries.
- (Update) Fix bugs in SPARQL CSV and TSV serializers.
- (Update) Fix sparql_tokens generation for integer and datatyped
literals.
- (Update) Fixed AtteanX::Parser::SPARQL to maintain its URI::NamespaceMap
on prefix declarations.
- (Update) Improve POD and test coverage (#55; #61 from KjetilK).
- (Update) Improve attean_parse and attean_parse including preservation of
prefix declarations where possible.
- (Update) Improve regex escaping in t/algebra.t to silence warnings in
perl 5.22.
- (Update) Improve use of SPARQL and Turtle token objects.
- (Update) Improved triple model classes to allow adding and droping
triple store graphs.
- (Update) Merge code paths for canonical NTriples serializer.
- (Update) Preserve in-scope variables in result iterators.
- (Update) Serialize SPARQL/XML bindings in a stable order.
- (Update) Simplify cost estimation code for hash joins in
Attean::API::QueryPlanner (#59 from KjetilK).
- (Update) Update SPARQL parser to die on unimplemented Update syntax.
- (Update) Update SPARQL/HTML serializer to implement
AbbreviatingSerializer (#54, #63 from Zoran Varadinsky).
- (Update) Update turtle serializer to consume
Attean::API::AppendableSerializer.
- (Update) Updated prerequisites in Makefile.PL and .travis.yml.
- (Update) Use Test::Modern.
0.011 2016-01-16
- (Addition) Add initial implementation for Attean::MutableTripleModel.
- (Addition) Add logging of costs to query planner (#56 from KjetilK).
- (Addition) Add use of MooX::Log::Any (from KjetilK).
- (Addition) Added
Attean::API::Plan->subplans_of_type_are_variable_connected method.
- (Addition) Added Attean::API::Plan->children_are_variable_connected.
- (Addition) Added AtteanX::Parser::SPARQL->parse convenience method.
- (Addition) Added RDF/XML parser tests.
- (Addition) Added Turtle serializer.
- (Addition) Added exportable quadpattern constructor.
- (Addition) Added tests for get_sequence model accessor method (#3).
- (Update) Change API for Attean::API::CostPlanner->cost_for_plan to pass
in the query planner.
- (Update) Fix bug in handling unbound join variables in hash join
evaluation.
- (Update) Fix use of blank and variable shortcut constructors (#57 from
KjetilK).
- (Update) Fixed bug in
AtteanX::Serializer::SPARQLHTML->serialize_iter_to_bytes.
- (Update) Implementation of canonicalize method for triple and quad
patterns (#43 from KjetilK).
- (Update) Improve Attean::ExistsExpression->as_string.
- (Update) Improve cost estimation for cartesian joins in
Attean::API::QueryPlanner.
- (Update) Improved SPARQL serialization of algebra and expression trees
(including #51).
- (Update) Improved error handling in Attean::ListIterator->BUILD.
- (Update) Improved recognition of invalid aggregation queries.
- (Update) Make regexes used for prefixname parsing publicly accessibly.
- (Update) Merged shared constants for Turtle and SPARQL tokens.
- (Update) Moved subpatterns_of_type from Attean::API::Algebra to
Attean::API::DirectedAcyclicGraph.
- (Update) Renamed parse_term_from_string methods to parse_term_from_bytes
(adding delegating methods that should be decprecated in the future).
- (Update) Silence XML::Parser warnings on empty input documents.
- (Update) Update AtteanX::Parser::RDFXML to populate a namespace map
during parsing.
- (Update) Updated Attean::API::CanonicalizingBindingSet to produce the
same type of object as are input.
- (Update) Updated copyright years.
0.010 2015-12-22
- (Addition) Add INVOKE function expression to allow representing
IRI-defined functions.
- (Addition) Added Attean::API::Algebra methods blank_nodes and
subpatterns_of_type.
- (Addition) Added Attean::API::SimpleCostPlanner.
- (Addition) Added Attean::API::UnionScopeVariablesPlan role to handle
common computation of in-scope variables (Github issue #38).
- (Addition) Added Attean::Algebra::Sequence class.
- (Addition) Added AtteanX::API::JoinRotatingPlanner role.
- (Addition) Added SPARQL parsing support for RANK operator (Github issue
#35).
- (Addition) Added initial algebra and plan support for group ranking
(Github issue #34).
- (Addition) Added simple SPARQL HTML serializer (ported from
RDF::Endpoint; Github issue #27).
- (Addition) Added simple SPARQL serializer implementation (Github issue
#36).
- (Update) Added ability to turn some query algebras into SPARQL token
interators.
- (Update) Compute in-scope variables in Attean::Plan::Quad instead of
relying on calling code (Github issue #39).
- (Update) Ensure query plan costs are integers, fixing a bug when running
on perl with long doubles (#42).
- (Update) Fixed attean_query to support custom output serializers.
- (Update) Fixed bug in Attean::Algebra::Project->in_scope_variables.
- (Update) Fixed bug in t/http-negotiation.t that caused false failures
when negotiation led to the Canonical NTriples serializer.
- (Update) Fixed mis-named method call in AtteanX::Store::Memory.
- (Update) Improve error messages in query planning code (manual patch
from #41).
- (Update) Improve serializer negotiation to support multiple classes that
handle the same media type.
- (Update) Ported RDF::Query SPARQL parser to Attean.
- (Update) Refactored query planner to separate IDP code from the core
planning code.
- (Update) Renamed Attean::API::Planner to Attean::API::QueryPlanner and
re-organized planning code.
- (Update) Update Changes metadata handling to use
Module::Instal::DOAPChangeSets (Github issue #25).
- (Update) Updated Attean::Algebra::Join to be n-ary, not binary.
- (Update) Updated attean_query to use the native SPARQL parser.
0.009 2015-11-04
- (Addition) Added Attean::API::Result->shared_domain method.
- (Update) Improve handling on unicode data in SPARQL TSV parser.
- (Update) Improve query planner and plan implementations to support
SPARQL 1.1 test suite.
- (Update) Removed HeapSort plan implementation and use of Array::Heap due
to packaging concerns (issue #32).
0.008 2015-08-18
- (Addition) Added Attean::API::Plan::Join role.
- (Addition) Added apply_triple and apply_quad methods to triple and quad
pattern classes to produce Result objects.
- (Addition) Added heap sort plan implementation.
- (Update) Attean::API::TripleOrQuadPattern constructors accept
non-existent parameters (#13).
- (Update) Consolidated BUILDARGS handling in
Attean::API::TripleOrQuadPattern.
- (Update) Moved computation of in_scope_variables from calling code to to
Plan class BUILDARGS.
0.007 2015-07-16
- (Addition) Added Attean::API::Binding->apply_bindings to bind additional
variables.
- (Addition) Added Attean::API::Binding->is_ground.
- (Addition) Added Attean::API::TriplePattern->as_triple,
Attean::API::QuadPattern->as_quad.
- (Update) Added evaluation support for REGEX functions.
- (Update) Fix Attean plugin loading to allow non-plugins nested below the
plugin namespace.
- (Update) Improve SPARQL serialization for IRIs and triple patterns.
- (Update) Improve SPARQL serialization of OPTIONAL and boolean literals.
- (Update) POD improvements (PR #15 from Kjetil Kjernsmo).
0.006 2015-06-30
- (Addition) Added
Attean::API::DirectedAcyclicGraph->has_only_subtree_types method.
- (Addition) Added Attean->acceptable_parsers method (GH issue #11).
- (Addition) Added methods to test terms and variables for common term
role consumption.
- (Update) Added HSP heuristics to Attean::IDPQueryPlanner (patch from
Kjetil Kjernsmo).
- (Update) Added documentation (patches from Kjetil Kjernsmo).
- (Update) Disable stable sortint in Attean::IDPQueryPlanner where it is
unnecessary (patch from Kjetil Kjernsmo).
- (Update) Fixed handling of blank nodes in BGPs in
Attean::IDPQueryPlanner.
- (Update) Updated Attean::IDPQueryPlanner->join_plans API to allow easier
extensibility.
- (Update) Updated attean_query to use the IDPQueryPlanner.
0.005 2015-05-27
- (Update) Add initial code to support interesting orders in
Attean::IDPQueryPlanner.
- (Update) Added Attean::Plan::Unique class.
- (Update) Added POD description of each Attean::Plan class.
- (Update) Added evaluation support for type checking functions (ISIRI,
ISLITERAL, etc.).
- (Update) Added planning support for Extend and Ask algebra operations.
- (Update) Added planning support for Unique plans for DISTINCT queries
which are already ordered.
- (Update) Added query planning tests.
- (Update) Added use Set::Scalar in lib/Attean/Algebra.pm.
- (Update) Allow store-planning of more than just BGPs in
Attean::TripleModel.
- (Update) Change use of ListIterator to CodeIterator in plan classes that
can be pipelined.
- (Update) Changed Attean::Plan::Filter to check the EBV of a single,
named variable binding.
- (Update) Fixed bug in IDPQueryPlanner->cost_for_plan to reflect recently
changed Attean::Plan::Quad API.
- (Update) Improve propagation of distinct and ordered attributes during
query planning.
- (Update) Improved query planning.
- (Update) Removed references to Attean::QueryEvaluator (obviated by
$plan->evaluate).
- (Update) Removed unused/unnecessary code and comments.
- (Update) Rename Attean::Plan::Distinct to Attean::Plan::HashDistinct
(making room for different implementation strategies).
- (Update) Renamed Attean::Plan::Filter to Attean::Plan::EBVFilter.
- (Update) Simplified implementation of Attean::Plan::Unique.
- (Update) Split handling of BGP and GGP join planning in
Attean::IDPQueryPlanner for easier subclass overriding.
- (Update) Updated Attean::Plan::Quad to consume Attean::API::QuadPattern.
- (Update) Updated IDP query planner to produce correct plans for empty
BGPs.
0.004 2015-05-18
- (Addition) Add Attean::ValueExpression->in_scope_variables method.
- (Addition) Add initial implementation of Attean::TripleModel.
- (Addition) Added Attean::API::Binding->values_consuming_role method.
- (Addition) Added Attean::TriplePattern->as_quadpattern method.
- (Addition) Added SPARQL CSV and XML serializers.
- (Addition) Added Test::Attean roles for caching quadstores.
- (Addition) Added Test::Attean::MutableTripleStore.
- (Addition) Added an IDP-based query planner and associated classes and
roles.
- (Addition) Added initial support for representing, translating, and
evaluating SERVICE patterns.
- (Update) Add SPARQL serialization support for Expression classes.
- (Update) Add algebra_as_string methods for some algebra classes missing
an implementation.
- (Update) Add variables to result iterators.
- (Update) Added Math::Cartesian::Product to prerequisite list.
- (Update) Added Test::Roo-based store tests.
- (Update) Added comments about handling of graphs in
Test::Attean::MutableQuadStore.
- (Update) Added missing use statements.
- (Update) Fix documentation of serialize_iter_to_io method.
- (Update) Fixed Attean->get_parser to accept media types with parameters.
- (Update) Fixed required version of perl in store test roles to be v5.14.
- (Update) Fixed serialization bug in
Attean::FunctionExpression->as_sparql.
- (Update) Improve SPARQL serialization for projection, slicing, ordering,
and distinct/reduced modifiers.
- (Update) Improve SPARQL serialization of algebra trees.
- (Update) Update Attean::API::Expression to consume
Attean::API::UnionScopeVariables.
- (Update) Updated AtteanX::Store::Memory to conform to both etag and time
caching roles.
- (Update) Updated Memory store matching methods to accept node arrays for
any quad pattern position.
0.003 2015-02-19
- (Addition) Added Attean::TreeRewriter class.
- (Addition) Added count estimate methods to TripleStore QuadStore roles
(in lieu of github pull request #6).
- (Addition) Added missing algebra_as_string impelementations in
Attean::API::Query and Attean::Algebra.
- (Addition) Added tree_attributes methods to tree classes.
- (Update) Fixed method name typo in
Attean::API::TimeCacheableTripleStore.
- (Update) Split Cacheable roles into ETagCacheable and TimeCacheable
variants.
0.002 2014-10-15
- (Addition) Added Attean->negotiate_serializer method.
- (Addition) Added POD for many classes and roles.
- (Update) Changed media_type attributes to class methods in Serializer
classes.
- (Update) Moved RDF::Query algebra translator to
AtteanX::RDFQueryTranslator.
- (Update) Switched from Sub::Name to Sub::Util (github issue #5).
- (Update) Updated Attean->get_serializer to support media_type argument.
- (Update) Wrap mutating methods in a single bulk-update.
0.001 2014-09-27
- (Addition) Initial release.
Attean-0.033/MANIFEST 000644 000765 000024 00000012252 14316377025 014165 0 ustar 00greg staff 000000 000000 bin/attean_parse
bin/attean_query
bin/canonicalize_bgp.pl
Changes
CONTRIBUTING
inc/Module/Install.pm
inc/Module/Install/AuthorTests.pm
inc/Module/Install/Base.pm
inc/Module/Install/Can.pm
inc/Module/Install/DOAPChangeSets.pm
inc/Module/Install/Fetch.pm
inc/Module/Install/Makefile.pm
inc/Module/Install/Metadata.pm
inc/Module/Install/Scripts.pm
inc/Module/Install/Win32.pm
inc/Module/Install/WriteAll.pm
lib/Attean.pm
lib/Attean/AggregateExpression.pod
lib/Attean/Algebra.pm
lib/Attean/API.pm
lib/Attean/API/AbbreviatingParser.pod
lib/Attean/API/AbbreviatingSerializer.pod
lib/Attean/API/AggregateExpression.pod
lib/Attean/API/AppendableSerializer.pod
lib/Attean/API/AtOnceParser.pod
lib/Attean/API/Binding.pm
lib/Attean/API/Blank.pod
lib/Attean/API/BlankOrIRI.pod
lib/Attean/API/BulkUpdatableModel.pod
lib/Attean/API/Expression.pm
lib/Attean/API/IRI.pod
lib/Attean/API/Iterator.pm
lib/Attean/API/Literal.pod
lib/Attean/API/MixedStatementParser.pod
lib/Attean/API/MixedStatementSerializer.pod
lib/Attean/API/Model.pm
lib/Attean/API/MutableModel.pod
lib/Attean/API/MutableTripleStore.pod
lib/Attean/API/Parser.pm
lib/Attean/API/Plan.pm
lib/Attean/API/PullParser.pod
lib/Attean/API/PushParser.pod
lib/Attean/API/Quad.pod
lib/Attean/API/QuadParser.pod
lib/Attean/API/QuadPattern.pod
lib/Attean/API/QuadSerializer.pod
lib/Attean/API/Query.pm
lib/Attean/API/QueryPlanner.pm
lib/Attean/API/RepeatableIterator.pod
lib/Attean/API/Result.pod
lib/Attean/API/ResultParser.pod
lib/Attean/API/ResultSerializer.pod
lib/Attean/API/Serializer.pm
lib/Attean/API/Store.pm
lib/Attean/API/Term.pm
lib/Attean/API/TermOrVariable.pod
lib/Attean/API/TermParser.pod
lib/Attean/API/TermSerializer.pod
lib/Attean/API/Triple.pod
lib/Attean/API/TripleOrQuad.pod
lib/Attean/API/TripleParser.pod
lib/Attean/API/TriplePattern.pod
lib/Attean/API/TripleSerializer.pod
lib/Attean/API/Variable.pod
lib/Attean/BindingEqualityTest.pm
lib/Attean/Blank.pm
lib/Attean/CodeIterator.pm
lib/Attean/Expression.pm
lib/Attean/IDPQueryPlanner.pm
lib/Attean/IRI.pm
lib/Attean/IteratorSequence.pm
lib/Attean/ListIterator.pm
lib/Attean/Literal.pm
lib/Attean/Plan.pm
lib/Attean/Quad.pm
lib/Attean/QuadModel.pm
lib/Attean/QueryPlanner.pm
lib/Attean/RDF.pm
lib/Attean/Result.pm
lib/Attean/SimpleQueryEvaluator.pm
lib/Attean/SPARQLClient.pm
lib/Attean/TermMap.pm
lib/Attean/TreeRewriter.pm
lib/Attean/Triple.pm
lib/Attean/TripleModel.pm
lib/Attean/Variable.pm
lib/AtteanX/API/JoinRotatingPlanner.pm
lib/AtteanX/API/Lexer.pm
lib/AtteanX/Parser/NQuads.pm
lib/AtteanX/Parser/NTriples.pm
lib/AtteanX/Parser/NTuples.pm
lib/AtteanX/Parser/RDFXML.pm
lib/AtteanX/Parser/SPARQL.pm
lib/AtteanX/Parser/SPARQLJSON.pm
lib/AtteanX/Parser/SPARQLLex.pm
lib/AtteanX/Parser/SPARQLTSV.pm
lib/AtteanX/Parser/SPARQLXML.pm
lib/AtteanX/Parser/SPARQLXML/SAXHandler.pm
lib/AtteanX/Parser/Trig.pm
lib/AtteanX/Parser/Turtle.pm
lib/AtteanX/Parser/Turtle/Constants.pm
lib/AtteanX/Parser/Turtle/Lexer.pm
lib/AtteanX/Parser/Turtle/Token.pm
lib/AtteanX/Serializer/CanonicalNTriples.pm
lib/AtteanX/Serializer/NQuads.pm
lib/AtteanX/Serializer/NTriples.pm
lib/AtteanX/Serializer/NTuples.pm
lib/AtteanX/Serializer/RDFXML.pm
lib/AtteanX/Serializer/SPARQL.pm
lib/AtteanX/Serializer/SPARQLCSV.pm
lib/AtteanX/Serializer/SPARQLHTML.pm
lib/AtteanX/Serializer/SPARQLJSON.pm
lib/AtteanX/Serializer/SPARQLTSV.pm
lib/AtteanX/Serializer/SPARQLXML.pm
lib/AtteanX/Serializer/TextTable.pm
lib/AtteanX/Serializer/Turtle.pm
lib/AtteanX/Serializer/TurtleTokens.pm
lib/AtteanX/SPARQL/Constants.pm
lib/AtteanX/SPARQL/Token.pm
lib/AtteanX/Store/Memory.pm
lib/AtteanX/Store/Simple.pm
lib/AtteanX/Store/SimpleTripleStore.pm
lib/Test/Attean/ETagCacheableQuadStore.pm
lib/Test/Attean/MutableETagCacheableQuadStore.pm
lib/Test/Attean/MutableQuadStore.pm
lib/Test/Attean/MutableTimeCacheableQuadStore.pm
lib/Test/Attean/MutableTripleStore.pm
lib/Test/Attean/QuadStore.pm
lib/Test/Attean/SPARQLStarSuite.pm
lib/Test/Attean/SPARQLSuite.pm
lib/Test/Attean/StoreCleanup.pm
lib/Test/Attean/TimeCacheableQuadStore.pm
lib/Test/Attean/TripleStore.pm
lib/Test/Attean/W3CManifestTestSuite.pm
lib/Types/Attean.pm
Makefile.PL
MANIFEST This list of files
META.yml
meta/changes.ttl
README.md
t/00.load.t
t/algebra.t
t/binding-equality.t
t/binding.t
t/convenience.t
t/cost_planner.t
t/export-functions.t
t/expression.t
t/http-negotiation.t
t/idp_planner.t
t/iter.t
t/join_rotating_planner.t
t/model-quad.t
t/model-triple.t
t/naive_planner.t
t/parser_serializer_api.t
t/parser-nquads.t
t/parser-ntriples.t
t/parser-rdfxml.t
t/parser-sparql-star.t
t/parser-sparql.t
t/parser-sparqljson.t
t/parser-sparqltsv.t
t/parser-sparqlxml.t
t/parser-turtle-star.t
t/parser-turtle.t
t/parser.t
t/plan.t
t/plans.t
t/serializer-canonicalntriples.t
t/serializer-nquads.t
t/serializer-ntriples.t
t/serializer-rdfxml.t
t/serializer-sparql.t
t/serializer-sparqlcsv.t
t/serializer-sparqlhtml.t
t/serializer-sparqljson.t
t/serializer-sparqltsv.t
t/serializer-sparqlxml.t
t/serializer-turtle.t
t/serializer.t
t/simple-eval.t
t/simple.t
t/store-memory.t
t/store-simple.t
t/store-simpletriple.t
t/term-map.t
t/term.t
t/treerewrite.t
t/types-iri.t
xt/dawg11-memory.t
xt/eval-sparql-star-memory-simpleeval.t
xt/eval-sparql-star-memory.t
xt/pod-coverage.t
xt/pod.t
SIGNATURE Public-key signature (added by MakeMaker)
Attean-0.033/meta/ 000755 000765 000024 00000000000 14316377024 013757 5 ustar 00greg staff 000000 000000 Attean-0.033/t/ 000755 000765 000024 00000000000 14316377024 013274 5 ustar 00greg staff 000000 000000 Attean-0.033/xt/ 000755 000765 000024 00000000000 14316377024 013464 5 ustar 00greg staff 000000 000000 Attean-0.033/README.md 000644 000765 000024 00000002253 14273070744 014313 0 ustar 00greg staff 000000 000000 Attean Semantic Web Framework
=============================
Attean is a Perl framework for working with RDF data and SPARQL queries.
It features parsers and serializers for many different RDF formats including
RDF/XML, Turtle, N-Triples and N-Quads, as well as SPARQL formats like
SPARQL-XML, SPARQL-JSON, SPARQL-CSV and SPARQL-TSV.
Attean features support for SPARQL 1.1 queries, and a set of APIs and command
line tools to parse, transform, query, and serialize RDF data.
Getting Attean
--------------
Attean is available from:
* [GitHub](https://github.com/kasei/attean/)
* [CPAN](https://metacpan.org/release/Attean)
And is also available as [Debian packages](https://packages.qa.debian.org/liba/libattean-perl.html).
Getting Help
------------
A group of perl-rdf developers are usually available in the
[perlrdf IRC channel](irc://irc.perl.org/perlrdf) where we're happy to answer
questions.
You can also:
* Create a new [GitHub Issue](https://github.com/kasei/attean/issues) or submit a pull request
Licensing
---------
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
Attean-0.033/META.yml 000644 000765 000024 00000002750 14316377003 014303 0 ustar 00greg staff 000000 000000 ---
abstract: 'A Semantic Web Framework'
author:
- 'Gregory Todd Williams C<< >>'
- 'Gregory Todd Williams '
build_requires:
ExtUtils::MakeMaker: 6.59
HTTP::Message::PSGI: 0
Regexp::Common: 0
Test::Exception: 0
Test::LWP::UserAgent: 0
Test::More: 0.88
Test::Requires: 0
XML::Simple: 0
configure_requires:
ExtUtils::MakeMaker: 6.59
distribution_type: module
dynamic_config: 1
generated_by: 'Module::Install version 1.19'
license: perl
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
version: 1.4
name: Attean
no_index:
directory:
- inc
- t
- xt
requires:
Algorithm::Combinatorics: 0
DateTime::Format::W3CDTF: 0
Exporter::Tiny: 1
File::Slurp: 0
HTTP::Negotiate: 0
IRI: 0.005
JSON: 0
LWP::UserAgent: 0
List::MoreUtils: 0
Math::Cartesian::Product: 1.008
Module::Pluggable: 0
Moo: 2.000002
MooX::Log::Any: 0
PerlIO::Layers: 0
Role::Tiny: 2.000003
Set::Scalar: 0
Sub::Install: 0
Sub::Util: 1.4
Test::Modern: 0.012
Test::Moose: 0
Test::Roo: 0
Text::CSV: 0
Text::Table: 0
Try::Tiny: 0
Type::Tiny: 0
URI::Escape: 1.36
URI::NamespaceMap: 0.12
UUID::Tiny: 0
XML::SAX: 0
namespace::clean: 0
perl: 5.14.0
resources:
IRC: irc://irc.perl.org/#perlrdf
bugtracker: https://github.com/kasei/attean/issues
homepage: https://metacpan.org/release/Attean
license: http://dev.perl.org/licenses/
repository: https://github.com/kasei/attean/
version: '0.033'
Attean-0.033/lib/ 000755 000765 000024 00000000000 14316377024 013577 5 ustar 00greg staff 000000 000000 Attean-0.033/Makefile.PL 000644 000765 000024 00000003576 14305214736 015014 0 ustar 00greg staff 000000 000000 use strict;
use warnings;
use lib '.';
use inc::Module::Install;
name 'Attean';
all_from 'lib/Attean.pm';
author 'Gregory Todd Williams ';
license 'perl';
test_requires 'HTTP::Message::PSGI' => 0;
test_requires 'Regexp::Common' => 0;
test_requires 'Test::Exception' => 0;
test_requires 'Test::Requires' => 0;
test_requires 'Test::LWP::UserAgent' => 0;
test_requires 'Test::More' => 0.88;
test_requires 'XML::Simple' => 0;
perl_version '5.014';
requires 'Algorithm::Combinatorics' => 0;
requires 'UUID::Tiny' => 0;
requires 'DateTime::Format::W3CDTF' => 0;
requires 'Exporter::Tiny' => 1.000000;
requires 'File::Slurp' => 0;
requires 'HTTP::Negotiate' => 0;
requires 'IRI' => 0.005;
requires 'JSON' => 0;
requires 'List::MoreUtils' => 0;
requires 'LWP::UserAgent' => 0;
requires 'Math::Cartesian::Product' => 1.008;
requires 'Module::Pluggable' => 0;
requires 'Moo' => 2.000002;
requires 'MooX::Log::Any' => 0;
requires 'namespace::clean' => 0;
requires 'PerlIO::Layers' => 0;
requires 'Role::Tiny' => 2.000003;
requires 'Set::Scalar' => 0;
requires 'Sub::Install' => 0;
requires 'Sub::Util' => 1.40;
requires 'Test::Modern' => 0.012;
requires 'Test::Moose' => 0;
requires 'Test::Roo' => 0;
requires 'Text::CSV' => 0;
requires 'Text::Table' => 0;
requires 'Try::Tiny' => 0;
requires 'Type::Tiny' => 0;
requires 'URI::Escape' => 1.36;
requires 'URI::NamespaceMap' => 0.12;
requires 'XML::SAX' => 0;
resources(
'homepage' => "https://metacpan.org/release/Attean",
'repository' => "https://github.com/kasei/attean/",
'bugtracker' => "https://github.com/kasei/attean/issues",
'IRC' => "irc://irc.perl.org/#perlrdf",
);
author_tests('xt');
install_script glob('bin/attean_*');
write_doap_changes "meta/changes.ttl", "Changes", "turtle";
sign;
WriteAll;
Attean-0.033/lib/Types/ 000755 000765 000024 00000000000 14316377024 014703 5 ustar 00greg staff 000000 000000 Attean-0.033/lib/Test/ 000755 000765 000024 00000000000 14316377024 014516 5 ustar 00greg staff 000000 000000 Attean-0.033/lib/PaxHeader/Attean.pm 000644 000765 000024 00000000225 14316376071 017322 x ustar 00greg staff 000000 000000 30 mtime=1664744505.732302552
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean.pm 000644 000765 000024 00000032341 14316376071 015355 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean - A Semantic Web Framework
=head1 VERSION
This document describes Attean version 0.033
=head1 SYNOPSIS
use Attean;
use Attean::RDF qw(iri);
my $store = Attean->get_store('Memory')->new();
my $parser = Attean->get_parser('NTriples')->new();
# iterator of triples and quads
my $iter = $parser->parse_iter_from_io(\*STDIN);
# add a graph name to all triples
my $graph = iri('http://graph-name/');
my $quads = $iter->as_quads($graph);
$store->add_iter($quads);
my $model = Attean::QuadModel->new( store => $store );
my $iter = $model->get_quads();
while (my $quad = $iter->next) {
say $quad->object->ntriples_string;
}
# run a SPARQL query and iterate over the results
my $sparql = 'SELECT * WHERE { ?s ?p ?o }';
my $s = Attean->get_parser('SPARQL')->new();
my ($algebra) = $s->parse($sparql);
my $results = $model->evaluate($algebra, $graph);
while (my $r = $results->next) {
say $r->as_string;
}
=head1 DESCRIPTION
Attean provides APIs for parsing, storing, querying, and serializing
Semantic Web (RDF and SPARQL) data.
=head1 METHODS
=over 4
=cut
package Attean {
use v5.14;
use warnings;
our $VERSION = '0.033';
use Attean::API;
use Attean::Blank;
use Attean::Literal;
use Attean::Variable;
use Attean::IRI;
use Attean::Triple;
use Attean::Quad;
use Attean::Result;
use Attean::QuadModel;
use Attean::TripleModel;
use Attean::BindingEqualityTest;
use Attean::CodeIterator;
use Attean::ListIterator;
use Attean::IteratorSequence;
use Attean::IDPQueryPlanner;
use Attean::TermMap;
use HTTP::Negotiate qw(choose);
use List::MoreUtils qw(any all);
use Module::Load::Conditional qw(can_load);
use Role::Tiny ();
use Sub::Util qw(set_subname);
use namespace::clean;
use Module::Pluggable search_path => 'AtteanX::Parser', sub_name => 'parsers', max_depth => 3;
use Module::Pluggable search_path => 'AtteanX::Serializer', sub_name => 'serializers', max_depth => 3;
use Module::Pluggable search_path => 'AtteanX::Store', sub_name => 'stores', max_depth => 3;
sub import {
my $class = shift;
if (scalar(@_)) {
my %args = @_;
foreach my $p (@{ $args{parsers} || [] }) {
# warn "Loading $p parser...";
$class->get_parser($p) || die "Failed to load parser: $p";
}
foreach my $s (@{ $args{serializers} || [] }) {
# warn "Loading $s serializer...";
$class->get_serializer($s) || die "Failed to load serializer: $s";
}
foreach my $s (@{ $args{stores} || [] }) {
# warn "Loading $s store...";
$class->get_store($s) || die "Failed to load store: $s";
}
}
}
=item C<< get_store( $NAME ) >>
Attempts to find a L implementation with the
given C<< $NAME >>. This is done using L and will generally
be searching for class names C<< AtteanX::Store::$NAME >>.
Returns the full class name if a matching implementation is found, otherwise
returns undef.
=cut
sub get_store {
my $self = shift;
return $self->_get_plugin('stores', shift);
}
=item C<< temporary_model >>
Returns a temporary, mutable quad model based on a L store.
=cut
sub temporary_model {
my $self = shift;
return Attean::MutableQuadModel->new( store => $self->get_store('Memory')->new() )
}
=item C<< get_serializer( $NAME ) >>
=item C<< get_serializer( filename => $FILENAME ) >>
=item C<< get_serializer( media_type => $MEDIA_TYPE ) >>
Attempts to find a L serializer class with the given
C<< $NAME >>, or that can serialize files with the C<< $MEDIA_TYPE >> media
type.
Returns the full class name if a matching implementation is found, otherwise
returns undef.
=cut
sub get_serializer {
my $self = shift;
my $role = 'Attean::API::Serializer';
if (scalar(@_) == 1) {
my $name = shift;
my $p = $self->_get_plugin('serializers', $name, $role);
return $p if $p;
foreach my $type (qw'filename media_type') {
my $p = $self->get_serializer($type => $name);
return $p if $p;
}
return;
}
my $type = shift;
my %method = (filename => 'file_extensions', media_type => 'media_types');
if (my $method = $method{ $type }) {
my $value = shift;
$value =~ s/^.*[.]// if ($type eq 'filename');
$value =~ s/;.*$// if ($type eq 'media_type');
foreach my $p ($self->serializers()) {
if (can_load( modules => { $p => 0 })) {
next unless ($p->does($role));
my @exts = @{ $p->$method() };
return $p if (any { $value eq $_ } @exts);
}
}
return;
} else {
die "Not a valid constraint in get_serializer call: $type";
}
}
=item C<< get_parser( $NAME ) >>
=item C<< get_parser( filename => $FILENAME ) >>
=item C<< get_parser( media_type => $MEDIA_TYPE ) >>
Attempts to find a L parser class with the given
C<< $NAME >>, or that can parse files with the same extension as
C<< $FILENAME >>, or that can parse files with the C<< $MEDIA_TYPE >> media
type.
Returns the full class name if a matching implementation is found, otherwise
returns undef.
=cut
sub get_parser {
my $self = shift;
my $role = 'Attean::API::Parser';
if (scalar(@_) == 1) {
my $name = shift;
my $p = $self->_get_plugin('parsers', $name, $role);
return $p if $p;
foreach my $type (qw'filename media_type') {
my $p = $self->get_parser($type => $name);
return $p if $p;
}
return;
}
while (my $type = shift) {
my %method = (filename => 'file_extensions', media_type => 'media_types');
if (my $method = $method{ $type }) {
my $value = shift;
$value =~ s/^.*[.]// if ($type eq 'filename');
$value =~ s/;.*$// if ($type eq 'media_type');
foreach my $p ($self->parsers()) {
if (can_load( modules => { $p => 0 })) {
next unless ($p->can('does') and $p->does($role));
my @exts = @{ $p->$method() };
return $p if (any { $value eq $_ } @exts);
}
}
} else {
die "Not a valid constraint in get_parser call: $type";
}
}
return;
}
{
my %roles = (
serializers => 'Attean::API::Serializer',
parsers => 'Attean::API::Parser',
stores => 'Attean::API::Store',
);
for my $method (keys %roles) {
my $role = $roles{$method};
my $code = sub {
my $self = shift;
my @classes;
foreach my $class ($self->$method()) {
next unless (can_load( modules => { $class => 0 }));
push(@classes, $class) if ($class->can('does') and $class->does($role));
}
return @classes;
};
Sub::Install::install_sub({
code => set_subname("list_${method}", $code),
as => "list_${method}"
});
}
}
sub _get_plugin {
my $self = shift;
my $type = shift;
my $name = shift;
my @roles = @_;
foreach my $p ($self->$type()) {
if (lc(substr($p, -(length($name)+2))) eq lc("::$name")) {
unless (can_load( modules => { $p => 0 })) {
warn $Module::Load::Conditional::ERROR;
return;
}
foreach (@roles) {
unless ($p->does($_)) {
die ucfirst($type) . " class $p failed validation for role $_";
}
}
return $p;
}
}
}
=item C<< negotiate_serializer ( request_headers => $request_headers, restrict => \@serializer_names, extend => \%media_types ) >>
Returns a two-element list containing an appropriate media type and
L class as decided by L. If the
C<< 'request_headers' >> key-value is supplied, the C<< $request_headers >> is
passed to C<< HTTP::Negotiate::choose >>. The option C<< 'restrict' >>, set to
a list of serializer names, can be used to limit the serializers to choose from.
Finally, an C<<'extend'>> option can be set to a hashref that contains
MIME-types as keys and a custom variant as value. This will enable the user to
use this negotiator to return a type that isn't supported by any serializers.
The subsequent code will have to find out how to return a representation.
=cut
sub negotiate_serializer {
my $class = shift;
my %options = @_;
my $headers = delete $options{ 'request_headers' };
my $restrict = delete $options{ 'restrict' };
my $extend = delete $options{ 'extend' } || {};
my %serializer_names;
my %media_types;
foreach my $sclass ($class->list_serializers) {
my $name = $sclass =~ s/^.*://r;
$serializer_names{lc($name)} = $sclass;
for (@{ $sclass->media_types }) {
push(@{ $media_types{$_} }, $sclass);
}
}
my %sclasses;
if (ref($restrict) && ref($restrict) eq 'ARRAY') {
foreach (@$restrict) {
if (my $sclass = $serializer_names{lc($_)}) {
$sclasses{ $sclass } = 1;
}
}
} else {
%sclasses = reverse %serializer_names;
}
my @default_variants;
while (my($type, $sclasses) = each(%media_types)) {
foreach my $sclass (@$sclasses) {
next unless $sclasses{$sclass};
my $qv;
# slightly prefer turtle as a readable format to others
# try hard to avoid using ntriples as 'text/plain' isn't very useful for conneg
if ($type eq 'application/n-triples') {
$qv = 1.0;
} elsif ($type eq 'text/plain') {
$qv = 0.2;
} else {
$qv = 0.99;
$qv -= 0.01 if ($type =~ m#/x-#); # prefer non experimental media types
$qv -= 0.01 if ($type =~ m#^application/(?!rdf[+]xml)#); # prefer standard rdf/xml to other application/* formats
}
push(@default_variants, [$type, $qv, $type]);
}
}
my %custom_thunks;
my @custom_variants;
while (my($type,$thunk) = each(%$extend)) {
push(@custom_variants, [$thunk, 1.0, $type]);
$custom_thunks{ $thunk } = [$type, $thunk];
}
# remove variants with media types that are in custom_variants from @variants
my @variants = grep { not exists $extend->{ $_->[2] } } @default_variants;
push(@variants, @custom_variants);
my $stype = choose( \@variants, $headers );
if (defined($stype) and $custom_thunks{ $stype }) {
my $thunk = $stype;
my $type = $custom_thunks{ $stype }[0];
return ($type, $thunk);
}
if (defined($stype) and my $sclasses = $media_types{ $stype }) {
return ($stype, $sclasses->[0]);
} else {
die "No appropriate serializer found for content-negotiation: " . Data::Dumper->Dump([$headers, $restrict, $extend], [qw(headers restrict extend)]);
}
}
=item C<< acceptable_parsers ( handles => $item_role, prefer => $parser_role ) >>
Returns a string value expressing the media types that are acceptable to the
parsers available to the system. This string may be used as an 'Accept' HTTP
header value.
If a C<< handles >> role is supplied, only parsers that produce objects that
conform to C<< $item_role >> will be included.
If a C<< prefer >> role is supplied, only parsers that conform to
C<< $parser_role >> will be included.
Parsers are given a quality-value (expressing a preferred order or use) based
on the roles each parser consumes. Parsers consuming L
are preferred, while those consuming L are not
preferred. An exact ordering between parsers consuming similar roles is
currently undefined.
=cut
sub acceptable_parsers {
my $class = shift;
my %options = @_;
my $handles = delete $options{ 'handles' };
my $prefer = delete $options{ 'prefer' };
if (defined($handles) and $handles !~ /::/) {
$handles = ucfirst(lc($handles));
$handles = "Attean::API::$handles";
}
if (defined($prefer) and $prefer !~ /::/) {
$prefer = "Attean::API::" . ucfirst($prefer);
$prefer = "${prefer}Parser" unless ($prefer =~ /Parser$/);
}
my %media_types;
foreach my $pclass ($class->list_parsers) {
if (defined($handles)) {
my $type = $pclass->handled_type;
next unless ($type->can('role'));
my $role = $type->role;
next unless Role::Tiny::does_role($handles, $role);
}
if (defined($prefer)) {
next unless ($pclass->does($prefer));
}
my $q = 0.5;
if ($pclass->does('Attean::API::PullParser')) {
$q += 0.25;
} elsif ($pclass->does('Attean::API::AtOnceParser')) {
$q -= 0.25;
}
for (@{ $pclass->media_types }) {
my $mt = "$_;q=$q";
$media_types{$mt} = $q;
}
}
my @sorted = sort { $media_types{$b} <=> $media_types{$a} } keys %media_types;
return join(',', @sorted);
}
our %global_functions;
=item C<< register_global_function( %uri_to_func ) >>
=cut
sub register_global_function {
my $class = shift;
my %args = @_;
foreach my $uri (keys %args) {
my $func = $args{ $uri };
$global_functions{ $uri } = $func;
}
}
=item C<< get_global_function( $uri ) >>
=cut
sub get_global_function {
my $class = shift;
my $uri = shift;
return $global_functions{ $uri };
}
our %global_aggregates;
=item C<< register_global_aggregate( %uri_to_hash ) >>
=cut
sub register_global_aggregate {
my $class = shift;
my %args = @_;
foreach my $uri (keys %args) {
my $funcs = $args{ $uri };
$global_aggregates{ $uri } = $funcs;
}
}
=item C<< get_global_aggregate( $uri ) >>
=cut
sub get_global_aggregate {
my $class = shift;
my $uri = shift;
return $global_aggregates{ $uri };
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/AtteanX/ 000755 000765 000024 00000000000 14316377024 015143 5 ustar 00greg staff 000000 000000 Attean-0.033/lib/Attean/ 000755 000765 000024 00000000000 14316377024 015013 5 ustar 00greg staff 000000 000000 Attean-0.033/lib/Attean/PaxHeader/IRI.pm 000644 000765 000024 00000000225 14316376572 017753 x ustar 00greg staff 000000 000000 30 mtime=1664744826.833847169
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/IRI.pm 000644 000765 000024 00000004233 14316376572 016005 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::IRI - RDF Internationalized Resource Identifiers (IRIs)
=head1 VERSION
This document describes Attean::IRI version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $term = Attean::IRI->new('http://example.org/');
$term->ntriples_string; #
=head1 DESCRIPTION
The Attean::IRI class represents RDF IRIs.
It conforms to the L role
and extends the L class.
=head1 METHODS
=over 4
=cut
package Attean::IRI 0.033 {
use Moo;
use Types::Standard qw(Str);
use IRI 0.005;
use namespace::clean;
extends 'IRI';
has 'ntriples_string' => (is => 'ro', isa => Str, lazy => 1, builder => '_ntriples_string');
=item C<< equals ( $iri ) >>
Returns true if C<< $iri >> is equal to the invocant, false otherwise.
=cut
sub equals {
# This overrides the Attean::API::TermOrVariable::equals implementation
# to allow lazy IRIs to remain unparsed for the case where neither has
# a base IRI.
my ($a, $b) = @_;
if ($b->isa('Attean::IRI')) {
unless ($a->has_base or $b->has_base) {
return ($a->value eq $b->value);
}
}
return ($a->as_string eq $b->as_string);
}
with 'Attean::API::IRI';
with 'Attean::API::BlankOrIRI';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
my $args;
if (scalar(@_) == 1) {
$args = $class->$orig(value => shift);
} else {
$args = $class->$orig(@_);
}
if (exists $args->{base}) {
# fully qualify IRIs
my $iri = IRI->new( %$args );
$args = { value => $iri->as_string };
}
return $args;
};
=item C<< as_string >>
Returns the IRI value.
=cut
sub as_string {
my $self = shift;
return $self->abs;
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
L
L
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Quad.pm 000644 000765 000024 00000000225 14316376573 020223 x ustar 00greg staff 000000 000000 30 mtime=1664744827.132119276
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Quad.pm 000644 000765 000024 00000003627 14316376573 016263 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Quad - RDF Quads
=head1 VERSION
This document describes Attean::Quad version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $quad = Attean::Quad->new( $s, $p, $o, $g );
=head1 DESCRIPTION
The Attean::Quad class represents an RDF quad.
It conforms to the L role.
=head1 ROLES
This class consumes L.
=head1 METHODS
=over 4
=item C<< subject >>
=item C<< predicate >>
=item C<< object >>
=item C<< graph >>
=back
=cut
package Attean::QuadPattern 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Attean::RDF;
use Attean::API::Binding;
has 'subject' => (is => 'ro', required => 1);
has 'predicate' => (is => 'ro', required => 1);
has 'object' => (is => 'ro', required => 1);
has 'graph' => (is => 'ro', required => 1);
with 'Attean::API::QuadPattern';
}
package Attean::Quad 0.033 {
use Moo;
use Attean::API::Binding;
has 'subject' => (is => 'ro', does => 'Attean::API::BlankOrIRI', required => 1);
has 'predicate' => (is => 'ro', does => 'Attean::API::IRI', required => 1);
has 'object' => (is => 'ro', does => 'Attean::API::Term', required => 1);
has 'graph' => (is => 'ro', does => 'Attean::API::BlankOrIRI', required => 1);
with 'Attean::API::Quad';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
if (scalar(@_) == 4) {
my %args;
@args{ $class->variables } = @_;
return $class->$orig(%args);
}
return $class->$orig(@_);
};
}
1;
__END__
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Plan.pm 000644 000765 000024 00000000225 14316376573 020223 x ustar 00greg staff 000000 000000 30 mtime=1664744827.084820515
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Plan.pm 000644 000765 000024 00000232351 14316376573 016261 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use utf8;
=head1 NAME
Attean::Plan - Representation of SPARQL query plan operators
=head1 VERSION
This document describes Attean::Plan version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
=head1 DESCRIPTION
This is a utility package that defines all the Attean query plan classes
in the Attean::Plan namespace:
=over 4
=cut
use Attean::API::Query;
=item * L
Evaluates a quad pattern against the model.
=cut
package Attean::Plan::Quad 0.033 {
use Moo;
use Scalar::Util qw(blessed reftype);
use Types::Standard qw(ConsumerOf ArrayRef);
use namespace::clean;
has 'subject' => (is => 'ro', required => 1);
has 'predicate' => (is => 'ro', required => 1);
has 'object' => (is => 'ro', required => 1);
has 'graph' => (is => 'ro', required => 1);
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::NullaryQueryTree';
with 'Attean::API::QuadPattern';
around 'BUILDARGS' => sub {
my $orig = shift;
my $class = shift;
my $args = $orig->( $class, @_ );
if (exists $args->{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
my %vars;
foreach my $pos (qw(subject predicate object graph)) {
my $term = $args->{$pos};
if (blessed($term) and $term->does('Attean::API::Variable')) {
$vars{$term->value} = $term;
}
}
my @vars = keys %vars;
$args->{in_scope_variables} = [@vars];
return $args;
};
sub plan_as_string {
my $self = shift;
my @nodes = $self->values;
my @strings;
foreach my $t (@nodes) {
if (ref($t) eq 'ARRAY') {
my @tstrings = map { $_->ntriples_string } @$t;
if (scalar(@tstrings) == 1) {
push(@strings, @tstrings);
} else {
push(@strings, '[' . join(', ', @tstrings) . ']');
}
} elsif ($t->does('Attean::API::TermOrVariable')) {
push(@strings, $t->ntriples_string);
} else {
use Data::Dumper;
die "Unrecognized node in quad pattern: " . Dumper($t);
}
}
return sprintf('Quad { %s }', join(', ', @strings));
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
my @values = $self->values;
foreach my $i (0 .. $#values) {
my $value = $values[$i];
if (reftype($value) eq 'ARRAY') {
my @values;
foreach my $value (@{ $value }) {
my $name = $value->value;
if (my $node = $b->value($name)) {
push(@values, $node);
} else {
push(@values, $value);
}
$values[$i] = \@values;
}
} elsif ($value->does('Attean::API::Variable')) {
my $name = $value->value;
if (my $node = $b->value($name)) {
$values[$i] = $node;
}
}
}
return sub {
return $model->get_bindings( @values );
}
}
sub impl {
my $self = shift;
my $model = shift;
my @values = $self->values;
return sub {
return $model->get_bindings( @values );
}
}
}
=item * L
Evaluates a join (natural-, anti-, or left-) using a nested loop.
=cut
package Attean::Plan::NestedLoopJoin 0.033 {
use Moo;
use List::MoreUtils qw(all);
use namespace::clean;
with 'Attean::API::BindingSubstitutionPlan';
with 'Attean::API::Plan::Join';
sub plan_as_string {
my $self = shift;
if ($self->left) {
return 'NestedLoop Left Join';
} elsif ($self->anti) {
return 'NestedLoop Anti Join';
} else {
return 'NestedLoop Join';
}
}
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, @children);
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
unless (all { $_->does('Attean::API::BindingSubstitutionPlan') } @{ $self->children }) {
die "Plan children do not all consume BindingSubstitutionPlan role:\n" . $self->as_string;
}
my @children = map { $_->substitute_impl($model, $b) } @{ $self->children };
return $self->_impl($model, @children);
}
sub _impl {
my $self = shift;
my $model = shift;
my @children = @_;
my $left = $self->left;
my $anti = $self->anti;
my $iter_variables = $self->in_scope_variables;
return sub {
my ($lhs, $rhs) = map { $_->() } @children;
my @right = $rhs->elements;
my @results;
while (my $l = $lhs->next) {
my $seen = 0;
foreach my $r (@right) {
my @shared = $l->shared_domain($r);
if ($anti and scalar(@shared) == 0) {
# in a MINUS, two results that have disjoint domains are considered not to be joinable
next;
}
if (my $j = $l->join($r)) {
$seen++;
if ($left) {
# TODO: filter with expression
push(@results, $j);
} elsif ($anti) {
} else {
push(@results, $j);
}
}
}
if ($left and not($seen)) {
push(@results, $l);
} elsif ($anti and not($seen)) {
push(@results, $l);
}
}
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => \@results,
);
}
}
}
=item * L
Evaluates a join (natural-, anti-, or left-) using a hash join.
=cut
package Attean::Plan::HashJoin 0.033 {
use Moo;
use List::MoreUtils qw(all);
use namespace::clean;
sub BUILD {
my $self = shift;
if ($self->anti) {
die "Cannot use a HashJoin for anti-joins";
}
}
with 'Attean::API::BindingSubstitutionPlan';
with 'Attean::API::Plan::Join';
sub plan_as_string {
my $self = shift;
my $name;
if ($self->left) {
$name = "Hash Left Join";
} else {
$name = "Hash Join";
}
return sprintf('%s { %s }', $name, join(', ', @{$self->join_variables}));
}
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, @children);
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
unless (all { $_->does('Attean::API::BindingSubstitutionPlan') } @{ $self->children }) {
die "Plan children do not all consume BindingSubstitutionPlan role:\n" . $self->as_string;
}
my @children = map { $_->substitute_impl($model, $b) } @{ $self->children };
return $self->_impl($model, @children);
}
sub _impl {
my $self = shift;
my $model = shift;
my @children = @_;
my $left = $self->left;
my $iter_variables = $self->in_scope_variables;
return sub {
my %hash;
my @vars = @{ $self->join_variables };
my $rhs = $children[1]->();
while (my $r = $rhs->next()) {
my $has_unbound_right_join_var = 0;
my @values;
foreach my $var (@vars) {
my $value = $r->value($var);
unless (defined($value)) {
$has_unbound_right_join_var++;
}
push(@values, $value);
}
if ($has_unbound_right_join_var) {
# this is a RHS row that doesn't have a term bound to one of the join variables.
# this will make it impossible to compute the proper hash key to access the row bucket,
# so we add this row to the null bucket (hash key '') which we try to join all LHS rows
# against.
push(@{ $hash{''} }, $r);
} else {
my $key = join(',', map { ref($_) ? $_->as_string : '' } @values);
push(@{ $hash{$key} }, $r);
}
}
my @results;
my $lhs = $children[0]->();
while (my $l = $lhs->next()) {
my $seen = 0;
my @values;
my $has_unbound_left_join_var = 0;
foreach my $var (@vars) {
my $value = $l->value($var);
unless (defined($value)) {
$has_unbound_left_join_var++;
}
push(@values, $value);
}
my @buckets;
if (my $b = $hash{''}) {
push(@buckets, $b);
}
if ($has_unbound_left_join_var) {
my $pattern = join(',', map { ref($_) ? quotemeta($_->as_string) : '.*' } @values);
foreach my $key (keys %hash) {
if ($key =~ /^${pattern}$/) {
push(@buckets, $hash{$key});
}
}
} else {
my $key = join(',', map { ref($_) ? $_->as_string : '' } @values);
if (my $rows = $hash{$key}) {
push(@buckets, $rows);
}
}
foreach my $rows (@buckets) {
foreach my $r (@$rows) {
if (my $j = $l->join($r)) {
$seen++;
if ($left) {
# TODO: filter with expression
push(@results, $j);
} else {
push(@results, $j);
}
}
}
}
if ($left and not($seen)) {
push(@results, $l);
}
}
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => \@results
);
}
}
}
=item * L
=cut
package Attean::Plan::Construct 0.033 {
use Moo;
use List::MoreUtils qw(all);
use Types::Standard qw(Str ArrayRef ConsumerOf InstanceOf);
use namespace::clean;
has 'triples' => (is => 'ro', 'isa' => ArrayRef[ConsumerOf['Attean::API::TripleOrQuadPattern']], required => 1);
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::UnaryQueryTree';
sub plan_as_string {
my $self = shift;
my $triples = $self->triples;
return sprintf('Construct { %s }', join(' . ', map { $_->as_string } @$triples));
}
sub BUILDARGS {
# TODO: this code is repeated in several plan classes; figure out a way to share it.
my $class = shift;
my %args = @_;
my %vars = map { $_ => 1 } map { @{ $_->in_scope_variables } } @{ $args{ children } };
my @vars = keys %vars;
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = \@vars;
return $class->SUPER::BUILDARGS(%args);
}
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, @children);
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
unless (all { $_->does('Attean::API::BindingSubstitutionPlan') } @{ $self->children }) {
die "Plan children do not all consume BindingSubstitutionPlan role:\n" . $self->as_string;
}
warn "TODO: fix substitute_impl to substitute construct triples";
my @children = map { $_->substitute_impl($model, $b) } @{ $self->children };
return $self->_impl($model, @children);
}
sub _impl {
my $self = shift;
my $model = shift;
my $child = shift;
my @triples = @{ $self->triples };
return sub {
my $iter = $child->();
my @buffer;
my %seen;
return Attean::CodeIterator->new(
item_type => 'Attean::API::Triple',
generator => sub {
if (scalar(@buffer)) {
return shift(@buffer);
}
while (my $row = $iter->next) {
foreach my $tp (@triples) {
my $tp = $tp->apply_bindings($row);
my $t = eval { $tp->as_triple };
if ($t) {
push(@buffer, $t);
}
}
if (scalar(@buffer)) {
my $t = shift(@buffer);
return $t;
}
}
}
)->grep(sub {
return not $seen{$_->as_string}++;
});
}
}
}
=item * L
=cut
package Attean::Plan::Describe 0.033 {
use Moo;
use Attean::RDF;
use List::MoreUtils qw(all);
use Types::Standard qw(Str ArrayRef ConsumerOf InstanceOf);
use namespace::clean;
has 'graph' => (is => 'ro');
has 'terms' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TermOrVariable']]);
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
sub plan_as_string {
my $self = shift;
my $terms = $self->terms;
return sprintf('Describe { %s }', join(' . ', map { $_->as_string } @$terms));
}
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, @children);
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
unless (all { $_->does('Attean::API::BindingSubstitutionPlan') } @{ $self->children }) {
die "Plan children do not all consume BindingSubstitutionPlan role:\n" . $self->as_string;
}
warn "TODO: fix substitute_impl to substitute describe terms";
my @children = map { $_->substitute_impl($model, $b) } @{ $self->children };
return $self->_impl($model, @children);
}
sub _impl {
my $self = shift;
my $model = shift;
my $child = shift;
my $graph = $self->graph;
my @terms = @{ $self->terms };
# TODO: Split @terms into ground terms and variables.
# Only call get_quads once for ground terms.
# For variable terms, call get_quads for each variable-result combination.
return sub {
my $iter = $child->();
my @buffer;
my %seen;
return Attean::CodeIterator->new(
item_type => 'Attean::API::Triple',
generator => sub {
if (scalar(@buffer)) {
return shift(@buffer);
}
while (my $row = $iter->next) {
foreach my $term (@terms) {
my $value = $term->apply_binding($row);
if ($value->does('Attean::API::Term')) {
my $iter = $model->get_quads( $value, variable('predicate'), variable('object'), $graph );
push(@buffer, $iter->elements);
}
if (scalar(@buffer)) {
return shift(@buffer);
}
}
}
}
)->grep(sub {
return not $seen{$_->as_string}++;
});
}
}
}
=item * L
Filters results from a sub-plan based on the effective boolean value of a
named variable binding.
=cut
package Attean::Plan::EBVFilter 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(Str ConsumerOf);
use namespace::clean;
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'variable' => (is => 'ro', isa => Str, required => 1);
sub plan_as_string {
my $self = shift;
return sprintf('EBVFilter { ?%s }', $self->variable);
}
sub tree_attributes { return qw(expression) };
sub substitute_impl {
my $self = shift;
my $model = shift;
my $bind = shift;
my ($impl) = map { $_->substitute_impl($model, $bind) } @{ $self->children };
my $var = $self->variable;
return sub {
my $iter = $impl->();
return $iter->grep(sub {
my $r = shift;
my $term = $r->value($var);
return 0 unless (blessed($term) and $term->does('Attean::API::Term'));
return $term->ebv;
});
};
}
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
my $var = $self->variable;
return sub {
my $iter = $impl->();
return $iter->grep(sub {
my $r = shift;
my $term = $r->value($var);
return 0 unless (blessed($term) and $term->does('Attean::API::Term'));
return $term->ebv;
});
};
}
}
=item * L
Evaluates a set of sub-plans, returning the merged union of results, preserving
ordering.
=cut
package Attean::Plan::Merge 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(Str ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::BinaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'variables' => (is => 'ro', isa => ArrayRef[Str], required => 1);
sub plan_as_string { return 'Merge' }
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return sub {
die "Unimplemented";
};
}
}
=item * L
Evaluates a set of sub-plans, returning the union of results.
=cut
package Attean::Plan::Union 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use namespace::clean;
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::BinaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
sub plan_as_string { return 'Union' }
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, @children);
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $b = shift;
unless (all { $_->does('Attean::API::BindingSubstitutionPlan') } @{ $self->children }) {
die "Plan children do not all consume BindingSubstitutionPlan role:\n" . $self->as_string;
}
my @children = map { $_->substitute_impl($model, $b) } @{ $self->children };
return $self->_impl($model, @children);
}
sub _impl {
my $self = shift;
my $model = shift;
my @children = @_;
my $iter_variables = $self->in_scope_variables;
return sub {
if (my $current = shift(@children)) {
my $iter = $current->();
return Attean::CodeIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
generator => sub {
while (blessed($iter)) {
my $row = $iter->next();
if ($row) {
return $row;
} else {
$current = shift(@children);
if ($current) {
$iter = $current->();
} else {
undef $iter;
}
}
}
},
);
} else {
return Attean::ListIterator->new( item_type => 'Attean::API::Result', variables => [], values => [], );
}
};
}
}
=item * L
Evaluates a sub-plan, and extends each result by evaluating a set of
expressions, binding the produced values to new variables.
=cut
package Attean::Plan::Extend 0.033 {
use Moo;
use Encode;
use UUID::Tiny ':std';
use URI::Escape;
use Data::Dumper;
use I18N::LangTags;
use POSIX qw(ceil floor);
use Digest::SHA;
use Digest::MD5 qw(md5_hex);
use Scalar::Util qw(blessed looks_like_number);
use List::MoreUtils qw(uniq all);
use Types::Standard qw(ConsumerOf InstanceOf HashRef);
use namespace::clean;
with 'MooX::Log::Any';
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::UnaryQueryTree';
has 'expressions' => (is => 'ro', isa => HashRef[ConsumerOf['Attean::API::Expression']], required => 1);
sub plan_as_string {
my $self = shift;
my @strings = map { sprintf('?%s ↠%s', $_, $self->expressions->{$_}->as_string) } keys %{ $self->expressions };
return sprintf('Extend { %s }', join(', ', @strings));
}
sub tree_attributes { return qw(variable expression) };
sub BUILDARGS {
my $class = shift;
my %args = @_;
my $exprs = $args{ expressions };
my @vars = map { @{ $_->in_scope_variables } } @{ $args{ children } };
my @evars = (@vars, keys %$exprs);
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = [@evars];
return $class->SUPER::BUILDARGS(%args);
}
sub evaluate_expression {
my $self = shift;
my $model = shift;
my $expr = shift;
my $r = shift;
Carp::confess unless ($expr->can('operator'));
my $op = $expr->operator;
state $true = Attean::Literal->true;
state $false = Attean::Literal->false;
state $type_roles = { qw(URI IRI IRI IRI BLANK Blank LITERAL Literal NUMERIC NumericLiteral TRIPLE Triple) };
state $type_classes = { qw(URI Attean::IRI IRI Attean::IRI STR Attean::Literal) };
if ($expr->isa('Attean::CastExpression')) {
my $datatype = $expr->datatype->value;
my ($child) = @{ $expr->children };
my $term = $self->evaluate_expression($model, $child, $r);
if ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#string$>) {
my $value = $term->value;
if ($term->does('Attean::API::IRI')) {
return Attean::Literal->new(value => $term->value);
} elsif ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
my $v = ($value eq 'true' or $value eq '1') ? 'true' : 'false';
return Attean::Literal->new(value => $v);
} elsif ($term->does('Attean::API::NumericLiteral')) {
my $v = $term->numeric_value();
if ($v == int($v)) {
return Attean::Literal->new(value => int($v));
}
}
return Attean::Literal->new(value => $value);
}
die "TypeError $op" unless (blessed($term) and $term->does('Attean::API::Literal'));
if ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#(integer|float|double|decimal)>) {
my $value = $term->value;
my $num;
if ($datatype eq 'http://www.w3.org/2001/XMLSchema#integer') {
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
$value = ($value eq 'true' or $value eq '1') ? '1' : '0';
} elsif ($term->does('Attean::API::NumericLiteral')) {
my $v = $term->numeric_value();
$v =~ s/[.].*$//;
$value = int($v);
} elsif ($value =~ /^[-+]\d+$/) {
my ($v) = "$value";
$v =~ s/[.].*$//;
$value = int($v);
}
$num = $value;
} elsif ($datatype eq 'http://www.w3.org/2001/XMLSchema#decimal') {
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
$value = ($value eq 'true') ? '1' : '0';
} elsif ($term->does('Attean::API::NumericLiteral')) {
$value = $term->numeric_value;
} elsif (looks_like_number($value)) {
if ($value =~ /[eE]/) { # double
die "cannot cast to xsd:decimal as precision would be lost";
}
$value = +$value;
}
$num = "$value";
$num =~ s/[.]0+$/.0/;
$num =~ s/[.](\d+)0*$/.$1/;
} elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#(float|double)$>) {
my $typename = $1;
if ($term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#boolean') {
$value = ($value eq 'true') ? '1.0' : '0.0';
} elsif ($term->does('Attean::API::NumericLiteral')) {
# no-op
} elsif (looks_like_number($value)) {
$value = +$value;
} else {
die "cannot cast unrecognized value '$value' to xsd:$typename";
}
$num = sprintf("%e", $value);
}
my $c = Attean::Literal->new(value => $num, datatype => $expr->datatype);
if (my $term = $c->canonicalized_term()) {
return $term;
} else {
die "Term value is not a valid lexical form for $datatype";
}
} elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#boolean$>) {
if ($term->does('Attean::API::NumericLiteral')) {
my $value = $term->numeric_value;
return ($value == 0) ? Attean::Literal->false : Attean::Literal->true;
} else {
my $value = $term->value;
if ($value =~ m/^(true|false|0|1)$/) {
return ($value eq 'true' or $value eq '1') ? Attean::Literal->true : Attean::Literal->false;
} else {
die "Bad lexical form for xsd:boolean: '$value'";
}
}
} elsif ($datatype =~ m<^http://www.w3.org/2001/XMLSchema#dateTime$>) {
my $value = $term->value;
my $c = Attean::Literal->new(value => $value, datatype => $expr->datatype);
if ($c->does('Attean::API::DateTimeLiteral') and $c->datetime) {
return $c;
} else {
die "Bad lexical form for xsd:dateTime: '$value'";
}
}
$self->log->warn("Cast expression unimplemented for $datatype: " . Dumper($expr));
} elsif ($expr->isa('Attean::ValueExpression')) {
my $node = $expr->value;
if ($node->does('Attean::API::Variable')) {
return $r->value($node->value);
} else {
return $node;
}
} elsif ($expr->isa('Attean::UnaryExpression')) {
my ($child) = @{ $expr->children };
my $term = $self->evaluate_expression($model, $child, $r);
if ($op eq '!') {
return ($term->ebv) ? $false : $true;
} elsif ($op eq '-' or $op eq '+') {
die "TypeError $op" unless (blessed($term) and $term->does('Attean::API::NumericLiteral'));
my $v = $term->numeric_value;
return Attean::Literal->new( value => eval "$op$v", datatype => $term->datatype );
}
die "Unimplemented UnaryExpression evaluation: " . $expr->operator;
} elsif ($expr->isa('Attean::BinaryExpression')) {
my $op = $expr->operator;
if ($op eq '&&') {
foreach my $child (@{ $expr->children }) {
my $term = $self->evaluate_expression($model, $child, $r);
unless ($term->ebv) {
return $false;
}
}
return $true;
} elsif ($op eq '||') {
foreach my $child (@{ $expr->children }) {
my $term = $self->evaluate_expression($model, $child, $r);
if (blessed($term) and $term->ebv) {
return $true;
}
}
return $false;
} elsif ($op eq '=') {
my ($lhs, $rhs) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return $lhs->equals($rhs) ? $true : $false; # TODO: this may not be using value-space comparision for numerics...
} elsif ($op eq '!=') {
my ($lhs, $rhs) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return not($lhs->equals($rhs)) ? $true : $false; # TODO: this may not be using value-space comparision for numerics...
} elsif ($op =~ m#[<>]=?#) {
my ($lhs, $rhs) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $cmp = $lhs->compare($rhs);
if ($cmp < 0) {
return ($op =~ /^<=?/) ? $true : $false;
} elsif ($cmp > 0) {
return ($op =~ /^>=?/) ? $true : $false;
} else {
return ($op =~ /=/) ? $true : $false;
}
} elsif ($op =~ m<^[-+*/]$>) {
my ($lhs, $rhs) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
die "TypeError $op" unless all { blessed($_) and $_->does('Attean::API::NumericLiteral') } ($lhs, $rhs);
my ($lv, $rv) = map { $_->numeric_value } ($lhs, $rhs);
my $type = $lhs->binary_promotion_type($rhs, $op);
if ($op eq '+') {
return Attean::Literal->new(value => ($lv + $rv), datatype => $type);
} elsif ($op eq '-') {
return Attean::Literal->new(value => ($lv - $rv), datatype => $type);
} elsif ($op eq '*') {
return Attean::Literal->new(value => ($lv * $rv), datatype => $type);
} elsif ($op eq '/') {
return Attean::Literal->new(value => ($lv / $rv), datatype => $type);
}
}
$self->log->warn("Binary operator $op expression evaluation unimplemented: " . Dumper($expr));
die "Expression evaluation unimplemented: " . $expr->as_string;
} elsif ($expr->isa('Attean::FunctionExpression')) {
my $func = $expr->operator;
if ($func eq 'IF') {
my ($check, @children) = @{ $expr->children };
my ($term) = $self->evaluate_expression($model, $check, $r);
$self->log->warn($@) if ($@);
my $expr = $children[ (blessed($term) and $term->ebv) ? 0 : 1 ];
my $value = $self->evaluate_expression($model, $expr, $r);
# warn '############# ' . $value->as_string;
return $value;
} elsif ($func eq 'COALESCE') {
# warn "COALESCE: . " . $r->as_string . "\n";
foreach my $child (@{ $expr->children }) {
# warn '- ' . $child->as_string . "\n";
my $term = eval { $self->evaluate_expression($model, $child, $r) };
# warn $@ if $@;
if (blessed($term)) {
# warn ' returning ' . $term->as_string . "\n";
return $term;
}
}
# warn " no value\n";
return;
}
my @terms = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
if ($func =~ /^IS([UI]RI|BLANK|LITERAL|NUMERIC|TRIPLE)$/) {
my $role = "Attean::API::$type_roles->{$1}";
my $t = shift(@terms);
my $ok = (blessed($t) and $t->does($role));
return $ok ? $true : $false;
} elsif ($func eq 'REGEX') {
my ($string, $pattern, $flags) = @terms;
# my ($string, $pattern, $flags) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
# TODO: ensure that $string is a literal
($string, $pattern, $flags) = map { blessed($_) ? $_->value : '' } ($string, $pattern, $flags);
my $re;
if ($flags =~ /i/) {
$re = qr/$pattern/i;
} else {
$re = qr/$pattern/;
}
return ($string =~ $re) ? $true : $false;
} elsif ($func =~ /^(NOT)?IN$/) {
my $ok = ($func eq 'IN') ? $true : $false;
my $notok = ($func eq 'IN') ? $false : $true;
# my @children = @{ $expr->children };
my ($term, @children) = @terms;
# my ($term) = $self->evaluate_expression($model, shift(@children), $r);
# foreach my $child (@{ $expr->children }) {
foreach my $value (@children) {
# my $value = $self->evaluate_expression($model, $child, $r);
if ($term->equals($value)) {
return $ok;
}
}
return $notok;
} elsif ($func eq 'NOW') {
my $dt = DateTime->now;
my $value = DateTime::Format::W3CDTF->new->format_datetime( $dt );
return Attean::Literal->new(value => $value, datatype => 'http://www.w3.org/2001/XMLSchema#dateTime');
} elsif ($func eq 'STR') {
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return Attean::Literal->new(value => $term->value);
} elsif ($func =~ /^[UI]RI$/) { # IRI URI
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return Attean::IRI->new(value => $term->value, base => $expr->base);
} elsif ($func eq 'ABS') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = abs($string->numeric_value);
return Attean::Literal->new(value => $value, datatype => $string->datatype);
} elsif ($func eq 'ROUND') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = $string->numeric_value;
my $mult = 1;
if ($value < 0) {
$mult = -1;
$value = -$value;
}
my $round = $mult * POSIX::floor($value + 0.50000000000008);
return Attean::Literal->new(value => $round, datatype => $string->datatype);
} elsif ($func eq 'CEIL') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = ceil($string->numeric_value);
return Attean::Literal->new(value => $value, datatype => $string->datatype);
} elsif ($func eq 'FLOOR') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = floor($string->numeric_value);
return Attean::Literal->new(value => $value, datatype => $string->datatype);
} elsif ($func eq 'CONCAT') {
my @strings = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
# die "CONCAT called with terms that are not argument compatible" unless ($strings[0]->argument_compatible(@strings));
my %args;
if (my $l = $strings[0]->language) {
$args{language} = $l;
} else {
my $dt = $strings[0]->datatype;
if ($dt->value eq '') {
$args{datatype} = 'http://www.w3.org/2001/XMLSchema#string';
}
}
foreach my $s (@strings) {
die unless ($s->does('Attean::API::Literal'));
die if ($s->datatype and not($s->datatype->value =~ m));
if (my $l2 = $s->language) {
if (my $l1 = $args{language}) {
if ($l1 ne $l2) {
delete $args{language};
}
}
} else {
delete $args{language};
}
}
my $c = Attean::Literal->new(value => join('', map { $_->value } @strings), %args);
return $c;
} elsif ($func eq 'DATATYPE') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
die unless ($string->does('Attean::API::Literal'));
return $string->datatype;
} elsif ($func eq 'LANG') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
die unless ($string->does('Attean::API::Literal'));
my $value = $string->language // '';
return Attean::Literal->new(value => $value);
} elsif ($func eq 'LANGMATCHES') {
my ($term, $pat) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $lang = $term->value;
my $match = $pat->value;
if ($match eq '*') {
# """A language-range of "*" matches any non-empty language-tag string."""
return $lang ? $true : $false;
} else {
return (I18N::LangTags::is_dialect_of( $lang, $match )) ? $true : $false;
}
} elsif ($func eq 'ENCODE_FOR_URI') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return Attean::Literal->new(value => uri_escape_utf8($string->value));
} elsif ($func =~ /^[LU]CASE$/) {
my $term = shift(@terms);
my $value = ($func eq 'LCASE') ? lc($term->value) : uc($term->value);
return Attean::Literal->new(value => $value, $term->construct_args);
} elsif ($func eq 'STRLANG') {
my ($term, $lang) = @terms;
die unless ($term->does('Attean::API::Literal'));
die unless ($term->datatype->value =~ m);
die if ($term->language);
return Attean::Literal->new(value => $term->value, language => $lang->value);
} elsif ($func eq 'STRDT') {
my ($term, $dt) = @terms;
die unless ($term->does('Attean::API::Literal'));
die unless ($term->datatype->value =~ m);
die if ($term->language);
# my ($term, $dt) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return Attean::Literal->new(value => $term->value, datatype => $dt->value);
} elsif ($func eq 'REPLACE') {
my ($term, $pat, $rep) = @terms;
die unless ($term->does('Attean::API::Literal'));
die unless ($term->language or $term->datatype->value =~ m);
# my ($term, $pat, $rep) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = $term->value;
my $pattern = $pat->value;
my $replace = $rep->value;
die 'REPLACE() called with unsafe ?{} match pattern' if (index($pattern, '(?{') != -1 or index($pattern, '(??{') != -1);
die 'REPLACE() called with unsafe ?{} replace pattern' if (index($replace, '(?{') != -1 or index($replace, '(??{') != -1);
$replace =~ s/\\/\\\\/g;
$replace =~ s/\$(\d+)/\$$1/g;
$replace =~ s/"/\\"/g;
$replace = qq["$replace"];
no warnings 'uninitialized';
$value =~ s/$pattern/"$replace"/eeg;
# warn "==> " . Dumper($value);
return Attean::Literal->new(value => $value, $term->construct_args);
} elsif ($func eq 'SUBSTR') {
my ($term, @args) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $value = $term->value;
my @nums;
foreach my $i (0 .. $#args) {
my $argnum = $i + 2;
my $arg = $args[ $i ];
push(@nums, $arg->numeric_value);
}
$nums[0]--;
my $substring = (scalar(@nums) > 1) ? substr($value, $nums[0], $nums[1]) : substr($value, $nums[0]);
return Attean::Literal->new(value => $substring, $term->construct_args);
} elsif ($func eq 'CONTAINS') {
my ($term, $pattern) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
if ($term->has_language and $pattern->has_language) {
if ($term->literal_value_language ne $pattern->literal_value_language) {
die "CONTAINS called with literals of different languages";
}
}
my ($string, $pat) = map { $_->value } ($term, $pattern);
my $pos = index($string, $pat);
return ($pos >= 0) ? $true : $false;
} elsif ($func eq 'STRSTARTS') {
my (@terms) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my ($string, $pat) = map { $_->value } @terms;
return (substr($string, 0, length($pat)) eq $pat) ? $true : $false;
} elsif ($func eq 'STRENDS') {
my (@terms) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my ($string, $pat) = map { $_->value } @terms;
return (substr($string, length($string) - length($pat)) eq $pat) ? $true : $false;
} elsif ($func eq 'STRAFTER') {
my ($term, $pat) = @terms;
die "STRAFTER called without a literal" unless ($term->does('Attean::API::Literal'));
die "STRAFTER called without a plain literal" unless ($term->language or $term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string');
die "$func arguments are not term compatible: " . join(', ', map { $_->as_string } @terms) unless ($term->argument_compatible($pat));
# TODO: check that the terms are argument compatible
my $value = $term->value;
my $match = $pat->value;
my $i = index($value, $match, 0);
if ($i < 0) {
return Attean::Literal->new(value => '');
} else {
return Attean::Literal->new(value => substr($value, $i+length($match)), $term->construct_args);
}
} elsif ($func eq 'STRBEFORE') {
my ($term, $pat) = @terms;
die "STRBEFORE called without a literal" unless ($term->does('Attean::API::Literal'));
die "STRBEFORE called without a plain literal" unless ($term->language or $term->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string');
die "$func arguments are not term compatible: " . join(', ', map { $_->as_string } @terms) unless ($term->argument_compatible($pat));
# TODO: check that the terms are argument compatible
my $value = $term->value;
my $match = $pat->value;
my $i = index($value, $match, 0);
if ($i < 0) {
return Attean::Literal->new(value => '');
} else {
return Attean::Literal->new(value => substr($value, 0, $i), $term->construct_args);
}
} elsif ($func eq 'STRLEN') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
return Attean::Literal->new(value => length($string->value), datatype => 'http://www.w3.org/2001/XMLSchema#integer');
} elsif ($func eq 'MD5') {
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $bytes = encode('UTF-8', $string->value, Encode::FB_CROAK);
return Attean::Literal->new(value => md5_hex($bytes));
} elsif ($func =~ /^SHA(\d+)$/) {
my $sha = Digest::SHA->new($1);
my ($string) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $bytes = encode('UTF-8', $string->value, Encode::FB_CROAK);
$sha->add($bytes);
return Attean::Literal->new(value => $sha->hexdigest);
} elsif ($func eq 'RAND') {
return Attean::Literal->new(value => rand(), datatype => 'http://www.w3.org/2001/XMLSchema#double');
} elsif ($func =~ /^(YEAR|MONTH|DAY|HOUR|MINUTE)S?$/) {
my $method = lc($1);
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $dt = $term->datetime;
return Attean::Literal->new(value => $dt->$method(), datatype => 'http://www.w3.org/2001/XMLSchema#integer');
} elsif ($func eq 'SECONDS') {
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $dt = $term->datetime;
return Attean::Literal->new(value => $dt->second, datatype => 'http://www.w3.org/2001/XMLSchema#decimal');
} elsif ($func eq 'TIMEZONE') {
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $dt = $term->datetime;
my $tz = $dt->time_zone;
die "TIMEZONE called with a dateTime without a timezone" if ($tz->is_floating);
my $offset = $tz->offset_for_datetime( $dt );
my $minus = '';
if ($offset < 0) {
$minus = '-';
$offset = -$offset;
}
my $duration = "${minus}PT";
if ($offset >= 60*60) {
my $h = int($offset / (60*60));
$duration .= "${h}H" if ($h > 0);
$offset = $offset % (60*60);
}
if ($offset >= 60) {
my $m = int($offset / 60);
$duration .= "${m}M" if ($m > 0);
$offset = $offset % 60;
}
my $s = int($offset);
$duration .= "${s}S" if ($s > 0 or $duration eq 'PT');
return Attean::Literal->new(value => $duration, datatype => 'http://www.w3.org/2001/XMLSchema#dayTimeDuration');
} elsif ($func eq 'TZ') {
my ($term) = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $dt = $term->datetime;
my $tz = $dt->time_zone;
return Attean::Literal->new(value =>'') if ($tz->is_floating);
return Attean::Literal->new('Z') if ($tz->is_utc);
my $offset = $tz->offset_for_datetime( $dt );
my $hours = 0;
my $minutes = 0;
my $minus = '+';
if ($offset < 0) {
$minus = '-';
$offset = -$offset;
}
if ($offset >= 60*60) {
$hours = int($offset / (60*60));
$offset = $offset % (60*60);
}
if ($offset >= 60) {
$minutes = int($offset / 60);
$offset = $offset % 60;
}
my $seconds = int($offset);
return Attean::Literal->new(value => sprintf('%s%02d:%02d', $minus, $hours, $minutes));
} elsif ($func eq 'UUID') {
my $uuid = 'urn:uuid:' . uc(uuid_to_string(create_uuid()));
return Attean::IRI->new(value => $uuid);
} elsif ($func eq 'STRUUID') {
return Attean::Literal->new(value => uc(uuid_to_string(create_uuid())));
} elsif ($func eq 'BNODE') {
if (scalar(@{ $expr->children })) {
my $string = $self->evaluate_expression($model, $expr->children->[0], $r);
my $value = $string->value;
my $b = (exists $r->eval_stash->{'sparql:bnode'}{$value})
? $r->eval_stash->{'sparql:bnode'}{$value}
: Attean::Blank->new();
$r->eval_stash->{'sparql:bnode'}{$value} = $b;
return $b;
} else {
return Attean::Blank->new();
}
} elsif ($func eq 'SAMETERM') {
my @operands = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my ($a, $b) = @operands;
die "TypeError: SAMETERM" unless (blessed($operands[0]) and blessed($operands[1]));
if ($a->compare($b)) {
return $false;
}
if ($a->does('Attean::API::Binding')) {
my $ok = ($a->sameTerms($b));
return $ok ? $true : $false;
} else {
my $ok = ($a->value eq $b->value);
return $ok ? $true : $false;
}
} elsif ($func =~ /^(SUBJECT|PREDICATE|OBJECT)$/) {
my @operands = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $pos = lc($func);
my $term = $operands[0]->$pos();
return $term;
} elsif ($func eq 'INVOKE') {
my @operands = map { $self->evaluate_expression($model, $_, $r) } @{ $expr->children };
my $furi = shift(@operands)->value;
my $func = Attean->get_global_function($furi);
unless (ref($func)) {
die "No extension registered for <$furi>";
}
return $func->(@operands);
} else {
warn "Expression evaluation unimplemented: " . $expr->as_string;
$self->log->warn("Expression evaluation unimplemented: " . $expr->as_string);
die "Expression evaluation unimplemented: " . $expr->as_string;
}
} elsif ($expr->isa('Attean::ExistsPlanExpression')) {
my $plan = $expr->plan;
my $impl = $plan->substitute_impl($model, $r);
my $iter = $impl->();
my $found = 0;
if (my $row = $iter->next) {
# warn "EXISTS found row: " . $row->as_string;
$found++;
}
return $found ? Attean::Literal->true : Attean::Literal->false;
} else {
$self->log->warn("Expression evaluation unimplemented: " . $expr->as_string);
die "Expression evaluation unimplemented: " . $expr->as_string;
}
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $bind = shift;
my %exprs = %{ $self->expressions };
my ($impl) = map { $_->substitute_impl($model, $bind) } @{ $self->children };
# TODO: substitute variables in the expression
return $self->_impl($model, $impl, %exprs);
}
sub impl {
my $self = shift;
my $model = shift;
my %exprs = %{ $self->expressions };
my ($impl) = map { $_->impl($model) } @{ $self->children };
return $self->_impl($model, $impl, %exprs);
}
sub _impl {
my $self = shift;
my $model = shift;
my $impl = shift;
my %exprs = @_;
my $iter_variables = $self->in_scope_variables;
return sub {
my $iter = $impl->();
return Attean::CodeIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
generator => sub {
ROW: while (my $r = $iter->next) {
# warn 'Extend Row -------------------------------> ' . $r->as_string;
my %row = map { $_ => $r->value($_) } $r->variables;
foreach my $var (keys %exprs) {
my $expr = $exprs{$var};
# warn "-> $var => " . $expr->as_string;
my $term = eval { $self->evaluate_expression($model, $expr, $r) };
# warn $@ if ($@);
if (blessed($term)) {
# warn "===> " . $term->as_string;
if ($row{ $var } and $term->as_string ne $row{ $var }->as_string) {
next ROW;
}
if ($term->does('Attean::API::Binding')) {
# patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
$term = $term->ground($r);
}
$row{ $var } = $term;
}
}
return Attean::Result->new( bindings => \%row, eval_stash => $r->eval_stash );
}
return;
}
);
};
}
}
=item * L
Evaluates a sub-plan, and returns distinct results by checking a persistent
hash of already-seen results.
=cut
package Attean::Plan::HashDistinct 0.033 {
use Moo;
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
sub plan_as_string { return 'HashDistinct' }
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
my %seen;
return sub {
my $iter = $impl->();
return $iter->grep(sub { return not($seen{ shift->as_string }++); });
};
}
}
=item * L
Evaluates an already-ordered sub-plan, and returns distinct results by
filtering out sequential duplicates.
=cut
package Attean::Plan::Unique 0.033 {
use Moo;
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
sub plan_as_string { return 'Unique' }
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
return sub {
my $iter = $impl->();
my $last = '';
return $iter->grep(sub {
my $r = shift;
my $s = $r->as_string;
my $ok = $s ne $last;
$last = $s;
return $ok;
});
};
}
}
=item * L
Evaluates a sub-plan, and returns the results after optionally skipping some
number of results ("offset") and limiting the total number of returned results
("limit").
=cut
package Attean::Plan::Slice 0.033 {
use Moo;
use Types::Standard qw(Int);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'limit' => (is => 'ro', isa => Int, default => -1);
has 'offset' => (is => 'ro', isa => Int, default => 0);
sub plan_as_string {
my $self = shift;
my @str;
push(@str, "Limit=" . $self->limit) if ($self->limit >= 0);
push(@str, "Offset=" . $self->offset) if ($self->offset > 0);
return sprintf('Slice { %s }', join(' ', @str));
}
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
my $offset = $self->offset;
my $limit = $self->limit;
return sub {
my $iter = $impl->();
$iter = $iter->offset($offset) if ($offset > 0);
$iter = $iter->limit($limit) if ($limit >= 0);
return $iter;
};
}
}
=item * L
Evaluates a sub-plan and returns projected results by only keeping a fixed-set
of variable bindings in each result.
=cut
package Attean::Plan::Project 0.033 {
use Moo;
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::UnaryQueryTree';
use Types::Standard qw(ArrayRef ConsumerOf);
has 'variables' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Variable']], required => 1);
sub BUILDARGS {
my $class = shift;
my %args = @_;
my @vars = map { $_->value } @{ $args{variables} };
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = \@vars;
return $class->SUPER::BUILDARGS(%args);
}
# sub BUILD {
# my $self = shift;
# my @vars = map { $_->value } @{ $self->variables };
# unless (scalar(@vars)) {
# Carp::confess "No vars in project?";
# }
# }
sub plan_as_string {
my $self = shift;
return sprintf('Project { %s }', join(' ', map { '?' . $_->value } @{ $self->variables }));
}
sub tree_attributes { return qw(variables) };
sub substitute_impl {
my $self = shift;
my $model = shift;
my $bind = shift;
my ($impl) = map { $_->substitute_impl($model, $bind) } @{ $self->children };
my @vars = map { $_->value } @{ $self->variables };
my $iter_variables = $self->in_scope_variables;
# TODO: substitute variables in the projection where appropriate
return sub {
my $iter = $impl->();
return $iter->map(sub {
my $r = shift;
my $b = { map { my $t = $r->value($_); $t ? ($_ => $t) : () } @vars };
return Attean::Result->new( bindings => $b );
}, $iter->item_type, variables => $iter_variables);
};
}
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
my @vars = map { $_->value } @{ $self->variables };
my $iter_variables = $self->in_scope_variables;
return sub {
my $iter = $impl->();
return $iter->map(sub {
my $r = shift;
my $b = { map { my $t = $r->value($_); $t ? ($_ => $t) : () } @vars };
return Attean::Result->new( bindings => $b );
}, $iter->item_type, variables => $iter_variables);
};
}
}
=item * L
Evaluates a sub-plan and returns the results after fully materializing and
sorting is applied.
=cut
package Attean::Plan::OrderBy 0.033 {
use Moo;
use Types::Standard qw(HashRef ArrayRef InstanceOf Bool Str);
use Scalar::Util qw(blessed);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'variables' => (is => 'ro', isa => ArrayRef[Str], required => 1);
has 'ascending' => (is => 'ro', isa => HashRef[Bool], required => 1);
sub plan_as_string {
my $self = shift;
my @vars = @{ $self->variables };
my $ascending = $self->ascending;
my @strings = map { sprintf('%s(?%s)', ($ascending->{$_} ? 'ASC' : 'DESC'), $_) } @vars;
return sprintf('Order { %s }', join(', ', @strings));
}
sub sort_rows {
my $self = shift;
my $vars = shift;
my $ascending = shift;
my $rows = shift;
local($Attean::API::Binding::ALLOW_IRI_COMPARISON) = 1;
my @sorted = map { $_->[0] } sort {
my ($ar, $avalues) = @$a;
my ($br, $bvalues) = @$b;
my $c = 0;
foreach my $i (0 .. $#{ $vars }) {
my $ascending = $ascending->{ $vars->[$i] };
my ($av, $bv) = map { $_->[$i] } ($avalues, $bvalues);
# Mirrors code in Attean::SimpleQueryEvaluator->evaluate
if (blessed($av) and $av->does('Attean::API::Binding') and (not(defined($bv)) or not($bv->does('Attean::API::Binding')))) {
$c = 1;
} elsif (blessed($bv) and $bv->does('Attean::API::Binding') and (not(defined($av)) or not($av->does('Attean::API::Binding')))) {
$c = -1;
} else {
$c = eval { $av ? $av->compare($bv) : 1 };
if ($@) {
$c = 1;
}
}
$c *= -1 unless ($ascending);
last unless ($c == 0);
}
$c
} map {
my $r = $_;
[$r, [map { $r->value($_) } @$vars]]
} @$rows;
return @sorted;
}
sub impl {
my $self = shift;
my $model = shift;
my $vars = $self->variables;
my $ascending = $self->ascending;
my ($impl) = map { $_->impl($model) } @{ $self->children };
my $iter_variables = $self->in_scope_variables;
return sub {
my $iter = $impl->();
my @rows = $iter->elements;
my @sorted = $self->sort_rows($vars, $ascending, \@rows);
return Attean::ListIterator->new(
values => \@sorted,
variables => $iter_variables,
item_type => $iter->item_type
);
}
}
}
=item * L
Evaluates a SPARQL query against a remote endpoint.
=cut
package Attean::Plan::Service 0.033 {
use Moo;
use Types::Standard qw(ConsumerOf Bool Str InstanceOf);
use Encode qw(encode);
use Scalar::Util qw(blessed);
use URI::Escape;
use Attean::SPARQLClient;
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
has 'endpoint' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariable'], required => 1);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'sparql' => (is => 'ro', isa => Str, required => 1);
has 'user_agent' => (is => 'rw', isa => InstanceOf['LWP::UserAgent']);
has 'request_signer' => (is => 'rw');
sub plan_as_string {
my $self = shift;
my $sparql = $self->sparql;
$sparql =~ s/\s+/ /g;
return sprintf('Service <%s> %s', $self->endpoint->as_string, $sparql);
}
sub tree_attributes { return qw(endpoint) };
sub impl {
my $self = shift;
my $model = shift;
my $endpoint = $self->endpoint->value;
my $sparql = $self->sparql;
my $silent = $self->silent;
my %args = (
endpoint => $endpoint,
silent => $silent,
request_signer => $self->request_signer,
);
$args{user_agent} = $self->user_agent if ($self->user_agent);
my $client = Attean::SPARQLClient->new(%args);
return sub {
return $client->query($sparql);
};
}
}
=item * L
Returns a constant set of results.
=cut
package Attean::Plan::Table 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
has variables => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Variable']]);
has rows => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Result']]);
sub tree_attributes { return qw(variables rows) };
sub plan_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x ($level + 1);
my $vars = join(', ', map { "?$_" } @{ $self->in_scope_variables });
my $s = "Table (" . $vars . ")";
foreach my $row (@{ $self->rows }) {
$s .= "\n-${indent} " . $row->as_string;
}
return $s;
}
sub BUILDARGS {
my $class = shift;
my %args = @_;
my @vars = map { $_->value } @{ $args{variables} };
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = \@vars;
return $class->SUPER::BUILDARGS(%args);
}
sub impl {
my $self = shift;
my $model = shift;
my $rows = $self->rows;
my $iter_variables = $self->in_scope_variables;
return sub {
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => $rows
);
};
}
}
=item * L
Returns a constant set of results.
Be aware that if the iterator being wrapped is not repeatable (consuming the
L role), then this plan may only be evaluated
once.
A size estimate may be given if it is available. If the iterator is an
L, the size of that iterator will be used.
=cut
package Attean::Plan::Iterator 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf Int);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
has iterator => (is => 'ro', isa => ConsumerOf['Attean::API::ResultIterator']);
has size_estimate => (is => 'lazy', isa => Int, predicate => 1);
sub _build_size_estimate {
my $self = shift;
my $iter = $self->iterator;
if ($iter->isa('Attean::ListIterator')) {
return $iter->size;
}
}
sub tree_attributes { return qw(iterator) };
sub plan_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x ($level + 1);
my $string = 'Iterator (';
$string .= join(', ', map { "?$_" } @{ $self->in_scope_variables });
if ($self->has_size_estimate) {
$string .= ' with ' . $self->size_estimate . ' elements';
}
$string .= ')';
return $string;
}
sub BUILDARGS {
my $class = shift;
my %args = @_;
my $vars = $args{iterator}->variables;
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = $vars;
return $class->SUPER::BUILDARGS(%args);
}
sub impl {
my $self = shift;
my $model = shift;
my $iter = $self->iterator;
return sub {
if ($iter->does('Attean::API::RepeatableIterator')) {
$iter->reset;
}
return $iter;
};
}
}
=item * L
=cut
package Attean::Plan::ALPPath 0.033 {
use Moo;
use Attean::TreeRewriter;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
has 'subject' => (is => 'ro', required => 1);
has 'object' => (is => 'ro', required => 1);
has 'graph' => (is => 'ro', required => 1);
has 'step_begin' => (is => 'ro', required => 1);
has 'step_end' => (is => 'ro', required => 1);
has 'skip' => (is => 'ro', required => 1, default => 0);
# has 'children' => (is => 'ro', isa => ConsumerOf['Attean::API::BindingSubstitutionPlan'], required => 1);
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::NullaryQueryTree';
sub tree_attributes { return qw(subject object graph) };
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
sub plan_as_string {
my $self = shift;
my @strings;
push(@strings, sprintf('%s ↠%s', map { $_->ntriples_string } ($self->subject, $self->step_begin)));
push(@strings, sprintf('%s ↠%s', map { $_->ntriples_string } ($self->object, $self->step_end)));
return sprintf('ALPPath %s', join(', ', @strings));
}
sub BUILDARGS {
my $class = shift;
my %args = @_;
my @vars = map { $_->value } grep { $_->does('Attean::API::Variable') } (@args{qw(subject object)});
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = \@vars;
return $class->SUPER::BUILDARGS(%args);
}
sub alp {
my $model = shift;
my $graph = shift;
my $skip = shift;
my $x = shift;
my $path = shift;
my $v = shift;
my $start = shift;
my $end = shift;
my $bind = shift;
if (exists $v->{$x->as_string}) {
return;
}
my $binding = Attean::Result->new( bindings => { $start => $x } )->join($bind);
unless ($binding) {
return;
}
if ($skip) {
$skip--;
} else {
$v->{$x->as_string} = $x;
}
my $impl = $path->substitute_impl($model, $binding);
my $iter = $impl->();
while (my $row = $iter->next()) {
my $n = $row->value($end);
alp($model, $graph, $skip, $n, $path, $v, $start, $end, $bind);
}
}
sub substitute_impl {
my $self = shift;
my $model = shift;
my $bind = shift;
my $path = $self->children->[0];
my $subject = $self->subject;
my $object = $self->object;
my $graph = $self->graph;
my $start = $self->step_begin->value;
my $end = $self->step_end->value;
my $skip = $self->skip;
my $iter_variables = $self->in_scope_variables;
for ($subject, $object) {
if ($_->does('Attean::API::Variable')) {
my $name = $_->value;
if (my $node = $bind->value($name)) {
$_ = $node;
}
}
}
my $s_var = $subject->does('Attean::API::Variable');
my $o_var = $object->does('Attean::API::Variable');
if ($s_var and $o_var) {
return sub {
my $nodes = $model->graph_nodes($graph);
my @rows;
while (my $n = $nodes->next) {
my %seen;
alp($model, $graph, $skip, $n, $path, \%seen, $start, $end, $bind);
foreach my $term (values %seen) {
my $b = Attean::Result->new( bindings => {
$subject->value => $n,
$object->value => $term,
} );
push(@rows, $b);
}
}
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => \@rows,
);
};
} elsif ($o_var) {
return sub {
my %seen;
alp($model, $graph, $skip, $subject, $path, \%seen, $start, $end, $bind);
my @rows = map { Attean::Result->new( bindings => { $object->value => $_ } ) } (values %seen);
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => \@rows,
);
};
} elsif ($s_var) {
die "ALP for FB should never occur in a plan (should be inversed during planning)";
} else {
return sub {
my %seen;
alp($model, $graph, $skip, $subject, $path, \%seen, $start, $end, $bind);
if (exists $seen{ $object->as_string }) {
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => [Attean::Result->new()]
);
} else {
return Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
values => []
);
}
};
}
}
}
package Attean::Plan::ZeroOrOnePath 0.033 {
use Moo;
use Attean::TreeRewriter;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
has 'subject' => (is => 'ro', required => 1);
has 'object' => (is => 'ro', required => 1);
has 'graph' => (is => 'ro', required => 1);
with 'Attean::API::BindingSubstitutionPlan', 'Attean::API::NullaryQueryTree';
sub BUILDARGS {
my $class = shift;
my %args = @_;
my @vars = map { $_->value } grep { $_->does('Attean::API::Variable') } (@args{qw(subject object)});
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = \@vars;
return $class->SUPER::BUILDARGS(%args);
}
sub tree_attributes { return qw(subject object) };
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
sub plan_as_string { return 'ZeroOrOnePath' }
sub substitute_impl {
my $self = shift;
my $model = shift;
my $bind = shift;
my ($impl) = map { $_->substitute_impl($model, $bind) } @{ $self->children };
my $iter_variables = $self->in_scope_variables;
my $subject = $self->subject;
my $object = $self->object;
my $graph = $self->graph;
for ($subject, $object) {
if ($_->does('Attean::API::Variable')) {
my $name = $_->value;
if (my $node = $bind->value($name)) {
$_ = $node;
}
}
}
my $s_var = $subject->does('Attean::API::Variable');
my $o_var = $object->does('Attean::API::Variable');
return sub {
my @extra;
if ($s_var and $o_var) {
my $nodes = $model->graph_nodes($graph);
while (my $n = $nodes->next) {
push(@extra, Attean::Result->new( bindings => { map { $_->value => $n } ($subject, $object) } ));
}
} elsif ($s_var) {
push(@extra, Attean::Result->new( bindings => { $subject->value => $object } ));
} elsif ($o_var) {
push(@extra, Attean::Result->new( bindings => { $object->value => $subject } ));
} else {
if (0 == $subject->compare($object)) {
push(@extra, Attean::Result->new( bindings => {} ));
}
}
my $iter = $impl->();
my %seen;
return Attean::CodeIterator->new(
item_type => 'Attean::API::Result',
variables => $iter_variables,
generator => sub {
while (scalar(@extra)) {
my $r = shift(@extra);
unless ($seen{$r->as_string}++) {
return $r;
}
}
while (my $r = $iter->next()) {
return unless ($r);
if ($seen{$r->as_string}++) {
next;
}
return $r;
}
}
);
};
}
}
=item * L
Returns an iterator containing a single boolean term indicating whether any
results were produced by evaluating the sub-plan.
=cut
package Attean::Plan::Exists 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has variables => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Variable']]);
has rows => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Result']]);
sub tree_attributes { return qw(variables rows) };
sub plan_as_string { return 'Exists' }
sub impl {
my $self = shift;
my $model = shift;
my ($impl) = map { $_->impl($model) } @{ $self->children };
return sub {
my $iter = $impl->();
my $term = ($iter->next) ? Attean::Literal->true : Attean::Literal->false;
return Attean::ListIterator->new(values => [$term], item_type => 'Attean::API::Term');
}
}
}
=item * L
=cut
package Attean::Plan::Aggregate 0.033 {
use Moo;
use Encode;
use UUID::Tiny ':std';
use URI::Escape;
use I18N::LangTags;
use POSIX qw(ceil floor);
use Digest::SHA;
use Digest::MD5 qw(md5_hex);
use Scalar::Util qw(blessed);
use List::MoreUtils qw(uniq);
use Types::Standard qw(ConsumerOf InstanceOf HashRef ArrayRef);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
has 'aggregates' => (is => 'ro', isa => HashRef[ConsumerOf['Attean::API::Expression']], required => 1);
has 'groups' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Expression']], required => 1);
sub plan_as_string {
my $self = shift;
my @astrings = map { sprintf('?%s ↠%s', $_, $self->aggregates->{$_}->as_string) } keys %{ $self->aggregates };
my @gstrings = map { sprintf('%s', $_->as_string) } @{ $self->groups };
return sprintf('Aggregate { %s } Groups { %s }', join(', ', @astrings), join(', ', @gstrings));
}
sub tree_attributes { return qw(aggregates groups) };
sub BUILDARGS {
my $class = shift;
my %args = @_;
my $aggs = $args{ aggregates };
my @vars = map { $_->value } grep { $_->does('Attean::API::Variable') } map { $_->value } @{ $args{groups} // [] };
my @evars = (@vars, keys %$aggs);
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = [@evars];
return $class->SUPER::BUILDARGS(%args);
}
sub evaluate_aggregate {
my $self = shift;
my $model = shift;
my $expr = shift;
my $rows = shift;
my $op = $expr->operator;
my ($e) = @{ $expr->children };
# my @children = map { Attean::Plan::Extend->evaluate_expression($model, $_, $r) } @{ $expr->children };
# warn "$op — " . join(' ', map { $_->as_string } @children);
if ($op eq 'COUNT') {
my $count = 0;
foreach my $r (@$rows) {
if ($e) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
if ($term) {
$count++;
}
} else {
# This is the special-case branch for COUNT(*)
$count++;
}
}
return Attean::Literal->new(value => $count, datatype => 'http://www.w3.org/2001/XMLSchema#integer');
} elsif ($op eq 'SUM') {
my @cmp;
my @terms;
foreach my $r (@$rows) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
if ($term->does('Attean::API::NumericLiteral')) {
push(@terms, $term);
}
}
my $lhs = shift(@terms);
while (my $rhs = shift(@terms)) {
my $type = $lhs->binary_promotion_type($rhs, '+');
my ($lv, $rv) = map { $_->numeric_value } ($lhs, $rhs);
$lhs = Attean::Literal->new(value => ($lv + $rv), datatype => $type);
}
return $lhs;
} elsif ($op eq 'AVG') {
my @cmp;
my $count = 0;
my $all_ints = 1;
my @terms;
foreach my $r (@$rows) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
die unless ($term->does('Attean::API::NumericLiteral'));
push(@terms, $term);
$count++;
}
my $lhs = shift(@terms);
while (my $rhs = shift(@terms)) {
my $type = $lhs->binary_promotion_type($rhs, '+');
my ($lv, $rv) = map { $_->numeric_value } ($lhs, $rhs);
$lhs = Attean::Literal->new(value => ($lv + $rv), datatype => $type);
}
my $rhs = Attean::Literal->new(value => $count, datatype => 'http://www.w3.org/2001/XMLSchema#integer');
my ($lv, $rv) = map { $_->numeric_value } ($lhs, $rhs);
my $type = $lhs->binary_promotion_type($rhs, '/');
return Attean::Literal->new(value => ($lv / $rv), datatype => $type);
} elsif ($op eq 'SAMPLE') {
foreach my $r (@$rows) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
return $term if (blessed($term));
}
} elsif ($op =~ /^(MIN|MAX)$/) {
my @cmp;
foreach my $r (@$rows) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
push(@cmp, $term);
}
@cmp = sort { $a->compare($b) } @cmp;
return ($op eq 'MIN') ? shift(@cmp) : pop(@cmp);
} elsif ($op eq 'GROUP_CONCAT') {
my $sep = $expr->scalar_vars->{seperator} // ' ';
my @values;
foreach my $r (@$rows) {
my $term = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
push(@values, $term->value);
}
my $string = join($sep, @values);
return Attean::Literal->new(value => $string);
} elsif ($op eq 'CUSTOM') {
my $iri = $expr->custom_iri;
my $data = Attean->get_global_aggregate($iri);
unless ($data) {
die "No extension aggregate registered for <$iri>";
}
my $start = $data->{'start'};
my $process = $data->{'process'};
my $finalize = $data->{'finalize'};
my $thunk = $start->();
foreach my $r (@$rows) {
my $t = Attean::Plan::Extend->evaluate_expression($model, $e, $r);
$process->($thunk, $t);
}
return $finalize->($thunk);
}
die "$op not implemented";
}
sub impl {
my $self = shift;
my $model = shift;
my %aggs = %{ $self->aggregates };
my @groups = @{ $self->groups };
my $iter_variables = $self->in_scope_variables;
my $group_template_generator = sub {
my $r = shift;
my %components;
foreach my $g (@groups) {
if ($g->isa('Attean::ValueExpression')) {
my $value = $g->value;
if ($value->isa('Attean::Variable')) {
my $var = $value->value;
my $value = eval { Attean::Plan::Extend->evaluate_expression($model, $g, $r) };
if (blessed($value)) {
$components{$var} = $value;
}
}
}
}
return %components;
};
my $group_key_generator = sub {
my $r = shift;
my @components;
foreach my $g (@groups) {
my $value = eval { Attean::Plan::Extend->evaluate_expression($model, $g, $r) };
my $key = blessed($value) ? $value->as_string : '';
push(@components, $key);
}
my $group = join('|', @components);
return $group;
};
my $rank;
while (my($var, $agg) = each(%aggs)) {
if ($agg->operator eq 'RANK') {
$rank = $var;
}
}
my ($impl) = map { $_->impl($model) } @{ $self->children };
my %row_groups;
my %group_templates;
return sub {
my $iter = $impl->();
while (my $r = $iter->next) {
my $group_key = $group_key_generator->($r);
push(@{ $row_groups{ $group_key } }, $r);
unless (exists $group_templates{ $group_key }) {
$group_templates{ $group_key } = { $group_template_generator->($r) };
}
}
my @group_keys = keys %row_groups;
# SPARQL evaluation of aggregates over an empty input sequence should
# result in an empty result
my @results;
if (scalar(@group_keys) == 0 and scalar(@groups) == 0) {
push(@group_keys, '');
$row_groups{''} = [];
$group_templates{''} = {};
}
foreach my $group (@group_keys) {
my %row = %{ $group_templates{ $group } };
my $rows = $row_groups{$group};
if (defined $rank) {
my $agg = $aggs{$rank};
my $ascending = $agg->scalar_vars->{ascending} // {};
my $vars = [map { $_->value->value } @{ $agg->children }];
# TODO: support ordering by complex expressions in $vars, not just ValueExpressions with variables
my @sorted = Attean::Plan::OrderBy->sort_rows($vars, $ascending, $rows);
my $ord = 0;
foreach my $row (@sorted) {
my %b = %{ $row->bindings };
$b{ $rank } = Attean::Literal->integer($ord++);
my $r = Attean::Result->new( bindings => \%b );
push(@results, $r);
}
} else {
foreach my $var (keys %aggs) {
my $expr = $aggs{$var};
my $value = eval { $self->evaluate_aggregate($model, $expr, $rows) };
if ($value) {
$row{$var} = $value;
}
}
my $result = Attean::Result->new( bindings => \%row );
push(@results, $result);
}
}
return Attean::ListIterator->new(
values => \@results,
variables => $iter_variables,
item_type => 'Attean::API::Result'
);
};
}
}
package Attean::Plan::Sequence 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(ConsumerOf ArrayRef);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::QueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
sub plan_as_string { return 'Sequence'; }
sub impl {
my $self = shift;
my $model = shift;
my @children = map { $_->impl($model) } @{ $self->children };
return sub {
foreach my $child (@children) {
my $iter = $child->();
$iter->elements;
}
return Attean::ListIterator->new(values => [Attean::Literal->true], item_type => 'Attean::API::Term');
};
}
}
package Attean::Plan::Clear 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(ConsumerOf ArrayRef);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::NullaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'graphs' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Term']]);
sub plan_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x (1+$level);
my $s = sprintf("Clear { %d graphs }", scalar(@{ $self->graphs }));
foreach my $g (@{ $self->graphs }) {
my $name = $g->as_sparql;
chomp($name);
$s .= "\n-${indent} $name";
}
return $s;
}
sub impl {
my $self = shift;
my $model = shift;
my $graphs = $self->graphs;
return sub {
foreach my $g (@$graphs) {
$model->clear_graph($g);
}
return Attean::ListIterator->new(values => [Attean::Literal->true], item_type => 'Attean::API::Term');
};
}
}
package Attean::Plan::Drop 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(ConsumerOf ArrayRef);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::NullaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'graphs' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Term']]);
sub plan_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x (1+$level);
my $s = sprintf("Drop { %d graphs }", scalar(@{ $self->graphs }));
foreach my $g (@{ $self->graphs }) {
$s .= "\n-${indent} " . $g->as_sparql;
}
return $s;
}
sub impl {
my $self = shift;
my $model = shift;
my $graphs = $self->graphs;
return sub {
foreach my $g (@$graphs) {
$model->drop_graph($g);
}
return Attean::ListIterator->new(values => [Attean::Literal->true], item_type => 'Attean::API::Term');
};
}
}
package Attean::Plan::TripleTemplateToModelQuadMethod 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(ConsumerOf Str ArrayRef HashRef);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::UnaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'order' => (is => 'ro', isa => ArrayRef[Str], required => 1);
has 'patterns' => (is => 'ro', isa => HashRef[ArrayRef[ConsumerOf['Attean::API::TripleOrQuadPattern']]], required => 1);
has 'graph' => (is => 'ro', isa => ConsumerOf['Attean::API::Term']);
sub plan_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x (1+$level);
my $s = sprintf("Template-to-Model { Default graph: %s }", $self->graph->as_string);
foreach my $method (@{ $self->order }) {
my $pattern = $self->patterns->{ $method };
$s .= "\n-${indent} Method: ${method}";
foreach my $p (@$pattern) {
$s .= "\n-${indent} " . $p->as_string;
}
}
return $s;
}
sub impl {
my $self = shift;
my $model = shift;
my $child = $self->children->[0]->impl($model);
my $graph = $self->graph;
my @order = @{ $self->order };
my $method = shift(@order);
my $pattern = $self->patterns->{ $method };
return sub {
my $iter = $child->();
my @results;
while (my $t = $iter->next) {
if (scalar(@order)) {
push(@results, $t);
}
foreach my $p (@$pattern) {
my $q = $p->apply_bindings($t);
my $quad = $q->does('Attean::API::QuadPattern') ? $q : $q->as_quad_pattern($graph);
if ($quad->is_ground) {
# warn "# $method: " . $quad->as_string . "\n";
$model->$method($quad->as_quad);
} else {
# warn "not ground: " . $quad->as_string;
}
}
}
foreach my $method (@order) {
my $pattern = $self->patterns->{ $method };
foreach my $t (@results) {
foreach my $p (@$pattern) {
my $q = $p->apply_bindings($t);
my $quad = $q->does('Attean::API::QuadPattern') ? $q : $q->as_quad_pattern($graph);
if ($quad->is_ground) {
# warn "# $method: " . $quad->as_string . "\n";
$model->$method($quad->as_quad);
} else {
# warn "not ground: " . $quad->as_string;
}
}
}
}
return Attean::ListIterator->new(values => [Attean::Literal->integer($model->size)], item_type => 'Attean::API::Term');
};
}
}
package Attean::Plan::Load 0.033 {
use Moo;
use Encode;
use LWP::UserAgent;
use Scalar::Util qw(blessed);
use Types::Standard qw(Bool Str);
use namespace::clean;
with 'Attean::API::Plan', 'Attean::API::NullaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'url' => (is => 'ro', isa => Str);
sub plan_as_string {
my $self = shift;
return sprintf("Load { %s }", $self->url);
}
sub impl {
my $self = shift;
my $url = $self->url;
my $ua = LWP::UserAgent->new();
my $silent = $self->silent;
my $accept = Attean->acceptable_parsers( handles => 'Attean::API::Triple' );
$ua->default_headers->push_header( 'Accept' => $accept );
return sub {
my $resp = $ua->get( $url );
if ($resp->is_success) {
my $ct = $resp->header('Content-Type');
if (my $pclass = Attean->get_parser( media_type => $ct )) {
my $p = $pclass->new();
my $str = $resp->decoded_content;
my $bytes = encode('UTF-8', $str, Encode::FB_CROAK);
my $iter = $p->parse_iter_from_bytes( $bytes );
return $iter;
}
}
if ($silent) {
return Attean::ListIterator->new(values => [], item_type => 'Attean::API::Triple');
} else {
die "Failed to load url: " . $resp->status_line;
}
};
}
}
# Create(iri)
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/IDPQueryPlanner.pm 000644 000765 000024 00000000225 14316376572 022312 x ustar 00greg staff 000000 000000 30 mtime=1664744826.765950754
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/IDPQueryPlanner.pm 000644 000765 000024 00000002373 14316376572 020347 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::IDPQueryPlanner - Iterative dynamic programming query planner
=head1 VERSION
This document describes Attean::IDPQueryPlanner version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $planner = Attean::IDPQueryPlanner->new();
my $default_graphs = [ Attean::IRI->new('http://example.org/') ];
my $plan = $planner->plan_for_algebra( $algebra, $model, $default_graphs );
my $iter = $plan->evaluate($model);
my $iter = $e->evaluate( $model );
=head1 DESCRIPTION
The Attean::IDPQueryPlanner class implements a query planner using the
iterative dynamic programming approach.
=head1 ATTRIBUTES
=over 4
=back
=head1 METHODS
=over 4
=cut
package Attean::IDPQueryPlanner 0.033 {
use Moo;
use namespace::clean;
extends 'Attean::QueryPlanner';
with 'Attean::API::IDPJoinPlanner';
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/QuadModel.pm 000644 000765 000024 00000000225 14316376573 021204 x ustar 00greg staff 000000 000000 30 mtime=1664744827.185606108
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/QuadModel.pm 000644 000765 000024 00000007061 14316376573 017240 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::QuadModel - RDF model backed by a quad-store
=head1 VERSION
This document describes Attean::QuadModel version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $model = Attean::QuadModel->new( store => $store );
=head1 DESCRIPTION
The Attean::QuadModel class represents a model that is backed by a single
L object.
It conforms to the L role.
The Attean::QuadModel constructor requires one named argument:
=over 4
=item store
A L object representing the backing
quad-store.
=back
=head1 METHODS
=over 4
=cut
package Attean::QuadModel 0.033 {
use Moo;
use Scalar::Util qw(reftype);
use namespace::clean;
has 'store' => (
is => 'ro',
does => 'Attean::API::QuadStore',
required => 1,
handles => [qw(size count_quads count_quads_estimate get_graphs holds)],
);
=item C<< get_quads ( $subject, $predicate, $object, $graph ) >>
Returns an L for quads in the model that match the
supplied C<< $subject >>, C<< $predicate >>, C<< $object >>, and C<< $graph >>.
Any of these terms may be undefined or a L object, in
which case that term will be considered as a wildcard for the purposes of
matching.
The returned iterator conforms to both L and
L.
=cut
sub get_quads {
my $self = shift;
my @nodes = @_[0..3];
foreach my $i (0..3) {
my $t = $nodes[$i];
if (not(ref($t)) or reftype($t) ne 'ARRAY') {
$nodes[$i] = [$t];
}
}
my @iters;
foreach my $s (@{ $nodes[0] }) {
foreach my $p (@{ $nodes[1] }) {
foreach my $o (@{ $nodes[2] }) {
foreach my $g (@{ $nodes[3] }) {
push(@iters, $self->store->get_quads($s, $p, $o, $g));
}
}
}
}
if (scalar(@iters) == 0) {
return Attean::ListIterator->new(values => [], item_type => 'Attean::API::Quad');
} elsif (scalar(@iters) == 1) {
return shift(@iters);
} else {
return Attean::IteratorSequence->new( iterators => \@iters, item_type => $iters[0]->item_type );
}
}
=item C<< plans_for_algebra( $algebra, $model, $active_graphs, $default_graphs ) >>
Delegates to the underlying store if the store consumes Attean::API::CostPlanner.
=cut
sub plans_for_algebra {
my $self = shift;
if ($self->store->does('Attean::API::CostPlanner')) {
return $self->store->plans_for_algebra(@_);
}
return;
}
=item C<< cost_for_plan( $plan ) >>
Delegates to the underlying store if the store consumes Attean::API::CostPlanner.
=cut
sub cost_for_plan {
my $self = shift;
if ($self->store->does('Attean::API::CostPlanner')) {
return $self->store->cost_for_plan(@_);
}
return;
}
with 'Attean::API::Model';
with 'Attean::API::CostPlanner';
}
package Attean::MutableQuadModel 0.033 {
use Moo;
extends 'Attean::QuadModel';
has 'store' => (
is => 'ro',
does => 'Attean::API::MutableQuadStore',
required => 1,
handles => [qw(size count_quads count_quads_estimate add_quad remove_quad get_graphs create_graph drop_graph clear_graph add_iter)],
);
with 'Attean::API::MutableModel';
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/SimpleQueryEvaluator.pm 000644 000765 000024 00000000225 14316376573 023473 x ustar 00greg staff 000000 000000 30 mtime=1664744827.398708078
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/SimpleQueryEvaluator.pm 000644 000765 000024 00000127646 14316376573 021543 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::SimpleQueryEvaluator - Simple query evaluator
=head1 VERSION
This document describes Attean::SimpleQueryEvaluator version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $algebra = Attean->get_parser('SPARQL')->parse('SELECT * WHERE { ... }');
my $active_graph = Attean::IRI->new('http://example.org/');
my $e = Attean::SimpleQueryEvaluator->new( model => $model );
my $iter = $e->evaluate( $algebra, $active_graph );
=head1 DESCRIPTION
The Attean::SimpleQueryEvaluator class implements a simple query evaluator that,
given an L and a L
object, evaluates the query represented by the algebra using data from the
model, and returns a query result.
=head1 ATTRIBUTES
=over 4
=cut
use Attean::Algebra;
use Attean::Expression;
package Attean::SimpleQueryEvaluator 0.033 {
use Moo;
use Encode qw(encode);
use Attean::RDF;
use LWP::UserAgent;
use Scalar::Util qw(blessed);
use List::Util qw(all any reduce);
use Types::Standard qw(ConsumerOf InstanceOf Bool Object);
use URI::Escape;
use Attean::SPARQLClient;
use namespace::clean;
=item C<< model >>
The L object used for query evaluation.
=cut
has 'model' => (is => 'ro', isa => ConsumerOf['Attean::API::Model'], required => 1);
=item C<< default_graph >>
The L object representing the default graph in the C<< model >>.
The default graph will be excluded from enumeration of graph names for query
features such as C<< GRAPH ?g {} >>.
=cut
has 'default_graph' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI'], required => 1);
has 'user_agent' => (is => 'rw', isa => InstanceOf['LWP::UserAgent'], default => sub { my $ua = LWP::UserAgent->new(); $ua->agent("Attean/$Attean::VERSION " . $ua->_agent); $ua });
=item C<< request_signer >>
If set, used to modify HTTP::Request objects used in evaluating SERVICE calls
before the request is made. This may be used to, for example, add cryptographic
signature headers to the request. The modification is performed by calling
C<< $request_signer->sign( $request ) >>.
=cut
has 'request_signer' => (is => 'rw', isa => Object);
has 'ground_blanks' => (is => 'rw', isa => Bool, default => 0);
=back
=head1 METHODS
=over 4
=item C<< evaluate( $algebra, $active_graph ) >>
Returns an L object with results produced by evaluating
the query C<< $algebra >> against the evaluator's C<< model >>, using the
supplied C<< $active_graph >>.
=cut
sub evaluate {
my $self = shift;
my $algebra = shift;
my $active_graph = shift || Carp::confess "No active-graph passed to Attean::SimpleQueryEvaluator->evaluate";
Carp::confess "No algebra passed for evaluation" unless ($algebra);
my $expr_eval = Attean::SimpleQueryEvaluator::ExpressionEvaluator->new( evaluator => $self );
my @children = @{ $algebra->children };
my ($child) = $children[0];
if ($algebra->isa('Attean::Algebra::Query') or $algebra->isa('Attean::Algebra::Update')) {
return $self->evaluate($algebra->child, $active_graph, @_);
} elsif ($algebra->isa('Attean::Algebra::BGP')) {
my @triples = @{ $algebra->triples };
if (scalar(@triples) == 0) {
my $b = Attean::Result->new( bindings => {} );
return Attean::ListIterator->new(variables => [], values => [$b], item_type => 'Attean::API::Result');
} else {
my @iters;
my @new_vars;
my %blanks;
foreach my $t (@triples) {
push(@iters, $self->evaluate_pattern($t, $active_graph, \@new_vars, \%blanks));
}
while (scalar(@iters) > 1) {
my ($lhs, $rhs) = splice(@iters, 0, 2);
unshift(@iters, $lhs->join($rhs));
}
return shift(@iters)->map(sub { shift->project_complement(@new_vars) });
}
} elsif ($algebra->isa('Attean::Algebra::Distinct') or $algebra->isa('Attean::Algebra::Reduced')) {
my %seen;
my $iter = $self->evaluate( $child, $active_graph );
return $iter->grep(sub {
my $r = shift;
my $str = $r->as_string;
my $ok = not($seen{ $str }) ? 1 : 0;
$seen{ $str }++;
return $ok;
});
} elsif ($algebra->isa('Attean::Algebra::Extend')) {
my $child = $algebra;
my @extends;
my %extends;
while ($child->isa('Attean::Algebra::Extend')) {
my $expr = $child->expression;
my $var = $child->variable->value;
$extends{ $var } = $expr;
unshift(@extends, $var);
($child) = @{ $child->children };
}
return $self->evaluate( $child, $active_graph )->map(sub {
my $r = shift;
my %extension;
my %row_cache;
foreach my $var (@extends) {
my $expr = $extends{ $var };
my $val = $expr_eval->evaluate_expression( $expr, $r, $active_graph, \%row_cache );
if ($val->does('Attean::API::Binding')) {
# patterns need to be made ground to be bound as values (e.g. TriplePattern -> Triple)
$val = $val->ground($r);
}
# warn "Extend error: $@" if ($@);
$r = Attean::Result->new( bindings => { $var => $val } )->join($r) if ($val);
}
return $r;
});
} elsif ($algebra->isa('Attean::Algebra::Filter')) {
# TODO: Merge adjacent filter evaluation so that they can share a row_cache hash (as is done for Extend above)
my $expr = $algebra->expression;
my $iter = $self->evaluate( $child, $active_graph );
return $iter->grep(sub {
my $t = $expr_eval->evaluate_expression( $expr, shift, $active_graph, {} );
# if ($@) { warn "Filter evaluation: $@\n" };
return ($t ? $t->ebv : 0);
});
} elsif ($algebra->isa('Attean::Algebra::OrderBy')) {
local($Attean::API::Binding::ALLOW_IRI_COMPARISON) = 1;
my $iter = $self->evaluate( $child, $active_graph );
my @rows = $iter->elements;
my @cmps = @{ $algebra->comparators };
my @exprs = map { $_->expression } @cmps;
my @dirs = map { $_->ascending } @cmps;
my @sorted = map { $_->[0] } sort {
my ($ar, $avalues) = @$a;
my ($br, $bvalues) = @$b;
my $c = 0;
foreach my $i (0 .. $#cmps) {
my ($av, $bv) = map { $_->[$i] } ($avalues, $bvalues);
# Mirrors code in Attean::Plan::OrderBy->sort_rows
if (blessed($av) and $av->does('Attean::API::Binding') and (not(defined($bv)) or not($bv->does('Attean::API::Binding')))) {
$c = 1;
} elsif (blessed($bv) and $bv->does('Attean::API::Binding') and (not(defined($av)) or not($av->does('Attean::API::Binding')))) {
$c = -1;
} else {
$c = eval { $av ? $av->compare($bv) : 1 };
if ($@) {
$c = 1;
}
}
$c *= -1 if ($dirs[$i] == 0);
last unless ($c == 0);
}
$c
} map { my $r = $_; [$r, [map { $expr_eval->evaluate_expression( $_, $r, $active_graph, {} ) } @exprs]] } @rows;
return Attean::ListIterator->new( values => \@sorted, item_type => $iter->item_type, variables => $iter->variables);
} elsif ($algebra->isa('Attean::Algebra::Service')) {
my $endpoint = $algebra->endpoint->value;
my ($pattern) = @{ $algebra->children };
my $sparql = Attean::Algebra::Project->new( variables => [ map { variable($_) } $pattern->in_scope_variables ], children => [ $pattern ] )->as_sparql;
my $silent = $algebra->silent;
my $client = Attean::SPARQLClient->new(
endpoint => $endpoint,
silent => $silent,
user_agent => $self->user_agent,
request_signer => $self->request_signer,
);
return $client->query($sparql);
} elsif ($algebra->isa('Attean::Algebra::Graph')) {
my $graph = $algebra->graph;
return $self->evaluate($child, $graph) if ($graph->does('Attean::API::Term'));
my @iters;
my $graphs = $self->model->get_graphs();
my %vars;
while (my $g = $graphs->next) {
next if ($g->value eq $self->default_graph->value);
my $gr = Attean::Result->new( bindings => { $graph->value => $g } );
my $iter = $self->evaluate($child, $g)->map(sub { if (my $result = shift->join($gr)) { return $result } else { return } });
foreach my $v (@{ $iter->variables }) {
$vars{$v}++;
}
push(@iters, $iter);
}
return Attean::IteratorSequence->new( variables => [keys %vars], iterators => \@iters, item_type => 'Attean::API::Result' );
} elsif ($algebra->isa('Attean::Algebra::Group')) {
my @groupby = @{ $algebra->groupby };
my $iter = $self->evaluate($child, $active_graph);
my %groups;
while (my $r = $iter->next) {
my %vars;
my %row_cache;
my @group_terms = map { $expr_eval->evaluate_expression( $_, $r, $active_graph, \%row_cache ) } @groupby;
my $key = join(' ', map { blessed($_) ? $_->as_string : '' } @group_terms);
my %group_bindings;
foreach my $i (0 .. $#group_terms) {
my $v = $groupby[$i];
if (blessed($v) and $v->isa('Attean::ValueExpression') and $v->value->does('Attean::API::Variable') and $group_terms[$i]) {
$group_bindings{$v->value->value} = $group_terms[$i];
}
}
$groups{$key} = [Attean::Result->new( bindings => \%group_bindings ), []] unless (exists($groups{$key}));
push(@{ $groups{$key}[1] }, $r);
}
my @keys = keys %groups;
$groups{''} = [Attean::Result->new( bindings => {} ), []] if (scalar(@keys) == 0);
my $aggs = $algebra->aggregates;
my @results;
my %vars;
foreach my $key (keys %groups) {
my %row_cache;
my ($binding, $rows) = @{ $groups{$key} };
my $count = scalar(@$rows);
my %bindings;
foreach my $i (0 .. $#{ $aggs }) {
my $name = $aggs->[$i]->variable->value;
my $term = $expr_eval->evaluate_expression( $aggs->[$i], $rows, $active_graph, {} );
# warn "AGGREGATE error: $@" if ($@);
$vars{$name}++;
$bindings{ $name } = $term if ($term);
}
push(@results, Attean::Result->new( bindings => \%bindings )->join($binding));
}
return Attean::ListIterator->new(variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
} elsif ($algebra->isa('Attean::Algebra::Join')) {
my ($lhs, $rhs) = map { $self->evaluate($_, $active_graph) } @children;
return $lhs->join($rhs);
} elsif ($algebra->isa('Attean::Algebra::LeftJoin')) {
my $expr = $algebra->expression;
my ($lhs_iter, $rhs_iter) = map { $self->evaluate($_, $active_graph) } @children;
my @rhs = $rhs_iter->elements;
my @results;
my %vars = map { $_ => 1 } (@{ $lhs_iter->variables }, @{ $rhs_iter->variables });
while (my $lhs = $lhs_iter->next) {
my $joined = 0;
foreach my $rhs (@rhs) {
if (my $j = $lhs->join($rhs)) {
if ($expr_eval->evaluate_expression( $expr, $j, $active_graph, {} )->ebv) {
$joined++;
push(@results, $j);
}
}
}
push(@results, $lhs) unless ($joined);
}
return Attean::ListIterator->new( variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
} elsif ($algebra->isa('Attean::Algebra::Minus')) {
my ($lhsi, $rhs) = map { $self->evaluate($_, $active_graph) } @children;
my @rhs = $rhs->elements;
my @results;
while (my $lhs = $lhsi->next) {
my @compatible;
my @disjoint;
RHS: foreach my $rhs (@rhs) {
if (my $j = $lhs->join($rhs)) {
push(@compatible, 1);
} else {
push(@compatible, 0);
}
my $intersects = 0;
my %lhs_dom = map { $_ => 1 } $lhs->variables;
foreach my $rvar ($rhs->variables) {
if (exists $lhs_dom{$rvar}) {
$intersects = 1;
}
}
push(@disjoint, not($intersects));
}
my $count = scalar(@rhs);
my $keep = 1;
foreach my $i (0 .. $#rhs) {
$keep = 0 unless ($compatible[$i] == 0 or $disjoint[$i] == 1);
}
push(@results, $lhs) if ($keep);
}
return Attean::ListIterator->new( variables => $lhsi->variables, values => \@results, item_type => 'Attean::API::Result');
} elsif ($algebra->isa('Attean::Algebra::Path')) {
my $s = $algebra->subject;
my $path = $algebra->path;
my $o = $algebra->object;
my @children = @{ $path->children };
my ($child) = $children[0];
return $self->model->get_bindings( $s, $path->predicate, $o, $active_graph ) if ($path->isa('Attean::Algebra::PredicatePath'));
if ($path->isa('Attean::Algebra::InversePath')) {
my $path = Attean::Algebra::Path->new( subject => $o, path => $child, object => $s );
return $self->evaluate( $path, $active_graph );
} elsif ($path->isa('Attean::Algebra::AlternativePath')) {
my @children = @{ $path->children };
my @algebras = map { Attean::Algebra::Path->new( subject => $s, path => $_, object => $o ) } @children;
my @iters = map { $self->evaluate($_, $active_graph) } @algebras;
return Attean::IteratorSequence->new( iterators => \@iters, item_type => $iters[0]->item_type, variables => [$algebra->in_scope_variables] );
} elsif ($path->isa('Attean::Algebra::NegatedPropertySet')) {
my $preds = $path->predicates;
my %preds = map { $_->value => 1 } @$preds;
my $filter = $self->model->get_quads($s, undef, $o, $active_graph)->grep(sub {
my $q = shift;
my $p = $q->predicate;
return not exists $preds{ $p->value };
});
my %vars;
$vars{subject} = $s->value if ($s->does('Attean::API::Variable'));
$vars{object} = $o->value if ($o->does('Attean::API::Variable'));
return $filter->map(sub {
my $q = shift;
return unless $q;
my %bindings = map { $vars{$_} => $q->$_() } (keys %vars);
return Attean::Result->new( bindings => \%bindings );
}, 'Attean::API::Result', variables => [values %vars]);
} elsif ($path->isa('Attean::Algebra::SequencePath')) {
if (scalar(@children) == 1) {
my $path = Attean::Algebra::Path->new( subject => $s, path => $children[0], object => $o );
return $self->evaluate($path, $active_graph);
} else {
my @paths;
my $first = shift(@children);
my $join = Attean::Variable->new();
my @new_vars = ($join->value);
push(@paths, Attean::Algebra::Path->new( subject => $s, path => $first, object => $join ));
foreach my $i (0 .. $#children) {
my $newjoin = Attean::Variable->new();
my $obj = ($i == $#children) ? $o : $newjoin;
push(@new_vars, $newjoin->value);
push(@paths, Attean::Algebra::Path->new( subject => $join, path => $children[$i], object => $obj ));
$join = $newjoin;
}
while (scalar(@paths) > 1) {
my ($l, $r) = splice(@paths, 0, 2);
unshift(@paths, Attean::Algebra::Join->new( children => [$l, $r] ));
}
return $self->evaluate(shift(@paths), $active_graph)->map(sub { shift->project_complement(@new_vars) });
}
} elsif ($path->isa('Attean::Algebra::ZeroOrMorePath') or $path->isa('Attean::Algebra::OneOrMorePath')) {
if ($s->does('Attean::API::TermOrTriple') and $o->does('Attean::API::Variable')) {
my $v = {};
if ($path->isa('Attean::Algebra::ZeroOrMorePath')) {
$self->_ALP($active_graph, $s, $child, $v);
} else {
my $iter = $self->_eval($active_graph, $s, $child);
while (my $n = $iter->next) {
$self->_ALP($active_graph, $n, $child, $v);
}
}
my @results = map { Attean::Result->new( bindings => { $o->value => $_ } ) } (values %$v);
return Attean::ListIterator->new(variables => [$o->value], values => \@results, item_type => 'Attean::API::Result');
} elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::Variable')) {
my $nodes = $self->model->graph_nodes( $active_graph );
my @results;
while (my $t = $nodes->next) {
my $tr = Attean::Result->new( bindings => { $s->value => $t } );
my $p = Attean::Algebra::Path->new( subject => $t, path => $path, object => $o );
my $iter = $self->evaluate($p, $active_graph);
while (my $r = $iter->next) {
push(@results, $r->join($tr));
}
}
my %vars = map { $_ => 1 } ($s->value, $o->value);
return Attean::ListIterator->new(variables => [keys %vars], values => \@results, item_type => 'Attean::API::Result');
} elsif ($s->does('Attean::API::Variable') and $o->does('Attean::API::TermOrTriple')) {
my $pp = Attean::Algebra::InversePath->new( children => [$child] );
my $p = Attean::Algebra::Path->new( subject => $o, path => $pp, object => $s );
return $self->evaluate($p, $active_graph);
} else { # Term ZeroOrMorePath(path) Term
my $v = {};
$self->_ALP($active_graph, $s, $child, $v);
my @results;
foreach my $v (values %$v) {
return Attean::ListIterator->new(variables => [], values => [Attean::Result->new()], item_type => 'Attean::API::Result')
if ($v->equals($o));
}
return Attean::ListIterator->new(variables => [], values => [], item_type => 'Attean::API::Result');
}
} elsif ($path->isa('Attean::Algebra::ZeroOrOnePath')) {
my $path = Attean::Algebra::Path->new( subject => $s, path => $child, object => $o );
my @iters;
my %seen;
push(@iters, $self->evaluate( $path, $active_graph )->grep(sub { return not($seen{shift->as_string}++); }));
push(@iters, $self->_zeroLengthPath($s, $o, $active_graph));
my %vars;
foreach my $iter (@iters) {
$vars{$_}++ for (@{ $iter->variables });
}
return Attean::IteratorSequence->new( iterators => \@iters, item_type => 'Attean::API::Result', variables => [keys %vars] );
}
die "Unimplemented path type: $path";
} elsif ($algebra->isa('Attean::Algebra::Project')) {
my $iter = $self->evaluate( $child, $active_graph );
my @vars = map { $_->value } @{ $algebra->variables };
return $iter->map(sub {
my $r = shift;
my $b = { map { my $t = $r->value($_); $t ? ($_ => $t) : () } @vars };
return Attean::Result->new( bindings => $b );
}, undef, variables => \@vars); #->debug('Project result');
} elsif ($algebra->isa('Attean::Algebra::Slice')) {
my $iter = $self->evaluate( $child, $active_graph );
$iter = $iter->offset($algebra->offset) if ($algebra->offset > 0);
$iter = $iter->limit($algebra->limit) if ($algebra->limit >= 0);
return $iter;
} elsif ($algebra->isa('Attean::Algebra::Union')) {
my ($lhs, $rhs) = map { $self->evaluate($_, $active_graph) } @children;
return Attean::IteratorSequence->new(
iterators => [$lhs, $rhs],
item_type => 'Attean::API::Result',
variables => [$algebra->in_scope_variables]
);
} elsif ($algebra->isa('Attean::Algebra::Ask')) {
my $iter = $self->evaluate($child, $active_graph);
my $result = $iter->next;
return Attean::ListIterator->new(values => [$result ? Attean::Literal->true : Attean::Literal->false], item_type => 'Attean::API::Term');
} elsif ($algebra->isa('Attean::Algebra::Construct')) {
my $iter = $self->evaluate($child, $active_graph);
my $patterns = $algebra->triples;
use Data::Dumper;
my %seen;
return Attean::CodeIterator->new(
generator => sub {
my $r = $iter->next;
return unless ($r);
my %mapping = map { my $t = $r->value($_); $t ? ("?$_" => $t) : (); } ($r->variables);
my $mapper = Attean::TermMap->rewrite_map(\%mapping);
my @triples;
PATTERN: foreach my $p (@$patterns) {
my @terms = map {
($_->does('Attean::API::TriplePattern'))
? $_->as_triple
: $_
} $p->apply_map($mapper)->values;
unless (all { $_->does('Attean::API::TermOrTriple') } @terms) {
next PATTERN;
}
push(@triples, Attean::Triple->new(@terms));
}
return @triples;
},
item_type => 'Attean::API::Triple'
)->grep(sub { return not($seen{shift->as_string}++); });
} elsif ($algebra->isa('Attean::Algebra::Table')) {
my $vars = [map { $_->value } @{ $algebra->variables }];
return Attean::ListIterator->new(variables => $vars, values => $algebra->rows, item_type => 'Attean::API::Result');
}
die "Unimplemented algebra evaluation for: $algebra";
}
=item C<< evaluate_pattern( $pattern, $active_graph, \@new_vars, \%blanks ) >>
Returns an L object with results produced by evaluating
the triple- or quad-pattern C<< $pattern >> against the evaluator's
C<< model >>, using the supplied C<< $active_graph >>.
If the C<< ground_blanks >> option is false, replaces blank nodes in the
pattern with fresh variables before evaluation, and populates C<< %blanks >>
with pairs ($variable_name => $variable_node). Each new variable is also
appended to C<< @new_vars >> as it is created.
=cut
sub evaluate_pattern {
my $self = shift;
my $t = shift;
my $active_graph = shift || Carp::confess "No active-graph passed to Attean::SimpleQueryEvaluator->evaluate";
my $new_vars = shift;
my $blanks = shift;
my $q = $t->as_quad_pattern($active_graph);
my @values;
foreach my $v ($q->values) {
if (not($self->ground_blanks) and $v->does('Attean::API::Blank')) {
unless (exists $blanks->{$v->value}) {
$blanks->{$v->value} = Attean::Variable->new();
push(@$new_vars, $blanks->{$v->value}->value);
}
push(@values, $blanks->{$v->value});
} else {
push(@values, $v);
}
}
return $self->model->get_bindings( @values );
}
sub _ALP {
my $self = shift;
my $graph = shift;
my $term = shift;
my $path = shift;
my $v = shift;
return if (exists $v->{ $term->as_string });
$v->{ $term->as_string } = $term;
my $iter = $self->_eval($graph, $term, $path);
while (my $n = $iter->next) {
$self->_ALP($graph, $n, $path, $v);
}
}
sub _eval {
my $self = shift;
my $graph = shift;
my $term = shift;
my $path = shift;
my $pp = Attean::Algebra::Path->new( subject => $term, path => $path, object => variable('o') );
my $iter = $self->evaluate($pp, $graph);
my $terms = $iter->map(sub { shift->value('o') }, 'Attean::API::Term');
my %seen;
return $terms->grep(sub { not $seen{ shift->as_string }++ });
}
sub _zeroLengthPath {
my $self = shift;
my $s = shift;
my $o = shift;
my $graph = shift;
my $s_term = ($s->does('Attean::API::TermOrTriple'));
my $o_term = ($o->does('Attean::API::TermOrTriple'));
if ($s_term and $o_term) {
my @r;
push(@r, Attean::Result->new()) if ($s->equals($o));
return Attean::ListIterator->new(variables => [], values => \@r, item_type => 'Attean::API::Result');
} elsif ($s_term) {
my $name = $o->value;
my $r = Attean::Result->new( bindings => { $name => $s } );
return Attean::ListIterator->new(variables => [$name], values => [$r], item_type => 'Attean::API::Result');
} elsif ($o_term) {
my $name = $s->value;
my $r = Attean::Result->new( bindings => { $name => $o } );
return Attean::ListIterator->new(variables => [$name], values => [$r], item_type => 'Attean::API::Result');
} else {
my @vars = map { $_->value } ($s, $o);
my $nodes = $self->model->graph_nodes( $graph );
return $nodes->map(
sub {
my $term = shift;
Attean::Result->new( bindings => { map { $_ => $term } @vars } );
},
'Attean::API::Result',
variables => \@vars
);
}
}
}
package Attean::SimpleQueryEvaluator::ExpressionEvaluator 0.033 {
use Moo;
use Attean::RDF;
use Scalar::Util qw(blessed);
use Types::Standard qw(InstanceOf);
use URI::Escape qw(uri_escape_utf8);
use Encode qw(encode);
use POSIX qw(ceil floor);
use Digest;
use UUID::Tiny ':std';
use List::MoreUtils qw(zip);
use DateTime::Format::W3CDTF;
use I18N::LangTags;
use namespace::clean;
has 'evaluator' => (is => 'ro', isa => InstanceOf['Attean::SimpleQueryEvaluator']);
sub evaluate_expression {
my $self = shift;
my $expr = shift;
my $row = shift;
my $active_graph = shift;
my $row_cache = shift || {};
my $impl = $self->impl($expr, $active_graph);
return eval { $impl->($row, row_cache => $row_cache) };
}
sub impl {
my $self = shift;
my $expr = shift;
my $active_graph = shift;
my $op = $expr->operator;
my $true = Attean::Literal->true;
my $false = Attean::Literal->false;
if ($expr->isa('Attean::ExistsExpression')) {
my $pattern = $expr->pattern;
return sub {
my $r = shift;
my $table = Attean::Algebra::Table->new( variables => [map { variable($_) } $r->variables], rows => [$r] );
my $join = Attean::Algebra::Join->new( children => [$table, $pattern] );
# TODO: substitute variables at top-level of EXISTS pattern
my $iter = $self->evaluator->evaluate($join, $active_graph);
return ($iter->next) ? $true : $false;
};
} elsif ($expr->isa('Attean::ValueExpression')) {
my $node = $expr->value;
if ($node->does('Attean::API::Variable')) {
return sub { return shift->value($node->value); };
} else {
return sub { return $node };
}
} elsif ($expr->isa('Attean::UnaryExpression')) {
my ($child) = @{ $expr->children };
my $impl = $self->impl($child, $active_graph);
if ($op eq '!') {
return sub {
my $term = $impl->(@_);
return ($term->ebv) ? $false : $true;
}
} elsif ($op eq '-' or $op eq '+') {
return sub {
my $term = $impl->(@_);
die "TypeError $op" unless (blessed($term) and $term->does('Attean::API::NumericLiteral'));
my $v = $term->numeric_value;
return Attean::Literal->new( value => eval "$op$v", datatype => $term->datatype );
};
}
die "Unimplemented UnaryExpression evaluation: " . $expr->operator;
} elsif ($expr->isa('Attean::BinaryExpression')) {
my ($lhs, $rhs) = @{ $expr->children };
my ($lhsi, $rhsi) = map { $self->impl($_, $active_graph) } ($lhs, $rhs);
if ($op eq '&&') {
return sub {
my ($r, %args) = @_;
my $lbv = eval { $lhsi->($r, %args) };
my $rbv = eval { $rhsi->($r, %args) };
die "TypeError $op" unless ($lbv or $rbv);
return $false if (not($lbv) and not($rbv->ebv));
return $false if (not($rbv) and not($lbv->ebv));
die "TypeError $op" unless ($lbv and $rbv);
return ($lbv->ebv && $rbv->ebv) ? $true : $false;
}
} elsif ($op eq '||') {
return sub {
my ($r, %args) = @_;
my $lbv = eval { $lhsi->($r, %args) };
return $true if ($lbv and $lbv->ebv);
my $rbv = eval { $rhsi->($r, %args) };
die "TypeError $op" unless ($rbv);
return $true if ($rbv->ebv);
return $false if ($lbv);
die "TypeError $op";
}
} elsif ($op =~ m#^(?:[-+*/])$#) { # numeric operators: - + * /
return sub {
my ($r, %args) = @_;
($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
for ($lhs, $rhs) { die "TypeError $op" unless (blessed($_) and $_->does('Attean::API::NumericLiteral')); }
my $lv = $lhs->numeric_value;
my $rv = $rhs->numeric_value;
return Attean::Literal->new( value => eval "$lv $op $rv", datatype => $lhs->binary_promotion_type($rhs, $op) );
};
} elsif ($op =~ /^!?=$/) {
return sub {
my ($r, %args) = @_;
($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
for ($lhs, $rhs) { die "TypeError $op" unless (blessed($_) and $_->does('Attean::API::TermOrTriple')); }
my $ok;
if ($lhs->does('Attean::API::Binding')) {
$ok = $lhs->equals($rhs);
} else {
$ok = $lhs->equals($rhs);
}
$ok = not($ok) if ($op eq '!=');
return $ok ? $true : $false;
}
} elsif ($op =~ /^[<>]=?$/) {
return sub {
my ($r, %args) = @_;
($lhs, $rhs) = map { $_->($r, %args) } ($lhsi, $rhsi);
for ($lhs, $rhs) {
die "TypeError $op" unless $_->does('Attean::API::TermOrTriple');
die "TypeError $op" if ($_->does('Attean::API::IRI')); # comparison of IRIs is only defined for `ORDER BY`, not for general expressions
}
my $c = ($lhs->compare($rhs));
return $true if (($c < 0 and ($op =~ /<=?/)) or ($c > 0 and ($op =~ />=?/)) or ($c == 0 and ($op =~ /=/)));
return $false;
}
}
die "Unexpected operator evaluation: $op";
} elsif ($expr->isa('Attean::FunctionExpression')) {
my $func = $expr->operator;
my @children = map { $self->impl($_, $active_graph) } @{ $expr->children };
my %type_roles = qw(URI IRI IRI IRI BLANK Blank LITERAL Literal NUMERIC NumericLiteral TRIPLE Triple);
my %type_classes = qw(URI Attean::IRI IRI Attean::IRI STR Attean::Literal);
return sub {
my ($r, %args) = @_;
my $row_cache = $args{row_cache} || {};
if ($func eq 'IF') {
my $term = $children[0]->( $r, %args );
return ($term->ebv) ? $children[1]->( $r, %args ) : $children[2]->( $r, %args );
} elsif ($func eq 'IN' or $func eq 'NOTIN') {
($true, $false) = ($false, $true) if ($func eq 'NOTIN');
my $child = shift(@children);
my $term = $child->( $r, %args );
foreach my $c (@children) {
if (my $value = eval { $c->( $r, %args ) }) {
return $true if ($term->equals($value));
}
}
return $false;
} elsif ($func eq 'COALESCE') {
foreach my $c (@children) {
my $t = eval { $c->( $r, %args ) };
next if ($@);
return $t if $t;
}
return;
}
my @operands = map { $_->( $r, %args ) } @children;
if ($func =~ /^(STR)$/) {
return $type_classes{$1}->new($operands[0]->value);
} elsif ($func =~ /^(SUBJECT|PREDICATE|OBJECT)$/) {
my $pos = lc($func);
my $term = $operands[0]->$pos();
return $term;
} elsif ($func =~ /^([UI]RI)$/) {
my @base = $expr->has_base ? (base => $expr->base) : ();
return $type_classes{$1}->new(value => $operands[0]->value, @base);
} elsif ($func eq 'BNODE') {
if (scalar(@operands)) {
my $name = $operands[0]->value;
if (my $b = $row_cache->{bnodes}{$name}) {
return $b;
} else {
my $b = Attean::Blank->new();
$row_cache->{bnodes}{$name} = $b;
return $b;
}
}
return Attean::Blank->new();
} elsif ($func eq 'LANG') {
die "TypeError: LANG" unless ($operands[0]->does('Attean::API::Literal'));
return Attean::Literal->new($operands[0]->language // '');
} elsif ($func eq 'LANGMATCHES') {
my ($lang, $match) = map { $_->value } @operands;
if ($match eq '*') {
# """A language-range of "*" matches any non-empty language-tag string."""
return ($lang ? $true : $false);
} else {
return (I18N::LangTags::is_dialect_of( $lang, $match )) ? $true : $false;
}
} elsif ($func eq 'DATATYPE') {
return $operands[0]->datatype;
} elsif ($func eq 'BOUND') {
return $operands[0] ? $true : $false;
} elsif ($func eq 'RAND') {
return Attean::Literal->new( value => rand(), datatype => 'http://www.w3.org/2001/XMLSchema#double' );
} elsif ($func eq 'ABS') {
return Attean::Literal->new( value => abs($operands[0]->value), $operands[0]->construct_args );
} elsif ($func =~ /^(?:CEIL|FLOOR)$/) {
my $v = $operands[0]->value;
return Attean::Literal->new( value => (($func eq 'CEIL') ? ceil($v) : floor($v)), $operands[0]->construct_args );
} elsif ($func eq 'ROUND') {
return Attean::Literal->new( value => sprintf('%.0f', (0.000000000000001 + $operands[0]->numeric_value)), $operands[0]->construct_args );
} elsif ($func eq 'CONCAT') {
my $all_lang = 1;
my $all_str = 1;
my $lang;
foreach my $n (@operands) {
die "CONCAT called with a non-literal argument" unless ($n->does('Attean::API::Literal'));
if ($n->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string') {
die "CONCAT called with a datatyped-literal other than xsd:string";
} elsif ($n->language) {
$all_str = 0;
if (defined($lang) and $lang ne $n->language) {
$all_lang = 0;
} else {
$lang = $n->language;
}
} else {
$all_lang = 0;
$all_str = 0;
}
}
my %strtype;
if ($all_lang and $lang) {
$strtype{language} = $lang;
} elsif ($all_str) {
$strtype{datatype} = 'http://www.w3.org/2001/XMLSchema#string'
}
return Attean::Literal->new( value => join('', map { $_->value } @operands), %strtype );
} elsif ($func eq 'SUBSTR') {
my $str = shift(@operands);
my @args = map { $_->numeric_value } @operands;
my $v = scalar(@args == 1) ? substr($str->value, $args[0]-1) : substr($str->value, $args[0]-1, $args[1]);
return Attean::Literal->new( value => $v, $str->construct_args );
} elsif ($func eq 'STRLEN') {
return Attean::Literal->integer(length($operands[0]->value));
} elsif ($func eq 'REPLACE') {
my ($node, $pat, $rep) = @operands;
die "TypeError: REPLACE called without a literal arg1 term" unless (blessed($node) and $node->does('Attean::API::Literal'));
die "TypeError: REPLACE called without a literal arg2 term" unless (blessed($pat) and $pat->does('Attean::API::Literal'));
die "TypeError: REPLACE called without a literal arg3 term" unless (blessed($rep) and $rep->does('Attean::API::Literal'));
die "TypeError: REPLACE called with a datatyped (non-xsd:string) literal" if ($node->datatype and $node->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string');
my ($value, $pattern, $replace) = map { $_->value } @operands;
die "EvaluationError: REPLACE called with unsafe ?{} match pattern" if (index($pattern, '(?{') != -1 or index($pattern, '(??{') != -1);
die "EvaluationError: REPLACE called with unsafe ?{} replace pattern" if (index($replace, '(?{') != -1 or index($replace, '(??{') != -1);
$replace =~ s/\\/\\\\/g;
$replace =~ s/\$(\d+)/\$$1/g;
$replace =~ s/"/\\"/g;
$replace = qq["$replace"];
no warnings 'uninitialized';
$value =~ s/$pattern/"$replace"/eeg;
return Attean::Literal->new(value => $value, $node->construct_args);
} elsif ($func =~ /^[UL]CASE$/) {
return Attean::Literal->new( value => ($func eq 'UCASE' ? uc($operands[0]->value) : lc($operands[0]->value) ), $operands[0]->construct_args );
} elsif ($func eq 'ENCODE_FOR_URI') {
return Attean::Literal->new( uri_escape_utf8($operands[0]->value) );
} elsif ($func eq 'CONTAINS') {
my ($node, $pat) = @operands;
my ($lit, $plit) = map { $_->value } @operands;
die "TypeError: CONTAINS" if ($node->language and $pat->language and $node->language ne $pat->language);
return (index($lit, $plit) >= 0) ? $true : $false;
} elsif ($func eq 'STRSTARTS' or $func eq 'STRENDS') {
my ($lit, $plit) = map { $_->value } @operands;
if ($func eq 'STRENDS') {
my $pos = length($lit) - length($plit);
return (rindex($lit, $plit) == $pos) ? $true : $false;
} else {
return (index($lit, $plit) == 0) ? $true : $false;
}
} elsif ($func eq 'STRBEFORE' or $func eq 'STRAFTER') {
my ($node, $substr) = @operands;
die "$func called without a literal arg1 term" unless (blessed($node) and $node->does('Attean::API::Literal'));
die "$func called without a literal arg2 term" unless (blessed($substr) and $substr->does('Attean::API::Literal'));
die "$func called with a datatyped (non-xsd:string) literal" if ($node->datatype and $node->datatype->value ne 'http://www.w3.org/2001/XMLSchema#string');
my $lhs_simple = (not($node->language) and ($node->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'));
my $rhs_simple = (not($substr->language) and ($substr->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string'));
if ($lhs_simple and $rhs_simple) {
# ok
} elsif ($node->language and $substr->language and $node->language eq $substr->language) {
# ok
} elsif ($node->language and $rhs_simple) {
# ok
} else {
die "$func called with literals that are not argument compatible";
}
my $value = $node->value;
my $match = $substr->value;
my $i = index($value, $match, 0);
if ($i < 0) {
return Attean::Literal->new('');
} else {
if ($func eq 'STRBEFORE') {
return Attean::Literal->new(value => substr($value, 0, $i), $node->construct_args);
} else {
return Attean::Literal->new(value => substr($value, $i+length($match)), $node->construct_args);
}
}
} elsif ($func =~ /^(?:YEAR|MONTH|DAY|HOURS|MINUTES)$/) {
my $method = lc($func =~ s/^(HOUR|MINUTE)S$/$1/r);
my $dt = $operands[0]->datetime;
return Attean::Literal->integer($dt->$method());
} elsif ($func eq 'SECONDS') {
my $dt = $operands[0]->datetime;
return Attean::Literal->decimal($dt->second());
} elsif ($func eq 'TZ' or $func eq 'TIMEZONE') {
my $dt = $operands[0]->datetime;
my $tz = $dt->time_zone;
if ($tz->is_floating) {
return Attean::Literal->new('') if ($func eq 'TZ');
die "TIMEZONE called with a dateTime without a timezone";
}
return Attean::Literal->new('Z') if ($func eq 'TZ' and $tz->is_utc);
if ($tz) {
my $offset = $tz->offset_for_datetime( $dt );
my $hours = 0;
my $minutes = 0;
my $minus = ($func eq 'TZ') ? '+' : '';
if ($offset < 0) {
$minus = '-';
$offset = -$offset;
}
my $duration = "${minus}PT";
if ($offset >= 60*60) {
my $h = int($offset / (60*60));
$duration .= "${h}H" if ($h > 0);
$hours = int($offset / (60*60));
$offset = $offset % (60*60);
}
if ($offset >= 60) {
my $m = int($offset / 60);
$duration .= "${m}M" if ($m > 0);
$minutes = int($offset / 60);
$offset = $offset % 60;
}
my $seconds = int($offset);
my $s = int($offset);
$duration .= "${s}S" if ($s > 0 or $duration eq 'PT');
return ($func eq 'TZ')
? Attean::Literal->new(sprintf('%s%02d:%02d', $minus, $hours, $minutes))
: Attean::Literal->new( value => $duration, datatype => "http://www.w3.org/2001/XMLSchema#dayTimeDuration");
} else {
return Attean::Literal->new('') if ($func eq 'TZ');
die "TIMEZONE called without a valid dateTime";
}
} elsif ($func eq 'NOW') {
my $value = DateTime::Format::W3CDTF->new->format_datetime( DateTime->now );
return Attean::Literal->new( value => $value, datatype => 'http://www.w3.org/2001/XMLSchema#dateTime' );
} elsif ($func =~ /^(?:STR)?UUID$/) {
return Attean::Literal->new(uc(uuid_to_string(create_uuid()))) if ($func eq 'STRUUID');
return Attean::IRI->new('urn:uuid:' . uc(uuid_to_string(create_uuid())));
} elsif ($func =~ /^(MD5|SHA1|SHA256|SHA384|SHA512)$/) {
my $hash = $func =~ s/SHA/SHA-/r;
my $digest = eval { Digest->new($hash)->add(encode('UTF-8', $operands[0]->value, Encode::FB_CROAK))->hexdigest };
return Attean::Literal->new($digest);
} elsif ($func eq 'STRLANG') {
my ($str, $lang) = @operands;
my @values = map { $_->value } @operands;
die "TypeError: STRLANG must be called with two plain literals" unless (blessed($str) and $str->does('Attean::API::Literal') and blessed($lang) and $lang->does('Attean::API::Literal'));
die "TypeError: STRLANG not called with a simple literal" unless ($str->datatype->value eq 'http://www.w3.org/2001/XMLSchema#string' and not($str->language));
return Attean::Literal->new( value => $values[0], language => $values[1] );
} elsif ($func eq 'STRDT') {
die "TypeError: STRDT" unless ($operands[0]->does('Attean::API::Literal') and not($operands[0]->language));
if (my $dt = $operands[0]->datatype) {
die "TypeError: STRDT" unless ($dt->value eq 'http://www.w3.org/2001/XMLSchema#string');
}
die "TypeError: STRDT" unless ($operands[1]->does('Attean::API::IRI'));
my @values = map { $_->value } @operands;
return Attean::Literal->new( value => $values[0], datatype => $values[1] );
} elsif ($func eq 'SAMETERM') {
my ($a, $b) = @operands;
die "TypeError: SAMETERM" unless (blessed($operands[0]) and blessed($operands[1]));
if ($a->compare($b)) {
return $false;
}
if ($a->does('Attean::API::Binding')) {
my $ok = ($a->sameTerms($b));
return $ok ? $true : $false;
} else {
my $ok = ($a->value eq $b->value);
return $ok ? $true : $false;
}
} elsif ($func =~ /^IS([UI]RI|BLANK|LITERAL|NUMERIC|TRIPLE)$/) {
return $operands[0]->does("Attean::API::$type_roles{$1}") ? $true : $false;
} elsif ($func eq 'REGEX') {
my ($value, $pattern) = map { $_->value } @operands;
return ($value =~ /$pattern/) ? $true : $false;
} elsif ($func eq 'INVOKE') {
my $furi = shift(@operands)->value;
my $func = Attean->get_global_function($furi);
unless (ref($func)) {
die "No extension registered for <$furi>";
}
return $func->(@operands);
}
die "Unimplemented FunctionExpression evaluation: " . $expr->operator;
};
} elsif ($expr->isa('Attean::AggregateExpression')) {
my $agg = $expr->operator;
my ($child) = @{ $expr->children };
if ($agg eq 'COUNT') {
if ($child) {
my $impl = $self->impl($child, $active_graph);
return sub {
my ($rows, %args) = @_;
my @terms = grep { blessed($_) } map { $impl->($_, %args) } @{ $rows };
if ($expr->distinct) {
my %seen;
@terms = grep { not($seen{$_->as_string}++) } @terms;
}
return Attean::Literal->integer(scalar(@terms));
};
} else {
return sub {
my ($rows, %args) = @_;
return Attean::Literal->integer(scalar(@$rows));
};
}
} elsif ($agg =~ /^(?:SAMPLE|MIN|MAX|SUM|AVG|GROUP_CONCAT)$/) {
my $impl = $self->impl($child, $active_graph);
if ($agg eq 'SAMPLE') {
return sub {
my ($rows, %args) = @_;
return $impl->( shift(@$rows), %args )
};
} elsif ($agg eq 'MIN' or $agg eq 'MAX') {
my $expect = ($agg eq 'MIN') ? 1 : -1;
return sub {
my ($rows, %args) = @_;
my $extrema;
foreach my $r (@$rows) {
my $t = $impl->( $r, %args );
return if (not($t) and $agg eq 'MIN'); # unbound is always minimal
next if (not($t)); # unbound need not be considered for MAX
$extrema = $t if (not($extrema) or $extrema->compare($t) == $expect);
}
return $extrema;
};
} elsif ($agg eq 'SUM' or $agg eq 'AVG') {
return sub {
my ($rows, %args) = @_;
my $count = 0;
my $sum = Attean::Literal->integer(0);
my %seen;
foreach my $r (@$rows) {
my $term = $impl->( $r, %args );
if ($expr->distinct) {
next if ($seen{ $term->as_string }++);
}
if ($term->does('Attean::API::NumericLiteral')) {
$count++;
$sum = Attean::Literal->new( value => ($sum->numeric_value + $term->numeric_value), datatype => $sum->binary_promotion_type($term, '+') );
} else {
die "TypeError: AVG";
}
}
if ($agg eq 'AVG') {
$sum = not($count) ? undef : Attean::Literal->new( value => ($sum->numeric_value / $count), datatype => $sum->binary_promotion_type(Attean::Literal->integer($count), '/') );
}
return $sum;
};
} elsif ($agg eq 'GROUP_CONCAT') {
my $sep = $expr->scalar_vars->{ 'seperator' } // ' ';
return sub {
my ($rows, %args) = @_;
my %seen;
my @strings;
foreach my $r (@$rows) {
my $term = eval { $impl->( $r, %args ) };
if ($expr->distinct) {
next if ($seen{ blessed($term) ? $term->as_string : '' }++);
}
push(@strings, $term->value // '');
}
return Attean::Literal->new(join($sep, sort @strings));
};
}
} elsif ($agg eq 'CUSTOM') {
my $iri = $expr->custom_iri;
my $data = Attean->get_global_aggregate($iri);
unless ($data) {
die "No extension aggregate registered for <$iri>";
}
my $start = $data->{'start'};
my $process = $data->{'process'};
my $finalize = $data->{'finalize'};
my $impl = $self->impl($child, $active_graph);
return sub {
my ($rows, %args) = @_;
my $thunk = $start->();
foreach my $r (@$rows) {
my $t = $impl->( $r, %args );
$process->($thunk, $t);
}
return $finalize->($thunk);
};
}
die "Unimplemented AggregateExpression evaluation: " . $expr->operator;
} elsif ($expr->isa('Attean::CastExpression')) {
my ($child) = @{ $expr->children };
my $impl = $self->impl( $child, $active_graph );
my $type = $expr->datatype;
return sub {
my ($r, %args) = @_;
my $term = $impl->($r, %args);
# TODO: reformat syntax for xsd:double
my $cast = Attean::Literal->new( value => $term->value, datatype => $type );
return $cast->canonicalized_term if ($cast->does('Attean::API::CanonicalizingLiteral'));
return $cast;
}
} else {
Carp::confess "No impl for expression " . $expr->as_string;
}
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Literal.pm 000644 000765 000024 00000000224 14316376573 020724 x ustar 00greg staff 000000 000000 29 mtime=1664744827.03264279
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Literal.pm 000644 000765 000024 00000007611 14316376573 016762 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Literal - RDF Literals
=head1 VERSION
This document describes Attean::Literal version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $langterm = Attean::Literal->new(value => 'foo', language => 'en-US');
$langterm->ntriples_string; # "foo"@en-US
my $typeterm = Attean::Literal->new(value => '123', datatype => 'http://www.w3.org/2001/XMLSchema#integer');
$langterm->ntriples_string; # "123"^^
=head1 DESCRIPTION
The Attean::Literal class represents RDF literals.
It conforms to the L role.
=head1 ATTRIBUTES
The following attributes exist:
=over 4
=item C<< value >>
=item C<< language >>
=item C<< datatype >>
=back
=head1 METHODS
=over 4
=item C<< has_language >>
Returns true if the literal has a language tag, false otherwise.
=cut
package Attean::Literal 0.033 {
use Moo;
use Types::Standard qw(Str Maybe InstanceOf);
use Attean::API::Term;
use IRI;
use Sub::Install;
use Sub::Util qw(set_subname);
use Scalar::Util qw(blessed);
use namespace::clean;
my $XSD_STRING = IRI->new(value => 'http://www.w3.org/2001/XMLSchema#string');
has 'value' => (is => 'ro', isa => Str, required => 1);
has 'language' => (is => 'ro', isa => Maybe[Str], predicate => 'has_language');
has 'datatype' => (
is => 'ro',
isa => InstanceOf['Attean::IRI'],
required => 1,
coerce => sub {
my $dt = shift;
if (blessed($dt) and $dt->isa('Attean::IRI')) {
return $dt;
} else {
return blessed($dt) ? Attean::IRI->new($dt->as_string) : Attean::IRI->new($dt)
}
},
default => sub { $XSD_STRING }
);
has 'ntriples_string' => (is => 'ro', isa => Str, lazy => 1, builder => '_ntriples_string');
with 'Attean::API::Literal';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
return $class->$orig(@_) if (scalar(@_) == 1 and ref($_[0]) eq "HASH");
if (scalar(@_) == 1) {
my $dt = IRI->new('http://www.w3.org/2001/XMLSchema#string');
return $class->$orig(value => shift, datatype => $dt);
}
return $class->$orig(@_);
};
around 'datatype' => sub {
my $orig = shift;
my $self = shift;
if ($self->has_language) {
return Attean::IRI->new(value => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString');
} else {
return $self->$orig(@_);
}
};
sub _ntriples_string {
my $self = shift;
my $value = $self->value;
$value =~ s/\\/\\\\/g;
$value =~ s/\n/\\n/g;
$value =~ s/\r/\\r/g;
$value =~ s/"/\\"/g;
if ($self->has_language) {
return sprintf('"%s"@%s', $value, $self->language);
} else {
my $dt = $self->datatype->as_string;
if ($dt eq 'http://www.w3.org/2001/XMLSchema#string') {
return sprintf('"%s"', $value);
} else {
return sprintf('"%s"^^<%s>', $value, $dt);
}
}
}
=item C<< true >>
The xsd:true term.
=cut
sub true {
state $v = Attean::Literal->new( value => 'true', datatype => 'http://www.w3.org/2001/XMLSchema#boolean' );
return $v;
}
=item C<< false >>
The xsd:false term.
=cut
sub false {
state $v = Attean::Literal->new( value => 'false', datatype => 'http://www.w3.org/2001/XMLSchema#boolean' );
return $v;
}
{
for my $method (qw(integer decimal float double)) {
my $code = sub {
my $class = shift;
return $class->new( value => shift, datatype => "http://www.w3.org/2001/XMLSchema#$method" );
};
Sub::Install::install_sub({
code => set_subname("${method}", $code),
as => "${method}"
});
}
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Algebra.pm 000644 000765 000024 00000000225 14316376567 020671 x ustar 00greg staff 000000 000000 30 mtime=1664744823.402147972
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Algebra.pm 000644 000765 000024 00000126577 14316376567 016743 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use utf8;
=head1 NAME
Attean::Algebra - Representation of SPARQL algebra operators
=head1 VERSION
This document describes Attean::Algebra version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
=head1 DESCRIPTION
This is a utility package that defines all the Attean query algebra classes
in the Attean::Algebra namespace:
=over 4
=cut
use Attean::API::Query;
package Attean::Algebra::Query 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Bool ArrayRef HashRef ConsumerOf);
use Moo;
use namespace::clean;
has 'dataset' => (is => 'ro', isa => HashRef[ArrayRef[ConsumerOf['Attean::API::Term']]], default => sub { +{} });
has 'subquery' => (is => 'ro', isa => Bool, default => 0);
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
sub algebra_as_string {
my $self = shift;
my $name = $self->subquery ? 'SubQuery' : 'Query';
my %dataset = %{ $self->dataset };
my @default = @{ $dataset{ default } || [] };
my @named = @{ $dataset{ named } || [] };
my $has_dataset = (scalar(@default) + scalar(@named));
my $s = $name;
if ($has_dataset) {
my @parts;
if (scalar(@default)) {
push(@parts, 'Default graph(s): ' . join(', ', map { chomp; $_ } map { $_->as_sparql } @default));
}
if (scalar(@named)) {
push(@parts, 'Named graph(s): ' . join(', ', map { chomp; $_ } map { $_->as_sparql } @named));
}
$s .= ' { ' . join('; ', @parts) . ' }';
}
return $s;
}
sub sparql_tokens {
my $self = shift;
my $child = $self->child;
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my $from = AtteanX::SPARQL::Token->keyword('FROM');
my $named = AtteanX::SPARQL::Token->keyword('NAMED');
my %dataset = %{ $self->dataset };
my @default = @{ $dataset{ default } || [] };
my @named = @{ $dataset{ named } || [] };
my $has_dataset = (scalar(@default) + scalar(@named));
if ($child->does('Attean::API::SPARQLQuerySerializable')) {
if ($self->subquery) {
my @tokens;
push(@tokens, $l);
push(@tokens, $child->sparql_tokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
} else {
my %args;
if ($has_dataset) {
$args{dataset} = $self->dataset;
}
return $child->query_tokens(%args);
}
} else {
my $sel = AtteanX::SPARQL::Token->keyword('SELECT');
my $star = AtteanX::SPARQL::Token->star;
my $where = AtteanX::SPARQL::Token->keyword('WHERE');
my @tokens;
if ($self->subquery) {
push(@tokens, $l);
}
push(@tokens, $sel, $star);
if ($has_dataset) {
foreach my $i (sort { $a->as_string cmp $b->as_string } @default) {
push(@tokens, $from);
push(@tokens, $i->sparql_tokens->elements);
}
foreach my $i (sort { $a->as_string cmp $b->as_string } @named) {
push(@tokens, $from);
push(@tokens, $named);
push(@tokens, $i->sparql_tokens->elements);
}
}
push(@tokens, $where);
push(@tokens, $l);
push(@tokens, $child->sparql_tokens->elements);
push(@tokens, $r);
if ($self->subquery) {
push(@tokens, $r);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
}
package Attean::Algebra::Update 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Bool);
use Moo;
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
sub algebra_as_string { return 'Update' }
sub sparql_tokens {
my $self = shift;
my $child = $self->child;
return $child->sparql_tokens;
}
}
=item * L
=cut
package Attean::Algebra::Sequence 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::QueryTree';
sub arity {
my $self = shift;
return scalar(@{ $self->children });
}
sub algebra_as_string { return 'Sequence' }
sub sparql_tokens {
my $self = shift;
my $semi = AtteanX::SPARQL::Token->semicolon;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $semi);
}
pop(@tokens); # remove last SEMICOLON token
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Join 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::QueryTree';
sub algebra_as_string { return 'Join' }
sub sparql_tokens {
my $self = shift;
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my @tokens;
push(@tokens, $l);
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_subtokens->elements);
}
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::LeftJoin 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::BinaryQueryTree';
has 'expression' => (is => 'ro', isa => ConsumerOf['Attean::API::Expression'], required => 1, default => sub { Attean::ValueExpression->new( value => Attean::Literal->true ) });
sub algebra_as_string {
my $self = shift;
return sprintf('LeftJoin { %s }', $self->expression->as_string);
}
sub tree_attributes { return qw(expression) };
sub sparql_tokens {
my $self = shift;
my $opt = AtteanX::SPARQL::Token->keyword('OPTIONAL');
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my ($lhs, $rhs) = @{ $self->children };
my @tokens;
push(@tokens, $l);
push(@tokens, $lhs->sparql_subtokens->elements);
push(@tokens, $r, $opt, $l);
push(@tokens, $rhs->sparql_subtokens->elements);
my $expr = $self->expression;
my $is_true = 0;
if ($expr->isa('Attean::ValueExpression')) {
my $value = $expr->value;
if ($value->equals(Attean::Literal->true)) {
$is_true = 1;
}
}
unless ($is_true) {
my $f = AtteanX::SPARQL::Token->keyword('FILTER');
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
push(@tokens, $f);
push(@tokens, $lparen);
push(@tokens, $expr->sparql_tokens->elements);
push(@tokens, $rparen);
}
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Filter 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'expression' => (is => 'ro', isa => ConsumerOf['Attean::API::Expression'], required => 1);
sub algebra_as_string {
my $self = shift;
return sprintf('Filter { %s }', $self->expression->as_string);
}
sub tree_attributes { return qw(expression) };
sub sparql_tokens {
my $self = shift;
my $f = AtteanX::SPARQL::Token->keyword('FILTER');
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my ($child) = @{ $self->children };
my $expr = $self->expression;
my @tokens;
push(@tokens, $child->sparql_tokens->elements);
push(@tokens, $f);
push(@tokens, $l);
push(@tokens, $expr->sparql_tokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Union 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::BinaryQueryTree';
sub algebra_as_string { return 'Union' }
sub sparql_tokens {
my $self = shift;
my $union = AtteanX::SPARQL::Token->keyword('UNION');
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my ($lhs, $rhs) = @{ $self->children };
my @tokens;
push(@tokens, $l);
push(@tokens, $lhs->sparql_subtokens->elements);
push(@tokens, $r, $union, $l);
push(@tokens, $rhs->sparql_subtokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Graph 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'graph' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariable'], required => 1);
sub in_scope_variables {
my $self = shift;
my $graph = $self->graph;
my ($child) = @{ $self->children };
my @vars = $child->in_scope_variables;
if ($graph->does('Attean::API::Variable')) {
return Set::Scalar->new(@vars, $graph->value)->elements;
} else {
return @vars;
}
}
sub algebra_as_string {
my $self = shift;
return sprintf('Graph %s', $self->graph->as_string);
}
sub tree_attributes { return qw(graph) };
sub sparql_tokens {
my $self = shift;
my $graph = AtteanX::SPARQL::Token->keyword('GRAPH');
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my ($child) = @{ $self->children };
my @tokens;
push(@tokens, $graph);
push(@tokens, $self->graph->sparql_tokens->elements);
push(@tokens, $l);
push(@tokens, $child->sparql_subtokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Extend 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
sub in_scope_variables {
my $self = shift;
my ($child) = @{ $self->children };
my @vars = $child->in_scope_variables;
return Set::Scalar->new(@vars, $self->variable->value)->elements;
}
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'variable' => (is => 'ro', isa => ConsumerOf['Attean::API::Variable'], required => 1);
has 'expression' => (is => 'ro', isa => ConsumerOf['Attean::API::Expression'], required => 1);
sub algebra_as_string {
my $self = shift;
return sprintf('Extend { %s ↠%s }', $self->variable->as_string, $self->expression->as_string);
}
sub tree_attributes { return qw(variable expression) };
sub sparql_tokens {
my $self = shift;
my $bind = AtteanX::SPARQL::Token->keyword('BIND');
my $as = AtteanX::SPARQL::Token->keyword('AS');
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my ($child) = @{ $self->children };
my $var = $self->variable;
my $expr = $self->expression;
my @tokens;
push(@tokens, $child->sparql_tokens->elements);
push(@tokens, $bind);
push(@tokens, $l);
push(@tokens, $expr->sparql_tokens->elements);
push(@tokens, $as);
push(@tokens, $var->sparql_tokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Minus 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::BinaryQueryTree';
sub in_scope_variables {
my $self = shift;
my ($child) = @{ $self->children };
return $child->in_scope_variables;
}
sub algebra_as_string { return 'Minus' }
sub sparql_tokens {
my $self = shift;
my $minus = AtteanX::SPARQL::Token->keyword('MINUS');
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my ($lhs, $rhs) = @{ $self->children };
my @tokens;
push(@tokens, $l);
push(@tokens, $lhs->sparql_subtokens->elements);
push(@tokens, $r, $minus, $l);
push(@tokens, $rhs->sparql_subtokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Distinct 0.033 {
use Moo;
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
sub algebra_as_string { return 'Distinct' }
}
=item * L
=cut
package Attean::Algebra::Reduced 0.033 {
use Moo;
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
sub algebra_as_string { return 'Reduced' }
}
=item * L
=cut
package Attean::Algebra::Slice 0.033 {
use Moo;
use Types::Standard qw(Int);
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'limit' => (is => 'ro', isa => Int, default => -1);
has 'offset' => (is => 'ro', isa => Int, default => 0);
sub algebra_as_string {
my $self = shift;
my @str = ('Slice');
push(@str, "Limit=" . $self->limit) if ($self->limit >= 0);
push(@str, "Offset=" . $self->offset) if ($self->offset > 0);
return join(' ', @str);
}
}
=item * L
=cut
package Attean::Algebra::Project 0.033 {
use Types::Standard qw(ArrayRef ConsumerOf);
use Moo;
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'variables' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Variable']], required => 1);
sub in_scope_variables {
my $self = shift;
my ($child) = @{ $self->children };
my $set = Set::Scalar->new( $child->in_scope_variables );
my $proj = Set::Scalar->new( map { $_->value } @{ $self->variables } );
return $set->intersection($proj)->elements;
}
sub algebra_as_string {
my $self = shift;
return sprintf('Project { %s }', join(' ', map { '?' . $_->value } @{ $self->variables }));
}
sub tree_attributes { return qw(variables) };
}
=item * L
=cut
package Attean::Algebra::Comparator 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Bool ConsumerOf);
use namespace::clean;
has 'ascending' => (is => 'ro', isa => Bool, default => 1);
has 'expression' => (is => 'ro', isa => ConsumerOf['Attean::API::Expression'], required => 1);
sub tree_attributes { return qw(expression) };
sub as_string {
my $self = shift;
if ($self->ascending) {
return 'ASC(' . $self->expression->as_string . ')';
} else {
return 'DESC(' . $self->expression->as_string . ')';
}
}
sub sparql_tokens {
my $self = shift;
my $asc = AtteanX::SPARQL::Token->keyword('ASC');
my $desc = AtteanX::SPARQL::Token->keyword('DESC');
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
if ($self->ascending) {
push(@tokens, $self->expression->sparql_tokens->elements);
} else {
push(@tokens, $desc, $l);
push(@tokens, $self->expression->sparql_tokens->elements);
push(@tokens, $r);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::OrderBy 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef InstanceOf);
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::UnionScopeVariables', 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'comparators' => (is => 'ro', isa => ArrayRef[InstanceOf['Attean::Algebra::Comparator']], required => 1);
sub tree_attributes { return qw(comparators) };
sub algebra_as_string {
my $self = shift;
return sprintf('Order { %s }', join(', ', map { $_->as_string } @{ $self->comparators }));
}
}
=item * L
=cut
package Attean::Algebra::BGP 0.033 {
use Moo;
use Attean::RDF;
use Set::Scalar;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree', 'Attean::API::CanonicalizingBindingSet';
has 'triples' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TriplePattern']], default => sub { [] });
sub in_scope_variables {
my $self = shift;
my $set = Set::Scalar->new();
foreach my $t (@{ $self->triples }) {
my @vars = $t->referenced_variables();
$set->insert(@vars);
}
return $set->elements;
}
sub sparql_tokens {
my $self = shift;
my @tokens;
my $dot = AtteanX::SPARQL::Token->dot;
foreach my $t (@{ $self->triples }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $dot);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
sub algebra_as_string {
my $self = shift;
return 'BGP { ' . join(', ', map { $_->as_string } @{ $self->triples }) . ' }';
}
sub elements {
my $self = shift;
return @{ $self->triples };
}
sub canonicalize {
my $self = shift;
my ($algebra, $mapping) = $self->canonical_bgp_with_mapping();
my @proj = sort map { sprintf("(?v%03d AS $_)", $mapping->{$_}{id}) } grep { $mapping->{$_}{type} eq 'variable' } (keys %$mapping);
foreach my $var (keys %$mapping) {
$algebra = Attean::Algebra::Extend->new(
children => [$algebra],
variable => variable($var),
expression => Attean::ValueExpression->new( value => variable($mapping->{$var}{id}) ),
);
}
}
sub canonical_bgp_with_mapping {
my $self = shift;
my ($triples, $mapping) = $self->canonical_set_with_mapping();
my $algebra = Attean::Algebra::BGP->new( triples => $triples );
return ($algebra, $mapping);
}
sub tree_attributes { return qw(triples) };
}
=item * L
=cut
package Attean::Algebra::Service 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo;
use Types::Standard qw(ConsumerOf Bool);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree', 'Attean::API::UnionScopeVariables';
has 'endpoint' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariable'], required => 1);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
sub algebra_as_string {
my $self = shift;
my $endpoint = $self->endpoint->as_sparql;
chomp($endpoint);
return sprintf('Service %s', $endpoint);
}
sub tree_attributes { return qw(endpoint) };
sub sparql_tokens {
my $self = shift;
my $service = AtteanX::SPARQL::Token->keyword('SERVICE');
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my ($child) = @{ $self->children };
my @tokens;
push(@tokens, $service);
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
push(@tokens, $self->endpoint->sparql_tokens->elements);
push(@tokens, $l);
push(@tokens, $child->sparql_subtokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Path 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has 'subject' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariableOrTriplePattern'], required => 1);
has 'path' => (is => 'ro', isa => ConsumerOf['Attean::API::PropertyPath'], required => 1);
has 'object' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariableOrTriplePattern'], required => 1);
sub in_scope_variables {
my $self = shift;
my @vars = map { $_->value } grep { $_->does('Attean::API::Variable') } ($self->subject, $self->object);
return Set::Scalar->new(@vars)->elements;
}
sub tree_attributes { return qw(subject path object) };
sub algebra_as_string {
my $self = shift;
return 'Path { ' . join(', ', map { $_->as_string } map { $self->$_() } qw(subject path object)) . ' }';
}
sub sparql_tokens {
my $self = shift;
my @tokens;
foreach my $t ($self->subject, $self->path, $self->object) {
push(@tokens, $t->sparql_tokens->elements);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Group 0.033 {
use utf8;
use Moo;
use Attean::API::Query;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'groupby' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Expression']]);
has 'aggregates' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::AggregateExpression']]);
sub BUILD {
my $self = shift;
foreach my $a (@{ $self->aggregates }) {
my $op = $a->operator;
if ($op eq 'RANK') {
if (scalar(@{ $self->aggregates }) > 1) {
die "Cannot use both aggregates and RANKing in grouping operator";
}
}
}
}
sub in_scope_variables {
my $self = shift;
my $aggs = $self->aggregates // [];
my $groups = $self->groupby // [];
my %vars;
foreach my $a (@$aggs) {
$vars{ $a->variable->value }++;
}
foreach my $e (@$groups) {
if ($e->isa('Attean::ValueExpression')) {
my $value = $e->value;
if ($value->does('Attean::API::Variable')) {
$vars{ $value->value }++;
}
}
}
return keys %vars;
}
sub algebra_as_string {
my $self = shift;
my @aggs;
my $aggs = $self->aggregates // [];
my $groups = $self->groupby // [];
foreach my $a (@$aggs) {
my $v = $a->variable->as_string;
my $op = $a->operator;
my $d = $a->distinct ? "DISTINCT " : '';
my ($e) = ((map { $_->as_string } @{ $a->children }), '');
my $s = "$v ↠${op}($d$e)";
push(@aggs, $s);
}
return sprintf('Group { %s } aggregate { %s }', join(', ', map { $_->as_string() } @$groups), join(', ', @aggs));
}
sub tree_attributes { return qw(groupby aggregates) };
}
=item * L
=cut
package Attean::Algebra::NegatedPropertySet 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::PropertyPath';
has 'predicates' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::IRI']], required => 1);
sub as_string {
my $self = shift;
return sprintf("!(%s)", join('|', map { $_->ntriples_string } @{ $self->predicates }));
}
sub algebra_as_string { return 'NPS' }
sub tree_attributes { return qw(predicates) };
sub as_sparql {
my $self = shift;
return "!(" . join('|', map { $_->as_sparql } @{$self->predicates}) . ")";
}
sub sparql_tokens {
my $self = shift;
my $bang = AtteanX::SPARQL::Token->op_bang;
my $or = AtteanX::SPARQL::Token->path_or;
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
push(@tokens, $bang, $l);
foreach my $t (@{ $self->predicates }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $or);
}
pop(@tokens); # remove last OR token
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::PredicatePath 0.033 {
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::PropertyPath';
has 'predicate' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI'], required => 1);
sub as_string {
my $self = shift;
return $self->predicate->ntriples_string;
}
sub algebra_as_string {
my $self = shift;
return 'Property Path ' . $self->as_string;
}
sub tree_attributes { return qw(predicate) };
sub as_sparql {
my $self = shift;
return $self->predicate->as_sparql;
}
sub sparql_tokens {
my $self = shift;
return $self->predicate->sparql_tokens;
}
}
=item * L
=cut
package Attean::Algebra::InversePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnaryPropertyPath';
sub prefix_name { return "^" }
sub as_sparql {
my $self = shift;
my ($path) = @{ $self->children };
return '^' . $self->path->as_sparql;
}
sub sparql_tokens {
my $self = shift;
my $hat = AtteanX::SPARQL::Token->path_hat;
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
}
if (scalar(@tokens) > 1) {
unshift(@tokens, $hat, $l);
push(@tokens, $r);
} else {
unshift(@tokens, $hat);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::SequencePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
with 'Attean::API::NaryPropertyPath';
sub separator { return "/" }
sub as_sparql {
my $self = shift;
my @paths = @{ $self->children };
return '(' . join('/', map { $_->as_sparql } @paths) . ')';
}
sub sparql_tokens {
my $self = shift;
my $slash = AtteanX::SPARQL::Token->slash;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $slash);
}
pop(@tokens); # remove last SLASH token
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::AlternativePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
with 'Attean::API::NaryPropertyPath';
sub separator { return "|" }
sub as_sparql {
my $self = shift;
my @paths = @{ $self->children };
return '(' . join('|', map { $_->as_sparql } @paths) . ')';
}
sub sparql_tokens {
my $self = shift;
my $or = AtteanX::SPARQL::Token->path_or;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $or);
}
pop(@tokens); # remove last OR token
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::ZeroOrMorePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnaryPropertyPath';
sub postfix_name { return "*" }
sub as_sparql {
my $self = shift;
my ($path) = @{ $self->children };
return $self->path->as_sparql . '*';
}
sub sparql_tokens {
my $self = shift;
my $star = AtteanX::SPARQL::Token->star;
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
}
if (scalar(@tokens) > 1) {
unshift(@tokens, $l);
push(@tokens, $r);
}
push(@tokens, $star);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::OneOrMorePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnaryPropertyPath';
sub postfix_name { return "+" }
sub as_sparql {
my $self = shift;
my ($path) = @{ $self->children };
return $self->path->as_sparql . '+';
}
sub sparql_tokens {
my $self = shift;
my $plus = AtteanX::SPARQL::Token->op_plus;
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
}
if (scalar(@tokens) > 1) {
unshift(@tokens, $l);
push(@tokens, $r);
}
push(@tokens, $plus);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::ZeroOrOnePath 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::UnaryPropertyPath';
sub postfix_name { return "?" }
sub as_sparql {
my $self = shift;
my ($path) = @{ $self->children };
return $self->path->as_sparql . '?';
}
sub sparql_tokens {
my $self = shift;
my $q = AtteanX::SPARQL::Token->question;
my $l = AtteanX::SPARQL::Token->lparen;
my $r = AtteanX::SPARQL::Token->rparen;
my @tokens;
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
}
if (scalar(@tokens) > 1) {
unshift(@tokens, $l);
push(@tokens, $r);
}
push(@tokens, $q);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Table 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has variables => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Variable']]);
has rows => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Result']]);
sub in_scope_variables {
my $self = shift;
return map { $_->value } @{ $self->variables };
}
sub tree_attributes { return qw(variables rows) };
sub algebra_as_string { return 'Table' }
sub sparql_tokens {
my $self = shift;
my $values = AtteanX::SPARQL::Token->keyword('VALUES');
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
my $lbrace = AtteanX::SPARQL::Token->lbrace;
my $rbrace = AtteanX::SPARQL::Token->rbrace;
my @tokens;
push(@tokens, $values);
push(@tokens, $lparen);
foreach my $var (@{ $self->variables }) {
push(@tokens, $var->sparql_tokens->elements);
}
push(@tokens, $rparen);
push(@tokens, $lbrace);
foreach my $row (@{ $self->rows }) {
push(@tokens, $lparen);
foreach my $val ($row->values) {
# TODO: verify correct serialization of UNDEF
push(@tokens, $val->sparql_tokens->elements);
}
push(@tokens, $rparen);
}
push(@tokens, $rbrace);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Ask 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
sub in_scope_variables { return; }
sub algebra_as_string { return 'Ask' }
}
=item * L
=cut
package Attean::Algebra::Construct 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'triples' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TriplePattern']]);
sub in_scope_variables { return qw(subject predicate object); }
sub tree_attributes { return; }
sub algebra_as_string {
my $self = shift;
my $triples = $self->triples;
return sprintf('Construct { %s }', join(' . ', map { $_->as_string } @$triples));
}
}
=item * L
=cut
package Attean::Algebra::Describe 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::SPARQLQuerySerializable';
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree';
has 'terms' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TermOrVariable']]);
sub in_scope_variables { return qw(subject predicate object); }
sub tree_attributes { return; }
sub algebra_as_string { return 'Describe' }
}
=item * L
=cut
package Attean::Algebra::Load 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Bool ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'url' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI'], required => 1);
has 'graph' => (is => 'ro', isa => ConsumerOf['Attean::API::Term'], predicate => 'has_graph');
sub in_scope_variables { return; }
sub tree_attributes { return; }
sub algebra_as_string {
my $self = shift;
return 'Load ' . $self->url->as_string;
}
sub sparql_tokens {
my $self = shift;
my @tokens;
push(@tokens, AtteanX::SPARQL::Token->keyword('LOAD'));
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
push(@tokens, $self->url->sparql_tokens->elements);
if ($self->has_graph) {
push(@tokens, AtteanX::SPARQL::Token->keyword('INTO'));
push(@tokens, AtteanX::SPARQL::Token->keyword('GRAPH'));
push(@tokens, $self->graph->sparql_tokens->elements);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Clear 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Enum Bool ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has 'drop' => (is => 'ro', isa => Bool, default => 0);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'target' => (is => 'ro', isa => Enum[qw(GRAPH DEFAULT NAMED ALL)], required => 1);
has 'graph' => (is => 'ro', isa => ConsumerOf['Attean::API::Term']);
sub BUILD {
my $self = shift;
if ($self->target eq 'GRAPH') {
unless (blessed($self->graph)) {
die "Attean::Algebra::Clear operations with a GRAPH target must include a graph IRI";
}
}
}
sub in_scope_variables { return; }
sub tree_attributes { return; }
sub algebra_as_string {
my $self = shift;
return $self->drop ? 'Drop' : 'Clear';
}
sub sparql_tokens {
my $self = shift;
my @tokens;
push(@tokens, AtteanX::SPARQL::Token->keyword($self->drop ? 'DROP' : 'CLEAR'));
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
if ($self->target =~ /^(DEFAULT|NAMED|ALL)$/) {
push(@tokens, AtteanX::SPARQL::Token->keyword($self->target));
} else {
push(@tokens, AtteanX::SPARQL::Token->keyword('GRAPH'));
push(@tokens, $self->graph->sparql_tokens->elements);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Create 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Bool ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'graph' => (is => 'ro', isa => ConsumerOf['Attean::API::Term'], required => 1);
sub in_scope_variables { return; }
sub tree_attributes { return; }
sub algebra_as_string { return 'Create' }
sub sparql_tokens {
my $self = shift;
my @tokens;
push(@tokens, AtteanX::SPARQL::Token->keyword('CREATE'));
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
push(@tokens, AtteanX::SPARQL::Token->keyword('GRAPH'));
push(@tokens, $self->graph->sparql_tokens->elements);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Add 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(Enum Bool ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::NullaryQueryTree';
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'drop_source' => (is => 'ro', isa => Bool, default => 0);
has 'drop_destination' => (is => 'ro', isa => Bool, default => 0);
has 'source' => (is => 'ro', isa => ConsumerOf['Attean::API::Term'], predicate => 'has_source');
has 'destination' => (is => 'ro', isa => ConsumerOf['Attean::API::Term'], predicate => 'has_destination');
sub in_scope_variables { return; }
sub tree_attributes { return; }
sub algebra_as_string {
my $self = shift;
return ($self->drop_source and $self->drop_destination) ? 'Move' : ($self->drop_destination) ? 'Copy' : 'Add';
}
sub sparql_tokens {
my $self = shift;
my @tokens;
my $op = ($self->drop_source and $self->drop_destination) ? 'MOVE' : ($self->drop_destination) ? 'COPY' : 'ADD';
push(@tokens, AtteanX::SPARQL::Token->keyword($op));
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
if ($self->has_source) {
push(@tokens, AtteanX::SPARQL::Token->keyword('GRAPH'));
push(@tokens, $self->source->sparql_tokens->elements);
} else {
push(@tokens, AtteanX::SPARQL::Token->keyword('DEFAULT'));
}
push(@tokens, AtteanX::SPARQL::Token->keyword('TO'));
if ($self->has_destination) {
push(@tokens, AtteanX::SPARQL::Token->keyword('GRAPH'));
push(@tokens, $self->destination->sparql_tokens->elements);
} else {
push(@tokens, AtteanX::SPARQL::Token->keyword('DEFAULT'));
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
=item * L
=cut
package Attean::Algebra::Modify 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use List::MoreUtils qw(all any);
use Types::Standard qw(HashRef ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::QueryTree';
has 'dataset' => (is => 'ro', isa => HashRef, default => sub { +{} });
has 'insert' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TripleOrQuadPattern']], default => sub { [] });
has 'delete' => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::TripleOrQuadPattern']], default => sub { [] });
sub in_scope_variables { return; }
sub tree_attributes { return; }
sub _op_type {
my $self = shift;
my $i = scalar(@{ $self->insert });
my $d = scalar(@{ $self->delete });
my $w = scalar(@{ $self->children });
my $ig = all { $_->is_ground } @{ $self->insert };
my $dg = all { $_->is_ground } @{ $self->delete };
if ($i and not $d) {
# INSERT
return ($ig and not $w) ? 'ID' : 'I';
} elsif ($d and not $i) {
# DELETE
return ($dg and not $w) ? 'DD' : 'D';
} else {
# INSERT + DELETE
return 'U'
}
}
around 'blank_nodes' => sub {
my $orig = shift;
my $self = shift;
my @blanks = $orig->($self, @_);
my %seen = map { $_->value => 1 } @blanks;
foreach my $data ($self->insert, $self->delete) {
my @triples = @{ $data };
my @b = grep { $_->does('Attean::API::Blank') } map { $_->values } @triples;
push(@blanks, grep { not $seen{$_->value}++ } @b);
}
return @blanks;
};
sub algebra_as_string {
my $self = shift;
my $level = shift;
my $indent = ' ' x ($level + 1);
state $S = {
'ID' => 'Insert Data',
'I' => 'Insert',
'DD' => 'Delete Data',
'D' => 'Delete',
'U' => 'Update',
};
my $op = $self->_op_type();
my $s = $S->{ $op };
my @data;
my $ic = scalar(@{ $self->insert });
my $dc = scalar(@{ $self->delete });
if ($ic) {
my $name = $dc ? 'Insert Data' : 'Data';
push(@data, [$name, $self->insert]);
}
if ($dc) {
my $name = $ic ? 'Delete Data' : 'Data';
push(@data, [$name, $self->delete]);
}
foreach my $data (@data) {
my ($name, $quads) = @$data;
$s .= "\n-${indent} $name";
foreach my $q (@$quads) {
$s .= "\n-${indent} " . $q->as_string;
}
}
return $s;
}
sub sparql_tokens {
my $self = shift;
my $op = $self->_op_type();
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my $dot = AtteanX::SPARQL::Token->dot;
my $data = AtteanX::SPARQL::Token->keyword('DATA');
my $insert = AtteanX::SPARQL::Token->keyword('INSERT');
my $delete = AtteanX::SPARQL::Token->keyword('DELETE');
my $where = AtteanX::SPARQL::Token->keyword('WHERE');
my $using = AtteanX::SPARQL::Token->keyword('USING');
my $named = AtteanX::SPARQL::Token->keyword('NAMED');
# TODO: Support 'DELETE WHERE' shortcut syntax
# TODO: Support WITH
my @dataset;
my $dataset = $self->dataset;
my @default = @{ $dataset->{default} || [] };
my @named = values %{ $dataset->{named} || {} };
if (scalar(@default) or scalar(@named)) {
foreach my $g (sort { $a->as_string cmp $b->as_string } @default) {
push(@dataset, $using, $g->sparql_tokens->elements);
}
foreach my $g (sort { $a->as_string cmp $b->as_string } @named) {
push(@dataset, $using, $named, $g->sparql_tokens->elements);
}
}
my @tokens;
if ($op eq 'ID' or $op eq 'DD') {
my $statements = ($op eq 'ID') ? $self->insert : $self->delete;
my $kw = ($op eq 'ID') ? $insert : $delete;
push(@tokens, $kw);
push(@tokens, $data);
push(@tokens, $l);
foreach my $t (@{ $statements }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $dot);
}
push(@tokens, $r);
} elsif ($op eq 'I' or $op eq 'D') {
my $statements = ($op eq 'I') ? $self->insert : $self->delete;
my $kw = ($op eq 'I') ? $insert : $delete;
push(@tokens, $kw);
push(@tokens, $l);
foreach my $t (@{ $statements }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $dot);
}
push(@tokens, $r);
push(@tokens, @dataset);
push(@tokens, $where);
push(@tokens, $l);
foreach my $c (@{ $self->children }) {
push(@tokens, $c->sparql_tokens->elements);
}
push(@tokens, $r);
} else {
foreach my $x ([$delete, $self->delete], [$insert, $self->insert]) {
my ($kw, $statements) = @$x;
push(@tokens, $kw);
push(@tokens, $l);
foreach my $t (@{ $statements }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $dot);
}
push(@tokens, $r);
}
push(@tokens, @dataset);
push(@tokens, $where);
push(@tokens, $l);
foreach my $c (@{ $self->children }) {
push(@tokens, $c->sparql_tokens->elements);
}
push(@tokens, $r);
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/TermMap.pm 000644 000765 000024 00000000225 14316376573 020676 x ustar 00greg staff 000000 000000 30 mtime=1664744827.489007083
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/TermMap.pm 000644 000765 000024 00000010212 14316376573 016722 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::TermMap - Mapping terms to new terms
=head1 VERSION
This document describes Attean::TermMap version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $m = Attean::TermMap->short_blank_map;
my $new_blank = $m->map( Attean::Blank->new('abcdefg') );
say $new_blank->ntriples_string; # _:a
=head1 DESCRIPTION
The Attean::TermMap class represents a one-way mapping process from and to
L objects. This mapping may rename the blank identifiers,
skolemize nodes, or map the nodes in some other, custom way.
It conforms to the L role.
=head1 ATTRIBUTES
=over 4
=item C<< mapper >>
A CODE reference that will map L objects to (possibly different)
term objects.
=back
=head1 CLASS METHODS
=over 4
=cut
package Attean::TermMap 0.033 {
use Moo;
use Types::Standard qw(CodeRef);
use Attean::API::Binding;
use UUID::Tiny ':std';
use namespace::clean;
with 'Attean::Mapper';
has 'mapper' => (is => 'ro', isa => CodeRef, default => sub { shift }, required => 1);
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
if (scalar(@_) == 1) {
return $class->$orig(mapper => shift);
}
return $class->$orig(@_);
};
=item C<< canonicalization_map >>
Returns a new L that canonicalizes recognized typed
L values.
=cut
sub canonicalization_map {
my $class = shift;
my %map;
return $class->new(mapper => sub {
my $term = shift;
return $term unless ($term->does('Attean::API::Literal'));
if ($term->does('Attean::API::CanonicalizingLiteral')) {
my $c = eval { $term->canonicalized_term };
return ($@) ? undef : $c;
}
return $term;
});
}
=item C<< uuid_blank_map >>
Returns a new L that renames blank nodes with UUID values.
=cut
sub uuid_blank_map {
my $class = shift;
my %map;
return $class->new(mapper => sub {
my $term = shift;
return $term unless ($term->does('Attean::API::Blank'));
my $id = $term->value;
return $map{$id} if (defined($map{$id}));
my $uuid = unpack('H*', create_uuid());
my $new = Attean::Blank->new( 'b' . $uuid );
$map{$id} = $new;
return $new;
});
}
=item C<< short_blank_map >>
Returns a new L that renames blank nodes with short
alphabetic names (e.g. _:a, _:b).
=cut
sub short_blank_map {
my $class = shift;
my %map;
my $next = 'a';
return $class->new(mapper => sub {
my $term = shift;
return $term unless ($term->does('Attean::API::Blank'));
my $id = $term->value;
if (defined(my $t = $map{$id})) {
return $t;
} else {
my $new = Attean::Blank->new( $next++ );
$map{$id} = $new;
return $new;
}
});
}
=item C<< rewrite_map( \%map ) >>
Given C<< %map >> whose keys are term C<< as_string >> serializations, and
objects are L objects, returns a new term map object that
maps terms matching entries in C<< %map >>, and all other terms to themselves.
=cut
sub rewrite_map {
my $class = shift;
my $map = shift;
return $class->new(mapper => sub {
my $term = shift;
return $map->{ $term->as_string } if (exists $map->{ $term->as_string });
return $term;
});
}
=back
=head1 METHODS
=over 4
=item C<< map( $term ) >>
Returns the term that is mapped to by the supplied C<< $term >>.
=cut
sub map {
my $self = shift;
my $term = shift;
return $self->mapper->( $term );
}
=item C<< binding_mapper >>
Returns a mapping function reference that maps L
objects by mapping their constituent mapped L objects.
=cut
sub binding_mapper {
my $self = shift;
return sub {
my $binding = shift;
return $binding->apply_map($self);
}
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/AggregateExpression.pod 000644 000765 000024 00000000225 14316376567 023450 x ustar 00greg staff 000000 000000 30 mtime=1664744823.324433341
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/AggregateExpression.pod 000644 000765 000024 00000002702 14316376567 021501 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::AggregateExpression - Representation of aggregate expression trees
=head1 VERSION
This document describes Attean::AggregateExpression version 0.033
=head1 DESCRIPTION
The Attean::AggregateExpression class represents an expression tree where the
root node is an aggregate operation (e.g. SUM(?a) or COALESCE(?a/?b, ?c, 0)).
=head1 ROLES
This role consumes the L role.
=head1 ATTRIBUTES
The following attributes exist:
=over 4
=item C<< operator >>
The name of the aggregate operator, from the allowable set: COUNT, SUM, MIN,
MAX, AVG, GROUP_CONCAT, SAMPLE.
=item C<< scalar_vars >>
A HASH reference of scalar variables. The only scalar variable defined for
SPARQL 1.1 is C<'seperator'>, a string separator used with the GROUP_CONCAT
aggregate.
=item C<< distinct >>
A boolean indicating whether the aggregate should operate over distinct term sets, or full multisets.
=item C<< variable >>
A L object which will be bound to the produced aggregate value in results.
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/BindingEqualityTest.pm 000644 000765 000024 00000000225 14316376572 023260 x ustar 00greg staff 000000 000000 30 mtime=1664744826.561905816
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/BindingEqualityTest.pm 000644 000765 000024 00000023606 14316376572 021317 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::BindingEqualityTest - Test for equality of binding sets with bnode isomorphism
=head1 VERSION
This document describes Attean::BindingEqualityTest version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $test = Attean::BindingEqualityTest->new();
if ($test->equals($iter_a, $iter_b)) {
say "Iterators contain equivalent bindings";
}
=head1 DESCRIPTION
...
=head1 METHODS
=over 4
=cut
package Attean::BindingEqualityTest::_Iter {
sub new {
my $class = shift;
my @iters = @_;
my @values = $class->_materialize([], @iters);
return bless(\@values, $class);
}
sub _materialize {
my $class = shift;
my $v = shift;
my @iters = @_;
if (scalar(@iters)) {
my $i = shift(@iters);
my @values;
while (my $vv = $i->next) {
my $prefix = [@$v, @$vv];
push(@values, $class->_materialize($prefix, @iters));
}
return @values;
} else {
return $v;
}
}
sub next {
my $self = shift;
return shift(@$self);
}
}
package Attean::BindingEqualityTest 0.033 {
use v5.14;
use warnings;
use Moo;
use Types::Standard qw(CodeRef ConsumerOf Str);
use Data::Dumper;
use Algorithm::Combinatorics qw(permutations);
use Scalar::Util qw(blessed);
use List::Util qw(shuffle);
use Attean::RDF;
use Digest::MD5 qw(md5_hex);
use namespace::clean;
with 'MooX::Log::Any';
has error => (is => 'rw', isa => Str, init_arg => undef);
sub _coerce {
my $o = shift;
if ($o->does('Attean::API::Model')) {
return $o->get_quads;
} elsif ($o->does('Attean::API::Iterator')) {
return $o;
}
return;
}
=item C<< equals ( $graph1, $graph2 ) >>
Returns true if the invocant and $graph represent two equal RDF graphs (e.g.
there exists a bijection between the RDF statements of the invocant and $graph).
=cut
sub equals {
my $self = shift;
$self->error('');
return $self->_check_equality(@_) ? 1 : 0;
}
sub _check_equality {
my $self = shift;
my ($a, $b) = map { _coerce($_) } @_;
my @graphs = ($a, $b);
my ($ba, $nba) = $self->split_blank_statements($a);
my ($bb, $nbb) = $self->split_blank_statements($b);
if (scalar(@$nba) != scalar(@$nbb)) {
my $nbac = scalar(@$nba);
my $nbbc = scalar(@$nbb);
# warn "====================================================\n";
# warn "BindingEqualityTest count of non-blank statements didn't match:\n";
# warn "-------- a\n";
# foreach my $t (@$nba) {
# warn $t->as_string . "\n";
# }
# warn "-------- b\n";
# foreach my $t (@$nbb) {
# warn $t->as_string . "\n";
# }
$self->error("count of non-blank statements didn't match ($nbac != $nbbc)");
return 0;
}
my $bac = scalar(@$ba);
my $bbc = scalar(@$bb);
if ($bac != $bbc) {
$self->error("count of blank statements didn't match ($bac != $bbc)");
return 0;
}
for ($nba, $nbb) {
@$_ = sort map { $_->as_string } @$_;
}
foreach my $i (0 .. $#{ $nba }) {
unless ($nba->[$i] eq $nbb->[$i]) {
# warn "====================================================\n";
# warn "BindingEqualityTest non-blank statements didn't match:\n";
# warn "-------- a\n";
# foreach my $t (@$nba) {
# warn $t . "\n";
# }
# warn "-------- b\n";
# foreach my $t (@$nbb) {
# warn $t . "\n";
# }
$self->error("non-blank triples don't match:\n" . Dumper($nba->[$i], $nbb->[$i]));
return 0;
}
}
return _find_mapping($self, $ba, $bb, 1);
}
=item C<< is_subgraph_of ( $graph1, $graph2 ) >>
Returns true if the invocant is a subgraph of $graph. (i.e. there exists an
injection of RDF statements from the invocant to $graph.)
=cut
sub is_subgraph_of {
my $self = shift;
$self->error('');
return $self->_check_subgraph(@_) ? 1 : 0;
}
=item C<< injection_map ( $graph1, $graph2 ) >>
If the invocant is a subgraph of $graph, returns a mapping of blank node
identifiers from the invocant graph to $graph as a hashref. Otherwise
returns false. The solution is not always unique; where there exist multiple
solutions, the solution returned is arbitrary.
=cut
sub injection_map {
my $self = shift;
$self->error('');
my $map = $self->_check_subgraph(@_);
return $map if $map;
return;
}
sub _check_subgraph {
my $self = shift;
my ($a, $b) = map { _coerce($_) } @_;
my @graphs = ($a, $b);
my ($ba, $nba) = $self->split_blank_statements($a);
my ($bb, $nbb) = $self->split_blank_statements($b);
if (scalar(@$nba) > scalar(@$nbb)) {
$self->error("invocant had too many blank node statements to be a subgraph of argument");
return 0;
} elsif (scalar(@$ba) > scalar(@$bb)) {
$self->error("invocant had too many non-blank node statements to be a subgraph of argument");
return 0;
}
my %NBB = map { $_->as_string => 1 } @$nbb;
foreach my $st (@$nba) {
unless ($NBB{ $st->as_string }) {
return 0;
}
}
return _find_mapping($self, $ba, $bb);
}
sub _statement_blank_irisets {
my $self = shift;
my @st = @_;
my %blank_ids_b_iris;
foreach my $st (@st) {
my @iris = map { $_->value } grep { $_->does('Attean::API::IRI') } $st->values;
unless (scalar(@iris)) {
push(@iris, '_');
}
foreach my $n (grep { $_->does('Attean::API::Blank') } $st->values) {
foreach my $i (@iris) {
$blank_ids_b_iris{$n->value}{$i}++;
}
}
}
my %iri_blanks;
foreach my $bid (sort keys %blank_ids_b_iris) {
my $d = Digest::MD5->new();
foreach my $iri (sort keys %{ $blank_ids_b_iris{$bid} }) {
$d->add($iri);
}
$iri_blanks{$d->hexdigest}{$bid}++;
}
return \%iri_blanks;
}
sub _find_mapping {
my $self = shift;
my $ba = shift;
my $bb = shift;
my $equal = shift || 0;
# warn "########### _find_mapping:\n";
# warn "============ A\n";
# foreach my $t (@$ba) {
# warn $t->as_string . "\n";
# }
# warn "============ B\n";
# foreach my $t (@$bb) {
# warn $t->as_string . "\n";
# }
if (scalar(@$ba) == 0) {
return {};
}
my %blank_ids_a;
foreach my $st (@$ba) {
foreach my $n ($st->blanks) {
$blank_ids_a{ $n->value }++;
}
}
my %blank_ids_b;
foreach my $st (@$bb) {
foreach my $n ($st->blanks) {
$blank_ids_b{ $n->value }++;
}
}
my (@ka, @kb);
my $kbp;
# if ($equal) {
# # if we're testing for equality, and not just finding an injection mapping,
# # we can avoid unnecessary work by restricting mappings to those where each
# # permutation only maps blank nodes to other blank nodes that appear in
# # similar bindings (in this case they appear with all the same IRIs)
# my $ba_iri_blanks = $self->_statement_blank_irisets(@$ba);
#
# my $bb_iri_blanks = $self->_statement_blank_irisets(@$bb);
#
# my $ba_keys = join('|', sort keys %$ba_iri_blanks);
# my $bb_keys = join('|', sort keys %$bb_iri_blanks);
# unless ($ba_keys eq $bb_keys) {
# $self->error("didn't find blank node mapping\n");
# return 0;
# }
#
# my @iters;
# foreach my $k (sort keys %$ba_iri_blanks) {
# unless (scalar(@{[keys %{ $ba_iri_blanks->{$k} }]}) == scalar(@{[keys %{ $bb_iri_blanks->{$k} }]})) {
# $self->error("didn't find blank node mapping\n");
# return 0;
# }
# push(@ka, keys %{ $ba_iri_blanks->{$k} });
# push(@kb, keys %{ $bb_iri_blanks->{$k} });
# my $i = permutations([keys %{ $bb_iri_blanks->{$k} }]);
# push(@iters, $i);
# }
#
# if (scalar(@iters) == 1) {
# $kbp = shift(@iters);
# } else {
# $kbp = Attean::BindingEqualityTest::_Iter->new(@iters);
# }
# } else {
@ka = keys %blank_ids_a;
@kb = keys %blank_ids_b;
$kbp = permutations( [shuffle @kb] );
# }
my $canon_map = Attean::TermMap->canonicalization_map;
my %bb_master = map { $_->apply_map($canon_map)->as_string => 1 } @$bb;
my $count = 0;
MAPPING: while (my $mapping = $kbp->next) {
my %mapping_str;
@mapping_str{ @ka } = @$mapping;
my %mapping = map {
Attean::Blank->new($_)->as_string => Attean::Blank->new($mapping_str{$_})
} (keys %mapping_str);
my $mapper = Attean::TermMap->rewrite_map(\%mapping);
$self->log->trace("trying mapping: " . Dumper($mapping));
my %bb = %bb_master;
foreach my $st (@$ba) {
my $mapped_st = $st->apply_map($mapper)->as_string;
# warn ">>>>>>>\n";
# warn "-> " . $st->as_string . "\n";
# warn "-> " . $mapped_st . "\n";
$self->log->trace("checking for '$mapped_st' in " . Dumper(\%bb));
if ($bb{ $mapped_st }) {
$self->log->trace("Found mapping for binding: " . Dumper($mapped_st));
delete $bb{ $mapped_st };
} else {
$self->log->trace("No mapping found for binding: " . Dumper($mapped_st));
# warn "No mapping found for binding: " . Dumper($mapped_st);
# warn Dumper(\%bb);
next MAPPING;
}
}
$self->error("found mapping: " . Dumper(\%mapping_str));
return \%mapping_str;
}
# warn "didn't find blank node mapping:\n";
# warn "============ A\n";
# foreach my $t (@$ba) {
# warn $t->as_string . "\n";
# }
# warn "============ B\n";
# foreach my $t (@$bb) {
# warn $t->as_string . "\n";
# }
$self->error("didn't find blank node mapping\n");
return 0;
}
=item C<< split_blank_statements( $iter ) >>
Returns two array refs containing bindings from C<< $iter >>, with bindings
containing blank nodes and bindings without any blank nodes, respectively.
=cut
sub split_blank_statements {
my $self = shift;
my $iter = shift;
my (@blanks, @nonblanks);
while (my $st = $iter->next) {
if ($st->has_blanks) {
push(@blanks, $st);
} else {
push(@nonblanks, $st);
}
}
return (\@blanks, \@nonblanks);
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/QueryPlanner.pm 000644 000765 000024 00000000225 14316376573 021756 x ustar 00greg staff 000000 000000 30 mtime=1664744827.240968198
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/QueryPlanner.pm 000644 000765 000024 00000111436 14316376573 020014 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::QueryPlanner - Query planner
=head1 VERSION
This document describes Attean::QueryPlanner version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $planner = Attean::QueryPlanner->new();
my $default_graphs = [ Attean::IRI->new('http://example.org/') ];
my $plan = $planner->plan_for_algebra( $algebra, $model, $default_graphs );
my $iter = $plan->evaluate($model);
while (my $result = $iter->next()) {
say $result->as_string;
}
=head1 DESCRIPTION
The Attean::QueryPlanner class is a base class implementing common behavior for
query planners. Subclasses will need to consume or compose the
L role.
Trivial sub-classes may consume L, while more
complex planners may choose to implement complex join planning (e.g.
L).
=head1 ATTRIBUTES
=over 4
=cut
use Attean::Algebra;
use Attean::Plan;
use Attean::Expression;
package Attean::QueryPlanner 0.033 {
use Moo;
use Encode qw(encode);
use Attean::RDF;
use Scalar::Util qw(blessed reftype);
use List::Util qw(reduce);
use List::MoreUtils qw(all any);
use Types::Standard qw(Int ConsumerOf InstanceOf);
use URI::Escape;
use Algorithm::Combinatorics qw(subsets);
use List::Util qw(min);
use Math::Cartesian::Product;
use namespace::clean;
with 'Attean::API::QueryPlanner', 'MooX::Log::Any';
has 'counter' => (is => 'rw', isa => Int, default => 0);
has 'table_threshold' => (is => 'rw', isa => Int, default => 10);
=back
=head1 METHODS
=over 4
=item C<< new_temporary( $type ) >>
Returns a new unique (in the context of the query planner) ID string that may
be used for things like fresh (temporary) variables. The C<< $type >> string is
used in the generated name to aid in identifying different uses for the names.
=cut
sub new_temporary {
my $self = shift;
my $type = shift;
my $c = $self->counter;
$self->counter($c+1);
return sprintf('.%s-%d', $type, $c);
}
=item C<< plan_for_algebra( $algebra, $model, \@active_graphs, \@default_graphs ) >>
Returns the first plan returned from C<< plans_for_algebra >>.
=cut
sub plan_for_algebra {
my $self = shift;
my @plans = $self->plans_for_algebra(@_);
return shift(@plans);
}
=item C<< plans_for_algebra( $algebra, $model, \@active_graphs, \@default_graphs ) >>
Returns L objects representing alternate query plans for
evaluating the query C<< $algebra >> against the C<< $model >>, using
the supplied C<< $active_graph >>.
=cut
sub plans_for_algebra {
my $self = shift;
my $algebra = shift;
my $model = shift;
my $active_graphs = shift;
my $default_graphs = shift;
my %args = @_;
if ($model->does('Attean::API::CostPlanner')) {
my @plans = $model->plans_for_algebra($algebra, $self, $active_graphs, $default_graphs, %args);
if (@plans) {
return @plans; # trust that the model knows better than us what plans are best
} else {
$self->log->info("*** Model did not provide plans: $model");
}
}
Carp::confess "No algebra passed for evaluation" unless ($algebra);
# TODO: propagate interesting orders
my $interesting = [];
my @children = @{ $algebra->children };
my ($child) = $children[0];
if ($algebra->isa('Attean::Algebra::Query') or $algebra->isa('Attean::Algebra::Update')) {
return $self->plans_for_algebra($algebra->child, $model, $active_graphs, $default_graphs, %args);
} elsif ($algebra->isa('Attean::Algebra::BGP')) {
my $triples = $algebra->triples;
my @triples = @$triples;
my %blanks;
foreach my $i (0 .. $#triples) {
my $t = $triples[$i];
my @nodes = $t->values;
my $changed = 0;
foreach (@nodes) {
if ($_->does('Attean::API::Blank')) {
$changed++;
my $id = $_->value;
unless (exists $blanks{$id}) {
$blanks{$id} = Attean::Variable->new(value => $self->new_temporary('blank'));
}
$_ = $blanks{$id};
}
}
if ($changed) {
my $new = Attean::TriplePattern->new(@nodes);
$triples[$i] = $new;
}
}
my $bgp = Attean::Algebra::BGP->new( triples => \@triples );
my @plans = $self->bgp_join_plans($bgp, $model, $active_graphs, $default_graphs, $interesting, map {
[$self->access_plans($model, $active_graphs, $_)]
} @triples);
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Join')) {
return $self->group_join_plans($model, $active_graphs, $default_graphs, $interesting, map {
[$self->plans_for_algebra($_, $model, $active_graphs, $default_graphs, %args)]
} @children);
} elsif ($algebra->isa('Attean::Algebra::Distinct') or $algebra->isa('Attean::Algebra::Reduced')) {
my @plans = $self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args);
my @dist;
foreach my $p (@plans) {
if ($p->distinct) {
push(@dist, $p);
} else {
my @vars = @{ $p->in_scope_variables };
my $cmps = $p->ordered;
if ($self->_comparators_are_stable_and_cover_vars($cmps, @vars)) {
# the plan has a stable ordering which covers all the variables, so we can just uniq the iterator
push(@dist, Attean::Plan::Unique->new(children => [$p], distinct => 1, ordered => $p->ordered));
} else {
# TODO: if the plan isn't distinct, but is ordered, we can use a batched implementation
push(@dist, Attean::Plan::HashDistinct->new(children => [$p], distinct => 1, ordered => $p->ordered));
}
}
}
return @dist;
} elsif ($algebra->isa('Attean::Algebra::Filter')) {
# TODO: simple range relation filters can be handled differently if that filter operates on a variable that is part of the ordering
my $expr = $algebra->expression;
my $w = Attean::TreeRewriter->new(types => ['Attean::API::DirectedAcyclicGraph']);
$w->register_pre_handler(sub {
my ($t, $parent, $thunk) = @_;
if ($t->isa('Attean::ExistsExpression')) {
my $pattern = $t->pattern;
my $plan = $self->plan_for_algebra($pattern, $model, $active_graphs, $default_graphs, @_);
unless ($plan->does('Attean::API::BindingSubstitutionPlan')) {
die 'Exists plan does not consume Attean::API::BindingSubstitutionPlan: ' . $plan->as_string;
}
my $new = Attean::ExistsPlanExpression->new(
plan => $plan,
);
return (1, 0, $new);
}
return (0, 1, $t);
});
my ($changed, $rewritten) = $w->rewrite($expr, {});
if ($changed) {
$expr = $rewritten;
}
my $var = $self->new_temporary('filter');
my %exprs = ($var => $expr);
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args)) {
my $distinct = $plan->distinct;
my $ordered = $plan->ordered;
if ($expr->isa('Attean::ValueExpression') and $expr->value->does('Attean::API::Variable')) {
my $filtered = Attean::Plan::EBVFilter->new(children => [$plan], variable => $expr->value->value, distinct => $distinct, ordered => $ordered);
push(@plans, $filtered);
} else {
my @vars = ($var);
my @inscope = ($var, @{ $plan->in_scope_variables });
my @pvars = map { Attean::Variable->new($_) } @{ $plan->in_scope_variables };
my $extend = Attean::Plan::Extend->new(children => [$plan], expressions => \%exprs, distinct => 0, ordered => $ordered);
my $filtered = Attean::Plan::EBVFilter->new(children => [$extend], variable => $var, distinct => 0, ordered => $ordered);
my $proj = $self->new_projection($filtered, $distinct, @{ $plan->in_scope_variables });
push(@plans, $proj);
}
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::OrderBy')) {
# TODO: no-op if already ordered
my @cmps = @{ $algebra->comparators };
my ($exprs, $ascending, $svars) = $self->_order_by($algebra);
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, interesting_order => $algebra->comparators, %args)) {
my $distinct = $plan->distinct;
if (scalar(@cmps) == 1 and $cmps[0]->expression->isa('Attean::ValueExpression') and $cmps[0]->expression->value->does('Attean::API::Variable')) {
# TODO: extend this to handle more than one comparator, so long as they are *all* just variables (and not complex expressions)
# If we're sorting by just a variable name, don't bother creating new variables for the sort expressions, use the underlying variable directy
my @vars = @{ $plan->in_scope_variables };
my @pvars = map { Attean::Variable->new($_) } @{ $plan->in_scope_variables };
my $var = $cmps[0]->expression->value->value;
my $ascending = { $var => $cmps[0]->ascending };
my $ordered = Attean::Plan::OrderBy->new(children => [$plan], variables => [$var], ascending => $ascending, distinct => $distinct, ordered => \@cmps);
push(@plans, $ordered);
} else {
my @vars = (@{ $plan->in_scope_variables }, keys %$exprs);
my @pvars = map { Attean::Variable->new($_) } @{ $plan->in_scope_variables };
my $extend = Attean::Plan::Extend->new(children => [$plan], expressions => $exprs, distinct => 0, ordered => $plan->ordered);
my $ordered = Attean::Plan::OrderBy->new(children => [$extend], variables => $svars, ascending => $ascending, distinct => 0, ordered => \@cmps);
my $proj = $self->new_projection($ordered, $distinct, @{ $plan->in_scope_variables });
push(@plans, $proj);
}
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::LeftJoin')) {
my $l = [$self->plans_for_algebra($children[0], $model, $active_graphs, $default_graphs, %args)];
my $r = [$self->plans_for_algebra($children[1], $model, $active_graphs, $default_graphs, %args)];
return $self->join_plans($model, $active_graphs, $default_graphs, $l, $r, 'left', $algebra->expression);
} elsif ($algebra->isa('Attean::Algebra::Minus')) {
my $l = [$self->plans_for_algebra($children[0], $model, $active_graphs, $default_graphs, %args)];
my $r = [$self->plans_for_algebra($children[1], $model, $active_graphs, $default_graphs, %args)];
return $self->join_plans($model, $active_graphs, $default_graphs, $l, $r, 'minus');
} elsif ($algebra->isa('Attean::Algebra::Project')) {
my $vars = $algebra->variables;
my @vars = map { $_->value } @{ $vars };
my $vars_key = join(' ', sort @vars);
my $distinct = 0;
my @plans = map {
($vars_key eq join(' ', sort @{ $_->in_scope_variables }))
? $_ # no-op if plan is already properly-projected
: $self->new_projection($_, $distinct, @vars)
} $self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args);
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Graph')) {
my $graph = $algebra->graph;
if ($graph->does('Attean::API::Term')) {
if (my $available = $args{available_graphs}) {
# the list of available graphs has been restricted, and this
# graph is not available so return an empty table plan.
unless (any { $_->equals($graph) } @$available) {
my $plan = Attean::Plan::Table->new( variables => [], rows => [], distinct => 0, ordered => [] );
return $plan;
}
}
return $self->plans_for_algebra($child, $model, [$graph], $default_graphs, %args);
} else {
my $gvar = $graph->value;
my $graphs = $model->get_graphs;
my @plans;
my %vars = map { $_ => 1 } $child->in_scope_variables;
$vars{ $gvar }++;
my @vars = keys %vars;
my %available;
if (my $available = $args{available_graphs}) {
foreach my $a (@$available) {
$available{ $a->value }++;
}
$graphs = $graphs->grep(sub { $available{ $_->value } });
}
my @branches;
my %ignore = map { $_->value => 1 } @$default_graphs;
while (my $graph = $graphs->next) {
next if $ignore{ $graph->value };
my %exprs = ($gvar => Attean::ValueExpression->new(value => $graph));
# TODO: rewrite $child pattern here to replace any occurrences of the variable $gvar to $graph
my @plans = map {
Attean::Plan::Extend->new(children => [$_], expressions => \%exprs, distinct => 0, ordered => $_->ordered);
} $self->plans_for_algebra($child, $model, [$graph], $default_graphs, %args);
push(@branches, \@plans);
}
if (scalar(@branches) == 1) {
@plans = @{ shift(@branches) };
} else {
cartesian { push(@plans, Attean::Plan::Union->new(children => [@_], distinct => 0, ordered => [])) } @branches;
}
return @plans;
}
} elsif ($algebra->isa('Attean::Algebra::Table')) {
my $rows = $algebra->rows;
my $vars = $algebra->variables;
my @vars = map { $_->value } @{ $vars };
if (scalar(@$rows) < $self->table_threshold) {
return Attean::Plan::Table->new( variables => $vars, rows => $rows, distinct => 0, ordered => [] );
} else {
my $iter = Attean::ListIterator->new(
item_type => 'Attean::API::Result',
variables => \@vars,
values => $rows
);
return Attean::Plan::Iterator->new( iterator => $iter, distinct => 0, ordered => [] );
}
} elsif ($algebra->isa('Attean::Algebra::Service')) {
my $endpoint = $algebra->endpoint;
my $silent = $algebra->silent;
my $sparql = sprintf('SELECT * WHERE { %s }', $child->as_sparql);
my @vars = $child->in_scope_variables;
my $plan = Attean::Plan::Service->new(
request_signer => $self->request_signer,
endpoint => $endpoint,
silent => $silent,
sparql => $sparql,
distinct => 0,
in_scope_variables => \@vars,
ordered => []
);
return $plan;
} elsif ($algebra->isa('Attean::Algebra::Slice')) {
my $limit = $algebra->limit;
my $offset = $algebra->offset;
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args)) {
my $vars = $plan->in_scope_variables;
push(@plans, Attean::Plan::Slice->new(children => [$plan], limit => $limit, offset => $offset, distinct => $plan->distinct, ordered => $plan->ordered));
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Union')) {
# TODO: if both branches are similarly ordered, we can use Attean::Plan::Merge to keep the resulting plan ordered
my @vars = keys %{ { map { map { $_ => 1 } $_->in_scope_variables } @children } };
my @plansets = map { [$self->plans_for_algebra($_, $model, $active_graphs, $default_graphs, %args)] } @children;
my @plans;
cartesian {
push(@plans, Attean::Plan::Union->new(children => \@_, distinct => 0, ordered => []))
} @plansets;
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Extend')) {
my $var = $algebra->variable->value;
my $expr = $algebra->expression;
my %exprs = ($var => $expr);
my @vars = $algebra->in_scope_variables;
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args)) {
my $extend = Attean::Plan::Extend->new(children => [$plan], expressions => \%exprs, distinct => 0, ordered => $plan->ordered);
push(@plans, $extend);
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Group')) {
my $aggs = $algebra->aggregates;
my $groups = $algebra->groupby;
my %exprs;
foreach my $expr (@$aggs) {
my $var = $expr->variable->value;
$exprs{$var} = $expr;
}
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args)) {
my $extend = Attean::Plan::Aggregate->new(children => [$plan], aggregates => \%exprs, groups => $groups, distinct => 0, ordered => []);
push(@plans, $extend);
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Ask')) {
my @plans;
foreach my $plan ($self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args)) {
return Attean::Plan::Exists->new(children => [$plan], distinct => 1, ordered => []);
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Path')) {
my $s = $algebra->subject;
my $path = $algebra->path;
my $o = $algebra->object;
my @algebra = $self->simplify_path($s, $path, $o);
my @join;
if (scalar(@algebra)) {
my @triples;
while (my $pa = shift(@algebra)) {
if ($pa->isa('Attean::TriplePattern')) {
push(@triples, $pa);
} else {
if (scalar(@triples)) {
push(@join, Attean::Algebra::BGP->new( triples => [@triples] ));
@triples = ();
}
push(@join, $pa);
}
}
if (scalar(@triples)) {
push(@join, Attean::Algebra::BGP->new( triples => [@triples] ));
}
my @vars = $algebra->in_scope_variables;
my @joins = $self->group_join_plans($model, $active_graphs, $default_graphs, $interesting, map {
[$self->plans_for_algebra($_, $model, $active_graphs, $default_graphs, %args)]
} @join);
my @plans;
foreach my $j (@joins) {
push(@plans, Attean::Plan::Project->new(children => [$j], variables => [map { Attean::Variable->new($_) } @vars], distinct => 0, ordered => []));
}
return @plans;
} elsif ($path->isa('Attean::Algebra::ZeroOrMorePath') or $path->isa('Attean::Algebra::OneOrMorePath')) {
my $skip = $path->isa('Attean::Algebra::OneOrMorePath') ? 1 : 0;
my $begin = Attean::Variable->new(value => $self->new_temporary('pp'));
my $end = Attean::Variable->new(value => $self->new_temporary('pp'));
my $s_var = $s->does('Attean::API::Variable');
my $o_var = $o->does('Attean::API::Variable');
my $child = $path->children->[0];
my $a;
if ($s_var and not($o_var)) {
my $inv = Attean::Algebra::InversePath->new( children => [$child] );
$a = Attean::Algebra::Path->new( subject => $end, path => $inv, object => $begin );
} else {
$a = Attean::Algebra::Path->new( subject => $begin, path => $child, object => $end );
}
my @cplans = $self->plans_for_algebra($a, $model, $active_graphs, $default_graphs, %args);
my @plans;
foreach my $cplan (@cplans) {
my $plan = Attean::Plan::ALPPath->new(
subject => $s,
children => [$cplan],
object => $o,
graph => $active_graphs,
skip => $skip,
step_begin => $begin,
step_end => $end,
distinct => 0,
ordered => []
);
push(@plans, $plan);
}
return @plans;
} elsif ($path->isa('Attean::Algebra::ZeroOrOnePath')) {
my $a = Attean::Algebra::Path->new( subject => $s, path => $path->children->[0], object => $o );
my @children = $self->plans_for_algebra($a, $model, $active_graphs, $default_graphs, %args);
my @plans;
foreach my $plan (@children) {
push(@plans, Attean::Plan::ZeroOrOnePath->new(
subject => $s,
children => [$plan],
object => $o,
graph => $active_graphs,
distinct => 0,
ordered => []
));
}
return @plans;
} else {
die "Cannot simplify property path $path: " . $algebra->as_string;
}
} elsif ($algebra->isa('Attean::Algebra::Construct')) {
my @children = $self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args);
my @plans;
foreach my $plan (@children) {
push(@plans, Attean::Plan::Construct->new(triples => $algebra->triples, children => [$plan], distinct => 0, ordered => []));
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Describe')) {
my @children = $self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args);
my @plans;
foreach my $plan (@children) {
push(@plans, Attean::Plan::Describe->new(terms => $algebra->terms, graph => $active_graphs, children => [$plan], distinct => 0, ordered => []));
}
return @plans;
} elsif ($algebra->isa('Attean::Algebra::Clear')) {
my $plan_class = $algebra->drop ? 'Attean::Plan::Drop' : 'Attean::Plan::Clear';
my $target = $algebra->target;
if ($target eq 'GRAPH') {
return Attean::Plan::Clear->new(graphs => [$algebra->graph]);
} else {
my %default = map { $_->value => 1 } @$active_graphs;
my $graphs = $model->get_graphs;
my @graphs;
while (my $graph = $graphs->next) {
if ($target eq 'ALL') {
push(@graphs, $graph);
} else {
if ($target eq 'DEFAULT' and $default{ $graph->value }) {
push(@graphs, $graph);
} elsif ($target eq 'NAMED' and not $default{ $graph->value }) {
push(@graphs, $graph);
}
}
}
return $plan_class->new(graphs => \@graphs);
}
} elsif ($algebra->isa('Attean::Algebra::Add')) {
my $triple = triplepattern(variable('s'), variable('p'), variable('o'));
my $child;
my $default_source = 0;
if (my $from = $algebra->source) {
($child) = $self->access_plans( $model, $active_graphs, $triple->as_quad_pattern($from) );
} else {
$default_source++;
my $bgp = Attean::Algebra::BGP->new( triples => [$triple] );
($child) = $self->plans_for_algebra($bgp, $model, $active_graphs, $default_graphs, %args);
}
my $dest;
my $default_dest = 0;
if (my $g = $algebra->destination) {
$dest = $triple->as_quad_pattern($g);
} else {
$default_dest++;
$dest = $triple->as_quad_pattern($default_graphs->[0]);
}
my @plans;
my $run_update = 1;
if ($default_dest and $default_source) {
$run_update = 0;
} elsif ($default_dest or $default_source) {
#
} elsif ($algebra->source->equals($algebra->destination)) {
$run_update = 0;
}
if ($run_update) {
if ($algebra->drop_destination) {
my @graphs = $algebra->has_destination ? $algebra->destination : @$default_graphs;
unshift(@plans, Attean::Plan::Clear->new(graphs => [@graphs]));
}
push(@plans, Attean::Plan::TripleTemplateToModelQuadMethod->new(
graph => $default_graphs->[0],
order => ['add_quad'],
patterns => {'add_quad' => [$dest]},
children => [$child],
));
if ($algebra->drop_source) {
my @graphs = $algebra->has_source ? $algebra->source : @$default_graphs;
push(@plans, Attean::Plan::Clear->new(graphs => [@graphs]));
}
}
my $plan = (scalar(@plans) == 1) ? shift(@plans) : Attean::Plan::Sequence->new( children => \@plans );
return $plan;
} elsif ($algebra->isa('Attean::Algebra::Modify')) {
unless ($child) {
# This is an INSERT/DELETE DATA algebra with ground data and no pattern
$child = Attean::Algebra::BGP->new( triples => [] );
}
my $dataset = $algebra->dataset;
my @default = @{ $dataset->{default} || [] };
my @named = values %{ $dataset->{named} || {} };
my @active_graphs = @$active_graphs;
my @default_graphs = @$default_graphs;
if (scalar(@default) or scalar(@named)) {
# change the available named graphs
# change the active graph(s)
@active_graphs = @default;
@default_graphs = @default;
$args{ available_graphs } = [@named];
} else {
# no custom dataset
}
my @children = $self->plans_for_algebra($child, $model, \@active_graphs, \@default_graphs, %args);
my $i = $algebra->insert;
my $d = $algebra->delete;
my %patterns;
my @order;
if (scalar(@$d)) {
push(@order, 'remove_quad');
$patterns{ 'remove_quad' } = $d;
}
if (scalar(@$i)) {
push(@order, 'add_quad');
$patterns{ 'add_quad' } = $i;
}
return map {
Attean::Plan::TripleTemplateToModelQuadMethod->new(
graph => $default_graphs->[0],
order => \@order,
patterns => \%patterns,
children => [$_],
)
} @children;
} elsif ($algebra->isa('Attean::Algebra::Load')) {
my $pattern = triplepattern(variable('subject'), variable('predicate'), variable('object'));
my $load = Attean::Plan::Load->new( url => $algebra->url->value, silent => $algebra->silent );
my $graph = $algebra->has_graph ? $algebra->graph : $default_graphs->[0];
my $plan = Attean::Plan::TripleTemplateToModelQuadMethod->new(
graph => $graph,
order => ['add_quad'],
patterns => {'add_quad' => [$pattern]},
children => [$load],
);
return $plan;
} elsif ($algebra->isa('Attean::Algebra::Create')) {
return Attean::Plan::Sequence->new( children => [] );
} elsif ($algebra->isa('Attean::Algebra::Sequence')) {
my @plans;
foreach my $child (@{ $algebra->children }) {
my ($plan) = $self->plans_for_algebra($child, $model, $active_graphs, $default_graphs, %args);
push(@plans, $plan);
}
return Attean::Plan::Sequence->new( children => \@plans );
}
die "Unimplemented algebra evaluation for: " . $algebra->as_string;
}
# sub plans_for_unbounded_path {
# my $self = shift;
# my $algebra = shift;
# my $model = shift;
# my $active_graphs = shift;
# my $default_graphs = shift;
# my %args = @_;
#
# my $s = $algebra->subject;
# my $path = $algebra->path;
# my $o = $algebra->object;
#
# return Attean::Plan::ALPPath->new(distinct => 0, ordered => []);
# }
sub _package {
my $self = shift;
my @args = @_;
my @bgptriples = map { @{ $_->triples } } grep { $_->isa('Attean::Algebra::BGP') } @args;
my @triples = grep { $_->isa('Attean::TriplePattern') } @args;
my @rest = grep { not $_->isa('Attean::Algebra::BGP') and not $_->isa('Attean::TriplePattern') } @args;
if (scalar(@rest) == 0) {
return Attean::Algebra::BGP->new( triples => [@bgptriples, @triples] );
} else {
my $p = Attean::Algebra::BGP->new( triples => [@bgptriples, @triples] );
while (scalar(@rest) > 0) {
$p = Attean::Algebra::Join->new( children => [$p, shift(@rest)] );
}
return $p;
}
}
=item C<< simplify_path( $subject, $path, $object ) >>
Return a simplified L object corresponding to the given
property path.
=cut
sub simplify_path {
my $self = shift;
my $s = shift;
my $path = shift;
my $o = shift;
if ($path->isa('Attean::Algebra::SequencePath')) {
my $jvar = Attean::Variable->new(value => $self->new_temporary('pp'));
my ($lhs, $rhs) = @{ $path->children };
my @paths;
push(@paths, $self->simplify_path($s, $lhs, $jvar));
push(@paths, $self->simplify_path($jvar, $rhs, $o));
return $self->_package(@paths);
} elsif ($path->isa('Attean::Algebra::InversePath')) {
my ($ipath) = @{ $path->children };
return $self->simplify_path($o, $ipath, $s);
} elsif ($path->isa('Attean::Algebra::PredicatePath')) {
my $pred = $path->predicate;
return Attean::TriplePattern->new($s, $pred, $o);
} elsif ($path->isa('Attean::Algebra::AlternativePath')) {
my ($l, $r) = @{ $path->children };
my $la = $self->_package($self->simplify_path($s, $l, $o));
my $ra = $self->_package($self->simplify_path($s, $r, $o));
return Attean::Algebra::Union->new( children => [$la, $ra] );
} elsif ($path->isa('Attean::Algebra::NegatedPropertySet')) {
my @preds = @{ $path->predicates };
my $pvar = Attean::Variable->new(value => $self->new_temporary('nps'));
my $pvar_e = Attean::ValueExpression->new( value => $pvar );
my $t = Attean::TriplePattern->new($s, $pvar, $o);
my @vals = map { Attean::ValueExpression->new( value => $_ ) } @preds;
my $expr = Attean::FunctionExpression->new( children => [$pvar_e, @vals], operator => 'notin' );
my $bgp = Attean::Algebra::BGP->new( triples => [$t] );
my $f = Attean::Algebra::Filter->new( children => [$bgp], expression => $expr );
return $f;
} else {
return;
}
}
=item C<< new_projection( $plan, $distinct, @variable_names ) >>
Return a new L<< Attean::Plan::Project >> plan over C<< $plan >>, projecting
the named variables. C<< $disctinct >> should be true if the caller can
guarantee that the resulting plan will produce distinct results, false otherwise.
This method takes care of computing plan metadata such as the resulting ordering.
=cut
sub new_projection {
my $self = shift;
my $plan = shift;
my $distinct = shift;
my @vars = @_;
my $order = $plan->ordered;
my @pvars = map { Attean::Variable->new($_) } @vars;
my %pvars = map { $_ => 1 } @vars;
my @porder;
CMP: foreach my $cmp (@{ $order }) {
my @cmpvars = $self->_comparator_referenced_variables($cmp);
foreach my $v (@cmpvars) {
unless ($pvars{ $v }) {
# projection is dropping a variable used in this comparator
# so we lose any remaining ordering that the sub-plan had.
last CMP;
}
}
# all the variables used by this comparator are available after
# projection, so the resulting plan will continue to be ordered
# by this comparator
push(@porder, $cmp);
}
return Attean::Plan::Project->new(children => [$plan], variables => \@pvars, distinct => $distinct, ordered => \@porder);
}
=item C<< bgp_join_plans( $bgp, $model, \@active_graphs, \@default_graphs, \@interesting_order, \@plansA, \@plansB, ... ) >>
Returns a list of alternative plans for the join of a set of triples.
The arguments C<@plansA>, C<@plansB>, etc. represent alternative plans for each
triple participating in the join.
=cut
sub bgp_join_plans {
my $self = shift;
my $bgp = shift;
my $model = shift;
my $active = shift;
my $default = shift;
my $interesting = shift;
my @triples = @_;
if (scalar(@triples)) {
my @plans = $self->joins_for_plan_alternatives($model, $active, $default, $interesting, @triples);
my @triples = @{ $bgp->triples };
# If the BGP does not contain any blanks, then the results are
# guaranteed to be distinct. Otherwise, we have to assume they're
# not distinct.
my $distinct = 1;
LOOP: foreach my $t (@triples) {
foreach my $b ($t->values_consuming_role('Attean::API::Blank')) {
$distinct = 0;
last LOOP;
}
foreach my $b ($t->values_consuming_role('Attean::API::Variable')) {
if ($b->value =~ /^[.]/) {
# variable names starting with a dot represent placeholders introduced during query planning (with C)
# they are not projectable, and so may cause an otherwise distinct result to become non-distinct
$distinct = 0;
last LOOP;
}
}
}
# Set the distinct flag on each of the top-level join plans that
# represents the entire BGP. (Sub-plans won't ever be marked as
# distinct, but that shouldn't matter to the rest of the planning
# process.)
if ($distinct) {
foreach my $p (@plans) {
$p->distinct(1);
}
}
return @plans;
} else {
# The empty BGP is a special case -- it results in a single join-identity result
my $r = Attean::Result->new( bindings => {} );
my $plan = Attean::Plan::Table->new( rows => [$r], variables => [], distinct => 1, ordered => [] );
return $plan;
}
}
=item C<< group_join_plans( $model, \@active_graphs, \@default_graphs, \@interesting_order, \@plansA, \@plansB, ... ) >>
Returns a list of alternative plans for the join of a set of sub-plans.
The arguments C<@plansA>, C<@plansB>, etc. represent alternative plans for each
sub-plan participating in the join.
=cut
sub group_join_plans {
my $self = shift;
return $self->joins_for_plan_alternatives(@_);
}
=item C<< joins_for_plan_alternatives( $model, \@active_graphs, \@default_graphs, $interesting, \@plan_A, \@plan_B, ... ) >>
Returns a list of alternative plans that may all be used to produce results
matching the join of C<< plan_A >>, C< plan_B >>, etc. Each plan array here
(e.g. C<< @plan_A >>) should contain equivalent plans.
=cut
sub joins_for_plan_alternatives {
my $self = shift;
my $model = shift;
my $active_graphs = shift;
my $default_graphs = shift;
my $interesting = shift;
my @args = @_; # each $args[$i] here is an array reference containing alternate plans for element $i
die "This query planner does not seem to consume a Attean::API::JoinPlanner role (which is necessary for query planning)";
}
=item C<< access_plans( $model, $active_graphs, $pattern ) >>
Returns a list of alternative L objects that may be used to
produce results matching the L $pattern in
the context of C<< $active_graphs >>.
=cut
# $pattern is a Attean::API::TripleOrQuadPattern object
# Return a Attean::API::Plan object that represents the evaluation of $pattern.
# e.g. different plans might represent different ways of producing the matches (table scan, index match, etc.)
sub access_plans {
my $self = shift;
my $model = shift;
my $active_graphs = shift;
my $pattern = shift;
my @vars = map { $_->value } $pattern->values_consuming_role('Attean::API::Variable');
my %vars;
my $dup = 0;
foreach my $v (@vars) {
$dup++ if ($vars{$v}++);
}
my $distinct = 0; # TODO: is this pattern distinct? does it have blank nodes?
my @nodes = $pattern->values;
unless ($nodes[3]) {
$nodes[3] = $active_graphs;
}
my $plan = Attean::Plan::Quad->new(
subject => $nodes[0],
predicate => $nodes[1],
object => $nodes[2],
graph => $nodes[3],
values => \@nodes,
distinct => $distinct,
ordered => [],
);
return $plan;
}
=item C<< join_plans( $model, \@active_graphs, \@default_graphs, \@plan_left, \@plan_right, $type [, $expr] ) >>
Returns a list of alternative plans for the join of one plan from C<< @plan_left >>
and one plan from C<< @plan_right >>. The join C<< $type >> must be one of
C<< 'inner' >>, C<< 'left' >>, or C<< 'minus' >>, indicating the join algorithm
to be used. If C<< $type >> is C<< 'left' >>, then the optional C<< $expr >>
may be used to supply a filter expression that should be used by the SPARQL
left-join algorithm.
=cut
# $lhs and $rhs are both Attean::API::Plan objects
# Return a Attean::API::Plan object that represents the evaluation of $lhs ⋈ $rhs.
# The $left and $minus flags indicate the type of the join to be performed (⟕ and ▷, respectively).
# e.g. different plans might represent different join algorithms (nested loop join, hash join, etc.) or different orderings ($lhs ⋈ $rhs or $rhs ⋈ $lhs)
sub join_plans {
my $self = shift;
my $model = shift;
my $active_graphs = shift;
my $default_graphs = shift;
my $lplans = shift;
my $rplans = shift;
my $type = shift;
my $left = ($type eq 'left');
my $minus = ($type eq 'minus');
my $expr = shift;
my @plans;
Carp::confess unless (reftype($lplans) eq 'ARRAY');
foreach my $lhs (@{ $lplans }) {
foreach my $rhs (@{ $rplans }) {
my @vars = (@{ $lhs->in_scope_variables }, @{ $rhs->in_scope_variables });
my %vars;
my %join_vars;
foreach my $v (@vars) {
if ($vars{$v}++) {
$join_vars{$v}++;
}
}
my @join_vars = keys %join_vars;
if ($left) {
if (scalar(@join_vars) > 0) {
push(@plans, Attean::Plan::HashJoin->new(children => [$lhs, $rhs], left => 1, expression => $expr, join_variables => \@join_vars, distinct => 0, ordered => []));
}
push(@plans, Attean::Plan::NestedLoopJoin->new(children => [$lhs, $rhs], left => 1, expression => $expr, join_variables => \@join_vars, distinct => 0, ordered => $lhs->ordered));
} elsif ($minus) {
# we can't use a hash join for MINUS queries, because of the definition of MINUS having a special case for compatible results that have disjoint domains
push(@plans, Attean::Plan::NestedLoopJoin->new(children => [$lhs, $rhs], anti => 1, join_variables => \@join_vars, distinct => 0, ordered => $lhs->ordered));
} else {
if (scalar(@join_vars) > 0) {
# if there's shared variables (hopefully), we can also use a hash join
push(@plans, Attean::Plan::HashJoin->new(children => [$lhs, $rhs], join_variables => \@join_vars, distinct => 0, ordered => []));
push(@plans, Attean::Plan::HashJoin->new(children => [$rhs, $lhs], join_variables => \@join_vars, distinct => 0, ordered => []));
# } else {
# warn "No join vars for $lhs ⋈ $rhs";
}
# nested loop joins work in all cases
push(@plans, Attean::Plan::NestedLoopJoin->new(children => [$lhs, $rhs], join_variables => \@join_vars, distinct => 0, ordered => $lhs->ordered));
push(@plans, Attean::Plan::NestedLoopJoin->new(children => [$rhs, $lhs], join_variables => \@join_vars, distinct => 0, ordered => $rhs->ordered));
}
}
}
return @plans;
}
sub _comparator_referenced_variables {
my $self = shift;
my %vars;
while (my $c = shift) {
my $expr = $c->expression;
foreach my $v ($expr->in_scope_variables) {
$vars{$v}++;
}
}
return keys %vars;
}
sub _comparators_are_stable_and_cover_vars {
my $self = shift;
my $cmps = shift;
my @vars = @_;
my %unseen = map { $_ => 1 } @vars;
foreach my $c (@$cmps) {
return 0 unless ($c->expression->is_stable);
foreach my $v ($self->_comparator_referenced_variables($c)) {
delete $unseen{$v};
}
}
my @keys = keys %unseen;
return (scalar(@keys) == 0);
}
sub _order_by {
my $self = shift;
my $algebra = shift;
my ($exprs, $ascending, $svars);
my @cmps = @{ $algebra->comparators };
my %ascending;
my %exprs;
my @svars;
foreach my $i (0 .. $#cmps) {
my $var = $self->new_temporary('order');
my $cmp = $cmps[$i];
push(@svars, $var);
$ascending{$var} = $cmp->ascending;
$exprs{$var} = $cmp->expression;
}
return (\%exprs, \%ascending, \@svars);
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/SPARQLClient.pm 000644 000765 000024 00000000225 14316376573 021472 x ustar 00greg staff 000000 000000 30 mtime=1664744827.441633803
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/SPARQLClient.pm 000644 000765 000024 00000007117 14316376573 017530 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::SPARQLClient - RDF blank nodes
=head1 VERSION
This document describes Attean::SPARQLClient version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $client = Attean::SPARQLClient->new(endpoint => 'http://example.org/sparql');
my $results = $client->query('SELECT * WHERE { ?s ?p ?o }');
while (my $r = $results->next) {
say $r->as_string;
}
=head1 DESCRIPTION
The Attean::SPARQLClient class provides an API to execute SPARQL queries
against a remote SPARQL Protocol endpoint.
=head1 ATTRIBUTES
The following attributes exist:
=over 4
=item C<< endpoint >>
A URL of the remote service implementing the SPARQL 1.1 Protocol. This value
is a L, but can be coerced from a string.
=item C<< silent >>
=item << user_agent >>
=item C<< request_signer >>
=back
=head1 METHODS
=over 4
=cut
package Attean::SPARQLClient 0.033 {
use Moo;
use Types::Standard qw(ConsumerOf Bool Str InstanceOf);
use Encode qw(encode);
use Scalar::Util qw(blessed);
use URI::Escape;
use Attean::RDF qw(iri);
use namespace::clean;
has 'endpoint' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI'], coerce => sub { iri(shift) }, required => 1);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
has 'user_agent' => (is => 'rw', isa => InstanceOf['LWP::UserAgent'], default => sub { my $ua = LWP::UserAgent->new(); $ua->agent("Attean/$Attean::VERSION " . $ua->_agent); $ua });
has 'request_signer' => (is => 'rw');
=item C<< query_request( $sparql ) >>
Returns an HTTP::Request object for the given SPARQL query string.
=cut
sub query_request {
my $self = shift;
my $sparql = shift;
my $endpoint = $self->endpoint->value;
my $uri = URI->new($endpoint);
my %params = $uri->query_form;
$params{'query'} = $sparql;
$uri->query_form(%params);
my $url = $uri->as_string;
my $req = HTTP::Request->new('GET', $url);
if (my $signer = $self->request_signer) {
$signer->sign($req);
}
return $req;
}
=item C<< query( $sparql ) >>
Executes the given SPARQL query string at the remote endpoint. If execution is
successful, returns an Attean::API::Iterator object with the results. If
execution fails but the client C<< silent >> flag is true, returns an empty
iterator. Otherwise raises an error via C<< die >>.
=cut
sub query {
my $self = shift;
my $sparql = shift;
my $req = $self->query_request($sparql);
my $silent = $self->silent;
my $ua = $self->user_agent;
my $response = $ua->request($req);
if (blessed($response) and $response->is_success) {
my $type = $response->header('Content-Type');
my $pclass = Attean->get_parser(media_type => $type) or die "No parser for media type: $type";
my $parser = $pclass->new();
my $xml = $response->decoded_content;
my $bytes = encode('UTF-8', $xml, Encode::FB_CROAK);
return $parser->parse_iter_from_bytes($bytes);
} elsif ($silent) {
my $b = Attean::Result->new( bindings => {} );
return Attean::ListIterator->new(variables => [], values => [$b], item_type => 'Attean::API::Result');
} else {
die "SPARQL Protocol error: " . $response->status_line;
}
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
L
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Result.pm 000644 000765 000024 00000000225 14316376573 020607 x ustar 00greg staff 000000 000000 30 mtime=1664744827.352354794
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Result.pm 000644 000765 000024 00000004617 14316376573 016647 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Result - SPARQL Result
=head1 VERSION
This document describes Attean::Result version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $result = Attean::Result->new(bindings => { name => $literal, homepage => $iri } );
my @vars = $result->variables; # ('name', 'homepage')
my $term = $result->value('name'); # $term == $literal
=head1 DESCRIPTION
The Attean::Result class represents a SPARQL result (a set of bindings from
variable names to Ls).
It conforms to the L role.
=head1 METHODS
=over 4
=cut
package Attean::Result 0.033 {
use Moo;
use Types::Standard qw(HashRef ConsumerOf);
use Attean::API::Binding;
use namespace::clean;
with 'Attean::API::Result';
=item C<< bindings >>
Returns the HASH reference containing the variable bindings for this result.
=cut
has 'bindings' => (is => 'ro', isa => HashRef[ConsumerOf['Attean::API::TermOrTriple']], default => sub { +{} });
# sub BUILD {
# my $self = shift;
# my $args = shift;
# use Data::Dumper;
# my $b = $args->{bindings};
# my $keys = [keys %$b];
# if (scalar(@$keys) == 2) {
# Carp::cluck 'NEW RESULT CONSTRUCTED with variables ' . Dumper($keys);
# }
# }
=item C<< value( $name ) >>
Returns the term object bound to the C<< $name >>d variable, or undef if the
name does not map to a term.
=cut
sub value {
my $self = shift;
my $k = shift;
return $self->bindings->{$k};
}
=item C<< variables >>
Returns a list of the variable names that are bound to terms in this result
object.
=cut
sub variables {
my $self = shift;
return keys %{ $self->bindings };
}
=item C<< as_string >>
Returns a string serialization of the variable bindings contained in the result.
=cut
sub as_string {
my $self = shift;
my @vars = $self->variables;
my @strs = map { join('=', $_, $self->value($_)->ntriples_string) } sort $self->variables;
return '{' . join(', ', @strs) . '}';
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/API.pm 000644 000765 000024 00000000225 14316376572 017741 x ustar 00greg staff 000000 000000 30 mtime=1664744826.500877899
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API.pm 000644 000765 000024 00000015647 14316376572 016006 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::API - Utility package for loading all Attean role packages.
=head1 VERSION
This document describes Attean::API version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
=head1 DESCRIPTION
This is a utility package that will load all the Attean-related Moo roles
in the Attean::API namespace.
=head1 METHODS
=over 4
=cut
package Attean::API::ResultOrTerm 0.033 {
use Moo::Role;
}
package Attean::API::BlankOrIRI 0.033 {
use Moo::Role;
with 'Attean::API::Term', 'Attean::API::BlankOrIRIOrTriple';
}
package Attean::API::BlankOrIRIOrTriple 0.033 {
use Moo::Role;
}
package Attean::API::TermOrTriple 0.033 {
use Moo::Role;
}
package Attean::API::TermOrVariable 0.033 {
use Scalar::Util qw(blessed);
use Sub::Install;
use Sub::Util qw(set_subname);
use Moo::Role;
with 'Attean::API::SPARQLSerializable';
sub equals {
my ($a, $b) = @_;
return ($a->as_string eq $b->as_string);
}
sub is_bound {
my $self = shift;
return (! $self->does('Attean::API::Variable'));
}
sub apply_binding {
my $self = shift;
my $class = ref($self);
my $bind = shift;
if ($self->does('Attean::API::Variable')) {
my $name = $self->value;
my $replace = $bind->value($name);
if (defined($replace) and blessed($replace)) {
return $replace;
} else {
return $self;
}
} else {
return $self;
}
}
BEGIN {
my %types = (
variable => 'Variable',
blank => 'Blank',
literal => 'Literal',
resource => 'IRI',
iri => 'IRI',
);
while (my ($name, $role) = each(%types)) {
my $method = "is_$name";
my $code = sub { return shift->does("Attean::API::$role") };
Sub::Install::install_sub({
code => set_subname($method, $code),
as => $method
});
}
}
}
package Attean::API::TermOrVariableOrTriplePattern 0.033 {
use Scalar::Util qw(blessed);
use Sub::Install;
use Sub::Util qw(set_subname);
use Moo::Role;
with 'Attean::API::SPARQLSerializable';
sub is_bound {
my $self = shift;
return (! $self->does('Attean::API::Variable'));
}
sub apply_binding {
my $self = shift;
my $class = ref($self);
my $bind = shift;
if ($self->does('Attean::API::Variable')) {
my $name = $self->value;
my $replace = $bind->value($name);
if (defined($replace) and blessed($replace)) {
return $replace;
} else {
return $self;
}
} else {
return $self;
}
}
BEGIN {
my %types = (
variable => 'Variable',
blank => 'Blank',
literal => 'Literal',
resource => 'IRI',
iri => 'IRI',
pattern => 'TriplePattern'
);
while (my ($name, $role) = each(%types)) {
my $method = "is_$name";
my $code = sub { return shift->does("Attean::API::$role") };
Sub::Install::install_sub({
code => set_subname($method, $code),
as => $method
});
}
}
}
package Attean::Mapper 0.033 {
use Moo::Role;
requires 'map'; # my $that = $object->map($this)
}
package Attean::API::Variable 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Moo::Role;
with 'Attean::API::TermOrVariable';
=item C<< as_string >>
Returns a string representation of the variable.'
=cut
sub as_string {
my $self = shift;
return '?' . $self->value;
}
sub sparql_tokens {
my $self = shift;
my $t = AtteanX::SPARQL::Token->fast_constructor( VAR, -1, -1, -1, -1, [$self->value] );
return Attean::ListIterator->new( values => [$t], item_type => 'AtteanX::SPARQL::Token' );
}
}
package Attean::API::CanonicalizingBindingSet 0.033 {
use Attean::RDF;
use Moo::Role;
use namespace::clean;
with 'MooX::Log::Any';
requires 'elements';
sub canonical_set {
my $self = shift;
my ($set) = $self->canonical_set_with_mapping;
return $set;
}
sub canonical_set_with_mapping {
my $self = shift;
my @t = $self->elements;
my @tuples = map { [ $_->tuples_string, $_, {} ] } @t;
my $replacements = 0;
foreach my $p (@tuples) {
my ($str, $t) = @$p;
foreach my $pos ($t->variables) {
my $term = $t->value($pos);
my $tstr = $term->ntriples_string;
if ($term->does('Attean::API::Blank') or $term->does('Attean::API::Variable')) {
$str =~ s/\Q$tstr\E/~/;
$str .= "#$tstr";
$p->[2]{$pos} = $tstr;
$replacements++;
$p->[0] = $str;
}
}
}
@tuples = sort { $a->[0] cmp $b->[0] } @tuples;
my $counter = 1;
my %mapping;
foreach my $i (0 .. $#tuples) {
my $p = $tuples[$i];
my ($str, $t) = @$p;
my $item_class = ref($t);
my ($next, $last) = ('')x2;
$last = $tuples[$i-1][0] if ($i > 0);
$next = $tuples[$i+1][0] if ($i < $#tuples);
next if ($str eq $last or $str eq $next);
foreach my $pos (reverse $t->variables) {
if (defined(my $tstr = $p->[2]{$pos})) {
$tstr =~ /^([?]|_:)([^#]+)$/;
my $prefix = $1;
my $name = $2;
my $key = "$prefix$name";
delete $p->[2]{$pos};
my $id = (exists($mapping{$key})) ? $mapping{$key}{id} : sprintf("v%03d", $counter++);
my $type = ($prefix eq '?' ? 'variable' : 'blank');
$mapping{ $key } = { id => $id, prefix => $prefix, type => $type };
my %t = $p->[1]->mapping;
$t{ $pos } = ($type eq 'blank') ? Attean::Blank->new($id) : Attean::Variable->new($id);
my $t = $item_class->new( %t );
$p->[1] = $t;
$p->[0] = $t->tuples_string;
}
}
}
foreach my $p (@tuples) {
my ($str, $t) = @$p;
my $item_class = ref($t);
foreach my $pos (reverse $t->variables) {
if (defined(my $tstr = $p->[2]{$pos})) {
$tstr =~ /^([?]|_:)([^#]+)$/;
my $prefix = $1;
my $name = $2;
my $key = "$prefix$name";
delete $p->[2]{$pos};
unless (exists($mapping{$key})) {
$self->error("Cannot canonicalize binding set");
return;
}
my $id = $mapping{$key}{id};
my $type = ($prefix eq '?' ? 'variable' : 'blank');
$mapping{ $key } = { id => $id, prefix => $prefix, type => $type };
my %t = $p->[1]->mapping;
$t{ $pos } = ($type eq 'blank') ? Attean::Blank->new($id) : Attean::Variable->new($id);
my $t = $item_class->new( %t );
$p->[1] = $t;
$p->[0] = $t->tuples_string;
}
}
}
@tuples = sort { $a->[0] cmp $b->[0] } @tuples;
my $elements = [ map { $_->[1] } @tuples ];
return ($elements, \%mapping);
}
}
package Attean::API 0.033 {
use Attean::API::Term;
use Attean::API::Store;
use Attean::API::Model;
use Attean::API::Iterator;
use Attean::API::Parser;
use Attean::API::Serializer;
use Attean::API::Query;
use Attean::API::Expression;
use Attean::API::Plan;
use Attean::API::QueryPlanner;
use Attean::Variable;
use Attean::Blank;
use Attean::IRI;
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Variable.pm 000644 000765 000024 00000000225 14316376573 021056 x ustar 00greg staff 000000 000000 30 mtime=1664744827.680129639
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Variable.pm 000644 000765 000024 00000003275 14316376573 017115 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Variable - Pattern matching variables
=head1 VERSION
This document describes Attean::Variable version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $term = Attean::Variable->new('name');
$term->ntriples_string; # ?name
=head1 DESCRIPTION
The Attean::Variable class represents variables for use in pattern matching.
It conforms to the L role.
=head1 ATTRIBUTES
=over 4
=item C<< value >>
=item C<< ntriples_string >>
=back
=cut
package Attean::Variable 0.033 {
use Moo;
use Types::Standard qw(Str);
use UUID::Tiny ':std';
use namespace::clean;
has 'value' => (is => 'ro', isa => Str, required => 1);
has 'ntriples_string' => (is => 'ro', isa => Str, lazy => 1, builder => '_ntriples_string');
with 'Attean::API::Variable';
with 'Attean::API::TermOrVariable';
with 'Attean::API::TermOrVariableOrTriplePattern';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
if (scalar(@_) == 0) {
my $uuid = unpack('H*', create_uuid());
return $class->$orig(value => 'v' . $uuid);
} elsif (scalar(@_) == 1) {
return $class->$orig(value => shift);
}
return $class->$orig(@_);
};
sub _ntriples_string {
my $self = shift;
return '?' . $self->value;
}
}
1;
__END__
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/TripleModel.pm 000644 000765 000024 00000000224 14316376573 021550 x ustar 00greg staff 000000 000000 29 mtime=1664744827.62171289
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/TripleModel.pm 000644 000765 000024 00000022547 14316376573 017613 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::TripleModel - RDF model backed by a set of triple-stores
=head1 VERSION
This document describes Attean::TripleModel version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $model = Attean::TripleModel->new( stores => {
'http://example.org/graph1' => $store1,
'http://example.org/graph2' => $store2,
} );
=head1 DESCRIPTION
The Attean::TripleModel class represents a model that is backed by a set of
L objects, identified by an IRI
string. It conforms to the L role.
The Attean::TripleModel constructor requires one named argument:
=over 4
=item stores
A hash mapping graph IRI values to L
objects representing the backing triple-store for that graph.
=back
=head1 METHODS
=over 4
=cut
package Attean::TripleModel 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf HashRef);
use Scalar::Util qw(reftype blessed);
use namespace::clean;
with 'MooX::Log::Any';
with 'Attean::API::Model';
with 'Attean::API::CostPlanner';
has 'stores' => (
is => 'ro',
isa => HashRef[ConsumerOf['Attean::API::TripleStore']],
required => 1,
default => sub { +{} },
);
=item C<< size >>
=cut
sub size {
my $self = shift;
my $count = 0;
foreach my $store (values %{ $self->stores }) {
$count += $store->size;
}
return $count;
}
=item C<< count_quads >>
=cut
sub count_quads {
my $self = shift;
# TODO: don't materialize results here just to count them
my $iter = $self->get_quads( @_ );
my $count = 0;
while (my $r = $iter->next) {
$count++;
}
return $count;
}
=item C<< count_quads_estimate >>
=cut
sub count_quads_estimate {
my $self = shift;
my ($s, $p, $o, $g) = @_;
if (blessed($g) and $g->does('Attean::API::IRI')) {
if (my $store = $self->stores->{ $g->value }) {
return $store->count_quads_estimate(@_);
} else {
return 0;
}
} else {
return $self->count_quads(@_);
}
}
=item C<< holds >>
=cut
sub holds {
my $self = shift;
return ($self->count_quads_estimate(@_) > 0)
}
=item C<< get_graphs >>
=cut
sub get_graphs {
my $self = shift;
my @graphs = map { Attean::IRI->new($_) } keys %{ $self->stores };
return Attean::ListIterator->new( values => \@graphs, item_type => 'Attean::API::Term' );
}
=item C<< get_quads ( $subject, $predicate, $object, $graph ) >>
Returns an L for quads in the model that match the
supplied C<< $subject >>, C<< $predicate >>, C<< $object >>, and C<< $graph >>.
Any of these terms may be undefined or a L object, in
which case that term will be considered as a wildcard for the purposes of
matching.
The returned iterator conforms to both L and
L.
=cut
sub get_quads {
my $self = shift;
my @nodes = @_[0..3];
foreach my $i (0..3) {
my $t = $nodes[$i] // Attean::Variable->new();
if (not(ref($t)) or reftype($t) ne 'ARRAY') {
$nodes[$i] = [$t];
}
}
my @iters;
foreach my $s (@{ $nodes[0] }) {
foreach my $p (@{ $nodes[1] }) {
foreach my $o (@{ $nodes[2] }) {
foreach my $g (@{ $nodes[3] }) {
my $iter = $self->_get_quads($s, $p, $o, $g);
push(@iters, $iter);
}
}
}
}
if (scalar(@iters) <= 1) {
return shift(@iters);
} else {
return Attean::IteratorSequence->new( iterators => \@iters, item_type => $iters[0]->item_type );
}
}
sub _get_quads {
my $self = shift;
my $s = shift;
my $p = shift;
my $o = shift;
my $g = shift;
if (blessed($g) and $g->does('Attean::API::IRI')) {
if (my $store = $self->stores->{ $g->value }) {
my $iter = $store->get_triples($s, $p, $o);
return $iter->as_quads($g);
}
} elsif (blessed($g) and $g->does('Attean::API::Variable')) {
my @iters;
while (my ($g, $store) = each %{ $self->stores }) {
my $iter = $store->get_triples($s, $p, $o);
my $graph = Attean::IRI->new($g);
my $quads = $iter->map(sub { $_->as_quad($graph) }, 'Attean::API::Quad');
push(@iters, $quads);
}
my $iter = Attean::IteratorSequence->new( iterators => \@iters, item_type => $iters[0]->item_type );
return $iter;
} else {
my $name = (blessed($g) and $g->can('as_string')) ? $g->as_string : "$g";
$self->log->warn("TripleModel cannot produce quads for non-IRI graph: $name");
}
return Attean::ListIterator->new( values => [], item_type => 'Attean::API::Quad' );
}
=item C<< plans_for_algebra( $algebra, $planner, $active_graphs, $default_graphs ) >>
Delegates to an underlying store if the active graph is bound to the store,
and the store consumes Attean::API::CostPlanner.
=cut
sub plans_for_algebra {
my $self = shift;
my $algebra = shift;
my $planner = shift;
my $active_graphs = shift;
my $default_graphs = shift;
my @plans;
if (scalar(@$active_graphs) == 1) {
my $graph = $active_graphs->[0];
if (my $store = $self->stores->{ $graph->value }) {
if ($store->does('Attean::API::CostPlanner')) {
push(@plans, $store->plans_for_algebra($algebra, $planner, $active_graphs, $default_graphs));
}
}
}
return @plans;
}
=item C<< cost_for_plan( $plan ) >>
Attempts to delegate to all the underlying stores if that store consumes Attean::API::CostPlanner.
=cut
sub cost_for_plan {
my $self = shift;
my $plan = shift;
foreach my $store (values %{ $self->stores }) {
if ($store->does('Attean::API::CostPlanner')) {
if (defined(my $cost = $store->cost_for_plan($plan, @_))) {
return $cost;
}
}
}
return;
}
}
package Attean::AddativeTripleModelRole 0.033 {
use Scalar::Util qw(blessed);
use Types::Standard qw(CodeRef);
use Moo::Role;
with 'Attean::API::Model';
has 'store_constructor' => (is => 'ro', isa => CodeRef, required => 1);
=item C<< add_store( $graph => $store ) >>
Add the L C<< $store >> object to the model using the
IRI string value C<< $graph >> as the graph name.
=cut
sub add_store {
my $self = shift;
my $graph = shift;
my $iri = blessed($graph) ? $graph->value : $graph;
my $store = shift;
die if exists $self->stores->{ $iri };
$self->stores->{ $iri } = $store;
}
=item C<< create_graph( $graph ) >>
Create a new L and add it to the model using the
L C<< $graph >> as the graph name.
The store is constructed by using this object's C<< store_constructor >>
attribute:
my $store = $self->store_constructor->($graph);
=cut
sub create_graph {
my $self = shift;
my $graph = shift;
my $iri = $graph->value;
return if exists $self->stores->{ $iri };
my $store = $self->store_constructor->($graph);
$self->stores->{ $iri } = $store;
};
=item C<< drop_graph( $graph ) >>
Removes the store associated with the given C<< $graph >>.
=cut
sub drop_graph {
my $self = shift;
my $g = shift;
if ($g->does('Attean::API::IRI')) {
delete $self->stores->{ $g->value };
}
}
}
package Attean::MutableTripleModel 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf HashRef);
use Scalar::Util qw(reftype);
use namespace::clean;
extends 'Attean::TripleModel';
with 'Attean::API::MutableModel';
has 'stores' => (
is => 'ro',
isa => HashRef[ConsumerOf['Attean::API::MutableTripleStore']],
required => 1,
default => sub { +{} },
);
=item C<< add_quad ( $quad ) >>
Adds the specified C<$quad> to the underlying model.
=cut
sub add_quad {
my $self = shift;
my $q = shift;
my $g = $q->graph;
die "Cannot add a quad whose graph is not an IRI" unless ($g->does('Attean::API::IRI'));
my $v = $g->value;
if (my $store = $self->stores->{ $v }) {
$store->add_triple( $q->as_triple );
} else {
Carp::confess "No such graph: $v";
}
}
=item C<< remove_quad ( $quad ) >>
Removes the specified C<< $quad >> from the underlying store.
=cut
sub remove_quad {
my $self = shift;
my $q = shift;
my $g = $q->graph;
if ($g->does('Attean::API::IRI')) {
my $v = $g->value;
if (my $store = $self->stores->{ $v }) {
$store->remove_triple( $q->as_triple );
}
}
}
sub create_graph { die; }
=item C<< drop_graph( $graph ) >>
Removes the store associated with the given C<< $graph >>.
=cut
sub drop_graph {
my $self = shift;
my $g = shift;
if ($g->does('Attean::API::IRI')) {
delete $self->stores->{ $g->value };
}
}
=item C<< clear_graph( $graph ) >>
Removes all quads with the given C<< $graph >>.
=cut
sub clear_graph {
my $self = shift;
my $g = shift;
$self->drop_graph($g);
$self->create_graph($g);
}
}
package Attean::AddativeTripleModel 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(CodeRef);
use namespace::clean;
extends 'Attean::TripleModel';
with 'Attean::AddativeTripleModelRole';
}
package Attean::AddativeMutableTripleModel 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Types::Standard qw(CodeRef);
use namespace::clean;
extends 'Attean::MutableTripleModel';
with 'Attean::AddativeTripleModelRole';
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/IteratorSequence.pm 000644 000765 000024 00000000225 14316376572 022612 x ustar 00greg staff 000000 000000 30 mtime=1664744826.896576905
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/IteratorSequence.pm 000644 000765 000024 00000004515 14316376572 020647 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::IteratorSequence - Iterator implementation backed by zero or more sub-iterators
=head1 VERSION
This document describes Attean::IteratorSequence version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $iter = Attean::IteratorSequence->new(iterators => [$iter1, $iter2]);
=head1 DESCRIPTION
The Attean::IteratorSequence class represents a typed iterator that is backed
by zero or more sub-iterators. When iterated over, it will return all the
elements of all of its sub-iterators, in order, before returning undef.
It conforms to the L role.
The Attean::IteratorSequence constructor requires two named arguments:
=over 4
=item iterators
An array reference containing zero or more L objects.
=item item_type
A string representing the type of the items that will be returned from the
iterator.
=back
=head1 METHODS
=over 4
=cut
package Attean::IteratorSequence 0.033 {
use Moo;
use Types::Standard qw(ArrayRef ConsumerOf);
use namespace::clean;
with 'Attean::API::Iterator';
has iterators => (is => 'ro', isa => ArrayRef[ConsumerOf['Attean::API::Iterator']], default => sub { [] });
=item C<< next >>
Returns the iterator's next item, or undef upon reaching the end of iteration.
=cut
sub next {
my $self = shift;
my $list = $self->iterators;
while (1) {
return unless (scalar(@$list));
my $iter = $list->[0];
my $item = $iter->next;
unless (defined($item)) {
shift(@$list);
next;
}
return $item;
}
}
=item C<< push( $iterator ) >>
Adds the new C<< $iterator >> to the end of the array of sub-iterators.
After this call, C<< $iterator >> will be owned by the IteratorSequence,
so making any method calls on C<< $iterator >> after this point may produce
unexpected results.
=cut
sub push {
my $self = shift;
my $iter = shift;
push(@{ $self->iterators }, $iter);
return;
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/RDF.pm 000644 000765 000024 00000000225 14316376573 017744 x ustar 00greg staff 000000 000000 30 mtime=1664744827.289760382
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/RDF.pm 000644 000765 000024 00000006077 14316376573 016006 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::RDF - Utility package for exporting shorthand functions for constructing RDF objects
=head1 VERSION
This document describes Attean::RDF version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean::RDF;
my $s = blank('b');
my $p = iri('http://xmlns.com/foaf/0.1/name');
my $o = langliteral("Eve", "en");
my $triple = triple($s, $p, $o);
say $triple->as_string; # _:b "Eve"@en .
=head1 DESCRIPTION
This is a utility package for exporting shorthand functions for constructing
RDF objects such as IRIs, Literals, Blanks, Triples, etc.
=head1 FUNCTIONS
All of the functions defined in this package may be exported (and are exported
by default).
=over 4
=cut
package Attean::RDF 0.033 {
use v5.14;
use warnings;
use Attean;
use List::MoreUtils qw(zip);
require Exporter::Tiny;
use namespace::clean;
our @ISA = qw(Exporter::Tiny);
our @EXPORT = qw(iri blank literal dtliteral langliteral variable triple quad triplepattern quadpattern bgp);
=item C<< variable( $value ) >>
C<< Attean::Variable->new($value) >>
=cut
sub variable {
return Attean::Variable->new(@_);
}
=item C<< iri( $value ) >>
C<< Attean::IRI->new($value) >>
=cut
sub iri {
return Attean::IRI->new(@_);
}
=item C<< blank( $value ) >>
C<< Attean::Blank->new($value) >>
=cut
sub blank {
return Attean::Blank->new(@_);
}
=item C<< literal( $value ) >>
C<< Attean::Literal->new($value) >>
=cut
sub literal {
return Attean::Literal->new(@_);
}
=item C<< dtliteral( $value, $dt ) >>
C<< Attean::Literal->new( value => $value, datatype => $dt ) >>
=cut
sub dtliteral {
my @k = qw(value datatype);
return Attean::Literal->new(zip @k, @_);
}
=item C<< langliteral( $value, $lang ) >>
C<< Attean::Literal->new( value => $value, language => $lang ) >>
=cut
sub langliteral {
my @k = qw(value language);
return Attean::Literal->new(zip @k, @_);
}
=item C<< triple( @terms ) >>
C<< Attean::Triple->new( @terms ) >>
=cut
sub triple {
return Attean::Triple->new(@_);
}
=item C<< triplepattern( @terms ) >>
C<< Attean::TriplePattern->new( @terms ) >>
=cut
sub triplepattern {
return Attean::TriplePattern->new(@_);
}
=item C<< quad( @terms ) >>
C<< Attean::Quad->new( @terms ) >>
=cut
sub quad {
return Attean::Quad->new(@_);
}
=item C<< quadpattern( @terms ) >>
C<< Attean::QuadPattern->new( @terms ) >>
=cut
sub quadpattern {
return Attean::QuadPattern->new(@_);
}
=item C<< bgp( @triplepatterns ) >>
C<< Attean::Algebra::BGP->new( triples => \@triplepatterns ) >>
=cut
sub bgp {
return Attean::Algebra::BGP->new(triples => \@_);
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
L
L
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/ 000755 000765 000024 00000000000 14316377024 015424 5 ustar 00greg staff 000000 000000 Attean-0.033/lib/Attean/PaxHeader/ListIterator.pm 000644 000765 000024 00000000225 14316376572 021755 x ustar 00greg staff 000000 000000 30 mtime=1664744826.967470729
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/ListIterator.pm 000644 000765 000024 00000005235 14316376572 020012 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::ListIterator - Iterator implementation backed by a list/array of values
=head1 VERSION
This document describes Attean::ListIterator version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my @values = map { Attean::Literal->new($_) } (1,2,3);
my $iter = Attean::ListIterator->new(
values => \@values,
item_type => 'Attean::API::Term',
);
say $iter->next->value; # 1
say $iter->next->value; # 2
say $iter->next->value; # 3
=head1 DESCRIPTION
The Attean::ListIterator class represents a typed iterator.
It conforms to the L role.
The Attean::ListIterator constructor requires two named arguments:
=over 4
=item values
An array reference containing the items to iterate over.
=item item_type
A string representing the type of the items that will be returned from the
iterator.
=back
=head1 METHODS
=over 4
=cut
package Attean::ListIterator 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Type::Tiny::Role;
use Types::Standard qw(ArrayRef Int);
use namespace::clean;
has values => (is => 'ro', isa => ArrayRef, required => 1);
has current => (is => 'rw', isa => Int, init_arg => undef, default => 0);
sub BUILD {
my $self = shift;
my $role = $self->item_type;
foreach my $item (@{ $self->values }) {
if (Role::Tiny->is_role($role)) {
die "ListIterator item <$item> is not a $role" unless (blessed($item) and $item->does($role));
}
}
}
=item C<< reset >>
Resets the iterator's internal state so that iteration begins again at the
beginning of the values array.
=cut
sub reset {
my $self = shift;
$self->current(0);
}
=item C<< next >>
Returns the iterator's next item, or undef upon reaching the end of iteration.
=cut
sub next {
my $self = shift;
my $list = $self->values;
my $index = $self->current;
my $item = $list->[$index];
return unless defined($item);
$self->current(1+$index);
return $item;
}
=item C<< size >>
Returns the number of elements still remaining in the iterator until it is
fully consumed or until C<< reset >> is called.
=cut
sub size {
my $self = shift;
return scalar(@{ $self->values }) - $self->current;
}
with 'Attean::API::RepeatableIterator';
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Triple.pm 000644 000765 000024 00000000225 14316376573 020570 x ustar 00greg staff 000000 000000 30 mtime=1664744827.579676946
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Triple.pm 000644 000765 000024 00000004174 14316376573 016626 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Triple - RDF Triples
=head1 VERSION
This document describes Attean::Triple version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $triple = Attean::Triple->new( $s, $p, $o );
=head1 DESCRIPTION
The Attean::Triple class represents an RDF triple.
It conforms to the L role.
=head1 ROLES
This role consumes L.
=head1 METHODS
=over 4
=item C<< subject >>
=item C<< predicate >>
=item C<< object >>
=back
=cut
package Attean::TriplePattern 0.033 {
use Moo;
use Scalar::Util qw(blessed);
use Attean::RDF;
use Attean::API::Binding;
has 'subject' => (is => 'ro', required => 1);
has 'predicate' => (is => 'ro', required => 1);
has 'object' => (is => 'ro', required => 1);
with 'Attean::API::TriplePattern';
sub as_quadpattern {
my $self = shift;
my $graph = shift;
# TODO: deprecate this in favor of as_quad_pattern() provided by Attean::API::TriplePattern
return $self->as_quad_pattern($graph);
}
sub ntriples_string {
my $self = shift;
return join(' ', '<<', (map { $self->$_()->ntriples_string() } qw(subject predicate object)), '>>');
}
}
package Attean::Triple 0.033 {
use Moo;
use Attean::API::Binding;
has 'subject' => (is => 'ro', does => 'Attean::API::BlankOrIRI', required => 1);
has 'predicate' => (is => 'ro', does => 'Attean::API::IRI', required => 1);
has 'object' => (is => 'ro', does => 'Attean::API::Term', required => 1);
with 'Attean::API::Triple';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
if (scalar(@_) == 3) {
my %args;
@args{ $class->variables } = @_;
return $class->$orig(%args);
}
return $class->$orig(@_);
};
}
1;
__END__
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/TreeRewriter.pm 000644 000765 000024 00000000225 14316376573 021754 x ustar 00greg staff 000000 000000 30 mtime=1664744827.534760585
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/TreeRewriter.pm 000644 000765 000024 00000012261 14316376573 020006 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::TreeRewriter - Walk and rewrite subtrees
=head1 VERSION
This document describes Attean::TreeRewriter version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $w = Attean::TreeRewriter->new();
my ($rewritten, $tree) = $w->rewrite($tree, $thunk);
if ($rewritten) {
...
}
=head1 DESCRIPTION
The Attean::TreeRewriter class walks the nodes of query trees and rewrites
sub-trees based on handlers that have been registered prior to rewriting.
=head1 ROLES
None.
=head1 METHODS
=over 4
=cut
package Attean::TreeRewriter 0.033 {
use Moo;
use Types::Standard qw(CodeRef ArrayRef Str);
use Scalar::Util qw(blessed refaddr);
use namespace::clean;
with 'MooX::Log::Any';
has types => (is => 'rw', isa => ArrayRef[Str], default => sub { ['Attean::API::DirectedAcyclicGraph'] });
has pre_handlers => (is => 'rw', isa => ArrayRef[CodeRef], default => sub { [] });
=item C<< register_pre_handler( \&code ) >>
Register a handler that will be called for each sub-tree during tree rewriting.
The function will be called as C<< &code( $tree, $parent_node, $thunk ) >> where
C<< $thunk >> is an opaque value passed to C<< rewrite >>.
The function must return a list C<< ($handled, $descend, $rewritten) >>.
C<< $handled >> is a boolean indicating whether the handler function rewrote
the sub-tree, which is returned as C<< $rewritten >>. The C<< $descend >>
boolean value indicates whether the the tree rewriting should continue downwards
in the tree.
=cut
sub register_pre_handler {
my $self = shift;
my $code = shift;
push(@{ $self->pre_handlers }, $code);
}
sub _fire_pre_handlers {
my $self = shift;
my ($t, $parent, $thunk) = @_;
my $main_descend = 0;
foreach my $cb (@{ $self->pre_handlers }) {
my ($handled, $descend, $rewritten) = $cb->($t, $parent, $thunk);
unless (defined($descend)) {
$descend = 1;
}
if ($handled) {
return ($descend, $rewritten);
} elsif ($descend) {
$main_descend = 1;
}
}
return ($main_descend, undef);
}
=item C<< rewrite( $tree, $thunk, \%seen, $parent ) >>
Rewrites the given C<< $tree >> using the registered handler functions.
C<< $thunk >> is passed through to each handler function.
C<< %seen >> is currently unused.
C<< $parent >> is passed through to the handler functions as the value of the
pseudo-parent tree node for C<< $tree >>.
Returns a list C<< ($handled, $tree) >> with C<< $handled >> indicating whether
rewriting was performed, with the corresponding rewritten C<< $tree >>.
=cut
sub rewrite {
my $self = shift;
my $tree = shift;
my $thunk = shift;
my $seen = shift || {};
my $parent = shift;
my $ok = 0;
# if ($seen->{ refaddr($tree) }++) {
# return (0, $tree);
# }
foreach my $type (@{ $self->types }) {
if (blessed($tree) and $tree->does($type)) {
$ok++;
}
}
unless ($ok) {
$self->log->debug(ref($tree) . ' does not conform to any rewrite roles');
return (0, $tree);
}
my ($descend, $rewritten) = $self->_fire_pre_handlers($tree, $parent, $thunk);
if ($rewritten) {
if (refaddr($rewritten) == refaddr($tree)) {
return (0, $tree);
}
if ($descend) {
(undef, my $rewritten2) = $self->rewrite($rewritten, $thunk, $seen, $parent);
my $changed = (refaddr($rewritten) != refaddr($rewritten2));
return ($changed, $rewritten2);
} else {
return (1, $rewritten);
}
}
if ($descend) {
my @children;
my %attributes;
my $changed = 0;
if ($tree->does('Attean::API::DirectedAcyclicGraph')) {
my @c = @{ $tree->children };
foreach my $i (0 .. $#c) {
my $p = $c[$i];
my ($childchanged, $child) = $self->rewrite($p, $thunk, $seen, $tree);
push(@children, $childchanged ? $child : $p);
if ($childchanged) {
$self->log->debug("Child $p changed for parent $tree");
$changed = 1;
}
}
}
if ($tree->can('tree_attributes')) {
foreach my $attr ($tree->tree_attributes) {
my $p = $tree->$attr();
if (ref($p) eq 'ARRAY') {
my @patterns;
foreach my $pp (@$p) {
# warn "- $attr: $pp\n";
my ($childchanged, $child) = $self->rewrite($pp, $thunk, $seen, $tree);
if ($childchanged) {
$changed = 1;
}
push(@patterns, $child);
}
$attributes{$attr} = \@patterns;
} else {
# warn "- $attr: $p\n";
my ($childchanged, $child) = $self->rewrite($p, $thunk, $seen, $tree);
$attributes{$attr} = $child;
if ($childchanged) {
$changed = 1;
}
}
}
}
if ($changed) {
my $class = ref($tree);
$rewritten = $class->new( %attributes, children => \@children );
# (undef, $rewritten) = $self->rewrite($rewritten, $thunk, $seen, $parent);
return (1, $rewritten);
}
}
return (0, $tree);
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Blank.pm 000644 000765 000024 00000000225 14316376572 020357 x ustar 00greg staff 000000 000000 30 mtime=1664744826.629325997
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Blank.pm 000644 000765 000024 00000003172 14316376572 016412 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Blank - RDF blank nodes
=head1 VERSION
This document describes Attean::Blank version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $term = Attean::Blank->new('b1');
$term->ntriples_string; # _:b1
=head1 DESCRIPTION
The Attean::Blank class represents RDF blank nodes.
It conforms to the L role.
=head1 ROLES
This role consumes L, which provides the following methods:
=over 4
=item C<< value >>
=back
=cut
package Attean::Blank 0.033 {
use Moo;
use Types::Standard qw(Str);
use UUID::Tiny ':std';
use namespace::clean;
has 'value' => (is => 'ro', isa => Str, required => 1);
has 'ntriples_string' => (is => 'ro', isa => Str, lazy => 1, builder => '_ntriples_string');
with 'Attean::API::Blank';
around BUILDARGS => sub {
my $orig = shift;
my $class = shift;
if (scalar(@_) == 0) {
my $uuid = unpack('H*', create_uuid());
return $class->$orig(value => 'b' . $uuid);
} elsif (scalar(@_) == 1) {
my $value = shift // '';
return $class->$orig(value => $value);
}
return $class->$orig(@_);
};
sub _ntriples_string {
my $self = shift;
return '_:' . $self->value;
}
}
1;
__END__
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/Expression.pm 000644 000765 000024 00000000225 14316376626 021467 x ustar 00greg staff 000000 000000 30 mtime=1664744854.666785598
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/Expression.pm 000644 000765 000024 00000030253 14316376626 017522 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::Expression - SPARQL Expressions
=head1 VERSION
This document describes Attean::Expression version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $binding = Attean::Result->new();
my $value = Attean::ValueExpression->new( value => Attean::Literal->integer(2) );
my $plus = Attean::BinaryExpression->new( children => [$value, $value], operator => '+' );
my $result = $plus->evaluate($binding);
say $result->numeric_value; # 4
=head1 DESCRIPTION
This is a utility package that defines all the Attean SPARQL expression classes
consisting of logical, numeric, and function operators, constant terms, and
variables. Expressions may be evaluated in the context of a
L object, and either return a L object
or throw a type error exception.
The expression classes are:
=over 4
=cut
use Attean::API::Expression;
=item * L
=cut
package Attean::ValueExpression 0.033 {
use Moo;
use Types::Standard qw(ConsumerOf);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
with 'Attean::API::SPARQLSerializable';
with 'Attean::API::Expression';
has 'value' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariableOrTriplePattern']);
sub arity { return 0 }
sub BUILDARGS {
my $class = shift;
return $class->SUPER::BUILDARGS(@_, operator => '_value');
}
sub tree_attributes { return qw(operator) }
sub is_stable {
return 1;
}
sub as_string {
my $self = shift;
my $str = $self->value->ntriples_string;
if ($str =~ m[^"(true|false)"\^\^$]) {
return $1;
} elsif ($str =~ m[^"(\d+)"\^\^$]) {
return $1
}
return $str;
}
sub in_scope_variables {
my $self = shift;
if ($self->value->does('Attean::API::Variable')) {
return $self->value->value;
}
return;
}
sub sparql_tokens {
my $self = shift;
return $self->value->sparql_tokens;
}
sub unaggregated_variables {
my $self = shift;
if ($self->value->does('Attean::API::Variable')) {
return $self->value;
}
return;
}
}
=item * L
=cut
package Attean::UnaryExpression 0.033 {
use Moo;
use Types::Standard qw(Enum);
use namespace::clean;
with 'Attean::API::UnaryExpression', 'Attean::API::Expression', 'Attean::API::UnaryQueryTree';
my %map = ('NOT' => '!');
around 'BUILDARGS' => sub {
my $orig = shift;
my $class = shift;
my $args = $class->$orig(@_);
my $op = $args->{operator};
$args->{operator} = $map{uc($op)} if (exists $map{uc($op)});
return $args;
};
sub BUILD {
my $self = shift;
state $type = Enum[qw(+ - !)];
$type->assert_valid($self->operator);
}
sub tree_attributes { return qw(operator) }
sub is_stable {
my $self = shift;
foreach my $c (@{ $self->children }) {
return 0 unless ($c->is_stable);
}
return 1;
}
}
=item * L
=cut
package Attean::BinaryExpression 0.033 {
use Moo;
use Types::Standard qw(Enum);
use namespace::clean;
with 'Attean::API::BinaryExpression';
sub BUILD {
my $self = shift;
state $type = Enum[qw(+ - * / < <= > >= != = && ||)];
$type->assert_valid($self->operator);
}
sub tree_attributes { return qw(operator) }
sub is_stable {
my $self = shift;
foreach my $c (@{ $self->children }) {
return 0 unless ($c->is_stable);
}
return 1;
}
}
=item * L
=cut
package Attean::FunctionExpression 0.033 {
use Moo;
use Types::Standard qw(Enum ConsumerOf HashRef);
use Types::Common::String qw(UpperCaseStr);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
has 'operator' => (is => 'ro', isa => UpperCaseStr, coerce => UpperCaseStr->coercion, required => 1);
has 'base' => (is => 'rw', isa => ConsumerOf['Attean::IRI'], predicate => 'has_base');
with 'Attean::API::NaryExpression';
with 'Attean::API::SPARQLSerializable';
around 'BUILDARGS' => sub {
my $orig = shift;
my $class = shift;
my $args = $class->$orig(@_);
if ($args->{operator} eq 'ISURI') {
$args->{operator} = 'ISIRI';
}
$args->{operator} = UpperCaseStr->coercion->($args->{operator});
return $args;
};
sub BUILD {
my $self = shift;
state $type = Enum[qw(INVOKE IN NOTIN STR LANG LANGMATCHES DATATYPE BOUND IRI URI BNODE RAND ABS CEIL FLOOR ROUND CONCAT SUBSTR STRLEN REPLACE UCASE LCASE ENCODE_FOR_URI CONTAINS STRSTARTS STRENDS STRBEFORE STRAFTER YEAR MONTH DAY HOURS MINUTES SECONDS TIMEZONE TZ NOW UUID STRUUID MD5 SHA1 SHA256 SHA384 SHA512 COALESCE IF STRLANG STRDT SAMETERM ISIRI ISBLANK ISLITERAL ISNUMERIC REGEX TRIPLE ISTRIPLE SUBJECT PREDICATE OBJECT)];
$type->assert_valid($self->operator);
}
sub tree_attributes { return qw(operator) }
sub is_stable {
my $self = shift;
return 0 if ($self->operator =~ m/^(?:RAND|BNODE|UUID|STRUUID|NOW)$/);
foreach my $c (@{ $self->children }) {
return 0 unless ($c->is_stable);
}
return 1;
}
sub sparql_tokens {
my $self = shift;
my $func = AtteanX::SPARQL::Token->keyword($self->operator);
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
my $comma = AtteanX::SPARQL::Token->comma;
my @tokens;
push(@tokens, $func, $lparen);
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $comma);
}
if (scalar(@tokens) > 2) {
pop(@tokens); # remove the last comma
}
push(@tokens, $rparen);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
package Attean::AggregateExpression 0.033 {
use Moo;
use Types::Standard qw(Bool Enum Str HashRef ConsumerOf Maybe);
use Types::Common::String qw(UpperCaseStr);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
around 'BUILDARGS' => sub {
my $orig = shift;
my $class = shift;
my $args = $class->$orig(@_);
$args->{operator} = UpperCaseStr->coercion->($args->{operator});
return $args;
};
sub BUILD {
state $type = Enum[qw(COUNT SUM MIN MAX AVG GROUP_CONCAT SAMPLE RANK CUSTOM)];
$type->assert_valid(shift->operator);
}
has 'custom_iri' => (is => 'ro', isa => Maybe[Str]);
has 'operator' => (is => 'ro', isa => UpperCaseStr, coerce => UpperCaseStr->coercion, required => 1);
has 'scalar_vars' => (is => 'ro', isa => HashRef, default => sub { +{} });
has 'distinct' => (is => 'ro', isa => Bool, default => 0);
has 'variable' => (is => 'ro', isa => ConsumerOf['Attean::API::Variable'], required => 1);
with 'Attean::API::AggregateExpression';
with 'Attean::API::SPARQLSerializable';
sub tree_attributes { return qw(operator scalar_vars variable) }
sub is_stable {
my $self = shift;
foreach my $expr (@{ $self->groups }, values %{ $self->aggregates }) {
return 0 unless ($expr->is_stable);
}
return 1;
}
sub sparql_tokens {
my $self = shift;
my $distinct = AtteanX::SPARQL::Token->keyword('DISTINCT');
my $func = AtteanX::SPARQL::Token->keyword($self->operator);
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
my $comma = AtteanX::SPARQL::Token->comma;
my @tokens;
push(@tokens, $func);
push(@tokens, $lparen);
if ($self->distinct) {
push(@tokens, $distinct);
}
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $comma);
}
if (scalar(@tokens) > 2) {
pop(@tokens); # remove the last comma
}
my $vars = $self->scalar_vars;
my @keys = keys %$vars;
if (scalar(@keys)) {
die "TODO: Implement SPARQL serialization for aggregate scalar vars";
}
push(@tokens, $rparen);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
package Attean::CastExpression 0.033 {
use Moo;
use Types::Standard qw(Enum ConsumerOf);
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use namespace::clean;
with 'Attean::API::SPARQLSerializable';
with 'Attean::API::UnaryExpression', 'Attean::API::Expression', 'Attean::API::UnaryQueryTree';
has 'datatype' => (is => 'ro', isa => ConsumerOf['Attean::API::IRI']);
sub BUILDARGS {
my $class = shift;
return $class->SUPER::BUILDARGS(@_, operator => '_cast');
}
sub BUILD {
my $self = shift;
state $type = Enum[map { "http://www.w3.org/2001/XMLSchema#$_" } qw(integer decimal float double string boolean dateTime)];
$type->assert_valid($self->datatype->value);
}
sub tree_attributes { return qw(operator datatype) }
sub is_stable {
my $self = shift;
foreach my $c (@{ $self->children }) {
return 0 unless ($c->is_stable);
}
return 1;
}
sub sparql_tokens {
my $self = shift;
my $dt = AtteanX::SPARQL::Token->fast_constructor( IRI, -1, -1, -1, -1, [$self->datatype->value] ),
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
my $comma = AtteanX::SPARQL::Token->comma;
my @tokens;
push(@tokens, $dt, $lparen);
foreach my $t (@{ $self->children }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, $comma);
}
if (scalar(@tokens) > 2) {
pop(@tokens); # remove the last comma
}
push(@tokens, $rparen);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
package Attean::ExistsExpression 0.033 {
use Moo;
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::SPARQLSerializable';
with 'Attean::API::Expression';
sub arity { return 0 }
sub BUILDARGS {
my $class = shift;
return $class->SUPER::BUILDARGS(@_, operator => '_exists');
}
has 'pattern' => (is => 'ro', isa => ConsumerOf['Attean::API::Algebra']);
sub as_string {
my $self = shift;
my $sparql = $self->pattern->as_sparql;
$sparql =~ s/\s+/ /g;
return "EXISTS { $sparql }";
}
sub tree_attributes { return qw(operator pattern) }
sub is_stable {
my $self = shift;
# TODO: need deep analysis of exists pattern to tell if this is stable
# (there might be an unstable filter expression deep inside the pattern)
return 0;
}
sub sparql_tokens {
my $self = shift;
my $exists = AtteanX::SPARQL::Token->keyword('EXISTS');
my $lbrace = AtteanX::SPARQL::Token->lbrace;
my $rbrace = AtteanX::SPARQL::Token->rbrace;
my $child = $self->pattern;
my @tokens;
push(@tokens, $exists, $lbrace);
push(@tokens, $child->sparql_tokens->elements);
push(@tokens, $rbrace);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
sub unaggregated_variables {
my $self = shift;
return map { Attean::Variable->new($_) } $self->pattern->in_scope_variables;
}
}
package Attean::ExistsPlanExpression 0.033 {
use Moo;
use Types::Standard qw(ConsumerOf);
use namespace::clean;
with 'Attean::API::Expression';
sub arity { return 0 }
sub BUILDARGS {
my $class = shift;
return $class->SUPER::BUILDARGS(@_, operator => '_existsplan');
}
has 'plan' => (is => 'ro', isa => ConsumerOf['Attean::API::BindingSubstitutionPlan']);
sub as_string {
my $self = shift;
# TODO: implement as_string for EXISTS patterns
return "Attean::ExistsPlanExpression { ... }";
}
sub as_sparql {
my $self = shift;
my %args = @_;
my $level = $args{level} // 0;
my $sp = $args{indent} // ' ';
my $indent = $sp x $level;
# TODO: implement as_string for EXISTS patterns
return "EXISTS { " . $self->pattern->as_sparql( level => $level+1, indent => $sp ) . " }";
}
sub tree_attributes { return qw(operator plan) }
sub is_stable {
my $self = shift;
# TODO: need deep analysis of exists pattern to tell if this is stable
# (there might be an unstable filter expression deep inside the pattern)
return 0;
}
sub unaggregated_variables {
my $self = shift;
die "unaggregated_variables cannot be called on Attean::ExistsPlanExpression";
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/PaxHeader/CodeIterator.pm 000644 000765 000024 00000000225 14316376447 021715 x ustar 00greg staff 000000 000000 30 mtime=1664744743.793400204
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/CodeIterator.pm 000644 000765 000024 00000004525 14316376447 017753 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::CodeIterator - Iterator implementation backed by a generator function
=head1 VERSION
This document describes Attean::CodeIterator version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
my $iter = Attean::CodeIterator->new(
generator => sub {
state $value = 0;
Attean::Literal->new(++$value)
},
item_type => 'Attean::API::Term',
);
say $iter->next->value; # 1
say $iter->next->value; # 2
say $iter->next->value; # 3
=head1 DESCRIPTION
The Attean::CodeIterator class represents a typed iterator.
It conforms to the L role.
The Attean::CodeIterator constructor requires two named arguments:
=over 4
=item generator
A code reference that when called will return either the iterator's next item,
or undef upon reaching the end of iteration.
=item item_type
A L object representing the type of the items
that will be returned from the iterator.
=back
=head1 METHODS
=over 4
=cut
package Attean::CodeIterator 0.033 {
use Moo;
use Type::Tiny::Role;
use Scalar::Util qw(blessed);
use Types::Standard qw(CodeRef ArrayRef);
use Role::Tiny ();
use namespace::clean;
with 'Attean::API::Iterator';
has generator => (is => 'ro', isa => CodeRef, required => 1);
has _buffer => (is => 'ro', isa => ArrayRef, init_arg => undef, default => sub { [] });
=item C<< next >>
Returns the iterator's next item, or undef upon reaching the end of iteration.
=cut
sub next {
my $self = shift;
my $buffer = $self->_buffer;
if (scalar(@$buffer)) {
return shift(@$buffer);
}
my @items = $self->generator->();
my $item = shift(@items);
return unless defined($item);
if (scalar(@items)) {
push(@$buffer, @items);
}
my $role = $self->item_type;
if (Role::Tiny->is_role($role)) {
unless (blessed($item) and $item->does($role)) {
die "CodeIterator item is not a $role: $item";
}
}
return $item;
}
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/Plan.pm 000644 000765 000024 00000000225 14316376570 020631 x ustar 00greg staff 000000 000000 30 mtime=1664744824.618963144
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/Plan.pm 000644 000765 000024 00000015510 14316376570 016663 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
use utf8;
=head1 NAME
Attean::API::Plan - Query plan
=head1 VERSION
This document describes Attean::API::Plan version 0.033
=head1 DESCRIPTION
The Attean::API::Plan role defines a common API for all query plans.
=head1 ATTRIBUTES
=over 4
=item C<< cost >>
=item C<< distinct >>
=item C<< item_type >>
=item C<< in_scope_variables >>
=item C<< ordered >>
=back
=head1 REQUIRED METHODS
The following methods are required by the L role:
=over 4
=item C<< impl( $model ) >>
Returns a code reference that when called (without arguments), returns an
L object.
=back
=head1 METHODS
=over 4
=item C<< has_cost >>
=cut
use Type::Tiny::Role;
package Attean::API::Plan 0.033 {
use Scalar::Util qw(blessed);
use Types::Standard qw(ArrayRef CodeRef Str Object InstanceOf Bool Num Int);
use Moo::Role;
has 'cost' => (is => 'rw', isa => Int, predicate => 'has_cost');
has 'distinct' => (is => 'rw', isa => Bool, required => 1, default => 0);
has 'item_type' => (is => 'ro', isa => Str, required => 1, default => 'Attean::API::Result');
has 'in_scope_variables' => (is => 'ro', isa => ArrayRef[Str], required => 1);
has 'ordered' => (is => 'ro', isa => ArrayRef, required => 1, default => sub { [] });
requires 'impl';
requires 'plan_as_string';
=item C<< as_string >>
Returns a tree-structured string representation of this plan, including children.
=cut
sub as_string {
my $self = shift;
my $string = '';
$self->walk( prefix => sub {
my $a = shift;
my $level = shift;
my $parent = shift;
my $indent = ' ' x $level;
my @flags;
push(@flags, 'distinct') if ($a->distinct);
if (scalar(@{ $a->ordered })) {
my @orders;
foreach my $c (@{ $a->ordered }) {
my $dir = $c->ascending ? "↑" : "↓";
my $s = $dir . $c->expression->as_string;
push(@orders, $s);
}
push(@flags, "order: " . join('; ', @orders));
}
if (defined(my $cost = $a->cost)) {
push(@flags, "cost: $cost");
}
$string .= "-$indent " . $a->plan_as_string($level);
if (scalar(@flags)) {
$string .= ' (' . join(' ', @flags) . ")";
}
$string .= "\n";
});
return $string;
}
=item C<< evaluate( $model ) >>
Evaluates this plan and returns the resulting iterator.
=cut
sub evaluate {
my $self = shift;
my $impl = $self->impl(@_);
return $impl->();
}
=item C<< in_scope_variables_union( @plans ) >>
Returns the set union of C<< in_scope_variables >> of the given plan objects.
=cut
sub in_scope_variables_union {
my @plans = grep { blessed($_) } @_;
my %vars = map { $_ => 1 } map { @{ $_->in_scope_variables } } @plans;
return keys %vars;
}
=item C<< subplans_of_type_are_variable_connected( $type ) >>
Returns true if the subpatterns of the given C<< $type >> are all connected
through their C<< in_scope_variables >>, false otherwise (implying a cartesian
product if the connecting plans perform some form of join.
=cut
sub subplans_of_type_are_variable_connected {
my $self = shift;
my @types = @_;
my @c = $self->subpatterns_of_type(@types);
return $self->_plans_are_variable_connected(@c);
}
=item C<< children_are_variable_connected( $type ) >>
Returns true if the children of this plan are all connected
through their C<< in_scope_variables >>, false otherwise (implying a cartesian
product if this plan performs some form of join.
=cut
sub children_are_variable_connected {
my $self = shift;
my @c = @{ $self->children };
return $self->_plans_are_variable_connected(@c);
}
sub _plans_are_variable_connected {
# TODO: In the worst case, this is going to run in O(n^2) in the number
# of children. Better indexing of the children by variables can speed
# this up.
my $self = shift;
my @c = @_;
# warn "===========================\n";
# foreach my $c (@c) {
# warn $c->as_string;
# }
return 1 unless (scalar(@c));
my %vars_by_child;
foreach my $i (0 .. $#c) {
my $c = $c[$i];
foreach my $var (@{ $c->in_scope_variables }) {
$vars_by_child{$i}{$var}++;
}
}
#
my @remaining = keys %vars_by_child;
return 1 unless (scalar(@remaining));
my $current = shift(@remaining);
# warn 'Starting with ' . $c[$current]->as_string;
my %seen_vars = %{ $vars_by_child{$current} };
LOOP: while (scalar(@remaining)) {
foreach my $i (0 .. $#remaining) {
my $candidate = $remaining[$i];
my @candidate_vars = keys %{ $vars_by_child{$candidate} };
foreach my $var (@candidate_vars) {
if (exists $seen_vars{ $var }) {
foreach my $var (@candidate_vars) {
$seen_vars{$var}++;
}
# warn "connected with $var: " . $c[$candidate]->as_string;
splice(@remaining, $i, 1);
next LOOP;
}
}
}
# warn 'Not fully connected';
return 0;
}
# warn 'Fully connected';
return 1;
}
}
package Attean::API::BindingSubstitutionPlan 0.033 {
use Moo::Role;
with 'Attean::API::Plan';
requires 'substitute_impl'; # $code = $plan->impl($model, $binding);
sub impl {
my $self = shift;
my $model = shift;
my $b = Attean::Result->new();
return $self->substitute_impl($model, $b);
}
}
package Attean::API::UnionScopeVariablesPlan 0.033 {
use Moo::Role;
with 'Attean::API::Plan';
around 'BUILDARGS' => sub {
my $orig = shift;
my $class = shift;
my %args = @_;
my @vars = Attean::API::Plan->in_scope_variables_union( @{ $args{children} } );
if (exists $args{in_scope_variables}) {
Carp::confess "in_scope_variables is computed automatically, and must not be specified in the $class constructor";
}
$args{in_scope_variables} = [@vars];
return $orig->( $class, %args );
};
}
package Attean::API::Plan::Join 0.033 {
use Types::Standard qw(CodeRef);
use Types::Standard qw(ArrayRef Str ConsumerOf Bool);
use Moo::Role;
with 'Attean::API::Plan', 'Attean::API::BinaryQueryTree';
with 'Attean::API::UnionScopeVariablesPlan';
has 'join_variables' => (is => 'ro', isa => ArrayRef[Str], required => 1);
has 'anti' => (is => 'ro', isa => Bool, default => 0); # is this an anti-join
has 'left' => (is => 'ro', isa => Bool, default => 0); # is this a left, outer-join
# if this is a left, outer-join, this is the filter expression that acts as part of the join operation (see the SPARQL semantics for LeftJoin for more details)
has 'expression' => (is => 'ro', isa => ConsumerOf['Attean::API::Expression'], required => 0, default => sub { Attean::ValueExpression->new( value => Attean::Literal->true ) });
}
1;
__END__
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/PushParser.pod 000644 000765 000024 00000000225 14316376570 022201 x ustar 00greg staff 000000 000000 30 mtime=1664744824.738528395
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/PushParser.pod 000644 000765 000024 00000004176 14316376570 020241 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::API::PushParser - Role for parsers that natively call a callback function for each parsed item
=head1 VERSION
This document describes Attean::API::PushParser version 0.033
=head1 DESCRIPTION
The Attean::API::PushParser role defines parsers that can efficiently call a
callback function for each object constructed from the parsed data. This role
adds methods that builds on this functionality to allow parsing data using
different approaches.
=head1 ROLES
This role consumes the L role.
=head1 REQUIRED METHODS
Classes consuming this role must provide the following methods:
=over 4
=item C<< parse_cb_from_io( $fh ) >>
Calls the C<< $parser->handler >> function once for each object that result
from parsing the data read from the L object C<< $fh >>.
=item C<< parse_cb_from_bytes( $data ) >>
Calls the C<< $parser->handler >> function once for each object that result
from parsing the data read from the UTF-8 encoded byte string C<< $data >>.
=back
=head1 METHODS
This role provides default implementations of the following methods:
=over 4
=item C<< parse_iter_from_io( $fh ) >>
Returns an L that result from parsing the data read from
the L object C<< $fh >>.
=item C<< parse_iter_from_bytes( $data ) >>
Returns an L that result from parsing the data read from
the UTF-8 encoded byte string C<< $data >>.
=item C<< parse_list_from_io( $fh ) >>
Returns a list of all objects that result from parsing the data read from the
L object C<< $fh >>.
=item C<< parse_list_from_bytes( $data ) >>
Returns a list of all objects that result from parsing the data read from the
UTF-8 encoded byte string C<< $data >>.
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/Store.pm 000644 000765 000024 00000000225 14316376571 021034 x ustar 00greg staff 000000 000000 30 mtime=1664744825.816044847
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/Store.pm 000644 000765 000024 00000011370 14316376571 017066 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::API::Store - Triple/quad store role
=head1 VERSION
This document describes Attean::Store version 0.033
=head1 DESCRIPTION
The Attean::Store role is an empty role that more specialized roles conform to:
=over 4
=item * L
=item * L
=item * L
=item * L
=item * L
=item * L
=item * L
=item * L
=back
=cut
package Attean::API::Store 0.033 {
use Moo::Role;
}
package Attean::API::TripleStore 0.033 {
use Scalar::Util qw(blessed);
use Moo::Role;
with 'Attean::API::Store';
requires 'get_triples';
before 'get_triples' => sub {
if (scalar(@_) == 2 and blessed($_[1]) and not($_[1]->does('Attean::API::TermOrVariable'))) {
my $type = ref($_[0]);
die "get_triples called with a single $type argument, but expecting a list of terms/variables";
}
};
sub count_triples {
my $self = shift;
my $iter = $self->get_triples(@_);
my $count = 0;
while (my $r = $iter->next) {
$count++;
}
return $count;
}
sub count_triples_estimate {
my $self = shift;
return $self->count_triples(@_);
}
sub size {
my $self = shift;
return $self->count_triples();
}
sub holds {
my $self = shift;
return ($self->count_triples_estimate(@_) > 0)
}
}
package Attean::API::MutableTripleStore 0.033 {
use Moo::Role;
with 'Attean::API::TripleStore';
requires 'add_triple';
requires 'remove_triple';
before 'add_triple' => sub {
my $self = shift;
my $quad = shift;
unless ($quad->is_ground) {
die "Cannot add a non-ground triple (with variables) to a model";
}
};
}
package Attean::API::ETagCacheableTripleStore 0.033 {
use Moo::Role;
with 'Attean::API::TripleStore';
requires 'etag_value_for_triples';
}
package Attean::API::TimeCacheableTripleStore 0.033 {
use Moo::Role;
with 'Attean::API::TripleStore';
requires 'mtime_for_triples';
}
package Attean::API::QuadStore 0.033 {
use Scalar::Util qw(blessed);
use Moo::Role;
with 'Attean::API::Store';
requires 'get_quads';
before 'get_quads' => sub {
if (scalar(@_) == 2 and blessed($_[1]) and not($_[1]->does('Attean::API::TermOrVariable'))) {
my $type = ref($_[0]);
die "get_quads called with a single $type argument, but expecting a list of terms/variables";
}
};
sub count_quads {
my $self = shift;
my $iter = $self->get_quads(@_);
my $count = 0;
while (my $r = $iter->next) {
$count++;
}
return $count;
}
sub count_quads_estimate {
my $self = shift;
return $self->count_quads(@_);
}
sub holds {
my $self = shift;
return ($self->count_quads_estimate(@_) > 0)
}
sub get_graphs {
my $self = shift;
my $iter = $self->get_quads(@_);
my %graphs;
while (my $r = $iter->next) {
my $g = $r->graph;
$graphs{ $g->as_string }++;
}
return Attean::ListIterator->new( values => [map { Attean::IRI->new($_) } keys %graphs], item_type => 'Attean::API::Term' );
}
sub size {
my $self = shift;
return $self->count_quads();
}
}
package Attean::API::MutableQuadStore 0.033 {
use Role::Tiny ();
use Moo::Role;
use Type::Tiny::Role;
with 'Attean::API::QuadStore';
requires 'add_quad';
requires 'remove_quad';
requires 'create_graph';
requires 'drop_graph';
requires 'clear_graph';
before 'add_quad' => sub {
my $self = shift;
my $quad = shift;
unless ($quad->is_ground) {
die "Cannot add a non-ground quad (with variables) to a store";
}
};
sub add_iter {
my $self = shift;
my $iter = shift;
my $type = $iter->item_type;
use Data::Dumper;
die "Iterator type $type isn't quads" unless (Role::Tiny::does_role($type, 'Attean::API::Quad'));
while (my $q = $iter->next) {
$self->add_quad($q);
}
}
}
package Attean::API::ETagCacheableQuadStore 0.033 {
use Moo::Role;
with 'Attean::API::QuadStore';
requires 'etag_value_for_quads';
}
package Attean::API::TimeCacheableQuadStore 0.033 {
use Moo::Role;
with 'Attean::API::QuadStore';
requires 'mtime_for_quads';
}
package Attean::API::BulkUpdatableStore 0.033 {
use Moo::Role;
requires 'begin_bulk_updates';
requires 'end_bulk_updates';
}
package Attean::API::RDFStarStore 0.033 {
use Moo::Role;
with 'Attean::API::Store';
}
1;
__END__
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/Result.pod 000644 000765 000024 00000000224 14316376571 021363 x ustar 00greg staff 000000 000000 29 mtime=1664744825.26241979
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/Result.pod 000644 000765 000024 00000002131 14316376571 017411 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::API::Result - Role representing a set of variable bindings
=head1 VERSION
This document describes Attean::API::Result version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
=head1 DESCRIPTION
This is a Moo role representing quad patterns.
=head1 ROLES
This role consumes L.
=head1 METHODS
=over 4
=item C<< join( $result ) >>
Returns the combined variable binding set if the referent and C<< $result >>
are compatible (as defined by the SPARQL semantics), or C<< undef >> otherwise.
=item C<< apply_map( $mapper ) >>
Returns a new variable binding set object with all terms mapped through the
given L object C<< $mapper >>.
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/PullParser.pod 000644 000765 000024 00000000225 14316376570 022176 x ustar 00greg staff 000000 000000 30 mtime=1664744824.678099722
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/PullParser.pod 000644 000765 000024 00000004115 14316376570 020227 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::API::PullParser - Role for parsers that natively return an iterator
=head1 VERSION
This document describes Attean::API::PullParser version 0.033
=head1 DESCRIPTION
The Attean::API::PullParser role defines parsers that can efficiently construct
and return an iterator of the parsed data. This role adds methods that
builds on this functionality to allow parsing data using different approaches.
=head1 ROLES
This role consumes the L role.
=head1 REQUIRED METHODS
Classes consuming this role must provide the following methods:
=over 4
=item C<< parse_iter_from_io( $fh ) >>
Returns an L that result from parsing the data read from
the L object C<< $fh >>.
=item C<< parse_iter_from_bytes( $data ) >>
Returns an L that result from parsing the data read from
the UTF-8 encoded byte string C<< $data >>.
=back
=head1 METHODS
This role provides default implementations of the following methods:
=over 4
=item C<< parse_cb_from_io( $fh ) >>
Calls the C<< $parser->handler >> function once for each object that result
from parsing the data read from the L object C<< $fh >>.
=item C<< parse_cb_from_bytes( $data ) >>
Calls the C<< $parser->handler >> function once for each object that result
from parsing the data read from the UTF-8 encoded byte string C<< $data >>.
=item C<< parse_list_from_io( $fh ) >>
Returns a list of all objects that result from parsing the data read from the
L object C<< $fh >>.
=item C<< parse_list_from_bytes( $data ) >>
Returns a list of all objects that result from parsing the data read from the
UTF-8 encoded byte string C<< $data >>.
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/ResultParser.pod 000644 000765 000024 00000000225 14316376571 022541 x ustar 00greg staff 000000 000000 30 mtime=1664744825.628341927
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/ResultParser.pod 000644 000765 000024 00000001716 14316376571 020576 0 ustar 00greg staff 000000 000000 =head1 NAME
Attean::API::ResultParser - Role for parsers of L objects
=head1 VERSION
This document describes Attean::API::ResultParser version 0.033
=head1 DESCRIPTION
The Attean::API::ResultParser role defines parsers of L objects.
=head1 ROLES
This role consumes the L role.
=head1 METHODS
This role provides default implementations of the following methods:
=over 4
=item C<< handled_type >>
Returns a L object for objects which consume the
L role.
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L.
=head1 SEE ALSO
=head1 AUTHOR
Gregory Todd Williams C<< >>
=head1 COPYRIGHT
Copyright (c) 2014--2022 Gregory Todd Williams.
This program is free software; you can redistribute it and/or modify it under
the same terms as Perl itself.
=cut
Attean-0.033/lib/Attean/API/PaxHeader/Query.pm 000644 000765 000024 00000000224 14316376571 021044 x ustar 00greg staff 000000 000000 29 mtime=1664744825.07480135
64 LIBARCHIVE.xattr.com.apple.TextEncoding=VVRGLTg7MTM0MjE3OTg0
55 SCHILY.xattr.com.apple.TextEncoding=UTF-8;134217984
Attean-0.033/lib/Attean/API/Query.pm 000644 000765 000024 00000042407 14316376571 017104 0 ustar 00greg staff 000000 000000 use v5.14;
use warnings;
=head1 NAME
Attean::API::Query - Utility package defining query-related roles
=head1 VERSION
This document describes Attean::API::Query version 0.033
=head1 SYNOPSIS
use v5.14;
use Attean;
=head1 DESCRIPTION
This is a utility package for defining query-related roles:
=over 4
=item * L
=cut
package Attean::API::DirectedAcyclicGraph 0.033 {
use Scalar::Util qw(refaddr);
use Types::Standard qw(ArrayRef ConsumerOf);
use Moo::Role;
# =item C<< children >>
#
# An ARRAY reference of L objects.
#
# =back
#
# =cut
has 'children' => (
is => 'ro',
isa => ArrayRef[ConsumerOf['Attean::API::DirectedAcyclicGraph']],
default => sub { [] },
);
# =item C<< is_leaf >>
#
# Returns true if the referent has zero C<< children >>, false otherwise.
#
# =cut
sub is_leaf {
my $self = shift;
return not(scalar(@{ $self->children }));
}
# =item C<< walk( prefix => \&pre_cb, postfix => \&pre_cb ) >>
#
# Walks the graph rooted at the referent, calling C<< &pre_cb >> (if supplied)
# before descending, and C<< &post_cb >> (if supplied) after descending. The
# callback functions are passed the current graph walk node as the single
# argument.
#
# =cut
sub walk {
my $self = shift;
my %args = @_;
my $level = $args{ level } // 0;
my $parent = $args{ parent };
if (my $cb = $args{ prefix }) {
$cb->( $self, $level, $parent );
}
foreach my $c (@{ $self->children }) {
$c->walk( %args, level => (1+$level), parent => $self );
}
if (my $cb = $args{ postfix }) {
$cb->( $self, $level, $parent );
}
}
# =item C<< has_only_subtree_types( @classes ) >>
#
# Returns true if the invocant and all of its sub-trees are instances of only
# the listed classes, false otherwise.
#
# =cut
sub has_only_subtree_types {
my $self = shift;
my @types = @_;
my %types = map { $_ => 1 } @types;
return 0 unless (exists $types{ ref($self) });
my %classes;
$self->walk( prefix => sub {
my $plan = shift;
$classes{ref($plan)}++;
});
foreach my $type (@types) {
delete $classes{$type};
}
my @keys = keys %classes;
return (scalar(@keys) == 0) ? 1 : 0;
}
# =item C<< cover( prefix => \&pre_cb, postfix => \&pre_cb ) >>
#
# Similar to C<< walk >>, walks the graph rooted at the referent, calling
# C<< &pre_cb >> (if supplied) before descending, and C<< &post_cb >> (if
# supplied) after descending. However, unlike C<< walk >>, each node in the graph
# is visited only once.
#
# =cut
sub cover {
my $self = shift;
return $self->_cover({}, @_);
}
sub _cover {
my $self = shift;
my $seen = shift;
my %cb = @_;
return if ($seen->{refaddr($self)}++);
if (my $cb = $cb{ prefix }) {
$cb->( $self );
}
foreach my $c (@{ $self->children }) {
$c->_cover( $seen, %cb );
}
if (my $cb = $cb{ postfix }) {
$cb->( $self );
}
}
sub subpatterns_of_type {
my $self = shift;
my @types = @_;
my @p;
$self->walk( prefix => sub {
my $a = shift;
foreach my $t (@types) {
push(@p, $a) if ($a->isa($t) or $a->does($t));
}
});
return @p;
}
}
package Attean::API::SPARQLSerializable 0.033 {
use AtteanX::SPARQL::Constants;
use AtteanX::SPARQL::Token;
use Encode qw(decode_utf8);
use Attean::API::Iterator;
use Attean::API::Serializer;
use AtteanX::Serializer::SPARQL;
use Moo::Role;
requires 'sparql_tokens';
sub as_sparql {
my $self = shift;
my $s = AtteanX::Serializer::SPARQL->new();
my $i = $self->sparql_tokens;
my $bytes = $s->serialize_iter_to_bytes($i);
return decode_utf8($bytes);
}
sub sparql_subtokens {
my $self = shift;
if ($self->does('Attean::API::SPARQLQuerySerializable')) {
my $l = AtteanX::SPARQL::Token->lbrace;
my $r = AtteanX::SPARQL::Token->rbrace;
my @tokens;
push(@tokens, $l);
push(@tokens, $self->sparql_tokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
} else {
return $self->sparql_tokens;
}
}
sub dataset_tokens {
my $self = shift;
my $dataset = shift;
my @default = @{ $dataset->{ default } || [] };
my @named = @{ $dataset->{ named } || [] };
my $has_dataset = (scalar(@default) + scalar(@named));
my @tokens;
if ($has_dataset) {
my $from = AtteanX::SPARQL::Token->keyword('FROM');
my $named = AtteanX::SPARQL::Token->keyword('NAMED');
foreach my $i (sort { $a->as_string cmp $b->as_string } @default) {
push(@tokens, $from);
push(@tokens, $i->sparql_tokens->elements);
}
foreach my $i (sort { $a->as_string cmp $b->as_string } @named) {
push(@tokens, $from);
push(@tokens, $named);
push(@tokens, $i->sparql_tokens->elements);
}
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
sub query_tokens {
my $self = shift;
my %args = @_;
my $dataset = $args{dataset} || {};
my $as = AtteanX::SPARQL::Token->keyword('AS');
my $lparen = AtteanX::SPARQL::Token->lparen;
my $rparen = AtteanX::SPARQL::Token->rparen;
my $algebra = $self;
my %modifiers;
my $form = 'SELECT';
if ($algebra->isa('Attean::Algebra::Ask')) {
$form = 'ASK';
($algebra) = @{ $algebra->children };
} elsif ($algebra->isa('Attean::Algebra::Describe')) {
$form = 'DESCRIBE';
$modifiers{describe} = $algebra->terms;
($algebra) = @{ $algebra->children };
} elsif ($algebra->isa('Attean::Algebra::Construct')) {
$form = 'CONSTRUCT';
$modifiers{construct} = $algebra->triples;
($algebra) = @{ $algebra->children };
}
unless ($form eq 'CONSTRUCT' or $form eq 'DESCRIBE') {
while ($algebra->isa('Attean::Algebra::Extend') or $algebra->isa('Attean::Algebra::Group') or $algebra->isa('Attean::Algebra::OrderBy') or $algebra->isa('Attean::Algebra::Distinct') or $algebra->isa('Attean::Algebra::Reduced') or $algebra->isa('Attean::Algebra::Slice') or $algebra->isa('Attean::Algebra::Project')) {
# TODO: Handle HAVING
# TODO: Error if Slice appears before distinct/reduced
if ($algebra->isa('Attean::Algebra::Distinct')) {
$modifiers{ distinct } = 1;
} elsif ($algebra->isa('Attean::Algebra::Reduced')) {
$modifiers{ reduced } = 1;
} elsif ($algebra->isa('Attean::Algebra::Slice')) {
if ($algebra->limit >= 0) {
$modifiers{ limit } = $algebra->limit;
}
if ($algebra->offset > 0) {
$modifiers{ offset } = $algebra->offset;
}
} elsif ($algebra->isa('Attean::Algebra::OrderBy')) {
$modifiers{order} = $algebra->comparators;
} elsif ($algebra->isa('Attean::Algebra::Extend')) {
my $v = $algebra->variable;
my $name = $v->value;
my $expr = $algebra->expression;
my @tokens;
push(@tokens, $lparen);
push(@tokens, $expr->sparql_tokens->elements);
push(@tokens, $as);
push(@tokens, $v->sparql_tokens->elements);
push(@tokens, $rparen);
$modifiers{project_expression_tokens}{$name} = \@tokens;
} elsif ($algebra->isa('Attean::Algebra::Project')) {
my $vars = $algebra->variables;
my ($child) = @{ $algebra->children };
my @vars = sort(map { $_->value } @$vars);
my @subvars = sort($child->in_scope_variables);
if (scalar(@vars) == scalar(@subvars) and join('.', @vars) eq join('.', @subvars)) {
# this is a SELECT * query
} else {
foreach my $v (@$vars) {
my $name = $v->value;
unless ($modifiers{project_variables}{$name}++) {
push(@{ $modifiers{project_variables_order} }, $name);
}
}
}
} elsif ($algebra->isa('Attean::Algebra::Group')) {
my $aggs = $algebra->aggregates;
my $groups = $algebra->groupby;
foreach my $agg (@$aggs) {
my $v = $agg->variable;
my $name = $v->value;
my @tokens;
push(@tokens, $lparen);
push(@tokens, $agg->sparql_tokens->elements);
push(@tokens, $as);
push(@tokens, $v->sparql_tokens->elements);
push(@tokens, $rparen);
unless ($modifiers{project_variables}{$name}++) {
push(@{ $modifiers{project_variables_order} }, $name);
}
$modifiers{project_expression_tokens}{$name} = \@tokens;
}
foreach my $group (@$groups) {
push(@{ $modifiers{groups} }, $group->sparql_tokens->elements);
}
} else {
die "Unexpected pattern type encountered in query_tokens: " . ref($algebra);
}
($algebra) = @{ $algebra->children };
}
}
my @tokens;
my $where = AtteanX::SPARQL::Token->keyword('WHERE');
my $lbrace = AtteanX::SPARQL::Token->lbrace;
my $rbrace = AtteanX::SPARQL::Token->rbrace;
if ($form eq 'SELECT') {
push(@tokens, AtteanX::SPARQL::Token->keyword('SELECT'));
if ($modifiers{distinct}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('DISTINCT'));
} elsif ($modifiers{reduced}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('REDUCED'));
}
if (my $p = $modifiers{project_variables_order}) {
foreach my $name (@$p) {
if (my $etokens = $modifiers{project_expression_tokens}{$name}) {
push(@tokens, @$etokens);
} else {
my $v = Attean::Variable->new( value => $name );
push(@tokens, $v->sparql_tokens->elements);
}
}
} else {
push(@tokens, AtteanX::SPARQL::Token->star);
}
push(@tokens, $self->dataset_tokens($dataset)->elements);
push(@tokens, $where);
if ($algebra->isa('Attean::Algebra::Join')) {
# don't emit extraneous braces at the top-level
push(@tokens, $algebra->sparql_tokens->elements);
} else {
push(@tokens, $lbrace);
push(@tokens, $algebra->sparql_tokens->elements);
push(@tokens, $rbrace);
}
if (my $groups = $modifiers{groups}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('GROUP'));
push(@tokens, AtteanX::SPARQL::Token->keyword('BY'));
push(@tokens, @$groups);
}
if (my $expr = $modifiers{having}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('HAVING'));
push(@tokens, $expr->sparql_tokens->elements);
}
if (my $comps = $modifiers{order}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('ORDER'));
push(@tokens, AtteanX::SPARQL::Token->keyword('BY'));
foreach my $c (@$comps) {
push(@tokens, $c->sparql_tokens->elements);
}
}
if (exists $modifiers{limit}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('LIMIT'));
push(@tokens, AtteanX::SPARQL::Token->integer($modifiers{limit}));
}
if (exists $modifiers{offset}) {
push(@tokens, AtteanX::SPARQL::Token->keyword('OFFSET'));
push(@tokens, AtteanX::SPARQL::Token->integer($modifiers{offset}));
}
} elsif ($form eq 'DESCRIBE') {
push(@tokens, AtteanX::SPARQL::Token->keyword('DESCRIBE'));
foreach my $t (@{ $modifiers{describe} }) {
push(@tokens, $t->sparql_tokens->elements);
}
push(@tokens, $self->dataset_tokens($dataset)->elements);
push(@tokens, $where);
push(@tokens, $lbrace);
push(@tokens, $algebra->sparql_tokens->elements);
push(@tokens, $rbrace);
} elsif ($form eq 'CONSTRUCT') {
push(@tokens, AtteanX::SPARQL::Token->keyword('CONSTRUCT'));
push(@tokens, $lbrace);
foreach my $t (@{ $modifiers{construct} }) {
push(@tokens, $t->sparql_tokens->elements);
push(@tokens, AtteanX::SPARQL::Token->dot);
}
push(@tokens, $rbrace);
push(@tokens, $self->dataset_tokens($dataset)->elements);
push(@tokens, $where);
push(@tokens, $lbrace);
push(@tokens, $algebra->sparql_tokens->elements);
push(@tokens, $rbrace);
} elsif ($form eq 'ASK') {
push(@tokens, AtteanX::SPARQL::Token->keyword('ASK'));
push(@tokens, $self->dataset_tokens($dataset)->elements);
push(@tokens, $lbrace);
push(@tokens, $algebra->sparql_tokens->elements);
push(@tokens, $rbrace);
} else {
die "Unexpected query for '$form' in query_tokens";
}
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
}
package Attean::API::SPARQLQuerySerializable 0.033 {
use Moo::Role;
use namespace::clean;
with 'Attean::API::SPARQLSerializable';
sub sparql_tokens {
my $self = shift;
return $self->query_tokens;
}
}
=item * L
=cut
package Attean::API::Algebra 0.033 {
use Moo::Role;
use Types::Standard qw(ArrayRef ConsumerOf);
with 'Attean::API::SPARQLSerializable';
has 'hints' => (is => 'rw', isa => ArrayRef[ArrayRef[ConsumerOf['Attean::API::Term']]], default => sub { [] });
requires 'as_sparql';
requires 'in_scope_variables'; # variables that will be in-scope after this operation is evaluated
sub unary {
my $self = shift;
return unless (scalar(@{ $self->children }) == 1);
return $self->children->[0];
}
sub algebra_as_string {
my $self = shift;
return "$self";
}
sub as_string {
my $self = shift;
my $string = '';
$self->walk( prefix => sub {
my $a = shift;
my $level = shift;
my $parent = shift;
my $indent = ' ' x $level;
$string .= "-$indent " . $a->algebra_as_string($level) . "\n";
});
return $string;
}
sub blank_nodes {
my $self = shift;
my %blanks;
$self->walk( prefix => sub {
my $a = shift;
if ($a->isa('Attean::Algebra::BGP')) {
my @triples = @{ $a->triples };
my @nodes = grep { $_->does('Attean::API::Blank') } map { $_->values } @triples;
foreach my $b (@nodes) {
$blanks{ $b->value } = $b;
}
} elsif ($a->isa('Attean::Algebra::Path')) {
my @nodes = grep { $_->does('Attean::API::Blank') } ($a->subject, $a->object);
foreach my $b (@nodes) {
$blanks{ $b->value } = $b;
}
}
});
return values %blanks;
}
sub BUILD {}
if ($ENV{ATTEAN_TYPECHECK}) {
around 'BUILD' => sub {
my $orig = shift;
my $self = shift;
$self->$orig(@_);
my $name = ref($self);
$name =~ s/^.*://;
if ($self->can('arity')) {
my $arity = $self->arity;
my $children = $self->children;
my $size = scalar(@$children);
unless ($size == $arity) {
Carp::confess "${name} algebra construction with bad number of children (expected $arity, but got $size)";
}
}
}
}
}
=item * L
=cut
package Attean::API::QueryTree 0.033 {
use Moo::Role;
with 'Attean::API::DirectedAcyclicGraph';
}
=item * L
=cut
package Attean::API::NullaryQueryTree 0.033 {
use Moo::Role;
sub arity { return 0 }
with 'Attean::API::QueryTree';
}
=item * L
=cut
package Attean::API::UnaryQueryTree 0.033 {
use Moo::Role;
sub arity { return 1 }
with 'Attean::API::QueryTree';
sub child {
my $self = shift;
return $self->children->[0];
}
}
=item * L
=cut
package Attean::API::BinaryQueryTree 0.033 {
use Moo::Role;
sub arity { return 2 }
with 'Attean::API::QueryTree';
}
=item * L
=cut
package Attean::API::PropertyPath 0.033 {
use Moo::Role;
with 'Attean::API::QueryTree';
requires 'as_string';
requires 'as_sparql';
}
=item * L
=cut
package Attean::API::UnaryPropertyPath 0.033 {
use Types::Standard qw(ConsumerOf);
use Moo::Role;
sub arity { return 1 }
# has 'path' => (is => 'ro', isa => ConsumerOf['Attean::API::PropertyPath'], required => 1);
sub prefix_name { "" }
sub postfix_name { "" }
sub as_string {
my $self = shift;
my ($path) = @{ $self->children };
my $pstr = $path->as_string;
if ($path->does('Attean::API::UnaryPropertyPath')) {
$pstr = "($pstr)";
}
my $str = sprintf("%s%s%s", $self->prefix_name, $pstr, $self->postfix_name);
return $str;
}
sub algebra_as_string {
my $self = shift;
return "Property Path " . $self->prefix_name . $self->postfix_name;
}
with 'Attean::API::PropertyPath', 'Attean::API::UnaryQueryTree';
}
=item * L