Coverage report: /development/source/library/org/datagraph/spocq-shard/src/algebra/operators/service-ldf.lisp

Kind	Covered	All	%
expression	0	165	0.0
branch	0	20	0.0

Key

Not instrumented

Conditionalized out

Executed

Not executed

Both branches taken

One branch taken

Neither branch taken

1

;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: org.datagraph.spocq.implementation; -*-

2

3

(in-package :org.datagraph.spocq.implementation)

4

5

;;; results+ld-fragment serializer

6

;;;

7

;;; the principle process is to generate the content (with possible slice)

8

;;; generate the metadata

9

;;; construct a union of them and delegate to the respective base encoding

10

;;;

11

;;; (load "patches/service-ldf.lisp")

12

13

(defparameter *response-page-size* 128

14

"Set the statement count for a response page")

15

16

(defun slice-form-offset (form)

17

(getf (cddr form) :slice))

18

19

(defun slice-form-limit (form)

20

(or (getf (cddr form) :count) (getf (cddr form) :limit)))

21

22

23

(defgeneric compute-ldf-metadata (repository &key count offset s p o c)

24

(:documentation

25

"Return a quad solution field which covers the ldf metadata for the respective repository.

26

When the media type profile is 'http://www.hydra-cg.com/spec/latest/linked-data-fragments/',

27

include this data in the response.")

28

29

(:method ((repository-id string) &rest args)

30

(apply #'compute-ldf-metadata (repository repository-id) args))

31

32

(:method ((repository repository) &key offset s p o c (g c) (count *response-page-size*))

33

(labels ((find-form (op sse)

34

(when (consp sse)

35

(if (eq op (first sse))

36

sse

37

(find-form op (case (first sse)

38

(spocq.a:|graph| (third sse))

39

(t (second sse)))))))

40

(expression-bgp-form (sse)

41

(find-form 'spocq.a:|bgp| sse))

42

(expression-graph-form (sse)

43

(find-form 'spocq.a:|graph| sse))

44

(expression-slice-form (sse)

45

(find-form 'spocq.a:|slice| sse)))

46

(let* ((repository-uri (repository-uri repository))

47

(request-iri repository-uri)

48

              (metadata-graph (intern-iri (concatenate 'string (iri-lexical-form repository-uri) "#metadata")))

49

              (dataset-uri (intern-iri (concatenate 'string (iri-lexical-form repository-uri) "#dataset")))

50

              (template-pattern (concatenate 'string (iri-lexical-form repository-uri) "/ldf{?s,p,o}"))

51

(page (when (and offset count) (floor offset (max 1 count))))

52

(count (repository-pattern-count repository s p o (or g |urn:dydra|:|all|)))

53

(genid1 <_:genid1>)

54

(genid2 <_:genid2>)

55

(genid3 <_:genid3>)

56

(genid4 <_:genid4>))

57

`((,request-iri <void:triples> ,count ,metadata-graph)

58

(,request-iri <hydra:totalItems> ,count ,metadata-graph)

59

(,metadata-graph <foaf:primaryTopic> ,request-iri ,metadata-graph)

60

(,dataset-uri <http://rdfs.org/ns/void#subset> ,request-iri ,metadata-graph)

61

(,dataset-uri <http://www.w3.org/ns/hydra/core#search> ,genid4 ,metadata-graph)

62

(,genid1 <http://www.w3.org/ns/hydra/core#variable> "s" ,metadata-graph)

63

         (,genid1 <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#subject>  ,metadata-graph)

64

(,genid2 <http://www.w3.org/ns/hydra/core#variable> "p" ,metadata-graph)

65

         (,genid2 <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate>  ,metadata-graph)

66

(,genid3 <http://www.w3.org/ns/hydra/core#variable> "o" ,metadata-graph)

67

         (,genid3 <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#object>  ,metadata-graph)

68

(,genid4 <http://www.w3.org/ns/hydra/core#template> ,template-pattern ,metadata-graph)

69

(,genid4 <http://www.w3.org/ns/hydra/core#mapping> ,genid1 ,metadata-graph)

70

(,genid4 <http://www.w3.org/ns/hydra/core#mapping> ,genid2 ,metadata-graph)

71

(,genid4 <http://www.w3.org/ns/hydra/core#mapping> ,genid3 ,metadata-graph)

72

,@(when (and page (> page 1))

73

(let ((previous-uri (puri:uri (iri-lexical-form request-iri))))

74

(setf (iri-query-argument previous-uri :page) (1- page))

75

`((,request-iri <hydra:previousPage> ,(intern-iri previous-uri) ,metadata-graph))))

76

,@(when (and page (< page (/ count *response-page-size*)))

77

(let ((next-uri (puri:uri (iri-lexical-form request-iri))))

78

(setf (iri-query-argument next-uri :page) (1+ page))

79

`((,request-iri <hydra:nextPage> ,(intern-iri next-uri) ,metadata-graph)))))))))

80

81

;;; (compute-ldf-metadata "jhacker/foaf")

82

;;;

83

;;;

84

85

(defmethod spocq.e::service ((service (eql '|urn:dydra|:|fragmentMetadata|)) query-expression &rest args)

86

"Compute the fragment metadata and provide a values field for processing as part

87

of the normal algebrareduction process"

88

(declare (ignore args))

89

(when (select-form-p query-expression) (setf query-expression (second query-expression)))

90

(let ((offset (when (slice-form-p query-expression) (slice-form-offset query-expression))))

91

(when (slice-form-p query-expression) (setf query-expression (second query-expression)))

92

(let ((c (when (graph-form-p query-expression) (second query-expression) <urn:dydra:all>)))

93

(when (graph-form-p query-expression) (setf query-expression (third query-expression)))

94

(let ((statement-pattern (assoc 'spocq.a:|triple| (rest query-expression))))

95

(cond (statement-pattern

96

(destructuring-bind (s p o) (rest statement-pattern)

97

(let ((metadata (compute-ldf-metadata (task-repository *task*)

98

                                                        :s s :p p :o o :c c :offset offset)))

99

(spocq.e:bindings metadata '(?::|s| ?::|p| ?::|o| ?::|c|)))))

100

(t

101

(log-warn "spocq.e::service(<urn:dydra:fragmentMetadata>): invalid expression: ~s"

102

query-expression)

103

(null-generator '(?::|s| ?::|p| ?::|o| ?::|c|))))))))

104