Remove SPARQL query stuff from Redlandmm.

git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@2951 a436a847-0d15-0410-975c-d299462d15a1

2 files changed, 181 insertions, 294 deletions

diff --git a/src/gui/LoadRemotePatchWindow.cpp b/src/gui/LoadRemotePatchWindow.cpp
index 6fff2ff9..0f03b42e 100644
--- a/src/gui/LoadRemotePatchWindow.cpp
+++ b/src/gui/LoadRemotePatchWindow.cpp
@@ -66,6 +66,8 @@ LoadRemotePatchWindow::present(SharedPtr<PatchModel> patch, GraphObject::Propert
 	set_patch(patch);
 	_initial_data = data;
 
+	cerr << "FIXME: load remote patch" << endl;
+#if 0
 	Redland::Model model(*App::instance().world()->rdf_world(),
 			"http://rdf.drobilla.net/ingen_patches/index.ttl",
 			"http://rdf.drobilla.net/ingen_patches/");
@@ -86,6 +88,7 @@ LoadRemotePatchWindow::present(SharedPtr<PatchModel> patch, GraphObject::Propert
 	_treeview->columns_autosize();
 
 	Gtk::Window::present();
+#endif
 }
 
 
diff --git a/src/serialisation/Parser.cpp b/src/serialisation/Parser.cpp
index 9034c5c0..016d1804 100644
--- a/src/serialisation/Parser.cpp
+++ b/src/serialisation/Parser.cpp
@@ -36,10 +36,19 @@
 
 #define LOG(s) s << "[Parser] "
 
+#define NS_INGEN "http://drobilla.net/ns/ingen#"
+#define NS_LV2   "http://lv2plug.in/ns/lv2core#"
+#define NS_RDF   "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_RDFS  "http://www.w3.org/2000/01/rdf-schema#"
+
 using namespace std;
 using namespace Raul;
 using namespace Ingen::Shared;
 
+static const Redland::Node nil;
+
+typedef set<Redland::Node> RDFNodes;
+
 namespace Ingen {
 namespace Serialisation {
 
@@ -77,19 +86,25 @@ Parser::find_patches(
 	const Glib::ustring&  manifest_uri)
 {
 	Redland::Model model(*world->rdf_world(), manifest_uri, manifest_uri);
-	Redland::Query query(*world->rdf_world(),
-		"SELECT DISTINCT ?patch ?file WHERE {\n"
-		"?patch a            ingen:Patch ;\n"
-		"       rdfs:seeAlso ?file .\n"
-		"}");
 
-	std::list<PatchRecord> records;
+	Redland::Resource rdf_type(*world->rdf_world(),     NS_RDF   "type");
+	Redland::Resource rdfs_seeAlso(*world->rdf_world(), NS_RDFS  "seeAlso");
+	Redland::Resource ingen_Patch(*world->rdf_world(),  NS_INGEN "Patch");
 
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model, manifest_uri));
-	for (; !results->finished(); results->next()) {
-		const Redland::Node& patch(results->get("patch"));
-		const Redland::Node& file(results->get("file"));
-		records.push_back(PatchRecord(patch.to_c_string(), file.to_c_string()));
+	RDFNodes patches;
+	for (Redland::Iter i = model.find(nil, rdf_type, ingen_Patch); !i.end(); ++i) {
+		patches.insert(i.get_subject());
+	}
+
+	std::list<PatchRecord> records;
+	for (RDFNodes::const_iterator i = patches.begin(); i != patches.end(); ++i) {
+		Redland::Iter f = model.find(*i, rdfs_seeAlso, nil);
+		if (f.end()) {
+			LOG(error) << "Patch has no rdfs:seeAlso" << endl;
+			continue;
+		}
+		records.push_back(PatchRecord(i->to_c_string(),
+		                              f.get_object().to_c_string()));
 	}
 
 	return records;
@@ -111,6 +126,8 @@ Parser::parse_document(
 {
 	normalise_uri(document_uri);
 
+	assert(document_uri[document_uri.length() - 1] == '/');
+	
 	const std::string filename(Glib::filename_from_uri(document_uri));
 	const size_t      ext = filename.find(INGEN_BUNDLE_EXT);
 	const size_t      ext_len = strlen(INGEN_BUNDLE_EXT);
@@ -118,7 +135,7 @@ Parser::parse_document(
 			|| (ext == filename.length() - ext_len - 1 && filename[filename.length() - 1] == '/')) {
 		std::string basename(Glib::path_get_basename(filename));
 		basename = basename.substr(0, basename.find('.'));
-		document_uri += "/" + basename + INGEN_PATCH_FILE_EXT;
+		document_uri += basename + INGEN_PATCH_FILE_EXT;
 	}
 
 	Redland::Model model(*world->rdf_world(), document_uri, document_uri);
@@ -182,6 +199,7 @@ Parser::parse_update(
 		boost::optional<Raul::Symbol>            symbol,
 		boost::optional<GraphObject::Properties> data)
 {
+	#if 0
 	Redland::Model model(*world->rdf_world(), str.c_str(), str.length(), base_uri);
 
 	// Delete anything explicitly declared to not exist
@@ -235,6 +253,8 @@ Parser::parse_update(
 	}
 
 	return parse(world, target, model, base_uri, data_path, parent, symbol, data);
+	#endif
+	return false;
 }
 
 
@@ -251,15 +271,7 @@ Parser::parse(
 {
 	const Redland::Node::Type res = Redland::Node::RESOURCE;
 
-	const Glib::ustring query_str = data_path
-		? Glib::ustring("SELECT DISTINCT ?t WHERE { <") + data_path->chop_start("/") + "> a ?t . }"
-		: Glib::ustring("SELECT DISTINCT ?s ?t WHERE { ?s a ?t . }");
-
-	Redland::Query query(*world->rdf_world(), query_str);
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model, document_uri));
-
-#define NS_INGEN "http://drobilla.net/ns/ingen#"
-#define NS_LV2   "http://lv2plug.in/ns/lv2core#"
+	const Redland::Resource rdf_type(*world->rdf_world(), NS_RDF "type");
 
 	const Redland::Node patch_class    (*world->rdf_world(), res, NS_INGEN "Patch");
 	const Redland::Node node_class     (*world->rdf_world(), res, NS_INGEN "Node");
@@ -269,17 +281,22 @@ Parser::parse(
 	const Redland::Node out_port_class (*world->rdf_world(), res, NS_LV2 "OutputPort");
 	const Redland::Node lv2_class      (*world->rdf_world(), res, NS_LV2 "Plugin");
 
-	const Redland::Node subject_node = (data_path && !data_path->is_root())
-		? Redland::Node(*world->rdf_world(), res, data_path->chop_start("/"))
-		: model.base_uri();
+	Redland::Node subject;
+	if (data_path && data_path->is_root()) {
+		subject = model.base_uri();
+	} else if (data_path) {
+		subject = Redland::Node(*world->rdf_world(), res, data_path->chop_start("/"));
+	} else {
+		subject = nil;
+	}
 
 	std::string           path_str;
 	boost::optional<Path> ret;
 	boost::optional<Path> root_path;
 
-	for (; !results->finished(); results->next()) {
-		const Redland::Node& subject = (data_path ? subject_node : results->get("s"));
-		const Redland::Node& rdf_class = results->get("t");
+	for (Redland::Iter i = model.find(subject, rdf_type, nil); !i.end(); ++i) {
+		const Redland::Node& subject   = i.get_subject();
+		const Redland::Node& rdf_class = i.get_object();
 
 		if (!data_path)
 			path_str = relative_uri(document_uri, subject.to_c_string(), true);
@@ -356,10 +373,17 @@ Parser::parse_patch(
 		boost::optional<GraphObject::Properties> data)
 {
 	const LV2URIMap& uris = *world->uris().get();
-	uint32_t patch_poly = 0;
 
 	typedef Redland::QueryResults Results;
 
+	Redland::Resource ingen_polyphony(*world->rdf_world(), NS_INGEN "polyphony");
+	Redland::Resource lv2_port(*world->rdf_world(),        NS_LV2   "port");
+	Redland::Resource lv2_symbol(*world->rdf_world(),      NS_LV2   "symbol");
+
+	const Redland::Node& patch = subject_node;
+
+	uint32_t patch_poly = 0;
+
 	/* Use parameter overridden polyphony, if given */
 	if (data) {
 		GraphObject::Properties::iterator poly_param = data.get().find(uris.ingen_polyphony);
@@ -367,16 +391,11 @@ Parser::parse_patch(
 			patch_poly = poly_param->second.get_int32();
 	}
 
-	const Glib::ustring subject = subject_node.to_turtle_token();
-
 	/* Load polyphony from file if necessary */
 	if (patch_poly == 0) {
-		Redland::Query query(*world->rdf_world(), Glib::ustring(
-			"SELECT DISTINCT ?poly WHERE { ") + subject + " ingen:polyphony ?poly }");
-
-		SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model));
-		if (!results->finished()) {
-			const Redland::Node& poly_node = results->get("poly");
+		Redland::Iter i = model.find(subject_node, ingen_polyphony, nil);
+		if (!i.end()) {
+			const Redland::Node& poly_node = i.get_object();
 			if (poly_node.is_int())
 				patch_poly = poly_node.to_int();
 			else
@@ -384,7 +403,7 @@ Parser::parse_patch(
 		}
 	}
 
-	/* No polyphony value anywhere, 1 it is */
+	/* No polyphony found anywhere, use 1 */
 	if (patch_poly == 0)
 		patch_poly = 1;
 
@@ -407,7 +426,6 @@ Parser::parse_patch(
 		return boost::optional<Raul::Path>();
 	}
 
-
 	/* Create patch */
 	Path patch_path(patch_path_str);
 	Resource::Properties props;
@@ -415,252 +433,108 @@ Parser::parse_patch(
 	props.insert(make_pair(uris.ingen_polyphony, Raul::Atom(int32_t(patch_poly))));
 	target->put(patch_path, props);
 
-
-	/* Find patches in document */
-	Redland::Query query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?patch WHERE {\n") +
-			"?patch a ingen:Patch .\n"
-		"}");
-	set<string> patches;
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model, base_uri));
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		patches.insert(results->get("patch").to_string());
-	}
+	Redland::Resource rdf_type(*world->rdf_world(),    NS_RDF   "type");
+	Redland::Resource ingen_Patch(*world->rdf_world(), NS_INGEN "Patch");
+	Redland::Resource ingen_node(*world->rdf_world(),  NS_INGEN "node");
 
 	typedef multimap<Raul::URI, Raul::Atom> Properties;
 	typedef map<string, Redland::Node>      Resources;
 	typedef map<string, Properties>         Objects;
 	typedef map<string, string>             Types;
 
-	/* Find nodes on this patch */
-	query = Redland::Query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?node ?type WHERE {\n") +
-			subject + " ingen:node     ?node .\n"
-			"?node      rdf:instanceOf ?type .\n"
-		"}");
+	SharedPtr<Redland::QueryResults> results;
+
 	Objects   patch_nodes;
 	Objects   plugin_nodes;
 	Resources resources;
 	Types     types;
-	results = query.run(*world->rdf_world(), model, base_uri);
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const Redland::Node& node = results->get("node");
-		const Redland::Node& type = results->get("type");
-		if (node.type() == Redland::Node::RESOURCE && type.type() == Redland::Node::RESOURCE) {
-			types.insert(make_pair(node.to_string(), type.to_string()));
-			if (patches.find(type.to_string()) != patches.end()) {
-				patch_nodes.insert(make_pair(node.to_string(), Properties()));
-				resources.insert(make_pair(type.to_string(), type));
-			} else {
-				plugin_nodes.insert(make_pair(node.to_string(), Properties()));
-			}
-		}
-	}
-
 
-	/* Load nodes on this patch */
-	query = Redland::Query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?node ?predicate ?object WHERE {\n") +
-			subject + " ingen:node ?node .\n"
-			"?node      ?predicate ?object .\n"
-		"}");
-	results = query.run(*world->rdf_world(), model, base_uri);
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const Redland::Node& node      = results->get("node");
-		const Redland::Node& predicate = results->get("predicate");
-		const Redland::Node& object    = results->get("object");
-		Objects::iterator    patch_i   = patch_nodes.find(node.to_string());
-		Objects::iterator    plug_i    = plugin_nodes.find(node.to_string());
-		Types::iterator      type_i    = types.find(node.to_string());
-		if (node.type() == Redland::Node::RESOURCE && type_i != types.end()) {
-			if (skip_property(predicate))
-				continue;
-			const string key = predicate.to_string();
-			if (patch_i != patch_nodes.end()) {
-				patch_i->second.insert(make_pair(key, AtomRDF::node_to_atom(model, object)));
-			} else if (plug_i != plugin_nodes.end()) {
-				plug_i->second.insert(make_pair(key, AtomRDF::node_to_atom(model, object)));
-			} else {
-				LOG(warn) << "Unrecognized node: " << node.to_string() << endl;
+	/* For each node in this patch */
+	typedef map<Redland::Node, Properties> Nodes;
+	Nodes nodes;
+	for (Redland::Iter n = model.find(subject_node, ingen_node, nil); !n.end(); ++n) {
+		Redland::Node node = n.get_object();
+
+		/* Get all node properties */
+		Properties node_properties;
+		for (Redland::Iter np = model.find(node, nil, nil); !np.end(); ++np) {
+			const Redland::Node& predicate = np.get_predicate();
+			const Redland::Node& object    = np.get_object();
+			if (!skip_property(predicate)) {
+				node_properties.insert(
+					make_pair(predicate,
+					          AtomRDF::node_to_atom(model, object)));
 			}
 		}
-	}
-
-	/* Create patch nodes */
-	for (Objects::iterator i = patch_nodes.begin(); i != patch_nodes.end(); ++i) {
-		const Path      node_path = patch_path.child(relative_uri(base_uri, i->first, false));
-		Types::iterator type_i    = types.find(i->first);
-		if (type_i == types.end())
-			continue;
-		Resources::iterator res_i = resources.find(type_i->second);
-		if (res_i == resources.end())
-			continue;
-		parse_patch(world, target, model, res_i->second, patch_path, Symbol(node_path.symbol()));
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		target->put(node_path, i->second);
-	}
-
-	/* Create plugin nodes */
-	for (Objects::iterator i = plugin_nodes.begin(); i != plugin_nodes.end(); ++i) {
-		Types::iterator type_i = types.find(i->first);
-		if (type_i == types.end())
-			continue;
-		const Path node_path = patch_path.child(relative_uri(base_uri, i->first, false));
-		Resource::Properties props;
-		props.insert(make_pair(uris.rdf_type,       Raul::URI(uris.ingen_Node)));
-		props.insert(make_pair(uris.rdf_instanceOf, Raul::URI(type_i->second)));
-		props.insert(i->second.begin(), i->second.end());
-		target->put(node_path, props);
-	}
-
-
-	/* Load node ports */
-	query = Redland::Query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?node ?port ?key ?val WHERE {\n") +
-			subject + " ingen:node ?node .\n"
-			"?node      lv2:port   ?port .\n"
-			"?port      ?key       ?val .\n"
-		"}");
-	Objects node_ports;
-	results = query.run(*world->rdf_world(), model, base_uri);
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const string node_uri = results->get("node").to_string();
-		const string port_uri = results->get("port").to_string();
-		if (port_uri.length() <= node_uri.length()) {
-			LOG(warn) << "Port on " << node_uri << " has bad URI: " << port_uri << endl;
-			continue;
-		}
-
-		Objects::iterator p = node_ports.find(port_uri);
-		if (p == node_ports.end())
-			p = node_ports.insert(make_pair(port_uri, Properties())).first;
-
-		const Path   node_path = patch_path.child(relative_uri(base_uri, node_uri, false));
-		const Symbol port_sym  = port_uri.substr(node_uri.length() + 1);
-		const Path   port_path = node_path.child(port_sym);
-		const string key       = results->get("key").to_string();
-		p->second.insert(make_pair(key, AtomRDF::node_to_atom(model, results->get("val"))));
-	}
 
-	for (Objects::iterator i = node_ports.begin(); i != node_ports.end(); ++i) {
-		target->put(patch_path.child(relative_uri(base_uri, i->first, false)), i->second);
-	}
+		/* Create node */
+		const Path node_path = patch_path.child(
+			relative_uri(base_uri, node.to_string(), false));
+		target->put(node_path, node_properties);
+
+		/* For each port on this node */
+		for (Redland::Iter p = model.find(node, lv2_port, nil); !p.end(); ++p) {
+			Redland::Node port = p.get_object();
+
+			/* Get all port properties */
+			Properties port_properties;
+			for (Redland::Iter pp = model.find(port, nil, nil); !pp.end(); ++pp) {
+				const Redland::Node& predicate = pp.get_predicate();
+				const Redland::Node& object    = pp.get_object();
+				if (!skip_property(predicate)) {
+					port_properties.insert(
+						make_pair(predicate,
+						          AtomRDF::node_to_atom(model, object)));
+				}
+			}
 
+			/* Set port properties */
+			Properties::const_iterator s = port_properties.find(uris.lv2_symbol);
+			if (s == port_properties.end()) {
+				LOG(error) << "Port on " << node_path << " has no symbol" << endl;
+				return boost::optional<Path>();
+			}
 
-	/* Find ports on this patch */
-	query = Redland::Query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?port ?type WHERE {\n") +
-			subject + " lv2:port       ?port .\n"
-			"?port      rdf:instanceOf ?type .\n"
-		"}");
-	Objects patch_ports;
-	results = query.run(*world->rdf_world(), model, base_uri);
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const Redland::Node& port = results->get("port");
-		const Redland::Node& type = results->get("type");
-		if (port.type() == Redland::Node::RESOURCE && type.type() == Redland::Node::RESOURCE) {
-			types.insert(make_pair(port.to_string(), type.to_string()));
-			patch_ports.insert(make_pair(port.to_string(), Properties()));
+			const Symbol port_sym  = s->second.get_string();
+			const Path   port_path = node_path.child(port_sym);
+			target->put(port_path, port_properties);
 		}
 	}
 
-
-	/* Load patch ports */
-	query = Redland::Query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?port ?key ?val WHERE {\n") +
-			subject + " lv2:port ?port .\n"
-			"?port      ?key     ?val .\n"
-		"}");
-	results = query.run(*world->rdf_world(), model, base_uri);
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const string port_uri  = results->get("port").to_string();
-		const Path   port_path = patch_path.child(relative_uri(base_uri, port_uri, false));
-		const string key       = results->get("key").to_string();
-		Objects::iterator ports_i = patch_ports.find(port_uri);
-		if (ports_i == patch_ports.end())
-			ports_i = patch_ports.insert(make_pair(port_uri, Properties())).first;
-		ports_i->second.insert(make_pair(key, AtomRDF::node_to_atom(model, results->get("val"))));
-	}
-
-	std::vector<Objects::iterator> ports_by_index(patch_ports.size(), patch_ports.end());
-	for (Objects::iterator i = patch_ports.begin(); i != patch_ports.end(); ++i) {
-		Properties::const_iterator index_i = i->second.lower_bound(uris.lv2_index);
-		if (index_i == i->second.end()) {
-			error << "Patch port has no index" << endl;
-			return boost::optional<Raul::Path>();
-		}
-
-		if (index_i->second.type() != Atom::INT) {
-			error << "Patch port index has non-integer type" << endl;
-			return boost::optional<Raul::Path>();
-		}
-
-		const int32_t index = index_i->second.get_int32();
-
-		++index_i;
-		if (index_i != i->second.end() && index_i->first == uris.lv2_index) {
-			error << "Patch port has multiple indices" << endl;
-			return boost::optional<Raul::Path>();
-		}
-
-		if (index < 0 || static_cast<size_t>(index) >= patch_ports.size()) {
-			error << "Patch port index out of range" << endl;
-			return boost::optional<Raul::Path>();
-		}
-
-		if (ports_by_index[index] != patch_ports.end()) {
-			error << "Patch has several ports with index " << index << endl;
-			return boost::optional<Raul::Path>();
-		}
-
-		ports_by_index[index] = i;
-	}
-
-	for (uint32_t index = 0; index < patch_ports.size(); ++index) {
-		Objects::iterator i = ports_by_index[index];
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const Path port_path = patch_path.child(relative_uri(base_uri, i->first, false));
-		std::pair<Properties::iterator,Properties::iterator> types_range
-				= i->second.equal_range(uris.rdf_type);
-		if (types_range.first == i->second.end()) {
-			LOG(warn) << "Patch port has no types" << endl;
-			continue;
-		}
-		bool is_input  = false;
-		bool is_output = false;
-		Raul::Atom* type = 0;
-		for (Properties::iterator t = types_range.first; t != types_range.second; ++t) {
-			if (t->second.type() != Atom::URI) {
-				continue;
-			} else if (!strcmp(t->second.get_uri(), uris.lv2_InputPort.c_str())) {
-				is_input = true;
-			} else if (!strcmp(t->second.get_uri(), uris.lv2_OutputPort.c_str())) {
-				is_output = true;
-			} else if (!type) {
-				type = &t->second;
-			} else {
-				LOG(error) << "Port has several data types" << endl;
-				continue;
+	/* For each port on this patch */
+	for (Redland::Iter p = model.find(patch, lv2_port, nil); !p.end(); ++p) {
+		Redland::Node port = p.get_object();
+
+		/* Get all port properties */
+		Properties port_properties;
+		for (Redland::Iter pp = model.find(port, nil, nil); !pp.end(); ++pp) {
+			const Redland::Node& predicate = pp.get_predicate();
+			const Redland::Node& object    = pp.get_object();
+			if (!skip_property(predicate)) {
+				port_properties.insert(
+					make_pair(predicate,
+					          AtomRDF::node_to_atom(model, object)));
 			}
 		}
-		if ((is_input && is_output) || !type) {
-			LOG(error) << "Corrupt patch port" << endl;
-			continue;
+
+		/* Set port properties */
+		Properties::const_iterator s = port_properties.find(uris.lv2_symbol);
+		if (s == port_properties.end()) {
+			LOG(error) << "Port on " << patch_path << " has no symbol" << endl;
+			return boost::optional<Path>();
 		}
 
-		target->put(port_path, i->second);
+		const Symbol port_sym  = s->second.get_string();
+		const Path   port_path = patch_path.child(port_sym);
+		target->put(port_path, port_properties);
 	}
 
 	parse_properties(world, target, model, subject_node, patch_path, data);
 	parse_connections(world, target, model, subject_node, patch_path);
 
-
+	cerr << "FIXME: enable patch" << endl;
+	target->set_property(patch_path, uris.ingen_enabled, (bool)true);
+#if 0
 	/* Enable */
 	query = Redland::Query(*world->rdf_world(), Glib::ustring(
 		"SELECT DISTINCT ?enabled WHERE {\n")
@@ -678,7 +552,8 @@ Parser::parse_patch(
 			LOG(warn) << "Unknown type for ingen:enabled" << endl;
 		}
 	}
-
+#endif
+	
 	return patch_path;
 }
 
@@ -694,20 +569,16 @@ Parser::parse_node(
 {
 	const LV2URIMap& uris = *world->uris().get();
 
-	/* Get plugin */
-	Redland::Query query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?plug WHERE {\n")
-			+ subject.to_turtle_token() + " rdf:instanceOf ?plug .\n"
-		"}");
-
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model));
+	Redland::Resource rdf_instanceOf(*world->rdf_world(), NS_RDF "instanceOf");
 
-	if (results->finished()) {
+	/* Get plugin */
+	Redland::Iter i = model.find(subject, rdf_instanceOf, nil);
+	if (i.end()) {
 		LOG(error) << "Node missing mandatory rdf:instanceOf property" << endl;
 		return boost::optional<Path>();
 	}
 
-	const Redland::Node& plugin_node = results->get("plug");
+	const Redland::Node& plugin_node = i.get_object();
 	if (plugin_node.type() != Redland::Node::RESOURCE) {
 		LOG(error) << "Node's rdf:instanceOf property is not a resource" << endl;
 		return boost::optional<Path>();
@@ -732,20 +603,42 @@ Parser::parse_connections(
 		const Redland::Node&            subject,
 		const Raul::Path&               parent)
 {
-	Redland::Query query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?src ?dst WHERE {\n")
-			+ subject.to_turtle_token() + " ingen:connection  ?connection .\n"
-			"?connection  ingen:source      ?src ;\n"
-			"             ingen:destination ?dst .\n"
-		"}");
+	Redland::Resource ingen_connection(*world->rdf_world(),  NS_INGEN "connection");
+	Redland::Resource ingen_source(*world->rdf_world(),      NS_INGEN "source");
+	Redland::Resource ingen_destination(*world->rdf_world(), NS_INGEN "destination");
 
 	const Glib::ustring& base_uri = model.base_uri().to_string();
 
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model));
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const Path src_path(parent.child(relative_uri(base_uri, results->get("src").to_string(), false)));
-		const Path dst_path(parent.child(relative_uri(base_uri, results->get("dst").to_string(), false)));
+	RDFNodes connections;
+	for (Redland::Iter i = model.find(subject, ingen_connection, nil); !i.end(); ++i) {
+		connections.insert(i.get_object());
+	}
+
+	for (RDFNodes::const_iterator i = connections.begin(); i != connections.end(); ++i) {
+		Redland::Iter s = model.find(*i, ingen_source, nil);
+		Redland::Iter d = model.find(*i, ingen_destination, nil);
+
+		if (s.end()) {
+			LOG(error) << "Connection has no source" << endl;
+			return false;
+		} else if (d.end()) {
+			LOG(error) << "Connection has no destination" << endl;
+			return false;
+		}
+
+		const Path src_path(
+			parent.child(relative_uri(base_uri, s.get_object().to_string(), false)));
+		const Path dst_path(
+			parent.child(relative_uri(base_uri, d.get_object().to_string(), false)));
+
+		if (!(++s).end()) {
+			LOG(error) << "Connection has multiple sources" << endl;
+			return false;
+		} else if (!(++d).end()) {
+			LOG(error) << "Connection has multiple destinations" << endl;
+			return false;
+		}
+
 		target->connect(src_path, dst_path);
 	}
 
@@ -758,27 +651,18 @@ Parser::parse_properties(
 		Ingen::Shared::World*                    world,
 		Ingen::Shared::CommonInterface*          target,
 		Redland::Model&                          model,
-		const Redland::Node&                     subject_node,
+		const Redland::Node&                     subject,
 		const Raul::URI&                         uri,
 		boost::optional<GraphObject::Properties> data)
 {
-	const Glib::ustring& subject = subject_node.to_turtle_token();
-
-	Redland::Query query(*world->rdf_world(), Glib::ustring(
-		"SELECT DISTINCT ?key ?val WHERE {\n") +
-			subject + " ?key ?val .\n"
-		"}");
-
 	Resource::Properties properties;
-	SharedPtr<Redland::QueryResults> results(query.run(*world->rdf_world(), model));
-	for (; !results->finished(); results->next()) {
-		Glib::Mutex::Lock lock(world->rdf_world()->mutex());
-		const string         key = string(results->get("key"));
-		const Redland::Node& val = results->get("val");
-		if (skip_property(results->get("key")))
-			continue;
-		if (!key.empty() && val.type() != Redland::Node::BLANK)
-			properties.insert(make_pair(key, AtomRDF::node_to_atom(model, val)));
+	for (Redland::Iter i = model.find(subject, nil, nil); !i.end(); ++i) {
+		const Redland::Node& key = i.get_predicate();
+		const Redland::Node& val = i.get_object();
+		if (!skip_property(key)) {
+			properties.insert(make_pair(string(key),
+			                            AtomRDF::node_to_atom(model, val)));
+		}
 	}
 
 	target->put(uri, properties);