Coverage report: /development/source/library/org/datagraph/spocq-shard/src/core/encoding/nquads.lisp

Kind	Covered	All	%
expression	49	125	39.2
branch	0	6	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

;;; build nquads parser from sparql pieces

6

7

;;; see

8

;;; http://www.w3.org/TR/2014/REC-turtle-20140225/#sec-grammar

9

;;;

10

11

(defparameter *nquads-bnf* "

12

[[1]] nquadsDoc ::= statement*

13

[[2]] statement ::= subject predicate object graph? '.'

14

[[10]] subject ::= iri | BlankNode

15

[[11]] predicate ::= iri

16

[[12]] object ::= iri | BlankNode | literal

17

[[10]] graph ::= iri | BlankNode

18

[[13]] literal ::= RDFLiteral | NumericLiteral | BooleanLiteral

19

//[16]] NumericLiteral ::= INTEGER | DECIMAL | DOUBLE

20

[[128s]] RDFLiteral ::= String (LANGTAG | ( '^^' iri ))?

21

[[133s]] BooleanLiteral ::= 'true' | 'false'

22

 //[17]] String ::= STRING_LITERAL_QUOTE | STRING_LITERAL_SINGLE_QUOTE | STRING_LITERAL_LONG_SINGLE_QUOTE | STRING_LITERAL_LONG_QUOTE

23

[[135s]] iri ::= IRI_REF

24

[[137s]] BlankNode ::= '_:' BLANK_NODE_LABEL

25

26

// from sparql

27

[[119]] NumericLiteral ::= NumericLiteralUnsigned | NumericLiteralPositive | NumericLiteralNegative

28

[[120]] NumericLiteralUnsigned ::= INTEGER | DECIMAL | DOUBLE

29

[[121]] NumericLiteralPositive ::= INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE

30

[[122]] NumericLiteralNegative ::= INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE

31

[[124]] String ::= STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2

32

[[128]] IRI_REF ::= '<' IRI_NAMESTRING? '>'

33

"

34

   "An n-quads grammar which re-uses several productions from sparql in order to reuse the respective constructor logic.

35

It is EOL agnostic and would accept an entire document on a single line" )

36

37

(defpackage :org.datagraph.nquads

38

(:use :common-lisp

39

:org.datagraph.spocq.implementation

40

:de.setf.utility)

41

(:nicknames :odnq)

42

(:import-from :sparql-1-0-4

43

"BaseDecl-Constructor"

44

"BlankNodePropertyList-Constructor"

45

"BLANK_NODE_LABEL-Constructor"

46

"BooleanLiteral-Constructor"

47

"LANGTAG-Constructor"

48

"NumericLiteral-Constructor"

49

"PrefixDecl-Constructor"

50

"IRI_NAMESTRING-Constructor"

51

"IRI_REF-Constructor"

52

"NAMESPACE_REF-Constructor"

53

"PNAME_NS-Constructor"

54

"PrefixedName-Constructor"

55

"PropertyListNotEmpty-Constructor"

56

"RDFLiteral-Constructor"

57

"String-Constructor"

58

"VerbObjectList-Constructor")

59

(:import-from :spocq.i

60

*nquads-bnf*

61

:IS-IRI_NAMESTRING))

62

63

64

(defun odnq::|BlankNode-Constructor| (label)

65

(sparql-1-0-4::|BlankNode-Constructor| nil label))

66

67

(defun odnq::|nquadsDoc-Constructor| (statement*)

68

(reverse statement*))

69

70

;;; (parse-nquads "<http://asdf> <http://host> 'a' .")

71

72

(defun odnq::|graph-Constructor| (BlankNode iri)

73

(or BlankNode iri))

74

75

(defun odnq::|iri-Constructor| (IRI_REF)

76

IRI_REF)

77

78

(defun odnq::|literal-Constructor| (BooleanLiteral NumericLiteral RDFLiteral)

79

(or BooleanLiteral NumericLiteral RDFLiteral))

80

81

(defun odnq::|object-Constructor| (BlankNode iri literal)

82

(or BlankNode iri literal))

83

84

(defun odnq::|predicate-Constructor| (iri)

85

iri)

86

87

(defun odnq::|subject-Constructor| (BlankNode iri)

88

(or BlankNode iri))

89

90

(defun odnq::|statement-Constructor| (graph object predicate subject)

91

(if graph (list subject predicate object graph)

92

(list subject predicate object)))

93

94

(defun odnq::|verb-Constructor| (predicate)

95

(or predicate |rdf|:|type|))

96

97

98

99

(defgeneric parse-nquads (source &key start end start-name base-iri)

100

(:method ((source pathname) &rest args)

101

(with-open-file (stream source :direction :input)

102

(apply #'parse-nquads stream args)))

103

;; does not work above about 30K statements

104

;; (apply #'parse-nquads (read-file source) args)

105

(:method ((source stream) &key ((:base-iri *base-iri*) *base-iri*)

106

end start start-name)

107

(declare (ignore end start start-name))

108

(let ((*literal-string-tokens* (make-hash-table :test 'eq)))

109

(loop for line = (read-line source nil nil)

110

for count from 1

111

until (null line)

112

for terms = (parse-nquads-statement line)

113

if terms

114

collect terms

115

else do (spocq.e:request-error "parse-nquads: syntax error @~s: ~s"

116

count

117

line))))

118

(:method ((string string) &key (start 0) (end (length string)) (start-name 'odnq::|nquadsDoc|)

119

((:base-iri *base-iri*) *base-iri*))

120

(let ((*literal-string-tokens* (make-hash-table :test 'eq)))

121

(multiple-value-bind (tokens byte-offsets line-offsets)

122

(tokenize-sparql string :start start :end end)

123

(let ((*max-input-index* 0)

124

(atnp:*atn-term* nil)

125

(*namespace-bindings* *namespace-bindings*))

126

(when tokens

127

(multiple-value-bind (result index success)

128

                                  (funcall 'odnq::|nquadsDoc-Parser| tokens :start-name start-name)

129

(if success

130

(values result tokens index)

131

(flet ((_aref (array index)

132

                            (when (and (integerp index) (< index (length array))) (aref array index))))

133

(spocq.e::message-syntax-error :expression string

134

                                                    :token (_aref tokens *max-input-index*)

135

                                                    :byte-offset (_aref byte-offsets *max-input-index*)

136

                                                    :line-offset (_aref line-offsets *max-input-index*)))))))))))

137

138

(defun parse-nquads-to-cspo (source)

139

(loop for (s p o c) in (parse-nquads source)

140

collect (list c s p o)))

141

142

(defun parse-nquads-statement (source)

143

(parse-nquads source :start-name 'odnq::|statement|))

144

145

#|

146

(load (compile-file #p"/development/source/library/org/datagraph/spocq/src/core/encoding/nquads.lisp"))

147

(loop for sym being each present-symbol of :odnq

148

when (fboundp (print sym))

149

do (eval `(sb-profile:profile ,sym)))

150

(in-package :odnq)

151

(bnfp:compile-atn-system spocq.i::*nquads-bnf*

152

:execute t :compile nil

153

:token-package (find-package :spocq.s)

154

:source-package (find-package :odnq)

155

                           :source-pathname #p"/development/source/library/org/datagraph/spocq/src/core/encoding/nquads-grammar.lisp"

156

:input-function 'sparql-1-0-4::input-reference

157

:input-eof-function 'sparql-1-0-4::input-eof?

158

:ambiguous t

159

:trace nil)

160

(load (compile-file #p"/development/source/library/org/datagraph/spocq/src/core/encoding/nquads-grammar.lisp"

161

:output-file "turtle-grammar.fasl"))

162

163

164

(parse-nquads "

165

 _:triplePattern <http://www.w3.org/ns/hydra/core#template> 'http://fragments.dbpedia.org/{?subject,predicate,object}' <http://fragments.dbpedia.org/#metadata>.

166

_:triplePattern <http://www.w3.org/ns/hydra/core#mapping> _:subject <http://fragments.dbpedia.org/#metadata>.

167

_:triplePattern <http://www.w3.org/ns/hydra/core#mapping> _:predicate <http://fragments.dbpedia.org/#metadata>.

168

_:triplePattern <http://www.w3.org/ns/hydra/core#mapping> _:object <http://fragments.dbpedia.org/#metadata>.

169

_:subject <http://www.w3.org/ns/hydra/core#variable> 'subject' <http://fragments.dbpedia.org/#metadata>.

170

 _:subject <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#subject> <http://fragments.dbpedia.org/#metadata>.

171

_:predicate <http://www.w3.org/ns/hydra/core#variable> 'predicate' <http://fragments.dbpedia.org/#metadata>.

172

 _:predicate <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate> <http://fragments.dbpedia.org/#metadata>.

173

_:object <http://www.w3.org/ns/hydra/core#variable> 'object' <http://fragments.dbpedia.org/#metadata>.

174

 _:object <http://www.w3.org/ns/hydra/core#property> <http://www.w3.org/1999/02/22-rdf-syntax-ns#object> <http://fragments.dbpedia.org/#metadata>.")

175

176

 (parse-nquads " _:triplePattern <http://www.w3.org/ns/hydra/core#template> 'http://fragments.dbpedia.org/{?subject,predicate,object}' ."

177

:start-name 'odnq::|statement|)

178

179

(parse-nquads " _:tp <http://example.org/p> 'one' . _:tp <http://example.org/p> 'two' . ")

180

181

 (parse-nquads-statement " _:triplePattern <http://www.w3.org/ns/hydra/core#template> 'http://fragments.dbpedia.org/{?subject,predicate,object}' .")

182

183

(parse-sparql-profile " _:triplePattern " :production "BlankNode")

184

185

(parse-nquads-statement " _:triplePattern <http://www.w3.org/ns/hydra/core#template> 'asdf

186

qwer' .")

187

|#