private QueryNode BuildQueryTree(QueryFieldSet fields, Operator op, string target, bool force)
{
if (fields == null || op == null || String.IsNullOrEmpty(target))
{
return(null);
}
QueryListNode root = new QueryListNode(Keyword.Or);
foreach (QueryField field in fields)
{
if (force || field.IsDefault)
{
root.AddChild(CreateNode(field, op, target));
}
}
// force the query to build if no default fields in QueryFieldSet
if (!force && root.ChildCount == 0)
{
return(BuildQueryTree(fields, op, target, true));
}
return(root.Trim());
}
private bool PerformSearch(string target)
{
if (String.IsNullOrEmpty(target))
{
return(false);
}
ISearchable model = Model as ISearchable;
if (model == null)
{
return(false);
}
if (last_query == null || !last_query_fields.Equals(model.QueryFields))
{
last_query_fields = model.QueryFields;
last_query = BuildQueryTree(last_query_fields, StringQueryValue.StartsWith, target);
}
else
{
UpdateQueryTree(last_query, target);
}
int i = model.IndexOf(last_query, search_offset);
if (i >= 0)
{
SelectRow(i);
return(true);
}
return(false);
}
public override QueryNode BuildTree (QueryFieldSet fieldSet)
{
field_set = fieldSet;
root = current_parent = new QueryListNode (Keyword.And);
bool last_was_term = false;
while (true) {
QueryToken token = Scan ();
if (token.ID == TokenID.Unknown) {
break;
}
token.Column = token_start_column;
token.Line = token_start_line;
// If we have two terms in a row, put an AND between them
if (last_was_term && token.ID == TokenID.Term)
ParseToken (new QueryToken (TokenID.And));
ParseToken (token);
last_was_term = token.ID == TokenID.Term;
}
return root.Trim ();
}
private void LoadQueryFieldSet()
{
Assembly asm = Assembly.LoadFile("Banshee.Services.dll");
Type t = asm.GetType("Banshee.Query.BansheeQuery");
FieldInfo f = t.GetField("FieldSet", BindingFlags.Public | BindingFlags.Static);
query_field_set = (QueryFieldSet)f.GetValue(null);
}
public QueryBox(QueryFieldSet fieldSet, QueryOrder [] orders, QueryLimit [] limits) : base()
{
//this.sorted_fields = fieldSet.Fields;
field_set = fieldSet;
terms_box = new QueryTermsBox(field_set);
LimitBox = new QueryLimitBox(orders, limits);
BuildInterface();
}
public QueryBox (QueryFieldSet fieldSet, QueryOrder [] orders, QueryLimit [] limits) : base ()
{
//this.sorted_fields = fieldSet.Fields;
this.field_set = fieldSet;
terms_box = new QueryTermsBox (field_set);
limit_box = new QueryLimitBox (orders, limits);
BuildInterface ();
}
public QueryTermsBox (QueryFieldSet fieldSet) : base (1, 4, false)
{
// Sort the fields alphabetically by their label
sorted_fields = fieldSet.OrderBy (f => f.Label).ToArray ();
ColumnSpacing = 5;
RowSpacing = 5;
CreateRow (false);
}
public QueryTermsBox(QueryFieldSet fieldSet) : base(1, 4, false)
{
// Sort the fields alphabetically by their label
sorted_fields = fieldSet.OrderBy(f => f.Label).ToArray();
ColumnSpacing = 5;
RowSpacing = 5;
CreateRow(false);
}
public DatabaseAlbumListModel(DatabaseSource source, DatabaseTrackListModel trackModel, BansheeDbConnection connection, string uuid)
: base(BansheeQuery.AlbumField.Name, BansheeQuery.AlbumField.Label,
source, trackModel, connection, DatabaseAlbumInfo.Provider, new AllAlbumInfo(), uuid)
{
QueryFields = new QueryFieldSet(BansheeQuery.AlbumField);
ReloadFragmentFormat = @"
FROM CoreAlbums WHERE CoreAlbums.AlbumID IN
(SELECT CoreTracks.AlbumID FROM CoreTracks, CoreCache{0}
WHERE {4}(CoreCache.ModelID = {1}) AND
CoreCache.ItemId = {2} {3})
ORDER BY CoreAlbums.TitleSortKey, CoreAlbums.ArtistNameSortKey";
}
public DatabaseArtistListModel(Banshee.Sources.DatabaseSource source, DatabaseTrackListModel trackModel, BansheeDbConnection connection, string uuid)
: base(Banshee.Query.BansheeQuery.ArtistField.Name, Banshee.Query.BansheeQuery.ArtistField.Label,
source, trackModel, connection, DatabaseArtistInfo.Provider, new ArtistInfo(null, null), uuid)
{
QueryFields = new QueryFieldSet(Banshee.Query.BansheeQuery.ArtistField);
ReloadFragmentFormat = @"
FROM CoreArtists WHERE CoreArtists.ArtistID IN
(SELECT CoreTracks.ArtistID FROM CoreTracks, CoreCache{0}
WHERE {4}(CoreCache.ModelID = {1}) AND
CoreCache.ItemID = {2} {3})
ORDER BY NameSortKey";
}
public DatabaseYearListModel(Banshee.Sources.DatabaseSource source, DatabaseTrackListModel trackModel, BansheeDbConnection connection, string uuid)
: base(Banshee.Query.BansheeQuery.YearField.Name, Banshee.Query.BansheeQuery.YearField.Label,
source, trackModel, connection, DatabaseYearInfo.Provider, new YearInfo(), uuid)
{
QueryFields = new QueryFieldSet(Banshee.Query.BansheeQuery.YearField);
ReloadFragmentFormat = @"
FROM (SELECT MIN(CoreTracks.TrackID) AS TrackID, CoreTracks.Year FROM CoreTracks GROUP BY CoreTracks.Year) AS CoreTracks
WHERE CoreTracks.Year IN
(SELECT CoreTracks.Year FROM CoreTracks, CoreCache{0}
WHERE CoreCache.ModelID = {1} AND
CoreCache.ItemID = {2} {3})
ORDER BY Year";
}
public DatabaseQueryFilterModel(Banshee.Sources.DatabaseSource source, DatabaseTrackListModel trackModel,
HyenaSqliteConnection connection, string select_all_fmt, string uuid, QueryField field, string filter_column)
: base(field.Name, field.Label, source, trackModel, connection, QueryFilterInfo <T> .CreateProvider(filter_column, field), new QueryFilterInfo <T> (), String.Format("{0}-{1}", uuid, field.Name))
{
this.field = field;
this.select_all_fmt = select_all_fmt;
ReloadFragmentFormat = @"
FROM CoreTracks, CoreCache{0}
WHERE CoreCache.ModelID = {1} AND CoreCache.ItemID = {2} {3}
ORDER BY Value";
QueryFields = new QueryFieldSet(query_filter_field);
}
public override QueryNode BuildTree (QueryFieldSet fieldSet)
{
field_set = fieldSet;
XmlDocument doc = new XmlDocument ();
try {
doc.LoadXml (str);
XmlElement request = doc.FirstChild as XmlElement;
if (request == null || request.Name != "request")
throw new Exception ("Invalid request");
XmlElement query = request.FirstChild as XmlElement;
if (query == null || query.Name != "query" || query.GetAttribute ("banshee-version") != "1")
throw new Exception ("Invalid query");
QueryNode node = Parse (query.FirstChild as XmlElement, null);
return (node != null) ? node.Trim () : null;
} catch (Exception) {
}
return null;
}
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 void LoadQueryFieldSet ()
{
Assembly asm = Assembly.LoadFile ("Banshee.Services.dll");
Type t = asm.GetType ("Banshee.Query.BansheeQuery");
FieldInfo f = t.GetField ("FieldSet", BindingFlags.Public | BindingFlags.Static);
query_field_set = (QueryFieldSet)f.GetValue (null);
}
public override void AppendXml (XmlDocument doc, XmlNode parent, QueryFieldSet fieldSet)
{
if (ChildCount == 0)
return;
XmlElement node = doc.CreateElement (Keyword.ToString ().ToLower ());
parent.AppendChild (node);
foreach (QueryNode child in Children)
child.AppendXml (doc, node, fieldSet);
}
public override void AppendSql (StringBuilder sb, QueryFieldSet fieldSet)
{
if (ChildCount == 0)
return;
if (Keyword != Keyword.Not) {
sb.Append ("(");
bool first = true;
foreach (QueryNode child in Children) {
if (!first) {
sb.AppendFormat (" {0} ", Keyword);
} else {
first = false;
}
child.AppendSql (sb, fieldSet);
}
sb.Append (")");
} else {
sb.Append ("NOT(");
Children [0].AppendSql (sb, fieldSet);
sb.Append (")");
}
}
private QueryNode BuildQueryTree(QueryFieldSet fields, Operator op, string target)
{
return(BuildQueryTree(fields, op, target, false));
}
public static QueryNode Parse(string input, QueryFieldSet fieldSet)
{
return new UserQueryParser (input).BuildTree (fieldSet);
}
public override void AppendSql (StringBuilder sb, QueryFieldSet fieldSet)
{
if (Field == null) {
sb.Append ("(");
int emitted = 0;
foreach (QueryField field in fieldSet.Fields) {
if (field.IsDefault)
if (EmitTermMatch (sb, field, emitted > 0))
emitted++;
}
sb.Append (")");
} else {
EmitTermMatch (sb, Field, false);
}
}
public abstract QueryNode BuildTree (QueryFieldSet fieldSet);
public override void AppendXml (XmlDocument doc, XmlNode parent, QueryFieldSet fieldSet)
{
XmlElement op_node = doc.CreateElement (op == null ? "contains" : op.Name);
parent.AppendChild (op_node);
QueryField field = Field;
if (field != null) {
XmlElement field_node = doc.CreateElement ("field");
field_node.SetAttribute ("name", field.Name);
op_node.AppendChild (field_node);
}
XmlElement val_node = doc.CreateElement (Value.XmlElementName);
Value.AppendXml (val_node);
op_node.AppendChild (val_node);
}
