← Back to branch summary

~ubuntu-branches/ubuntu/saucy/evolution-data-server/saucy

« back to all changes in this revision

Viewing changes to camel/camel-search-sql-sexp.c

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2012-10-08 12:58:16 UTC
  • mfrom: (181.1.7 quantal)
  • Revision ID: package-import@ubuntu.com-20121008125816-i3n76e8c0m64e7xp
Tags: 3.6.0-0ubuntu2
https://launchpad.net/bugs/1038047
https://launchpad.net/bugs/1038047
* Fix LP: #1038047 part 1 - Don't abort in e_source_registry_new* when a
  problem occurs connecting to the Dbus service
  - add debian/patches/dont-abort-in-e_source_registry_new.patch
  - update debian/patches/series
* Fix LP: #1038047 part 2 - libedataserver depends on
  evolution-data-server-common to ensure that the GSettings schemas are
  present
  - update debian/control

Show diffs side-by-side

added added

removed removed

Lines of Context:
camel/camel-search-sql-sexp.c
87
87
        GString *string;
88
88
        gint i;
89
89
 
90
 
        d(printf("executing and: %d", argc));
 
90
        d (printf ("executing and: %d", argc));
91
91
 
92
 
        string = g_string_new("( ");
 
92
        string = g_string_new ("( ");
93
93
        for (i = 0; i < argc; i++) {
94
94
                r1 = camel_sexp_term_eval (f, argv[i]);
95
95
 
98
98
                        continue;
99
99
                }
100
100
                if (r1->value.string && *r1->value.string)
101
 
                        g_string_append_printf(string, "%s%s", r1->value.string, ((argc>1) && (i != argc-1)) ?  " AND ":"");
 
101
                        g_string_append_printf (string, "%s%s", r1->value.string, ((argc > 1) && (i != argc - 1)) ?  " AND ":"");
102
102
                camel_sexp_result_free (f, r1);
103
103
        }
104
 
        g_string_append(string, " )");
 
104
        g_string_append (string, " )");
105
105
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
106
106
 
107
107
        if (strlen (string->str) == 4)
108
 
                r->value.string = g_strdup("");
 
108
                r->value.string = g_strdup ("");
109
109
        else
110
110
                r->value.string = string->str;
111
111
        g_string_free (string, FALSE);
123
123
        GString *string;
124
124
        gint i;
125
125
 
126
 
        d(printf("executing or: %d", argc));
 
126
        d (printf ("executing or: %d", argc));
127
127
 
128
 
        string = g_string_new("( ");
 
128
        string = g_string_new ("( ");
129
129
        for (i = 0; i < argc; i++) {
130
130
                r1 = camel_sexp_term_eval (f, argv[i]);
131
131
 
133
133
                        camel_sexp_result_free (f, r1);
134
134
                        continue;
135
135
                }
136
 
                g_string_append_printf(string, "%s%s", r1->value.string, ((argc>1) && (i != argc-1)) ?  " OR ":"");
 
136
                g_string_append_printf (string, "%s%s", r1->value.string, ((argc > 1) && (i != argc - 1)) ?  " OR ":"");
137
137
                camel_sexp_result_free (f, r1);
138
138
        }
139
 
        g_string_append(string, " )");
 
139
        g_string_append (string, " )");
140
140
 
141
141
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
142
142
        r->value.string = string->str;
