2592506288
* Test the mentat_query directory on Travis.
* Export common types from edn.
This allows you to write
use edn::{PlainSymbol,Keyword};
instead of
use edn:🔣:{PlainSymbol,Keyword};
* Add an edn::Value::is_keyword predicate.
* Clean up query, preparing for query-parser.
* Make EDN keywords and symbols take Into<String> arguments.
* Implement parsing of simple :find lists.
* Rustfmt query-parser. Split find and query.
* Review comment: values_to_variables now returns a NotAVariableError on failure.
* Review comment: rename gimme to to_parsed_value.
* Review comment: add comments.
139 lines
4.7 KiB
Rust
139 lines
4.7 KiB
Rust
// Copyright 2016 Mozilla
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
// this file except in compliance with the License. You may obtain a copy of the
|
|
// License at http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software distributed
|
|
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations under the License.
|
|
|
|
/// ! This module defines the interface and implementation for parsing an EDN
|
|
/// ! input into a structured Datalog query.
|
|
/// !
|
|
/// ! The query types are defined in the `query` crate, because they
|
|
/// ! are shared between the parser (EDN -> query), the translator
|
|
/// ! (query -> SQL), and the executor (query, SQL -> running code).
|
|
/// !
|
|
/// ! The query input can be in two forms: a 'flat' human-oriented
|
|
/// ! sequence:
|
|
/// !
|
|
/// ! ```clojure
|
|
/// ! [:find ?y :in $ ?x :where [?x :foaf/knows ?y]]
|
|
/// ! ```
|
|
/// !
|
|
/// ! or a more programmatically generable map:
|
|
/// !
|
|
/// ! ```clojure
|
|
/// ! {:find [?y]
|
|
/// ! :in [$]
|
|
/// ! :where [[?x :foaf/knows ?y]]}
|
|
/// ! ```
|
|
/// !
|
|
/// ! We parse by expanding the array format into four parts, treating them as the four
|
|
/// ! parts of the map.
|
|
|
|
extern crate edn;
|
|
extern crate mentat_query;
|
|
|
|
use std::collections::BTreeMap;
|
|
|
|
use self::mentat_query::{FindQuery, SrcVar};
|
|
|
|
use super::error::{QueryParseError, QueryParseResult};
|
|
use super::util::{values_to_variables, vec_to_keyword_map};
|
|
|
|
#[allow(unused_variables)]
|
|
fn parse_find_parts(find: &[edn::Value],
|
|
ins: Option<&[edn::Value]>,
|
|
with: Option<&[edn::Value]>,
|
|
wheres: &[edn::Value])
|
|
-> QueryParseResult {
|
|
// :find must be an array of plain var symbols (?foo), pull expressions, and aggregates.
|
|
// For now we only support variables and the annotations necessary to declare which
|
|
// flavor of :find we want:
|
|
// ?x ?y ?z = FindRel
|
|
// [?x ...] = FindColl
|
|
// ?x . = FindScalar
|
|
// [?x ?y ?z] = FindTuple
|
|
//
|
|
// :in must be an array of sources ($), rules (%), and vars (?). For now we only support the
|
|
// default source. :in can be omitted, in which case the default is equivalent to `:in $`.
|
|
// TODO: process `ins`.
|
|
let source = SrcVar::DefaultSrc;
|
|
|
|
// :with is an array of variables. This is simple, so we don't use a parser.
|
|
let with_vars = with.map(values_to_variables);
|
|
// :wheres is a whole datastructure.
|
|
|
|
super::parse::find_seq_to_find_spec(find)
|
|
.map(|spec| {
|
|
FindQuery {
|
|
find_spec: spec,
|
|
default_source: source,
|
|
}
|
|
})
|
|
.map_err(QueryParseError::FindParseError)
|
|
|
|
|
|
}
|
|
|
|
fn parse_find_map(map: BTreeMap<edn::Keyword, Vec<edn::Value>>) -> QueryParseResult {
|
|
// Eagerly awaiting `const fn`.
|
|
let kw_find = edn::Keyword::new("find");
|
|
let kw_in = edn::Keyword::new("in");
|
|
let kw_with = edn::Keyword::new("with");
|
|
let kw_where = edn::Keyword::new("where");
|
|
|
|
// Oh, if only we had `guard`.
|
|
if let Some(find) = map.get(&kw_find) {
|
|
if let Some(wheres) = map.get(&kw_where) {
|
|
return parse_find_parts(find,
|
|
map.get(&kw_in).map(|x| x.as_slice()),
|
|
map.get(&kw_with).map(|x| x.as_slice()),
|
|
wheres);
|
|
} else {
|
|
return Err(QueryParseError::MissingField(kw_where));
|
|
}
|
|
} else {
|
|
return Err(QueryParseError::MissingField(kw_find));
|
|
}
|
|
}
|
|
|
|
fn parse_find_edn_map(map: BTreeMap<edn::Value, edn::Value>) -> QueryParseResult {
|
|
// Every key must be a Keyword. Every value must be a Vec.
|
|
let mut m = BTreeMap::new();
|
|
|
|
if map.is_empty() {
|
|
return parse_find_map(m);
|
|
}
|
|
|
|
for (k, v) in map {
|
|
if let edn::Value::Keyword(kw) = k {
|
|
if let edn::Value::Vector(vec) = v {
|
|
m.insert(kw, vec);
|
|
continue;
|
|
} else {
|
|
return Err(QueryParseError::InvalidInput(v));
|
|
}
|
|
} else {
|
|
return Err(QueryParseError::InvalidInput(k));
|
|
}
|
|
}
|
|
|
|
parse_find_map(m)
|
|
}
|
|
|
|
pub fn parse_find(expr: edn::Value) -> QueryParseResult {
|
|
// No `match` because scoping and use of `expr` in error handling is nuts.
|
|
if let edn::Value::Map(m) = expr {
|
|
return parse_find_edn_map(m);
|
|
}
|
|
if let edn::Value::Vector(ref v) = expr {
|
|
if let Some(m) = vec_to_keyword_map(v) {
|
|
return parse_find_map(m);
|
|
}
|
|
}
|
|
return Err(QueryParseError::InvalidInput(expr));
|
|
}
|