aboutsummaryrefslogtreecommitdiff
path: root/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java')
-rw-r--r--src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java313
1 files changed, 313 insertions, 0 deletions
diff --git a/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java b/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
new file mode 100644
index 0000000..31838bc
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/util/SparqlHelper.java
@@ -0,0 +1,313 @@
1package uk.ac.ox.cs.pagoda.util;
2
3import java.util.Collection;
4import java.util.HashSet;
5import java.util.Set;
6
7import org.semanticweb.HermiT.model.AnnotatedEquality;
8import org.semanticweb.HermiT.model.AtLeastConcept;
9import org.semanticweb.HermiT.model.Atom;
10import org.semanticweb.HermiT.model.AtomicConcept;
11import org.semanticweb.HermiT.model.AtomicDataRange;
12import org.semanticweb.HermiT.model.AtomicRole;
13import org.semanticweb.HermiT.model.Constant;
14import org.semanticweb.HermiT.model.DLPredicate;
15import org.semanticweb.HermiT.model.Equality;
16import org.semanticweb.HermiT.model.Individual;
17import org.semanticweb.HermiT.model.Inequality;
18import org.semanticweb.HermiT.model.Term;
19import org.semanticweb.HermiT.model.Variable;
20
21import uk.ac.ox.cs.pagoda.MyPrefixes;
22import uk.ac.ox.cs.pagoda.hermit.RuleHelper;
23
24import com.hp.hpl.jena.graph.Node;
25import com.hp.hpl.jena.query.Query;
26import com.hp.hpl.jena.query.QueryFactory;
27import com.hp.hpl.jena.sparql.core.TriplePath;
28import com.hp.hpl.jena.sparql.core.Var;
29import com.hp.hpl.jena.sparql.syntax.Element;
30import com.hp.hpl.jena.sparql.syntax.ElementAssign;
31import com.hp.hpl.jena.sparql.syntax.ElementBind;
32import com.hp.hpl.jena.sparql.syntax.ElementData;
33import com.hp.hpl.jena.sparql.syntax.ElementDataset;
34import com.hp.hpl.jena.sparql.syntax.ElementExists;
35import com.hp.hpl.jena.sparql.syntax.ElementFilter;
36import com.hp.hpl.jena.sparql.syntax.ElementGroup;
37import com.hp.hpl.jena.sparql.syntax.ElementMinus;
38import com.hp.hpl.jena.sparql.syntax.ElementNamedGraph;
39import com.hp.hpl.jena.sparql.syntax.ElementNotExists;
40import com.hp.hpl.jena.sparql.syntax.ElementOptional;
41import com.hp.hpl.jena.sparql.syntax.ElementPathBlock;
42import com.hp.hpl.jena.sparql.syntax.ElementService;
43import com.hp.hpl.jena.sparql.syntax.ElementSubQuery;
44import com.hp.hpl.jena.sparql.syntax.ElementTriplesBlock;
45import com.hp.hpl.jena.sparql.syntax.ElementUnion;
46import com.hp.hpl.jena.sparql.syntax.ElementVisitor;
47
48public class SparqlHelper {
49
50 public static String getSPARQLQuery(Atom[] atoms, String... vars) {
51 Set<Variable> undistinguishedVars = new HashSet<Variable>();
52 for (int i = 0; i < atoms.length; ++i) {
53 atoms[i].getVariables(undistinguishedVars);
54 }
55 int xIndex = 1;
56 while (undistinguishedVars.contains(Variable.create("X" + xIndex))) ++xIndex;
57
58 for (String var: vars)
59 if (var != null && !var.isEmpty())
60 undistinguishedVars.remove(Variable.create(var));
61
62 StringBuffer buffer = new StringBuffer();
63 if (vars.length > 0)
64 buffer.append("SELECT DISTINCT ");
65 else
66 buffer.append("SELECT *");
67 for (int i = 0; i < vars.length; ++i) {
68 if (vars[i] != null && !vars[i].isEmpty())
69 buffer.append("?").append(vars[i]).append(" ");
70 }
71 buffer.append( " WHERE {");
72 for (Atom atom: atoms)
73 if (atom.getDLPredicate() instanceof AtLeastConcept) {
74 AtLeastConcept atLeast = (AtLeastConcept) atom.getDLPredicate();
75 int number = atLeast.getNumber();
76 for (int i = 0; i < number; ++i) {
77 Variable newVar = Variable.create("X" + (xIndex + i));
78
79 Atom tAtom;
80 if (atLeast.getOnRole() instanceof AtomicRole)
81 tAtom = Atom.create(
82 (AtomicRole) atLeast.getOnRole(),
83 atom.getArgument(0),
84 newVar);
85 else
86 tAtom = Atom.create(
87 (AtomicRole) atLeast.getOnRole().getInverse(),
88 newVar,
89 atom.getArgument(0));
90 buffer.append(" ");
91 buffer.append(toSPARQLClause(tAtom, undistinguishedVars));
92 buffer.append(" .");
93
94 if (!atLeast.getToConcept().equals(AtomicConcept.THING)) {
95 if (atLeast.getToConcept() instanceof AtomicConcept);
96
97 tAtom = Atom.create((AtomicConcept) atLeast.getToConcept(), newVar);
98 buffer.append(" ");
99 buffer.append(toSPARQLClause(tAtom, undistinguishedVars));
100 buffer.append(" .");
101 }
102 }
103
104 for (int i = 0; i < number; ++i)
105 for (int j = i + 1; j < number; ++j) {
106 Atom tAtom = Atom.create(Inequality.INSTANCE, Variable.create("X" + (xIndex + i)), Variable.create("X" + (xIndex + j)));
107 buffer.append(" ");
108 buffer.append(toSPARQLClause(tAtom, undistinguishedVars));
109 buffer.append(" .");
110 }
111
112 xIndex += number;
113 }
114 else {
115 buffer.append(" ");
116 buffer.append(toSPARQLClause(atom, undistinguishedVars));
117 buffer.append(" .");
118 }
119 buffer.append(" ").append("}");
120 return buffer.toString();
121 }
122
123 private static String toSPARQLClause(Atom atom, Set<Variable> undisVars ) {
124 DLPredicate predicate = atom.getDLPredicate();
125 String r, a, b;
126
127 if (predicate instanceof Equality || predicate instanceof AnnotatedEquality)
128 atom = Atom.create(predicate = AtomicRole.create(Namespace.EQUALITY), atom.getArgument(0), atom.getArgument(1));
129 else if (predicate instanceof Inequality)
130 atom = Atom.create(predicate = AtomicRole.create(Namespace.INEQUALITY), atom.getArgument(0), atom.getArgument(1));
131
132 if (predicate instanceof AtomicConcept) {
133 r = Namespace.RDF_TYPE_QUOTED;
134 a = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(getName(atom.getArgument(0), undisVars));
135 b = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(RuleHelper.getText(predicate));
136 }
137 else if (predicate instanceof AtomicRole) {
138 r = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(RuleHelper.getText(predicate));
139 a = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(getName(atom.getArgument(0), undisVars));
140 b = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(getName(atom.getArgument(1), undisVars));
141 }
142 else if (predicate instanceof AtomicDataRange) {
143 r = Namespace.RDF_TYPE_QUOTED;
144 a = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(getName(atom.getArgument(0), undisVars));
145 b = MyPrefixes.PAGOdAPrefixes.getQuotedIRI(RuleHelper.getText(predicate));
146 }
147 else {
148 Utility.logError("error!!!!!!!!!!!");
149 return null;
150 }
151
152 return a + " " + r + " " + b;
153 }
154
155 private static String getName(Term t, Set<Variable> undisVars) {
156 if (t instanceof Variable)
157 if (undisVars.contains(t))
158 return "_:" + ((Variable) t).getName();
159 else return "?" + ((Variable) t).getName();
160 return MyPrefixes.PAGOdAPrefixes.abbreviateIRI(t.toString());
161 }
162
163 public static Query parse(String text, Collection<String> vars, Collection<Atom> atoms) {
164 Query query = QueryFactory.create(text);
165 if (vars != null) {
166 vars.clear();
167 for (Var var: query.getProjectVars())
168 vars.add(var.getName());
169 }
170 ElementVisitor visitor = new MySparqlElementVisitor(atoms);
171 query.getQueryPattern().visit(visitor);
172 return query;
173 }
174
175}
176
177class MySparqlElementVisitor implements ElementVisitor {
178
179 Collection<Atom> atoms;
180
181 public MySparqlElementVisitor(Collection<Atom> atoms) {
182 this.atoms = atoms;
183 }
184
185 @Override
186 public void visit(ElementSubQuery el) {
187 Utility.logError("ElmentSubQuery: " + el);
188 }
189
190 @Override
191 public void visit(ElementService el) {
192 // TODO Auto-generated method stub
193 Utility.logError("ElementService: " + el);
194 }
195
196 @Override
197 public void visit(ElementMinus el) {
198 // TODO Auto-generated method stub
199 Utility.logError("ElementMinus: " + el);
200 }
201
202 @Override
203 public void visit(ElementNotExists el) {
204 // TODO Auto-generated method stub
205 Utility.logError("ElementNotExists: " + el);
206 }
207
208 @Override
209 public void visit(ElementExists el) {
210 // TODO Auto-generated method stub
211 Utility.logError("ElementExists: " + el);
212 }
213
214 @Override
215 public void visit(ElementNamedGraph el) {
216 // TODO Auto-generated method stub
217 Utility.logError("ElementNamedGraph: " + el);
218 }
219
220 @Override
221 public void visit(ElementDataset el) {
222 // TODO Auto-generated method stub
223 Utility.logError("ElementDataset: " + el);
224 }
225
226 @Override
227 public void visit(ElementGroup el) {
228 // TODO Auto-generated method stub
229 for (Element e: el.getElements())
230 e.visit(this);
231 }
232
233 @Override
234 public void visit(ElementOptional el) {
235 // TODO Auto-generated method stub
236 Utility.logError("ElementOptional: " + el);
237 }
238
239 @Override
240 public void visit(ElementUnion el) {
241 // TODO Auto-generated method stub
242 Utility.logError("ElementUnion: " + el);
243 }
244
245 @Override
246 public void visit(ElementBind el) {
247 // TODO Auto-generated method stub
248 Utility.logError("ElementBind: " + el);
249 }
250
251 @Override
252 public void visit(ElementAssign el) {
253 // TODO Auto-generated method stub
254 Utility.logError("ElementAssign: " + el);
255 }
256
257 @Override
258 public void visit(ElementFilter el) {
259 // TODO Auto-generated method stub
260 Utility.logError("ElementFilter: " + el);
261 }
262
263 @Override
264 public void visit(ElementPathBlock el) {
265 // TODO Auto-generated method stub
266 for (TriplePath p: el.getPattern().getList()) {
267 if (p.getPredicate().isVariable()) {
268 AtomicRole r = AtomicRole.create("?" + p.getPredicate().getName());
269 Term a = getTerm(p.getSubject()), b = getTerm(p.getObject());
270 atoms.add(Atom.create(r, a, b));
271 }
272 else if (p.getPredicate().getURI().equals(Namespace.RDF_TYPE) && !p.getObject().isVariable()) {
273 AtomicConcept A = AtomicConcept.create(p.getObject().getURI());
274 Term c = getTerm(p.getSubject());
275 atoms.add(Atom.create(A, c));
276 }
277 else {
278 AtomicRole r = AtomicRole.create(p.getPredicate().getURI());
279 Term a = getTerm(p.getSubject()), b = getTerm(p.getObject());
280 atoms.add(Atom.create(r, a, b));
281 }
282 }
283 }
284
285 private Term getTerm(Node node) {
286 if (node.isVariable())
287 return Variable.create(node.getName());
288 if (node.isLiteral())
289 if (node.getLiteralDatatypeURI() == null)
290 return Constant.create(node.getLiteralLexicalForm(), Namespace.XSD_STRING);
291 else
292 return Constant.create(node.getLiteralLexicalForm(), node.getLiteralDatatypeURI());
293
294
295 if (node.isURI())
296 return Individual.create(node.getURI());
297 Utility.logError("unknown node: " + node);
298 return null;
299 }
300
301 @Override
302 public void visit(ElementTriplesBlock el) {
303 // TODO Auto-generated method stub
304
305 Utility.logError("ElementTriplesBlock: " + el);
306 }
307
308 @Override
309 public void visit(ElementData el) {
310 // TODO Auto-generated method stub
311
312 }
313} \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-05 15:34:15 +0000