Compute query signature in the correct module

This moves the implementation of `signature()` on `QueryGraph` into the
`QuerySignature` module, which is where it logically belongs.

Author: ms705

src/sql/mir.rs

@@ -11,6 +11,7 @@ use nom_sql::{Column, ColumnSpecification, ConditionBase, ConditionExpression, C
               Literal, Operator, SqlQuery, TableKey};
 use nom_sql::{LimitClause, OrderClause, SelectStatement};
 use sql::query_graph::{JoinRef, OutputColumn, QueryGraph, QueryGraphEdge};
+use sql::query_signature::Signature;
 
 use slog;
 use std::collections::{HashMap, HashSet};

src/sql/mod.rs

@@ -15,6 +15,7 @@ use self::mir::{MirNodeRef, SqlToMirConverter};
 use mir::query::MirQuery;
 use self::reuse::{ReuseConfig, ReuseConfigType};
 use sql::query_graph::{to_query_graph, QueryGraph};
+use sql::query_signature::Signature;
 
 use slog;
 use std::collections::HashMap;

src/sql/query_graph.rs

@@ -1,16 +1,12 @@
 use nom_sql::{Column, ConditionBase, ConditionExpression, ConditionTree, FieldExpression,
               JoinConstraint, JoinOperator, JoinRightSide, Literal, Operator};
 use nom_sql::SelectStatement;
-use nom_sql::ConditionExpression::*;
 
 use std::cmp::Ordering;
-use std::collections::{HashMap, HashSet};
-use std::hash::{Hash, Hasher};
+use std::collections::HashMap;
 use std::string::String;
 use std::vec::Vec;
 
-use sql::query_signature::QuerySignature;
-
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct LiteralColumn {
     pub name: String,
@@ -152,73 +148,6 @@ impl QueryGraph {
                 acc
             })
     }
-
-    /// Used to get a concise signature for a query graph. The `hash` member can be used to check
-    /// for identical sets of relations and attributes covered (as per Finkelstein algorithm),
-    /// while `relations` and `attributes` as `HashSet`s that allow for efficient subset checks.
-    pub fn signature(&self) -> QuerySignature {
-        use std::collections::hash_map::DefaultHasher;
-
-        let mut hasher = DefaultHasher::new();
-        let rels = self.relations.keys().map(|r| String::as_str(r)).collect();
-
-        // Compute relations part of hash
-        let mut r_vec: Vec<&str> = self.relations.keys().map(String::as_str).collect();
-        r_vec.sort();
-        for r in &r_vec {
-            r.hash(&mut hasher);
-        }
-
-        // Collect attributes from predicates and projected columns
-        let mut attrs = HashSet::<&Column>::new();
-        let mut attrs_vec = Vec::<&Column>::new();
-        for n in self.relations.values() {
-            for p in &n.predicates {
-                match *p {
-                    ComparisonOp(ref ct) | LogicalOp(ref ct) => for c in &ct.contained_columns() {
-                        attrs_vec.push(c);
-                        attrs.insert(c);
-                    },
-                    _ => unreachable!(),
-                }
-            }
-        }
-        for e in self.edges.values() {
-            match *e {
-                QueryGraphEdge::Join(ref join_predicates) |
-                QueryGraphEdge::LeftJoin(ref join_predicates) => for p in join_predicates {
-                    for c in &p.contained_columns() {
-                        attrs_vec.push(c);
-                        attrs.insert(c);
-                    }
-                },
-                QueryGraphEdge::GroupBy(ref cols) => for c in cols {
-                    attrs_vec.push(c);
-                    attrs.insert(c);
-                },
-            }
-        }
-
-        // Compute attributes part of hash
-        attrs_vec.sort();
-        for a in &attrs_vec {
-            a.hash(&mut hasher);
-        }
-
-        let mut proj_columns: Vec<&OutputColumn> = self.columns.iter().collect();
-        // Compute projected columns part of hash. We sort here since the order in which columns
-        // appear does not matter for query graph equivalence.
-        proj_columns.sort();
-        for c in proj_columns {
-            c.hash(&mut hasher);
-        }
-
-        QuerySignature {
-            relations: rels,
-            attributes: attrs,
-            hash: hasher.finish(),
-        }
-    }
 }
 
 /// Splits top level conjunctions into multiple predicates