152
152
{
153
153
        CamelSExpResult *r = NULL, *r1;
154
154
 
155
 
        d(printf("executing not: %d", argc));
 
155
        d (printf ("executing not: %d", argc));
156
156
        r1 = camel_sexp_term_eval (f, argv[0]);
157
157
 
158
158
        if (r1->type == CAMEL_SEXP_RES_STRING) {
161
161
                if (g_strcmp0 (r1->value.string, "( (usertags LIKE '%completed-on 0%' AND usertags LIKE '%completed-on%') )") == 0)
162
162
                        r->value.string = g_strdup ("( (not (usertags LIKE '%completed-on 0%')) AND usertags LIKE '%completed-on%' )");
163
163
                else
164
 
                        r->value.string = g_strdup_printf ("(NOT (%s))",
165
 
                                                           r1->value.string);
 
164
                        r->value.string = g_strdup_printf (
 
165
                                "(NOT (%s))", r1->value.string);
166
166
        }
167
167
        camel_sexp_result_free (f, r1);
168
168
 
181
181
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
182
182
 
183
183
        if (argc == 2) {
184
 
                GString *str = g_string_new("( ");
 
184
                GString *str = g_string_new ("( ");
185
185
                r1 = camel_sexp_term_eval (f, argv[0]);
186
186
                r2 = camel_sexp_term_eval (f, argv[1]);
187
187
 
188
188
                if (r1->type == CAMEL_SEXP_RES_INT)
189
 
                        g_string_append_printf(str, "%d", r1->value.number);
 
189
                        g_string_append_printf (str, "%d", r1->value.number);
190
190
                else if (r1->type == CAMEL_SEXP_RES_TIME)
191
 
                        g_string_append_printf(str, "%ld", r1->value.time);
 
191
                        g_string_append_printf (str, "%ld", r1->value.time);
192
192
                else if (r1->type == CAMEL_SEXP_RES_STRING)
193
 
                        g_string_append_printf(str, "%s", r1->value.string);
 
193
                        g_string_append_printf (str, "%s", r1->value.string);
194
194
 
195
 
                if (!strstr(str->str, "completed-on") && !strstr(str->str, "follow-up")) {
 
195
                if (!strstr (str->str, "completed-on") && !strstr (str->str, "follow-up")) {
196
196
                        gboolean ut = FALSE;
197
197
 
198
 
                        if (strstr(str->str, "usertags"))
 
198
                        if (strstr (str->str, "usertags"))
199
199
                                ut = TRUE;
200
200
                        if (ut)
201
 
                                g_string_append_printf(str, " LIKE ");
 
201
                                g_string_append_printf (str, " LIKE ");
202
202
                        else
203
 
                                g_string_append_printf(str, " = ");
 
203
                                g_string_append_printf (str, " = ");
204
204
                        if (r2->type == CAMEL_SEXP_RES_INT)
205
 
                                g_string_append_printf(str, "%d", r2->value.number);
 
205
                                g_string_append_printf (str, "%d", r2->value.number);
206
206
                        if (r2->type == CAMEL_SEXP_RES_BOOL)
207
 
                                g_string_append_printf(str, "%d", r2->value.boolean);
 
207
                                g_string_append_printf (str, "%d", r2->value.boolean);
208
208
                        else if (r2->type == CAMEL_SEXP_RES_TIME)
209
 
                                g_string_append_printf(str, "%ld", r2->value.time);
 
209
                                g_string_append_printf (str, "%ld", r2->value.time);
210
210
                        else if (r2->type == CAMEL_SEXP_RES_STRING) {
211
 
                                gchar *tmp = g_strdup_printf("%c%s%c", ut ? '%':' ', r2->value.string, ut?'%':' ');
 
211
                                gchar *tmp = g_strdup_printf ("%c%s%c", ut ? '%':' ', r2->value.string, ut ? '%':' ');
212
212
                                gchar *safe = get_db_safe_string (tmp);
213
 
                                g_string_append_printf(str, "%s", safe);
 
213
                                g_string_append_printf (str, "%s", safe);
214
214
                                g_free (safe);
215
215
                                g_free (tmp);
216
216
                        }
237
237
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
238
238
 
239
239
        if (argc == 2) {
240
 
                GString *str = g_string_new("( ");
 
240
                GString *str = g_string_new ("( ");
241
241
                r1 = camel_sexp_term_eval (f, argv[0]);
242
242
                r2 = camel_sexp_term_eval (f, argv[1]);
243
243
 
244
244
                if (r1->type == CAMEL_SEXP_RES_INT)
245
 
                        g_string_append_printf(str, "%d", r1->value.number);
 
245
                        g_string_append_printf (str, "%d", r1->value.number);
246
246
                else if (r1->type == CAMEL_SEXP_RES_TIME)
247
 
                        g_string_append_printf(str, "%ld", r1->value.time);
 
247
                        g_string_append_printf (str, "%ld", r1->value.time);
248
248
                else if (r1->type == CAMEL_SEXP_RES_STRING)
249
 
                        g_string_append_printf(str, "%s", r1->value.string);
 
249
                        g_string_append_printf (str, "%s", r1->value.string);
250
250
 
251
 
                g_string_append_printf(str, " < ");
 
251
                g_string_append_printf (str, " < ");
252
252
                if (r2->type == CAMEL_SEXP_RES_INT)
253
 
                        g_string_append_printf(str, "%d", r2->value.number);
 
253
                        g_string_append_printf (str, "%d", r2->value.number);
254
254
                if (r2->type == CAMEL_SEXP_RES_BOOL)
255
 
                        g_string_append_printf(str, "%d", r2->value.boolean);
 
255
                        g_string_append_printf (str, "%d", r2->value.boolean);
256
256
                else if (r2->type == CAMEL_SEXP_RES_TIME)
257
 
                        g_string_append_printf(str, "%ld", r2->value.time);
 
257
                        g_string_append_printf (str, "%ld", r2->value.time);
258
258
                else if (r2->type == CAMEL_SEXP_RES_STRING)
259
 
                        g_string_append_printf(str, "%s", r2->value.string);
 
259
                        g_string_append_printf (str, "%s", r2->value.string);
260
260
                camel_sexp_result_free (f, r1);
261
261
                camel_sexp_result_free (f, r2);
262
262
                g_string_append (str, " )");
279
279
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
280
280
 
281
281
        if (argc == 2) {
282
 
                GString *str = g_string_new("( ");
 
282
                GString *str = g_string_new ("( ");
283
283
                r1 = camel_sexp_term_eval (f, argv[0]);
284
284
                r2 = camel_sexp_term_eval (f, argv[1]);
285
285
 
286
286
                if (r1->type == CAMEL_SEXP_RES_INT)
287
 
                        g_string_append_printf(str, "%d", r1->value.number);
 
287
                        g_string_append_printf (str, "%d", r1->value.number);
288
288
                else if (r1->type == CAMEL_SEXP_RES_TIME)
289
 
                        g_string_append_printf(str, "%ld", r1->value.time);
 
289
                        g_string_append_printf (str, "%ld", r1->value.time);
290
290
                else if (r1->type == CAMEL_SEXP_RES_STRING)
291
 
                        g_string_append_printf(str, "%s", r1->value.string);
 
291
                        g_string_append_printf (str, "%s", r1->value.string);
292
292
 
293
 
                g_string_append_printf(str, " > ");
 
293
                g_string_append_printf (str, " > ");
294
294
                if (r2->type == CAMEL_SEXP_RES_INT)
295
 
                        g_string_append_printf(str, "%d", r2->value.number);
 
295
                        g_string_append_printf (str, "%d", r2->value.number);
296
296
                if (r2->type == CAMEL_SEXP_RES_BOOL)
297
 
                        g_string_append_printf(str, "%d", r2->value.boolean);
 
297
                        g_string_append_printf (str, "%d", r2->value.boolean);
298
298
                else if (r2->type == CAMEL_SEXP_RES_TIME)
299
 
                        g_string_append_printf(str, "%ld", r2->value.time);
 
299
                        g_string_append_printf (str, "%ld", r2->value.time);
300
300
                else if (r2->type == CAMEL_SEXP_RES_STRING)
301
 
                        g_string_append_printf(str, "%s", r2->value.string);
 
301
                        g_string_append_printf (str, "%s", r2->value.string);
302
302
                camel_sexp_result_free (f, r1);
303
303
                camel_sexp_result_free (f, r2);
304
304
                g_string_append (str, " )");
317
317
{
318
318
        CamelSExpResult *r;
319
319
 
320
 
        d(printf("executing match-all: %d", argc));
 
320
        d (printf ("executing match-all: %d", argc));
321
321
        if (argc == 0) {
322
322
                r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
323
323
                r->value.string = g_strdup ("1");
325
325
                r = camel_sexp_term_eval (f, argv[0]);
326
326
        else {
327
327
                r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
328
 
                r->value.string = g_strdup(argv[0]->value.boolean ? "1" : "0");
 
328
                r->value.string = g_strdup (argv[0]->value.boolean ? "1" : "0");
329
329
        }
330
330
 
331
331
        return r;
342
342
        gint i;
343
343
        GString *str = g_string_new ("( ");
344
344
 
345
 
        d(printf("executing match-threads: %d", argc));
 
345
        d (printf ("executing match-threads: %d", argc));
346
346
 
347
347
        for (i = 1; i < argc; i++) {
348
348
                r = camel_sexp_term_eval (f, argv[i]);
349
 
                g_string_append_printf(str, "%s%s", r->value.string, ((argc>1) && (i != argc-1)) ?  " AND ":"");
 
349
                g_string_append_printf (str, "%s%s", r->value.string, ((argc > 1) && (i != argc - 1)) ?  " AND ":"");
350
350
                camel_sexp_result_free (f, r);
351
351
        }
352
352
 
368
368
        CamelSExpResult *r;
369
369
        gchar *str = NULL;
370
370
 
371
 
        d(printf("executing check-header %d\n", how));
 
371
        d (printf ("executing check-header %d\n", how));
372
372
 
373
373
        /* are we inside a match-all? */
374
374
        if (argc > 1 && argv[0]->type == CAMEL_SEXP_RES_STRING) {
401
401
                                        value = get_db_safe_string (tstr);
402
402
                                        g_free (tstr);
403
403
                                }
404
 
                                str = g_strdup_printf("(%s IS NOT NULL AND %s LIKE %s)", headername, headername, value);
 
404
                                str = g_strdup_printf ("(%s IS NOT NULL AND %s LIKE %s)", headername, headername, value);
405
405
                                g_free (value);
406
406
                        }
407
407
                }
421
421
                 struct _CamelSExpResult **argv,
422
422
                 gpointer data)
423
423
{
424
 
        d(printf("executing header-contains: %d", argc));
 
424
        d (printf ("executing header-contains: %d", argc));
425
425
 
426
426
        return check_header (f, argc, argv, data, CAMEL_SEARCH_MATCH_CONTAINS);
427
427
}
432
432
                  struct _CamelSExpResult **argv,
433
433
                  gpointer data)
434
434
{
435
 
        d(printf("executing header-has-word: %d", argc));
 
435
        d (printf ("executing header-has-word: %d", argc));
436
436
 
437
437
        return check_header (f, argc, argv, data, CAMEL_SEARCH_MATCH_WORD);
438
438
}
443
443
                struct _CamelSExpResult **argv,
444
444
                gpointer data)
445
445
{
446
 
        d(printf("executing header-matches: %d", argc));
 
446
        d (printf ("executing header-matches: %d", argc));
447
447
 
448
448
        return check_header (f, argc, argv, data, CAMEL_SEARCH_MATCH_EXACT);
449
449
}
454
454
                    struct _CamelSExpResult **argv,
455
455
                    gpointer data)
456
456
{
457
 
        d(printf("executing header-starts-with: %d", argc));
 
457
        d (printf ("executing header-starts-with: %d", argc));
458
458
 
459
459
        return check_header (f, argc, argv, data, CAMEL_SEARCH_MATCH_STARTS);
460
460
}
465
465
                  struct _CamelSExpResult **argv,
466
466
                  gpointer data)
467
467
{
468
 
        d(printf("executing header-ends-with: %d", argc));
 
468
        d (printf ("executing header-ends-with: %d", argc));
469
469
 
470
470
        return check_header (f, argc, argv, data, CAMEL_SEARCH_MATCH_ENDS);
471
471
}
479
479
        CamelSExpResult *r;
480
480
        gchar *headername;
481
481
 
482
 
        d(printf("executing header-exists: %d", argc));
 
482
        d (printf ("executing header-exists: %d", argc));
483
483
 
484
484
        headername = camel_db_get_column_name (argv[0]->value.string);
485
485
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
496
496
{
497
497
        CamelSExpResult *r;
498
498
 
499
 
        d(printf("executing user-tag: %d", argc));
 
499
        d (printf ("executing user-tag: %d", argc));
500
500
 
501
501
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
502
502
        /* Hacks no otherway to fix these really :( */
503
503
        if (g_strcmp0 (argv[0]->value.string, "completed-on") == 0)
504
 
                r->value.string = g_strdup_printf("(usertags LIKE '%ccompleted-on 0%c' AND usertags LIKE '%ccompleted-on%c')", '%', '%', '%', '%');
 
504
                r->value.string = g_strdup_printf ("(usertags LIKE '%ccompleted-on 0%c' AND usertags LIKE '%ccompleted-on%c')", '%', '%', '%', '%');
505
505
        else if (g_strcmp0 (argv[0]->value.string, "follow-up") == 0)
506
 
                r->value.string = g_strdup_printf("usertags NOT LIKE '%cfollow-up%c'", '%', '%');
 
506
                r->value.string = g_strdup_printf ("usertags NOT LIKE '%cfollow-up%c'", '%', '%');
507
507
        else
508
 
                r->value.string = g_strdup("usertags");
 
508
                r->value.string = g_strdup ("usertags");
509
509
 
510
510
        return r;
511
511
}
519
519
        CamelSExpResult *r;
520
520
        gchar *tstr, *qstr;
521
521
 
522
 
        d(printf("executing user-flag: %d", argc));
 
522
        d (printf ("executing user-flag: %d", argc));
523
523
 
524
524
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
525
525
 
526
526
        if (argc != 1) {
527
527
                r->value.string = g_strdup ("(0)");
528
528
        } else {
529
 
                tstr = g_strdup_printf("%s", argv[0]->value.string);
 
529
                tstr = g_strdup_printf ("%s", argv[0]->value.string);
530
530
                qstr = get_db_safe_string (tstr);
531
531
                g_free (tstr);
532
 
                r->value.string = g_strdup_printf("(labels MATCH %s)", qstr);
 
532
                r->value.string = g_strdup_printf ("(labels MATCH %s)", qstr);
533
533
                g_free (qstr);
534
534
        }
535
535
 
545
545
        CamelSExpResult *r;
546
546
        gchar *tstr;
547
547
 
548
 
        d(printf("executing system-flag: %d", argc));
 
548
        d (printf ("executing system-flag: %d", argc));
549
549
 
550
550
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
551
551
 
553
553
                r->value.string = g_strdup ("(0)");
554
554
        } else {
555
555
                tstr = camel_db_get_column_name (argv[0]->value.string);
556
 
                r->value.string = g_strdup_printf("(%s = 1)", tstr);
 
556
                r->value.string = g_strdup_printf ("(%s = 1)", tstr);
557
557
                g_free (tstr);
558
558
        }
