public IEnumerable <QueryTermNode> GetTerms()
{
Queue <QueryNode> queue = new Queue <QueryNode> ();
queue.Enqueue(this);
do
{
QueryNode node = queue.Dequeue();
QueryListNode list = node as QueryListNode;
if (list != null)
{
foreach (QueryNode child in list.Children)
{
queue.Enqueue(child);
}
}
else
{
QueryTermNode term = node as QueryTermNode;
if (term != null)
{
yield return(term);
}
}
} while (queue.Count > 0);
}
private static IEnumerable <T> SearchForValuesByDepth <T> (QueryNode node) where T : QueryValue
{
QueryListNode list = node as QueryListNode;
if (list != null)
{
foreach (QueryNode child in list.Children)
{
foreach (T item in SearchForValuesByDepth <T> (child))
{
yield return(item);
}
}
}
else
{
QueryTermNode term = node as QueryTermNode;
if (term != null)
{
T value = term.Value as T;
if (value != null)
{
yield return(value);
}
}
}
}
private IEnumerable <T> SearchForValuesByBreadth <T> () where T : QueryValue
{
Queue <QueryNode> queue = new Queue <QueryNode> ();
queue.Enqueue(this);
do
{
QueryNode node = queue.Dequeue();
QueryListNode list = node as QueryListNode;
if (list != null)
{
foreach (QueryNode child in list.Children)
{
queue.Enqueue(child);
}
}
else
{
QueryTermNode term = node as QueryTermNode;
if (term != null)
{
T value = term.Value as T;
if (value != null)
{
yield return(value);
}
}
}
} while (queue.Count > 0);
}
void ParseToken(QueryToken token)
{
switch (token.ID)
{
case TokenID.OpenParen:
DepthPush();
break;
case TokenID.CloseParen:
DepthPop();
break;
case TokenID.Not:
NodePush(new QueryListNode(Keyword.Not));
break;
case TokenID.Or:
case TokenID.And:
// Only push a node if the current_parent is not the same as this token
if (current_parent.Keyword == Keyword.Not ||
current_parent.Keyword == (token.ID == TokenID.Or ? Keyword.And : Keyword.Or))
{
var list = new QueryListNode(token.ID == TokenID.Or ? Keyword.Or : Keyword.And);
var p = current_parent.Parent;
if (p != null)
{
current_parent.Parent.RemoveChild(current_parent);
}
if (current_parent.Keyword == Keyword.Not || current_parent.ChildCount > 1)
{
list.AddChild(current_parent);
}
else
{
list.TakeChildren(current_parent);
}
current_parent = p;
NodePush(list);
}
break;
case TokenID.Term:
NodePush(QueryTermNode.ParseUserQuery(field_set, token.Term));
break;
}
}
public static QueryTermNode ParseUserQuery(QueryFieldSet field_set, string token)
{
QueryTermNode term = new QueryTermNode();
// See if the query specifies a field, and if so, pull out the operator as well
string field_alias = field_set.FindAlias(token);
if (field_alias != null)
{
term.Field = field_set [field_alias];
string token_without_field = token.Substring(field_alias.Length);
foreach (QueryValue val in term.Field.CreateQueryValues())
{
term.Value = val;
string op_alias = term.Value.OperatorSet.FindAlias(token_without_field);
if (op_alias != null)
{
term.Operator = term.Value.OperatorSet [op_alias];
int field_separator = token.IndexOf(op_alias);
string temp = token.Substring(field_separator + op_alias.Length);
term.Value.ParseUserQuery(temp);
if (!term.Value.IsEmpty)
{
break;
}
}
term.Operator = null;
term.Value = null;
}
}
if (term.Value == null)
{
term.Field = null;
term.Value = QueryValue.CreateFromUserQuery(token, term.Field);
term.Operator = StringQueryValue.Contains;
}
return(term);
}
public static QueryTermNode ParseUserQuery (QueryFieldSet field_set, string token)
{
QueryTermNode term = new QueryTermNode ();
// See if the query specifies a field, and if so, pull out the operator as well
string field_alias = field_set.FindAlias (token);
if (field_alias != null) {
term.Field = field_set [field_alias];
string token_without_field = token.Substring (field_alias.Length);
foreach (QueryValue val in term.Field.CreateQueryValues ()) {
term.Value = val;
string op_alias = term.Value.OperatorSet.FindAlias (token_without_field);
if (op_alias != null) {
term.Operator = term.Value.OperatorSet [op_alias];
int field_separator = token.IndexOf (op_alias);
string temp = token.Substring (field_separator + op_alias.Length);
term.Value.ParseUserQuery (temp);
if (!term.Value.IsEmpty) {
break;
}
}
term.Operator = null;
term.Value = null;
}
}
if (term.Value == null) {
term.Field = null;
term.Value = QueryValue.CreateFromUserQuery (token, term.Field);
term.Operator = StringQueryValue.Contains;
}
return term;
}
private QueryNode Parse(XmlElement node, QueryListNode parent)
{
if (node == null)
{
return(null);
}
QueryListNode list = null;
//Console.WriteLine ("Parsing node: {0}", node.Name);
switch (node.Name.ToLower())
{
case "and":
list = new QueryListNode(Keyword.And);
break;
case "or":
list = new QueryListNode(Keyword.Or);
break;
case "not":
list = new QueryListNode(Keyword.Not);
break;
default:
QueryTermNode term = new QueryTermNode();
// Get the field (if any) that this term applies to
if (node["field"] != null)
{
term.Field = field_set [node["field"].GetAttribute("name")];
}
// Get the value
term.Value = QueryValue.CreateFromXml(node, term.Field);
// Get the operator from the term's name
term.Operator = term.Value.OperatorSet [node.Name];
if (parent != null)
{
parent.AddChild(term);
}
return(term);
}
if (list != null)
{
if (parent != null)
{
parent.AddChild(list);
}
// Recursively parse the children of a QueryListNode
foreach (XmlNode child in node.ChildNodes)
{
Parse(child as XmlElement, list);
}
}
return(list);
}
private QueryNode Parse (XmlElement node, QueryListNode parent)
{
if (node == null)
return null;
QueryListNode list = null;
//Console.WriteLine ("Parsing node: {0}", node.Name);
switch (node.Name.ToLower ()) {
case "and":
list = new QueryListNode (Keyword.And);
break;
case "or":
list = new QueryListNode (Keyword.Or);
break;
case "not":
list = new QueryListNode (Keyword.Not);
break;
default:
QueryTermNode term = new QueryTermNode ();
// Get the field (if any) that this term applies to
if (node["field"] != null)
term.Field = field_set [node["field"].GetAttribute ("name")];
// Get the value
term.Value = QueryValue.CreateFromXml (node, term.Field);
// Get the operator from the term's name
term.Operator = term.Value.OperatorSet [node.Name];
if (parent != null) {
parent.AddChild (term);
}
return term;
}
if (list != null) {
if (parent != null)
parent.AddChild (list);
// Recursively parse the children of a QueryListNode
foreach (XmlNode child in node.ChildNodes) {
Parse (child as XmlElement, list);
}
}
return list;
}
private void ParseRelativeDateCondition (QueryTermNode term, string val, QueryField field, string op)
{
string new_op = op.Replace ('>', '^');
new_op = new_op.Replace ('<', '>');
new_op = new_op.Replace ('^', '<');
RelativeTimeSpanQueryValue date_value = new RelativeTimeSpanQueryValue ();
// Have to flip the operator b/c of how we used to construct the SQL query
term.Operator = date_value.OperatorSet [new_op];
// Have to negate the value b/c of how we used to constuct the SQL query
date_value.SetRelativeValue (Convert.ToInt64 (val), TimeFactor.Second);
term.Value = date_value;
}
private string ParseCondition (string value)
{
if (String.IsNullOrEmpty (value))
return null;
// Check for ANDs or ORs and split into conditions as needed
string [] conditions;
bool ands = true;
if (value.IndexOf(") AND (") != -1) {
ands = true;
conditions = System.Text.RegularExpressions.Regex.Split (value, "\\) AND \\(");
} else if (value.IndexOf(") OR (") != -1) {
ands = false;
conditions = System.Text.RegularExpressions.Regex.Split (value, "\\) OR \\(");
} else {
conditions = new string [] {value};
}
QueryListNode root = new QueryListNode (ands ? Keyword.And : Keyword.Or);
// Remove leading spaces and parens from the first condition
conditions[0] = conditions[0].Remove(0, 2);
// Remove trailing spaces and last paren from the last condition
string tmp = conditions[conditions.Length-1];
tmp = tmp.TrimEnd(new char[] {' '});
tmp = tmp.Substring(0, tmp.Length - 1);
conditions[conditions.Length-1] = tmp;
int count = 0;
foreach (string condition in conditions) {
// Add a new row for this condition
string col, v1, v2;
foreach (QueryOperator op in QueryOperator.Operators) {
if (op.MatchesCondition (condition, out col, out v1, out v2)) {
QueryTermNode term = new QueryTermNode ();
QueryField field = BansheeQuery.FieldSet [col];
bool is_relative_date = false;
if (field == null) {
if (col.IndexOf ("DateAddedStamp") != -1) {
field = BansheeQuery.FieldSet ["added"];
} else if (col.IndexOf ("LastPlayedStamp") != -1) {
field = BansheeQuery.FieldSet ["lastplayed"];
}
// Fix ugly implementation of playlist/smart playlist conditions
if (op == QueryOperator.InPlaylist || op == QueryOperator.NotInPlaylist) {
field = BansheeQuery.FieldSet ["playlist"];
} else if (op == QueryOperator.InSmartPlaylist || op == QueryOperator.NotInSmartPlaylist) {
field = BansheeQuery.FieldSet ["smartplaylist"];
}
if (field == null) {
continue;
}
is_relative_date = true;
}
term.Field = field;
if (op == QueryOperator.Between) {
QueryListNode and = new QueryListNode (Keyword.And);
QueryTermNode t2 = new QueryTermNode ();
t2.Field = term.Field;
if (is_relative_date) {
ParseRelativeDateCondition (term, v1, field, ">=");
ParseRelativeDateCondition (t2, v2, field, "<=");
} else {
term.Value = QueryValue.CreateFromUserQuery (v1, field);
term.Operator = term.Value.OperatorSet ["<="];
t2.Value = QueryValue.CreateFromUserQuery (v2, field);
t2.Operator = t2.Value.OperatorSet [">="];
}
and.AddChild (term);
and.AddChild (t2);
root.AddChild (and);
} else if (is_relative_date) {
ParseRelativeDateCondition (term, v1, field, op.NewOp);
root.AddChild (term);
} else {
term.Value = QueryValue.CreateFromUserQuery (v1, field);
term.Operator = term.Value.OperatorSet [op.NewOp];
root.AddChild (term);
}
break;
}
}
count++;
}
QueryNode node = root.Trim ();
if (node != null) {
//Console.WriteLine ("After XML: {0}", node.ToXml (BansheeQuery.FieldSet, true));
//Console.WriteLine ("After SQL: {0}", node.ToSql (BansheeQuery.FieldSet));
}
return node == null ? String.Empty : node.ToXml (BansheeQuery.FieldSet);
}
