bludgeon/QueryFu.cs

   1
   2 using System;
   3 using System.Collections;
   4 using System.Threading;
   5
   6 using Beagle.Util;
   7 using Beagle;
   8
   9 namespace Bludgeon {
  10
  11         public class QueryFu {
  12
  13                 static public Query NewTokenQuery (string token)
  14                 {
  15                         Query query;
  16                         query = new Query ();
  17
  18                         QueryPart_Text part;
  19                         part = new QueryPart_Text ();
  20                         part.Text = token;
  21                         query.AddPart (part);
  22
  23                         return query;
  24                 }
  25
  26                 static public Query NewTokenQuery (int id)
  27                 {
  28                         return NewTokenQuery (Token.IdToString (id));
  29                 }
  30
  31                 static Random random = new Random ();
  32
  33                 static public Query NewRandomQuery (int length,
  34                                                     bool allow_inexpensive)
  35                 {
  36                         return NewRandomQuery (length, allow_inexpensive, false);
  37                 }
  38
  39                 static private Query NewRandomQuery (int length,
  40                                                      bool allow_inexpensive,
  41                                                      bool inside_an_or)
  42                 {
  43                         Query query;
  44                         query = new Query ();
  45
  46                         // One in four queries will contain some OR terms.
  47                         if (! inside_an_or && random.Next (4) == 0) {
  48                                 int N = random.Next (3) + 1;
  49                                 for (int i = 0; i < N; ++i) {
  50                                         QueryPart_Or part;
  51                                         part = new QueryPart_Or ();
  52
  53                                         int sub_length;
  54                                         sub_length = random.Next (length) + 1;
  55                                         if (sub_length < 2)
  56                                                 sub_length = 2;
  57
  58                                         // We generate a new query at random, and stuff its QueryParts
  59                                         // into our Or QueryPart.
  60                                         Query or_query;
  61                                         or_query = NewRandomQuery (sub_length, allow_inexpensive, true);
  62                                         foreach (QueryPart sub_part in or_query.Parts)
  63                                                 part.Add (sub_part);
  64
  65                                         query.AddPart (part);
  66                                 }
  67                         }
  68
  69                         if (allow_inexpensive && ! inside_an_or) {
  70                                 int mime_type;
  71                                 mime_type = random.Next (3);
  72                                 if (mime_type == 0)
  73                                         query.AddMimeType ("inode/directory");
  74                                 else if (mime_type == 1)
  75                                         query.AddMimeType ("text/plain");
  76                         }
  77
  78                         // Every query must contain at least
  79                         // one required part.
  80                         bool contains_required;
  81                         contains_required = false;
  82
  83                         for (int i = 0; i < length; ++i) {
  84                                 QueryPart_Text part;
  85                                 part = new QueryPart_Text ();
  86                                 part.Text = Token.GetRandom ();
  87
  88                                 // Prohibited parts are not allowed inside an or
  89                                 if (contains_required && ! inside_an_or) {
  90                                         if (random.Next (2) == 0)
  91                                                 part.Logic = QueryPartLogic.Prohibited;
  92                                 } else {
  93                                         // This part will be required.
  94                                         contains_required = true;
  95                                 }
  96
  97                                 if (random.Next (2) == 0)
  98                                         part.SearchTextProperties = false;
  99                                 else if (allow_inexpensive && random.Next (2) == 0)
 100                                         part.SearchFullText = false;
 101
 102                                 query.AddPart (part);
 103                         }
 104
 105                         if (allow_inexpensive && random.Next (3) == 0) {
 106                                 DateTime a, b;
 107                                 FileSystemObject.PickTimestampRange (out a, out b);
 108
 109                                 QueryPart_DateRange part;
 110                                 part = new QueryPart_DateRange ();
 111                                 part.StartDate = a;
 112                                 part.EndDate = b;
 113                                 query.AddPart (part);
 114                         }
 115
 116                         return query;
 117                 }
 118
 119                 static public Query NewRandomQuery ()
 120                 {
 121                         return NewRandomQuery (2 + random.Next (4), true);
 122                 }
 123
 124                 /////////////////////////////////////////////////////////////
 125
 126                 static public string QueryPartToString (QueryPart abstract_part)
 127                 {
 128                         string msg;
 129                         msg = "????";
 130
 131                         if (abstract_part is QueryPart_Text) {
 132                                 QueryPart_Text part;
 133                                 part = (QueryPart_Text) abstract_part;
 134
 135                                 msg = part.Text;
 136                                 if (! (part.SearchFullText && part.SearchTextProperties)) {
 137                                         if (part.SearchFullText)
 138                                                 msg += " IN FULLTEXT";
 139                                         else if (part.SearchTextProperties)
 140                                                 msg += " IN TEXT PROPERTIES";
 141                                 } else
 142                                         msg += " IN ANY TEXT";
 143
 144                         } else if (abstract_part is QueryPart_Property) {
 145                                 QueryPart_Property part;
 146                                 part = (QueryPart_Property) abstract_part;
 147                                 msg = String.Format ("PROPERTY {0} = {1}", part.Key, part.Value);
 148                         } else if (abstract_part is QueryPart_DateRange) {
 149                                 QueryPart_DateRange part;
 150                                 part = (QueryPart_DateRange) abstract_part;
 151                                 msg = String.Format ("DATE RANGE {0} to {1}", part.StartDate, part.EndDate);
 152                         }
 153
 154                         if (abstract_part.Logic == QueryPartLogic.Prohibited)
 155                                 msg = "NOT " + msg;
 156
 157
 158                         return msg;
 159                 }
 160
 161                 static public void SpewQuery (Query query)
 162                 {
 163                         int i = 0;
 164
 165                         foreach (QueryPart abstract_part in query.Parts) {
 166
 167                                 ++i;
 168
 169                                 if (abstract_part is QueryPart_Or) {
 170                                         QueryPart_Or part = abstract_part as QueryPart_Or;
 171                                         int j = 0;
 172                                         Log.Spew ("{0}: OR", i);
 173                                         foreach (QueryPart sub_part in part.SubParts) {
 174                                                 ++j;
 175                                                 Log.Spew ("    {0}.{1}: {2}", i, j, QueryPartToString (sub_part));
 176                                         }
 177
 178                                 } else {
 179                                         Log.Spew ("{0}: {1}", i, QueryPartToString (abstract_part));
 180                                 }
 181                         }
 182                 }
 183
 184                 /////////////////////////////////////////////////////////////
 185
 186                 private class QueryClosure {
 187
 188                         public Hashtable Hits;
 189                         private Query query;
 190
 191                         public QueryClosure (Query query)
 192                         {
 193                                 this.Hits = UriFu.NewHashtable ();
 194                                 this.query = query;
 195                         }
 196
 197                         public void OnHitsAdded (HitsAddedResponse response)
 198                         {
 199                                 foreach (Hit hit in response.Hits)
 200                                         Hits [hit.Uri] = hit;
 201                         }
 202
 203                         public void OnFinished (FinishedResponse response)
 204                         {
 205                                 query.Close ();
 206
 207                         }
 208                 }
 209
 210                 static public Hashtable GetHits (Query q)
 211                 {
 212                         QueryClosure qc;
 213                         qc = new QueryClosure (q);
 214                         q.HitsAddedEvent += qc.OnHitsAdded;
 215                         q.FinishedEvent += qc.OnFinished;
 216
 217                         q.SendAsyncBlocking ();
 218
 219                         return qc.Hits;
 220                 }
 221
 222                 static public ICollection GetUris (Query q)
 223                 {
 224                         return GetHits (q).Keys;
 225                 }
 226         }
 227 }