etc/spotlight/slmod_sparql_parser.y

   1 %{
   2   #include <atalk/standards.h>
   3
   4   #include <stdbool.h>
   5   #include <stdio.h>
   6   #include <string.h>
   7   #include <time.h>
   8
   9   #include <gio/gio.h>
  10
  11   #include <atalk/talloc.h>
  12   #include <atalk/logger.h>
  13   #include <atalk/errchk.h>
  14   #include <atalk/spotlight.h>
  15
  16   #include "slmod_sparql_map.h"
  17
  18   struct yy_buffer_state;
  19   typedef struct yy_buffer_state *YY_BUFFER_STATE;
  20   extern int yylex (void);
  21   extern void yyerror (char const *);
  22   extern void *yyterminate(void);
  23   extern YY_BUFFER_STATE yy_scan_string( const char *str);
  24   extern void yy_delete_buffer ( YY_BUFFER_STATE buffer );
  25
  26   /* forward declarations */
  27   static const char *map_expr(const char *attr, char op, const char *val);
  28   static const char *map_daterange(const char *dateattr, time_t date1, time_t date2);
  29   static time_t isodate2unix(const char *s);
  30
  31  /* global vars, eg needed by the lexer */
  32   slq_t *ssp_slq;
  33
  34   /* local vars */
  35   static gchar *ssp_result;
  36   static char sparqlvar;
  37 %}
  38
  39 %code provides {
  40   #define SPRAW_TIME_OFFSET 978307200
  41   extern int map_spotlight_to_sparql_query(slq_t *slq, gchar **sparql_result);
  42   extern slq_t *ssp_slq;
  43 }
  44
  45 %union {
  46     int ival;
  47     const char *sval;
  48     bool bval;
  49     time_t tval;
  50 }
  51
  52 %expect 5
  53 %error-verbose
  54
  55 %type <sval> match expr line function
  56 %type <tval> date
  57
  58 %token <sval> WORD
  59 %token <bval> BOOL
  60 %token FUNC_INRANGE
  61 %token DATE_ISO
  62 %token OBRACE CBRACE EQUAL UNEQUAL GT LT COMMA QUOTE
  63 %left AND
  64 %left OR
  65 %%
  66
  67 input:
  68 /* empty */
  69 | input line
  70 ;
  71
  72 line:
  73 expr                           {
  74     ssp_result = talloc_asprintf(ssp_slq,
  75                                  "SELECT ?url WHERE "
  76                                  "{ %s . ?obj nie:url ?url . FILTER(tracker:uri-is-descendant('file://%s/', ?url)) } LIMIT 100",
  77                                  $1, ssp_slq->slq_vol->v_path);
  78     $$ = ssp_result;
  79 }
  80 ;
  81
  82 expr:
  83 BOOL                             {
  84     if ($1 == false)
  85         YYACCEPT;
  86     else
  87         YYABORT;
  88 }
  89 | match OR match                 {
  90     if (strcmp($1, $3) != 0)
  91         $$ = talloc_asprintf(ssp_slq, "{ %s } UNION { %s }", $1, $3);
  92     else
  93         $$ = talloc_asprintf(ssp_slq, "%s", $1);
  94 }
  95 | match                        {$$ = $1; if ($$ == NULL) YYABORT;}
  96 | function                     {$$ = $1;}
  97 | OBRACE expr CBRACE           {$$ = talloc_asprintf(ssp_slq, "%s", $2);}
  98 | expr AND expr                {$$ = talloc_asprintf(ssp_slq, "%s . %s", $1, $3);}
  99 | expr OR expr                 {
 100     if (strcmp($1, $3) != 0)
 101         $$ = talloc_asprintf(ssp_slq, "{ %s } UNION { %s }", $1, $3);
 102     else
 103         $$ = talloc_asprintf(ssp_slq, "%s", $1);
 104 }
 105 ;
 106
 107 match:
 108 WORD EQUAL QUOTE WORD QUOTE     {$$ = map_expr($1, '=', $4);}
 109 | WORD UNEQUAL QUOTE WORD QUOTE {$$ = map_expr($1, '!', $4);}
 110 | WORD LT QUOTE WORD QUOTE      {$$ = map_expr($1, '<', $4);}
 111 | WORD GT QUOTE WORD QUOTE      {$$ = map_expr($1, '>', $4);}
 112 | WORD EQUAL QUOTE WORD QUOTE WORD    {$$ = map_expr($1, '=', $4);}
 113 | WORD UNEQUAL QUOTE WORD QUOTE WORD {$$ = map_expr($1, '!', $4);}
 114 | WORD LT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '<', $4);}
 115 | WORD GT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '>', $4);}
 116 ;
 117
 118 function:
 119 FUNC_INRANGE OBRACE WORD COMMA date COMMA date CBRACE {$$ = map_daterange($3, $5, $7);}
 120 ;
 121
 122 date:
 123 DATE_ISO OBRACE WORD CBRACE    {$$ = isodate2unix($3);}
 124 | WORD                         {$$ = atoi($1) + SPRAW_TIME_OFFSET;}
 125 ;
 126
 127 %%
 128
 129 static time_t isodate2unix(const char *s)
 130 {
 131     struct tm tm;
 132
 133     if (strptime(s, "%Y-%m-%dT%H:%M:%SZ", &tm) == NULL)
 134         return (time_t)-1;
 135     return mktime(&tm);
 136 }
 137
 138 static const char *map_daterange(const char *dateattr, time_t date1, time_t date2)
 139 {
 140     EC_INIT;
 141     char *result = NULL;
 142     struct spotlight_sparql_map *p;
 143     struct tm *tmp;
 144     char buf1[64], buf2[64];
 145
 146     EC_NULL_LOG( tmp = localtime(&date1) );
 147     strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 148     EC_NULL_LOG( tmp = localtime(&date2) );
 149     strftime(buf2, sizeof(buf2), "%Y-%m-%dT%H:%M:%SZ", tmp);
 150
 151     for (p = spotlight_sparql_map; p->ssm_spotlight_attr; p++) {
 152         if (strcmp(dateattr, p->ssm_spotlight_attr) == 0) {
 153             result = talloc_asprintf(ssp_slq,
 154                                      "?obj %s ?%c FILTER (?%c > '%s' && ?%c < '%s')",
 155                                      p->ssm_sparql_attr,
 156                                      sparqlvar,
 157                                      sparqlvar,
 158                                      buf1,
 159                                      sparqlvar,
 160                                      buf2);
 161             sparqlvar++;
 162             break;
 163         }
 164     }
 165
 166 EC_CLEANUP:
 167     if (ret != 0)
 168         return NULL;
 169     return result;
 170 }
 171
 172 static char *map_type_search(const char *attr, char op, const char *val)
 173 {
 174     char *result = NULL;
 175     const char *sparqlAttr;
 176
 177     for (struct MDTypeMap *p = MDTypeMap; p->mdtm_value; p++) {
 178         if (strcmp(p->mdtm_value, val) == 0) {
 179             switch (p->mdtm_type) {
 180             case kMDTypeMapRDF:
 181                 sparqlAttr = "rdf:type";
 182                 break;
 183             case kMDTypeMapMime:
 184                 sparqlAttr = "nie:mimeType";
 185                 break;
 186             default:
 187                 return NULL;
 188             }
 189             result = talloc_asprintf(ssp_slq, "?obj %s '%s'",
 190                                      sparqlAttr,
 191                                      p->mdtm_sparql);
 192             break;
 193         }
 194     }
 195     return result;
 196 }
 197
 198 static const char *map_expr(const char *attr, char op, const char *val)
 199 {
 200     EC_INIT;
 201     char *result = NULL;
 202     struct spotlight_sparql_map *p;
 203     time_t t;
 204     struct tm *tmp;
 205     char buf1[64];
 206     bstring q = NULL, search = NULL, replace = NULL;
 207
 208     for (p = spotlight_sparql_map; p->ssm_spotlight_attr; p++) {
 209         if (strcmp(p->ssm_spotlight_attr, attr) == 0) {
 210             if (p->ssm_type != ssmt_type && p->ssm_sparql_attr == NULL) {
 211                 yyerror("unsupported Spotlight attribute");
 212                 EC_FAIL;
 213             }
 214             switch (p->ssm_type) {
 215             case ssmt_bool:
 216                 result = talloc_asprintf(ssp_slq, "?obj %s '%s'", p->ssm_sparql_attr, val);
 217                 break;
 218             case ssmt_num:
 219                 result = talloc_asprintf(ssp_slq, "?obj %s ?%c FILTER(?%c %c%c '%s')",
 220                                          p->ssm_sparql_attr,
 221                                          sparqlvar,
 222                                          sparqlvar,
 223                                          op,
 224                                          op == '!' ? '=' : ' ', /* append '=' to '!' */
 225                                          val);
 226                 sparqlvar++;
 227                 break;
 228             case ssmt_str:
 229                 q = bformat("^%s$", val);
 230                 search = bfromcstr("*");
 231                 replace = bfromcstr(".*");
 232                 bfindreplace(q, search, replace, 0);
 233                 result = talloc_asprintf(ssp_slq, "?obj %s ?%c FILTER(regex(?%c, '%s'))",
 234                                          p->ssm_sparql_attr,
 235                                          sparqlvar,
 236                                          sparqlvar,
 237                                          bdata(q));
 238                 sparqlvar++;
 239                 break;
 240             case ssmt_fts:
 241                 result = talloc_asprintf(ssp_slq, "?obj %s '%s'", p->ssm_sparql_attr, val);
 242                 break;
 243             case ssmt_date:
 244                 t = atoi(val) + SPRAW_TIME_OFFSET;
 245                 EC_NULL( tmp = localtime(&t) );
 246                 strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 247                 result = talloc_asprintf(ssp_slq, "?obj %s ?%c FILTER(?%c %c '%s')",
 248                                          p->ssm_sparql_attr,
 249                                          sparqlvar,
 250                                          sparqlvar,
 251                                          op,
 252                                          buf1);
 253                 sparqlvar++;
 254                 break;
 255             case ssmt_type:
 256                 result = map_type_search(attr, op, val);
 257                 break;
 258             default:
 259                 EC_FAIL;
 260             }
 261             break;
 262         }
 263     }
 264
 265 EC_CLEANUP:
 266     if (q)
 267         bdestroy(q);
 268     if (search)
 269         bdestroy(search);
 270     if (replace)
 271         bdestroy(replace);
 272     return result;
 273 }
 274
 275 void yyerror(const char *str)
 276 {
 277 #ifdef MAIN
 278     printf("yyerror: %s\n", str);
 279 #else
 280     LOG(log_error, logtype_sl, "yyerror: %s", str);
 281 #endif
 282 }
 283
 284 int yywrap()
 285 {
 286     return 1;
 287 }
 288
 289 /**
 290  * Map a Spotlight RAW query string to a SPARQL query string
 291  *
 292  * @param[in]     slq            Spotlight query handle
 293  * @param[out]    sparql_result  Mapped SPARQL query, string is allocated in
 294  *                               talloc context of slq
 295  * @return        0 on success, -1 on error
 296  **/
 297 int map_spotlight_to_sparql_query(slq_t *slq, gchar **sparql_result)
 298 {
 299     EC_INIT;
 300     YY_BUFFER_STATE s = NULL;
 301     ssp_result = NULL;
 302
 303     ssp_slq = slq;
 304     s = yy_scan_string(slq->slq_qstring);
 305     sparqlvar = 'a';
 306
 307     EC_ZERO( yyparse() );
 308
 309 EC_CLEANUP:
 310     if (s)
 311         yy_delete_buffer(s);
 312     if (ret == 0)
 313         *sparql_result = ssp_result;
 314     else
 315         *sparql_result = NULL;
 316     EC_EXIT;
 317 }
 318
 319 #ifdef MAIN
 320 int main(int argc, char **argv)
 321 {
 322     int ret;
 323     YY_BUFFER_STATE s;
 324
 325     if (argc != 2) {
 326         printf("usage: %s QUERY\n", argv[0]);
 327         return 1;
 328     }
 329
 330     ssp_slq = talloc_zero(NULL, slq_t);
 331     struct vol *vol = talloc_zero(ssp_slq, struct vol);
 332     vol->v_path = "/Volumes/test";
 333     ssp_slq->slq_vol = vol;
 334     sparqlvar = 'a';
 335
 336     s = yy_scan_string(argv[1]);
 337
 338     ret = yyparse();
 339
 340     yy_delete_buffer(s);
 341
 342     if (ret == 0)
 343         printf("SPARQL: %s\n", ssp_result ? ssp_result : "(empty)");
 344
 345     return 0;
 346 }
 347 #endif