Accelerate key-value queries

by examining the stringtable for each PrimitiveBlock before iterating
over the contained elements.

src/query.rs

 
 pub trait Query {
     type BI;
-    fn create_block_index(&self, &PrimitiveBlock) -> Self::BI;
+    fn create_block_index(&self, &PrimitiveBlock) -> Option<Self::BI>;
     fn node_matches(&self, &Self::BI, node: &Node) -> bool;
     fn dense_node_matches(&self, &Self::BI, dnode: &DenseNode) -> bool;
     fn way_matches(&self, &Self::BI, way: &Way) -> bool;
 impl Query for ValuePatternQuery {
     type BI = ();
 
-    fn create_block_index(&self, _block: &PrimitiveBlock) -> () {
-        ()
+    fn create_block_index(&self, _block: &PrimitiveBlock) -> Option<()> {
+        Some(())
     }
 
     fn node_matches(&self, _: &(), node: &Node) -> bool {
 }
 
 impl Query for KeyValueQuery {
-    type BI = ();
+    type BI = (Vec<u32>, Vec<u32>);
+
+    fn create_block_index(&self, block: &PrimitiveBlock) -> Option<(Vec<u32>, Vec<u32>)> {
+        let mut key_indices = vec![];
+        let mut value_indices = vec![];
+
+        let key_bytes = self.key.as_bytes();
+        let value_bytes = self.value.as_bytes();
+
+        for (i, string) in block.raw_stringtable().iter().enumerate() {
+            if string.as_slice() == key_bytes {
+                key_indices.push(i as u32);
+            }
+            if string.as_slice() == value_bytes {
+                value_indices.push(i as u32);
+            }
+        }
+
+        if key_indices.is_empty() || value_indices.is_empty() {
+            // No matches possible for this block
+            return None;
+        }
 
-    fn create_block_index(&self, _block: &PrimitiveBlock) -> () {
-        ()
+        key_indices.sort();
+        value_indices.sort();
+
+        Some((key_indices, value_indices))
     }
 
-    fn node_matches(&self, _: &(), node: &Node) -> bool {
-        for (key, val) in node.tags() {
-            if key == self.key && val == self.value {
+    fn node_matches(&self, bi: &Self::BI, node: &Node) -> bool {
+        for (key, val) in node.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
                 return true;
             }
         }
         return false;
     }
 
-    fn dense_node_matches(&self, _: &(), dnode: &DenseNode) -> bool {
+    fn dense_node_matches(&self, _bi: &Self::BI, dnode: &DenseNode) -> bool {
+        //TODO use raw tags
         for (key, val) in dnode.tags() {
             if key == self.key && val == self.value {
                 return true;
         return false;
     }
 
-    fn way_matches(&self, _: &(), way: &Way) -> bool {
-        for (key, val) in way.tags() {
-            if key == self.key && val == self.value {
+    fn way_matches(&self, bi: &Self::BI, way: &Way) -> bool {
+        for (key, val) in way.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
                 return true;
             }
         }
         return false;
     }
 
-    fn relation_matches(&self, _: &(), relation: &Relation) -> bool {
-        for (key, val) in relation.tags() {
-            if key == self.key && val == self.value {
+    fn relation_matches(&self, bi: &Self::BI, relation: &Relation) -> bool {
+        for (key, val) in relation.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
                 return true;
             }
         }
     matches: &mut Vec<LatLonDeg>,
     way_node_ids: &mut Vec<i64>,
 ) {
-    let block_index = query.create_block_index(block);
-
-    for node in block.groups().flat_map(|g| g.nodes()) {
-        if query.node_matches(&block_index, &node) {
-            let pos = LatLonDeg::new(node.lat(), node.lon());
-            matches.push(pos);
+    if let Some(block_index) = query.create_block_index(block) {
+        for node in block.groups().flat_map(|g| g.nodes()) {
+            if query.node_matches(&block_index, &node) {
+                let pos = LatLonDeg::new(node.lat(), node.lon());
+                matches.push(pos);
+            }
         }
-    }
 
-    for node in block.groups().flat_map(|g| g.dense_nodes()) {
-        if query.dense_node_matches(&block_index, &node) {
-            let pos = LatLonDeg::new(node.lat(), node.lon());
-            matches.push(pos);
+        for node in block.groups().flat_map(|g| g.dense_nodes()) {
+            if query.dense_node_matches(&block_index, &node) {
+                let pos = LatLonDeg::new(node.lat(), node.lon());
+                matches.push(pos);
+            }
         }
-    }
 
-    for way in block.groups().flat_map(|g| g.ways()) {
-        if query.way_matches(&block_index, &way) {
-            way_node_ids.push(way.refs_slice()[0]);
+        for way in block.groups().flat_map(|g| g.ways()) {
+            if query.way_matches(&block_index, &way) {
+                way_node_ids.push(way.refs_slice()[0]);
+            }
         }
     }
 }