src/sql/query_signature.rs

@@ -1,8 +1,15 @@
 use nom_sql::Column;
+use nom_sql::ConditionExpression::*;
 
 use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 
+use sql::query_graph::{OutputColumn, QueryGraph, QueryGraphEdge};
+
+pub trait Signature {
+    fn signature(&self) -> QuerySignature;
+}
+
 #[derive(Clone, Debug)]
 pub struct QuerySignature<'a> {
     pub relations: HashSet<&'a str>,
@@ -66,6 +73,75 @@ impl<'a> QuerySignature<'a> {
     }
 }
 
+impl Signature for QueryGraph {
+    /// Used to get a concise signature for a query graph. The `hash` member can be used to check
+    /// for identical sets of relations and attributes covered (as per Finkelstein algorithm),
+    /// while `relations` and `attributes` as `HashSet`s that allow for efficient subset checks.
+    fn signature(&self) -> QuerySignature {
+        use std::collections::hash_map::DefaultHasher;
+
+        let mut hasher = DefaultHasher::new();
+        let rels = self.relations.keys().map(|r| String::as_str(r)).collect();
+
+        // Compute relations part of hash
+        let mut r_vec: Vec<&str> = self.relations.keys().map(String::as_str).collect();
+        r_vec.sort();
+        for r in &r_vec {
+            r.hash(&mut hasher);
+        }
+
+        // Collect attributes from predicates and projected columns
+        let mut attrs = HashSet::<&Column>::new();
+        let mut attrs_vec = Vec::<&Column>::new();
+        for n in self.relations.values() {
+            for p in &n.predicates {
+                match *p {
+                    ComparisonOp(ref ct) | LogicalOp(ref ct) => for c in &ct.contained_columns() {
+                        attrs_vec.push(c);
+                        attrs.insert(c);
+                    },
+                    _ => unreachable!(),
+                }
+            }
+        }
+        for e in self.edges.values() {
+            match *e {
+                QueryGraphEdge::Join(ref join_predicates) |
+                QueryGraphEdge::LeftJoin(ref join_predicates) => for p in join_predicates {
+                    for c in &p.contained_columns() {
+                        attrs_vec.push(c);
+                        attrs.insert(c);
+                    }
+                },
+                QueryGraphEdge::GroupBy(ref cols) => for c in cols {
+                    attrs_vec.push(c);
+                    attrs.insert(c);
+                },
+            }
+        }
+
+        // Compute attributes part of hash
+        attrs_vec.sort();
+        for a in &attrs_vec {
+            a.hash(&mut hasher);
+        }
+
+        let mut proj_columns: Vec<&OutputColumn> = self.columns.iter().collect();
+        // Compute projected columns part of hash. We sort here since the order in which columns
+        // appear does not matter for query graph equivalence.
+        proj_columns.sort();
+        for c in proj_columns {
+            c.hash(&mut hasher);
+        }
+
+        QuerySignature {
+            relations: rels,
+            attributes: attrs,
+            hash: hasher.finish(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/sql/reuse/finkelstein.rs

@@ -1,6 +1,7 @@
 use sql::reuse::helpers::predicate_implication::complex_predicate_implies;
 use sql::reuse::{ReuseConfiguration, ReuseType};
 use sql::query_graph::{QueryGraph, QueryGraphEdge};
+use sql::query_signature::Signature;
 use mir::query::MirQuery;
 
 use std::vec::Vec;

src/sql/reuse/relaxed.rs

@@ -1,6 +1,7 @@
 use sql::reuse::helpers::predicate_implication::complex_predicate_implies;
 use sql::reuse::{ReuseConfiguration, ReuseType};
 use sql::query_graph::{QueryGraph, QueryGraphEdge};
+use sql::query_signature::Signature;
 use mir::query::MirQuery;
 
 use std::vec::Vec;