559
559
 
568
568
{
569
569
        CamelSExpResult *r;
570
570
 
571
 
        d(printf("executing get-sent-date\n"));
 
571
        d (printf ("executing get-sent-date\n"));
572
572
 
573
573
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
574
 
        r->value.string = g_strdup("dsent");
 
574
        r->value.string = g_strdup ("dsent");
575
575
 
576
576
        return r;
577
577
}
584
584
{
585
585
        CamelSExpResult *r;
586
586
 
587
 
        d(printf("executing get-received-date\n"));
 
587
        d (printf ("executing get-received-date\n"));
588
588
 
589
589
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
590
 
        r->value.string = g_strdup("dreceived");
 
590
        r->value.string = g_strdup ("dreceived");
591
591
 
592
592
        return r;
593
593
}
600
600
{
601
601
        CamelSExpResult *r;
602
602
 
603
 
        d(printf("executing get-current-date\n"));
 
603
        d (printf ("executing get-current-date\n"));
604
604
 
605
605
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_INT);
606
606
        r->value.number = time (NULL);
615
615
{
616
616
        CamelSExpResult *r;
617
617
 
618
 
        d(printf("executing get-relative-months\n"));
 
618
        d (printf ("executing get-relative-months\n"));
619
619
 
620
620
        if (argc != 1 || argv[0]->type != CAMEL_SEXP_RES_INT) {
621
621
                r = camel_sexp_result_new (f, CAMEL_SEXP_RES_BOOL);
638
638
{
639
639
        CamelSExpResult *r;
640
640
 
641
 
        d(printf("executing get-size\n"));
 
641
        d (printf ("executing get-size\n"));
642
642
 
643
643
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
644
 
        r->value.string = g_strdup("size/1024");
 
644
        r->value.string = g_strdup ("size/1024");
645
645
 
646
646
        return r;
647
647
}
656
656
        gint i;
657
657
        GString *str = g_string_new (NULL);
658
658
 
659
 
        d(printf("executing sql-exp\n"));
 
659
        d (printf ("executing sql-exp\n"));
660
660
 
661
661
        r = camel_sexp_result_new (f, CAMEL_SEXP_RES_STRING);
662
662
        for (i = 0; i < argc; i++) {
678
678
        { "and", (CamelSExpFunc) func_and, 1 },
679
679
        { "or", (CamelSExpFunc) func_or, 1},
680
680
        { "not", (CamelSExpFunc) func_not, 1},
681
 
        { "=", (CamelSExpFunc)eval_eq, 1},
682
 
        { ">", (CamelSExpFunc)eval_gt, 1},
683
 
        { "<", (CamelSExpFunc)eval_lt, 1},
 
681
        { "=", (CamelSExpFunc) eval_eq, 1},
 
682
        { ">", (CamelSExpFunc) eval_gt, 1},
 
683
        { "<", (CamelSExpFunc) eval_lt, 1},
684
684
 
685
 
        { "match-all", (CamelSExpFunc)match_all, 1 },
686
 
        { "match-threads", (CamelSExpFunc)match_threads, 1 },
 
685
        { "match-all", (CamelSExpFunc) match_all, 1 },
 
686
        { "match-threads", (CamelSExpFunc) match_threads, 1 },
687
687
/*      { "body-contains", body_contains}, */ /* We don't store body on the db. */
688
688
        { "header-contains", header_contains, 0},
689
689
        { "header-has-words", header_has_words, 0},
724
724
                        camel_sexp_add_ifunction (sexp, 0, symbols[i].name,
725
725
                                             (CamelSExpIFunc) symbols[i].func, NULL);
726
726
                else
727
 
                        camel_sexp_add_function (sexp, 0, symbols[i].name,
728
 
                                            symbols[i].func, NULL);
 
727
                        camel_sexp_add_function (
 
728
                                sexp, 0, symbols[i].name,
 
729
                                symbols[i].func, NULL);
729
730
        }
730
731
 
731
732
        camel_sexp_input_text (sexp, sql, strlen (sql));
868
869
 
869
870
        for (i = 0; i < G_N_ELEMENTS (txt); i++) {
870
871
                gchar *sql = NULL;
871
 
                printf("Q: %s\n\"%c\"\n", txt[i], 40);
 
872
                printf ("Q: %s\n\"%c\"\n", txt[i], 40);
872
873
                sql = camel_sexp_to_sql_sexp (txt[i]);
873
 
                printf("A: %s\n\n\n", sql);
 
874
                printf ("A: %s\n\n\n", sql);
874
875
                g_free (sql);
875
876
        }
876
877