← Back to branch summary

~ubuntu-branches/ubuntu/raring/tracker/raring

« back to all changes in this revision

Viewing changes to src/libtracker-data/tracker-sparql-scanner.c

  • Committer: Package Import Robot
  • Author(s): Michael Biebl
  • Date: 2011-08-26 00:26:14 UTC
  • mfrom: (4.3.17 sid)
  • Revision ID: package-import@ubuntu.com-20110826002614-4qjfs9jhh5gs4p13
Tags: 0.10.24-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libtracker-data/tracker-sparql-scanner.c
81
81
        TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACE,
82
82
        TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACKET,
83
83
        TRACKER_SPARQL_TOKEN_TYPE_CLOSE_PARENS,
 
84
        TRACKER_SPARQL_TOKEN_TYPE_COALESCE,
84
85
        TRACKER_SPARQL_TOKEN_TYPE_COLON,
85
86
        TRACKER_SPARQL_TOKEN_TYPE_COMMA,
86
87
        TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT,
105
106
        TRACKER_SPARQL_TOKEN_TYPE_GRAPH,
106
107
        TRACKER_SPARQL_TOKEN_TYPE_GROUP,
107
108
        TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT,
 
109
        TRACKER_SPARQL_TOKEN_TYPE_HAVING,
108
110
        TRACKER_SPARQL_TOKEN_TYPE_IF,
109
111
        TRACKER_SPARQL_TOKEN_TYPE_INSERT,
110
112
        TRACKER_SPARQL_TOKEN_TYPE_INTEGER,
122
124
        TRACKER_SPARQL_TOKEN_TYPE_MINUS,
123
125
        TRACKER_SPARQL_TOKEN_TYPE_NAMED,
124
126
        TRACKER_SPARQL_TOKEN_TYPE_NOT,
 
127
        TRACKER_SPARQL_TOKEN_TYPE_NULL,
125
128
        TRACKER_SPARQL_TOKEN_TYPE_OFFSET,
126
129
        TRACKER_SPARQL_TOKEN_TYPE_OP_AND,
127
130
        TRACKER_SPARQL_TOKEN_TYPE_OP_EQ,
529
532
                                        }
530
533
                                        break;
531
534
                                }
 
535
                                case 'N':
 
536
                                case 'n':
 
537
                                {
 
538
                                        gboolean _tmp20_;
 
539
                                        _tmp20_ = tracker_sparql_scanner_matches (self, begin, "NULL");
 
540
                                        if (_tmp20_) {
 
541
                                                result = TRACKER_SPARQL_TOKEN_TYPE_NULL;
 
542
                                                return result;
 
543
                                        }
 
544
                                        break;
 
545
                                }
532
546
                                case 'T':
533
547
                                case 't':
534
548
                                {
535
 
                                        gboolean _tmp20_;
536
 
                                        _tmp20_ = tracker_sparql_scanner_matches (self, begin, "TRUE");
537
 
                                        if (_tmp20_) {
 
549
                                        gboolean _tmp21_;
 
550
                                        _tmp21_ = tracker_sparql_scanner_matches (self, begin, "TRUE");
 
551
                                        if (_tmp21_) {
538
552
                                                result = TRACKER_SPARQL_TOKEN_TYPE_TRUE;
539
553
                                                return result;
540
554
                                        }
543
557
                                case 'W':
544
558
                                case 'w':
545
559
                                {
546
 
                                        gboolean _tmp21_;
547
 
                                        _tmp21_ = tracker_sparql_scanner_matches (self, begin, "WITH");
548
 
                                        if (_tmp21_) {
 
560
                                        gboolean _tmp22_;
 
561
                                        _tmp22_ = tracker_sparql_scanner_matches (self, begin, "WITH");
 
562
                                        if (_tmp22_) {
549
563
                                                result = TRACKER_SPARQL_TOKEN_TYPE_WITH;
550
564
                                                return result;
551
565
                                        }
562
576
                                case 'B':
563
577
                                case 'b':
564
578
                                {
565
 
                                        gboolean _tmp22_;
566
 
                                        _tmp22_ = tracker_sparql_scanner_matches (self, begin, "BOUND");
567
 
                                        if (_tmp22_) {
568
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_BOUND;
569
 
                                                return result;
570
 
                                        }
571
 
                                        break;
572
 
                                }
573
 
                                case 'C':
574
 
                                case 'c':
575
 
                                {
576
579
                                        gboolean _tmp23_;
577
 
                                        _tmp23_ = tracker_sparql_scanner_matches (self, begin, "COUNT");
 
580
                                        _tmp23_ = tracker_sparql_scanner_matches (self, begin, "BOUND");
578
581
                                        if (_tmp23_) {
 
582
                                                result = TRACKER_SPARQL_TOKEN_TYPE_BOUND;
 
583
                                                return result;
 
584
                                        }
 
585
                                        break;
 
586
                                }
 
587
                                case 'C':
 
588
                                case 'c':
 
589
                                {
 
590
                                        gboolean _tmp24_;
 
591
                                        _tmp24_ = tracker_sparql_scanner_matches (self, begin, "COUNT");
 
592
                                        if (_tmp24_) {
579
593
                                                result = TRACKER_SPARQL_TOKEN_TYPE_COUNT;
580
594
                                                return result;
581
595
                                        }
588
602
                                                case 'A':
589
603
                                                case 'a':
590
604
                                                {
591
 
                                                        gboolean _tmp24_;
592
 
                                                        _tmp24_ = tracker_sparql_scanner_matches (self, begin, "GRAPH");
593
 
                                                        if (_tmp24_) {
 
605
                                                        gboolean _tmp25_;
 
606
                                                        _tmp25_ = tracker_sparql_scanner_matches (self, begin, "GRAPH");
 
607
                                                        if (_tmp25_) {
594
608
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_GRAPH;
595
609
                                                                return result;
596
610
                                                        }
599
613
                                                case 'O':
600
614
                                                case 'o':
601
615
                                                {
602
 
                                                        gboolean _tmp25_;
603
 
                                                        _tmp25_ = tracker_sparql_scanner_matches (self, begin, "GROUP");
604
 
                                                        if (_tmp25_) {
 
616
                                                        gboolean _tmp26_;
 
617
                                                        _tmp26_ = tracker_sparql_scanner_matches (self, begin, "GROUP");
 
618
                                                        if (_tmp26_) {
605
619
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_GROUP;
606
620
                                                                return result;
607
621
                                                        }
615
629
                                case 'L':
616
630
                                case 'l':
617
631
                                {
618
 
                                        gboolean _tmp26_;
619
 
                                        _tmp26_ = tracker_sparql_scanner_matches (self, begin, "LIMIT");
620
 
                                        if (_tmp26_) {
621
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_LIMIT;
622
 
                                                return result;
623
 
                                        }
624
 
                                        break;
625
 
                                }
626
 
                                case 'N':
627
 
                                case 'n':
628
 
                                {
629
632
                                        gboolean _tmp27_;
630
 
                                        _tmp27_ = tracker_sparql_scanner_matches (self, begin, "NAMED");
 
633
                                        _tmp27_ = tracker_sparql_scanner_matches (self, begin, "LIMIT");
631
634
                                        if (_tmp27_) {
632
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_NAMED;
 
635
                                                result = TRACKER_SPARQL_TOKEN_TYPE_LIMIT;
633
636
                                                return result;
634
637
                                        }
635
638
                                        break;
636
639
                                }
637
 
                                case 'O':
638
 
                                case 'o':
 
640
                                case 'N':
 
641
                                case 'n':
639
642
                                {
640
643
                                        gboolean _tmp28_;
641
 
                                        _tmp28_ = tracker_sparql_scanner_matches (self, begin, "ORDER");
 
644
                                        _tmp28_ = tracker_sparql_scanner_matches (self, begin, "NAMED");
642
645
                                        if (_tmp28_) {
643
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_ORDER;
 
646
                                                result = TRACKER_SPARQL_TOKEN_TYPE_NAMED;
644
647
                                                return result;
645
648
                                        }
646
649
                                        break;
647
650
                                }
648
 
                                case 'R':
649
 
                                case 'r':
 
651
                                case 'O':
 
652
                                case 'o':
650
653
                                {
651
654
                                        gboolean _tmp29_;
652
 
                                        _tmp29_ = tracker_sparql_scanner_matches (self, begin, "REGEX");
 
655
                                        _tmp29_ = tracker_sparql_scanner_matches (self, begin, "ORDER");
653
656
                                        if (_tmp29_) {
 
657
                                                result = TRACKER_SPARQL_TOKEN_TYPE_ORDER;
 
658
                                                return result;
 
659
                                        }
 
660
                                        break;
 
661
                                }
 
662
                                case 'R':
 
663
                                case 'r':
 
664
                                {
 
665
                                        gboolean _tmp30_;
 
666
                                        _tmp30_ = tracker_sparql_scanner_matches (self, begin, "REGEX");
 
667
                                        if (_tmp30_) {
654
668
                                                result = TRACKER_SPARQL_TOKEN_TYPE_REGEX;
655
669
                                                return result;
656
670
                                        }
659
673
                                case 'U':
660
674
                                case 'u':
661
675
                                {
662
 
                                        gboolean _tmp30_;
663
 
                                        _tmp30_ = tracker_sparql_scanner_matches (self, begin, "UNION");
664
 
                                        if (_tmp30_) {
665
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_UNION;
666
 
                                                return result;
667
 
                                        }
668
 
                                        break;
669
 
                                }
670
 
                                case 'W':
671
 
                                case 'w':
672
 
                                {
673
676
                                        gboolean _tmp31_;
674
 
                                        _tmp31_ = tracker_sparql_scanner_matches (self, begin, "WHERE");
 
677
                                        _tmp31_ = tracker_sparql_scanner_matches (self, begin, "UNION");
675
678
                                        if (_tmp31_) {
676
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_WHERE;
 
679
                                                result = TRACKER_SPARQL_TOKEN_TYPE_UNION;
677
680
                                                return result;
678
681
                                        }
679
682
                                        break;
680
683
                                }
681
 
                                case 'F':
682
 
                                case 'f':
 
684
                                case 'W':
 
685
                                case 'w':
683
686
                                {
684
687
                                        gboolean _tmp32_;
685
 
                                        _tmp32_ = tracker_sparql_scanner_matches (self, begin, "FALSE");
 
688
                                        _tmp32_ = tracker_sparql_scanner_matches (self, begin, "WHERE");
686
689
                                        if (_tmp32_) {
 
690
                                                result = TRACKER_SPARQL_TOKEN_TYPE_WHERE;
 
691
                                                return result;
 
692
                                        }
 
693
                                        break;
 
694
                                }
 
695
                                case 'F':
 
696
                                case 'f':
 
697
                                {
 
698
                                        gboolean _tmp33_;
 
699
                                        _tmp33_ = tracker_sparql_scanner_matches (self, begin, "FALSE");
 
700
                                        if (_tmp33_) {
687
701
                                                result = TRACKER_SPARQL_TOKEN_TYPE_FALSE;
688
702
                                                return result;
689
703
                                        }
700
714
                                                                case 'I':
701
715
                                                                case 'i':
702
716
                                                                {
703
 
                                                                        gboolean _tmp33_;
704
 
                                                                        _tmp33_ = tracker_sparql_scanner_matches (self, begin, "ISIRI");
705
 
                                                                        if (_tmp33_) {
 
717
                                                                        gboolean _tmp34_;
 
718
                                                                        _tmp34_ = tracker_sparql_scanner_matches (self, begin, "ISIRI");
 
719
                                                                        if (_tmp34_) {
706
720
                                                                                result = TRACKER_SPARQL_TOKEN_TYPE_ISIRI;
707
721
                                                                                return result;
708
722
                                                                        }
711
725
                                                                case 'U':
712
726
                                                                case 'u':
713
727
                                                                {
714
 
                                                                        gboolean _tmp34_;
715
 
                                                                        _tmp34_ = tracker_sparql_scanner_matches (self, begin, "ISURI");
716
 
                                                                        if (_tmp34_) {
 
728
                                                                        gboolean _tmp35_;
 
729
                                                                        _tmp35_ = tracker_sparql_scanner_matches (self, begin, "ISURI");
 
730
                                                                        if (_tmp35_) {
717
731
                                                                                result = TRACKER_SPARQL_TOKEN_TYPE_ISURI;
718
732
                                                                                return result;
719
733
                                                                        }
740
754
                                case 'D':
741
755
                                case 'd':
742
756
                                {
743
 
                                        gboolean _tmp35_;
744
 
                                        _tmp35_ = tracker_sparql_scanner_matches (self, begin, "DELETE");
745
 
                                        if (_tmp35_) {
 
757
                                        gboolean _tmp36_;
 
758
                                        _tmp36_ = tracker_sparql_scanner_matches (self, begin, "DELETE");
 
759
                                        if (_tmp36_) {
746
760
                                                result = TRACKER_SPARQL_TOKEN_TYPE_DELETE;
747
761
                                                return result;
748
762
                                        }
751
765
                                case 'E':
752
766
                                case 'e':
753
767
                                {
754
 
                                        gboolean _tmp36_;
755
 
                                        _tmp36_ = tracker_sparql_scanner_matches (self, begin, "EXISTS");
756
 
                                        if (_tmp36_) {
757
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_EXISTS;
758
 
                                                return result;
759
 
                                        }
760
 
                                        break;
761
 
                                }
762
 
                                case 'F':
763
 
                                case 'f':
764
 
                                {
765
768
                                        gboolean _tmp37_;
766
 
                                        _tmp37_ = tracker_sparql_scanner_matches (self, begin, "FILTER");
 
769
                                        _tmp37_ = tracker_sparql_scanner_matches (self, begin, "EXISTS");
767
770
                                        if (_tmp37_) {
768
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_FILTER;
 
771
                                                result = TRACKER_SPARQL_TOKEN_TYPE_EXISTS;
769
772
                                                return result;
770
773
                                        }
771
774
                                        break;
772
775
                                }
773
 
                                case 'I':
774
 
                                case 'i':
 
776
                                case 'F':
 
777
                                case 'f':
775
778
                                {
776
779
                                        gboolean _tmp38_;
777
 
                                        _tmp38_ = tracker_sparql_scanner_matches (self, begin, "INSERT");
 
780
                                        _tmp38_ = tracker_sparql_scanner_matches (self, begin, "FILTER");
778
781
                                        if (_tmp38_) {
779
 
                                                result = TRACKER_SPARQL_TOKEN_TYPE_INSERT;
 
782
                                                result = TRACKER_SPARQL_TOKEN_TYPE_FILTER;
780
783
                                                return result;
781
784
                                        }
782
785
                                        break;
783
786
                                }
784
 
                                case 'O':
785
 
                                case 'o':
 
787
                                case 'H':
 
788
                                case 'h':
786
789
                                {
787
790
                                        gboolean _tmp39_;
788
 
                                        _tmp39_ = tracker_sparql_scanner_matches (self, begin, "OFFSET");
 
791
                                        _tmp39_ = tracker_sparql_scanner_matches (self, begin, "HAVING");
789
792
                                        if (_tmp39_) {
 
793
                                                result = TRACKER_SPARQL_TOKEN_TYPE_HAVING;
 
794
                                                return result;
 
795
                                        }
 
796
                                        break;
 
797
                                }
 
798
                                case 'I':
 
799
                                case 'i':
 
800
                                {
 
801
                                        gboolean _tmp40_;
 
802
                                        _tmp40_ = tracker_sparql_scanner_matches (self, begin, "INSERT");
 
803
                                        if (_tmp40_) {
 
804
                                                result = TRACKER_SPARQL_TOKEN_TYPE_INSERT;
 
805
                                                return result;
 
806
                                        }
 
807
                                        break;
 
808
                                }
 
809
                                case 'O':
 
810
                                case 'o':
 
811
                                {
 
812
                                        gboolean _tmp41_;
 
813
                                        _tmp41_ = tracker_sparql_scanner_matches (self, begin, "OFFSET");
 
814
                                        if (_tmp41_) {
790
815
                                                result = TRACKER_SPARQL_TOKEN_TYPE_OFFSET;
791
816
                                                return result;
792
817
                                        }
795
820
                                case 'P':
796
821
                                case 'p':
797
822
                                {
798
 
                                        gboolean _tmp40_;
799
 
                                        _tmp40_ = tracker_sparql_scanner_matches (self, begin, "PREFIX");
800
 
                                        if (_tmp40_) {
 
823
                                        gboolean _tmp42_;
 
824
                                        _tmp42_ = tracker_sparql_scanner_matches (self, begin, "PREFIX");
 
825
                                        if (_tmp42_) {
801
826
                                                result = TRACKER_SPARQL_TOKEN_TYPE_PREFIX;
802
827
                                                return result;
803
828
                                        }
810
835
                                                case 'E':
811
836
                                                case 'e':
812
837
                                                {
813
 
                                                        gboolean _tmp41_;
814
 
                                                        _tmp41_ = tracker_sparql_scanner_matches (self, begin, "SELECT");
815
 
                                                        if (_tmp41_) {
 
838
                                                        gboolean _tmp43_;
 
839
                                                        _tmp43_ = tracker_sparql_scanner_matches (self, begin, "SELECT");
 
840
                                                        if (_tmp43_) {
816
841
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_SELECT;
817
842
                                                                return result;
818
843
                                                        }
821
846
                                                case 'I':
822
847
                                                case 'i':
823
848
                                                {
824
 
                                                        gboolean _tmp42_;
825
 
                                                        _tmp42_ = tracker_sparql_scanner_matches (self, begin, "SILENT");
826
 
                                                        if (_tmp42_) {
 
849
                                                        gboolean _tmp44_;
 
850
                                                        _tmp44_ = tracker_sparql_scanner_matches (self, begin, "SILENT");
 
851
                                                        if (_tmp44_) {
827
852
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_SILENT;
828
853
                                                                return result;
829
854
                                                        }
849
874
                                                case 'D':
850
875
                                                case 'd':
851
876
                                                {
852
 
                                                        gboolean _tmp43_;
853
 
                                                        _tmp43_ = tracker_sparql_scanner_matches (self, begin, "REDUCED");
854
 
                                                        if (_tmp43_) {
 
877
                                                        gboolean _tmp45_;
 
878
                                                        _tmp45_ = tracker_sparql_scanner_matches (self, begin, "REDUCED");
 
879
                                                        if (_tmp45_) {
855
880
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_REDUCED;
856
881
                                                                return result;
857
882
                                                        }
860
885
                                                case 'P':
861
886
                                                case 'p':
862
887
                                                {
863
 
                                                        gboolean _tmp44_;
864
 
                                                        _tmp44_ = tracker_sparql_scanner_matches (self, begin, "REPLACE");
865
 
                                                        if (_tmp44_) {
 
888
                                                        gboolean _tmp46_;
 
889
                                                        _tmp46_ = tracker_sparql_scanner_matches (self, begin, "REPLACE");
 
890
                                                        if (_tmp46_) {
866
891
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_REPLACE;
867
892
                                                                return result;
868
893
                                                        }
876
901
                                case 'I':
877
902
                                case 'i':
878
903
                                {
879
 
                                        gboolean _tmp45_;
880
 
                                        _tmp45_ = tracker_sparql_scanner_matches (self, begin, "ISBLANK");
881
 
                                        if (_tmp45_) {
 
904
                                        gboolean _tmp47_;
 
905
                                        _tmp47_ = tracker_sparql_scanner_matches (self, begin, "ISBLANK");
 
906
                                        if (_tmp47_) {
882
907
                                                result = TRACKER_SPARQL_TOKEN_TYPE_ISBLANK;
883
908
                                                return result;
884
909
                                        }
892
917
                case 8:
893
918
                {
894
919
                        switch (begin[0]) {
 
920
                                case 'C':
 
921
                                case 'c':
 
922
                                {
 
923
                                        gboolean _tmp48_;
 
924
                                        _tmp48_ = tracker_sparql_scanner_matches (self, begin, "COALESCE");
 
925
                                        if (_tmp48_) {
 
926
                                                result = TRACKER_SPARQL_TOKEN_TYPE_COALESCE;
 
927
                                                return result;
 
928
                                        }
 
929
                                        break;
 
930
                                }
895
931
                                case 'D':
896
932
                                case 'd':
897
933
                                {
899
935
                                                case 'A':
900
936
                                                case 'a':
901
937
                                                {
902
 
                                                        gboolean _tmp46_;
903
 
                                                        _tmp46_ = tracker_sparql_scanner_matches (self, begin, "DATATYPE");
904
 
                                                        if (_tmp46_) {
 
938
                                                        gboolean _tmp49_;
 
939
                                                        _tmp49_ = tracker_sparql_scanner_matches (self, begin, "DATATYPE");
 
940
                                                        if (_tmp49_) {
905
941
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_DATATYPE;
906
942
                                                                return result;
907
943
                                                        }
910
946
                                                case 'E':
911
947
                                                case 'e':
912
948
                                                {
913
 
                                                        gboolean _tmp47_;
914
 
                                                        _tmp47_ = tracker_sparql_scanner_matches (self, begin, "DESCRIBE");
915
 
                                                        if (_tmp47_) {
 
949
                                                        gboolean _tmp50_;
 
950
                                                        _tmp50_ = tracker_sparql_scanner_matches (self, begin, "DESCRIBE");
 
951
                                                        if (_tmp50_) {
916
952
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_DESCRIBE;
917
953
                                                                return result;
918
954
                                                        }
921
957
                                                case 'I':
922
958
                                                case 'i':
923
959
                                                {
924
 
                                                        gboolean _tmp48_;
925
 
                                                        _tmp48_ = tracker_sparql_scanner_matches (self, begin, "DISTINCT");
926
 
                                                        if (_tmp48_) {
 
960
                                                        gboolean _tmp51_;
 
961
                                                        _tmp51_ = tracker_sparql_scanner_matches (self, begin, "DISTINCT");
 
962
                                                        if (_tmp51_) {
927
963
                                                                result = TRACKER_SPARQL_TOKEN_TYPE_DISTINCT;
928
964
                                                                return result;
929
965
                                                        }
937
973
                                case 'O':
938
974
                                case 'o':
939
975
                                {
940
 
                                        gboolean _tmp49_;
941
 
                                        _tmp49_ = tracker_sparql_scanner_matches (self, begin, "OPTIONAL");
942
 
                                        if (_tmp49_) {
 
976
                                        gboolean _tmp52_;
 
977
                                        _tmp52_ = tracker_sparql_scanner_matches (self, begin, "OPTIONAL");
 
978
                                        if (_tmp52_) {
943
979
                                                result = TRACKER_SPARQL_TOKEN_TYPE_OPTIONAL;
944
980
                                                return result;
945
981
                                        }
948
984
                                case 'S':
949
985
                                case 's':
950
986
                                {
951
 
                                        gboolean _tmp50_;
952
 
                                        _tmp50_ = tracker_sparql_scanner_matches (self, begin, "SAMETERM");
953
 
                                        if (_tmp50_) {
 
987
                                        gboolean _tmp53_;
 
988
                                        _tmp53_ = tracker_sparql_scanner_matches (self, begin, "SAMETERM");
 
989
                                        if (_tmp53_) {
954
990
                                                result = TRACKER_SPARQL_TOKEN_TYPE_SAMETERM;
955
991
                                                return result;
956
992
                                        }
967
1003
                                case 'C':
968
1004
                                case 'c':
969
1005
                                {
970
 
                                        gboolean _tmp51_;
971
 
                                        _tmp51_ = tracker_sparql_scanner_matches (self, begin, "CONSTRUCT");
972
 
                                        if (_tmp51_) {
 
1006
                                        gboolean _tmp54_;
 
1007
                                        _tmp54_ = tracker_sparql_scanner_matches (self, begin, "CONSTRUCT");
 
1008
                                        if (_tmp54_) {
973
1009
                                                result = TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT;
974
1010
                                                return result;
975
1011
                                        }
978
1014
                                case 'I':
979
1015
                                case 'i':
980
1016
                                {
981
 
                                        gboolean _tmp52_;
982
 
                                        _tmp52_ = tracker_sparql_scanner_matches (self, begin, "ISLITERAL");
983
 
                                        if (_tmp52_) {
 
1017
                                        gboolean _tmp55_;
 
1018
                                        _tmp55_ = tracker_sparql_scanner_matches (self, begin, "ISLITERAL");
 
1019
                                        if (_tmp55_) {
984
1020
                                                result = TRACKER_SPARQL_TOKEN_TYPE_ISLITERAL;
985
1021
                                                return result;
986
1022
                                        }
993
1029
                }
994
1030
                case 11:
995
1031
                {
996
 
                        gboolean _tmp53_;
997
 
                        _tmp53_ = tracker_sparql_scanner_matches (self, begin, "LANGMATCHES");
998
 
                        if (_tmp53_) {
 
1032
                        gboolean _tmp56_;
 
1033
                        _tmp56_ = tracker_sparql_scanner_matches (self, begin, "LANGMATCHES");
 
1034
                        if (_tmp56_) {
999
1035
                                result = TRACKER_SPARQL_TOKEN_TYPE_LANGMATCHES;
1000
1036
                                return result;
1001
1037
                        }
1003
1039
                }
1004
1040
                case 12:
1005
1041
                {
1006
 
                        gboolean _tmp54_;
1007
 
                        _tmp54_ = tracker_sparql_scanner_matches (self, begin, "GROUP_CONCAT");
1008
 
                        if (_tmp54_) {
 
1042
                        gboolean _tmp57_;
 
1043
                        _tmp57_ = tracker_sparql_scanner_matches (self, begin, "GROUP_CONCAT");
 
1044
                        if (_tmp57_) {
1009
1045
                                result = TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT;
1010
1046
                                return result;
1011
1047
                        }
2233
2269
                        result = "`)'";
2234
2270
                        return result;
2235
2271
                }
 
2272
                case TRACKER_SPARQL_TOKEN_TYPE_COALESCE:
 
2273
                {
 
2274
                        result = "`COALESCE'";
 
2275
                        return result;
 
2276
                }
2236
2277
                case TRACKER_SPARQL_TOKEN_TYPE_COLON:
2237
2278
                {
2238
2279
                        result = "`:'";
2338
2379
                        result = "`GROUP_CONCAT'";
2339
2380
                        return result;
2340
2381
                }
 
2382
                case TRACKER_SPARQL_TOKEN_TYPE_HAVING:
 
2383
                {
 
2384
                        result = "`HAVING'";
 
2385
                        return result;
 
2386
                }
2341
2387
                case TRACKER_SPARQL_TOKEN_TYPE_IF:
2342
2388
                {
2343
2389
                        result = "`IF'";
2630
2676
GType tracker_sparql_token_type_get_type (void) {
2631
2677
        static volatile gsize tracker_sparql_token_type_type_id__volatile = 0;
2632
2678
        if (g_once_init_enter (&tracker_sparql_token_type_type_id__volatile)) {
2633
 
                static const GEnumValue values[] = {{TRACKER_SPARQL_TOKEN_TYPE_NONE, "TRACKER_SPARQL_TOKEN_TYPE_NONE", "none"}, {TRACKER_SPARQL_TOKEN_TYPE_A, "TRACKER_SPARQL_TOKEN_TYPE_A", "a"}, {TRACKER_SPARQL_TOKEN_TYPE_AS, "TRACKER_SPARQL_TOKEN_TYPE_AS", "as"}, {TRACKER_SPARQL_TOKEN_TYPE_ASC, "TRACKER_SPARQL_TOKEN_TYPE_ASC", "asc"}, {TRACKER_SPARQL_TOKEN_TYPE_ASK, "TRACKER_SPARQL_TOKEN_TYPE_ASK", "ask"}, {TRACKER_SPARQL_TOKEN_TYPE_ATBASE, "TRACKER_SPARQL_TOKEN_TYPE_ATBASE", "atbase"}, {TRACKER_SPARQL_TOKEN_TYPE_ATPREFIX, "TRACKER_SPARQL_TOKEN_TYPE_ATPREFIX", "atprefix"}, {TRACKER_SPARQL_TOKEN_TYPE_AVG, "TRACKER_SPARQL_TOKEN_TYPE_AVG", "avg"}, {TRACKER_SPARQL_TOKEN_TYPE_BASE, "TRACKER_SPARQL_TOKEN_TYPE_BASE", "base"}, {TRACKER_SPARQL_TOKEN_TYPE_BLANK_NODE, "TRACKER_SPARQL_TOKEN_TYPE_BLANK_NODE", "blank-node"}, {TRACKER_SPARQL_TOKEN_TYPE_BOUND, "TRACKER_SPARQL_TOKEN_TYPE_BOUND", "bound"}, {TRACKER_SPARQL_TOKEN_TYPE_BY, "TRACKER_SPARQL_TOKEN_TYPE_BY", "by"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACE, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACE", "close-brace"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACKET, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACKET", "close-bracket"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_PARENS, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_PARENS", "close-parens"}, {TRACKER_SPARQL_TOKEN_TYPE_COLON, "TRACKER_SPARQL_TOKEN_TYPE_COLON", "colon"}, {TRACKER_SPARQL_TOKEN_TYPE_COMMA, "TRACKER_SPARQL_TOKEN_TYPE_COMMA", "comma"}, {TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT, "TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT", "construct"}, {TRACKER_SPARQL_TOKEN_TYPE_COUNT, "TRACKER_SPARQL_TOKEN_TYPE_COUNT", "count"}, {TRACKER_SPARQL_TOKEN_TYPE_DATA, "TRACKER_SPARQL_TOKEN_TYPE_DATA", "data"}, {TRACKER_SPARQL_TOKEN_TYPE_DATATYPE, "TRACKER_SPARQL_TOKEN_TYPE_DATATYPE", "datatype"}, {TRACKER_SPARQL_TOKEN_TYPE_DECIMAL, "TRACKER_SPARQL_TOKEN_TYPE_DECIMAL", "decimal"}, {TRACKER_SPARQL_TOKEN_TYPE_DELETE, "TRACKER_SPARQL_TOKEN_TYPE_DELETE", "delete"}, {TRACKER_SPARQL_TOKEN_TYPE_DESC, "TRACKER_SPARQL_TOKEN_TYPE_DESC", "desc"}, {TRACKER_SPARQL_TOKEN_TYPE_DESCRIBE, "TRACKER_SPARQL_TOKEN_TYPE_DESCRIBE", "describe"}, {TRACKER_SPARQL_TOKEN_TYPE_DISTINCT, "TRACKER_SPARQL_TOKEN_TYPE_DISTINCT", "distinct"}, {TRACKER_SPARQL_TOKEN_TYPE_DIV, "TRACKER_SPARQL_TOKEN_TYPE_DIV", "div"}, {TRACKER_SPARQL_TOKEN_TYPE_DOT, "TRACKER_SPARQL_TOKEN_TYPE_DOT", "dot"}, {TRACKER_SPARQL_TOKEN_TYPE_DOUBLE, "TRACKER_SPARQL_TOKEN_TYPE_DOUBLE", "double"}, {TRACKER_SPARQL_TOKEN_TYPE_DOUBLE_CIRCUMFLEX, "TRACKER_SPARQL_TOKEN_TYPE_DOUBLE_CIRCUMFLEX", "double-circumflex"}, {TRACKER_SPARQL_TOKEN_TYPE_DROP, "TRACKER_SPARQL_TOKEN_TYPE_DROP", "drop"}, {TRACKER_SPARQL_TOKEN_TYPE_EOF, "TRACKER_SPARQL_TOKEN_TYPE_EOF", "eof"}, {TRACKER_SPARQL_TOKEN_TYPE_EXISTS, "TRACKER_SPARQL_TOKEN_TYPE_EXISTS", "exists"}, {TRACKER_SPARQL_TOKEN_TYPE_FALSE, "TRACKER_SPARQL_TOKEN_TYPE_FALSE", "false"}, {TRACKER_SPARQL_TOKEN_TYPE_FILTER, "TRACKER_SPARQL_TOKEN_TYPE_FILTER", "filter"}, {TRACKER_SPARQL_TOKEN_TYPE_FROM, "TRACKER_SPARQL_TOKEN_TYPE_FROM", "from"}, {TRACKER_SPARQL_TOKEN_TYPE_GRAPH, "TRACKER_SPARQL_TOKEN_TYPE_GRAPH", "graph"}, {TRACKER_SPARQL_TOKEN_TYPE_GROUP, "TRACKER_SPARQL_TOKEN_TYPE_GROUP", "group"}, {TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT, "TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT", "group-concat"}, {TRACKER_SPARQL_TOKEN_TYPE_IF, "TRACKER_SPARQL_TOKEN_TYPE_IF", "if"}, {TRACKER_SPARQL_TOKEN_TYPE_INSERT, "TRACKER_SPARQL_TOKEN_TYPE_INSERT", "insert"}, {TRACKER_SPARQL_TOKEN_TYPE_INTEGER, "TRACKER_SPARQL_TOKEN_TYPE_INTEGER", "integer"}, {TRACKER_SPARQL_TOKEN_TYPE_INTO, "TRACKER_SPARQL_TOKEN_TYPE_INTO", "into"}, {TRACKER_SPARQL_TOKEN_TYPE_IRI_REF, "TRACKER_SPARQL_TOKEN_TYPE_IRI_REF", "iri-ref"}, {TRACKER_SPARQL_TOKEN_TYPE_ISBLANK, "TRACKER_SPARQL_TOKEN_TYPE_ISBLANK", "isblank"}, {TRACKER_SPARQL_TOKEN_TYPE_ISIRI, "TRACKER_SPARQL_TOKEN_TYPE_ISIRI", "isiri"}, {TRACKER_SPARQL_TOKEN_TYPE_ISLITERAL, "TRACKER_SPARQL_TOKEN_TYPE_ISLITERAL", "isliteral"}, {TRACKER_SPARQL_TOKEN_TYPE_ISURI, "TRACKER_SPARQL_TOKEN_TYPE_ISURI", "isuri"}, {TRACKER_SPARQL_TOKEN_TYPE_LANG, "TRACKER_SPARQL_TOKEN_TYPE_LANG", "lang"}, {TRACKER_SPARQL_TOKEN_TYPE_LANGMATCHES, "TRACKER_SPARQL_TOKEN_TYPE_LANGMATCHES", "langmatches"}, {TRACKER_SPARQL_TOKEN_TYPE_LIMIT, "TRACKER_SPARQL_TOKEN_TYPE_LIMIT", "limit"}, {TRACKER_SPARQL_TOKEN_TYPE_MAX, "TRACKER_SPARQL_TOKEN_TYPE_MAX", "max"}, {TRACKER_SPARQL_TOKEN_TYPE_MIN, "TRACKER_SPARQL_TOKEN_TYPE_MIN", "min"}, {TRACKER_SPARQL_TOKEN_TYPE_MINUS, "TRACKER_SPARQL_TOKEN_TYPE_MINUS", "minus"}, {TRACKER_SPARQL_TOKEN_TYPE_NAMED, "TRACKER_SPARQL_TOKEN_TYPE_NAMED", "named"}, {TRACKER_SPARQL_TOKEN_TYPE_NOT, "TRACKER_SPARQL_TOKEN_TYPE_NOT", "not"}, {TRACKER_SPARQL_TOKEN_TYPE_OFFSET, "TRACKER_SPARQL_TOKEN_TYPE_OFFSET", "offset"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_AND, "TRACKER_SPARQL_TOKEN_TYPE_OP_AND", "op-and"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_EQ, "TRACKER_SPARQL_TOKEN_TYPE_OP_EQ", "op-eq"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_GE, "TRACKER_SPARQL_TOKEN_TYPE_OP_GE", "op-ge"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_GT, "TRACKER_SPARQL_TOKEN_TYPE_OP_GT", "op-gt"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_LE, "TRACKER_SPARQL_TOKEN_TYPE_OP_LE", "op-le"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_LT, "TRACKER_SPARQL_TOKEN_TYPE_OP_LT", "op-lt"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_NE, "TRACKER_SPARQL_TOKEN_TYPE_OP_NE", "op-ne"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_NEG, "TRACKER_SPARQL_TOKEN_TYPE_OP_NEG", "op-neg"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_OR, "TRACKER_SPARQL_TOKEN_TYPE_OP_OR", "op-or"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_IN, "TRACKER_SPARQL_TOKEN_TYPE_OP_IN", "op-in"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACE, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACE", "open-brace"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACKET, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACKET", "open-bracket"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_PARENS, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_PARENS", "open-parens"}, {TRACKER_SPARQL_TOKEN_TYPE_OPTIONAL, "TRACKER_SPARQL_TOKEN_TYPE_OPTIONAL", "optional"}, {TRACKER_SPARQL_TOKEN_TYPE_OR, "TRACKER_SPARQL_TOKEN_TYPE_OR", "or"}, {TRACKER_SPARQL_TOKEN_TYPE_ORDER, "TRACKER_SPARQL_TOKEN_TYPE_ORDER", "order"}, {TRACKER_SPARQL_TOKEN_TYPE_PLUS, "TRACKER_SPARQL_TOKEN_TYPE_PLUS", "plus"}, {TRACKER_SPARQL_TOKEN_TYPE_PN_PREFIX, "TRACKER_SPARQL_TOKEN_TYPE_PN_PREFIX", "pn-prefix"}, {TRACKER_SPARQL_TOKEN_TYPE_PREFIX, "TRACKER_SPARQL_TOKEN_TYPE_PREFIX", "prefix"}, {TRACKER_SPARQL_TOKEN_TYPE_REDUCED, "TRACKER_SPARQL_TOKEN_TYPE_REDUCED", "reduced"}, {TRACKER_SPARQL_TOKEN_TYPE_REGEX, "TRACKER_SPARQL_TOKEN_TYPE_REGEX", "regex"}, {TRACKER_SPARQL_TOKEN_TYPE_REPLACE, "TRACKER_SPARQL_TOKEN_TYPE_REPLACE", "replace"}, {TRACKER_SPARQL_TOKEN_TYPE_SAMETERM, "TRACKER_SPARQL_TOKEN_TYPE_SAMETERM", "sameterm"}, {TRACKER_SPARQL_TOKEN_TYPE_SELECT, "TRACKER_SPARQL_TOKEN_TYPE_SELECT", "select"}, {TRACKER_SPARQL_TOKEN_TYPE_SEMICOLON, "TRACKER_SPARQL_TOKEN_TYPE_SEMICOLON", "semicolon"}, {TRACKER_SPARQL_TOKEN_TYPE_SILENT, "TRACKER_SPARQL_TOKEN_TYPE_SILENT", "silent"}, {TRACKER_SPARQL_TOKEN_TYPE_STAR, "TRACKER_SPARQL_TOKEN_TYPE_STAR", "star"}, {TRACKER_SPARQL_TOKEN_TYPE_STR, "TRACKER_SPARQL_TOKEN_TYPE_STR", "str"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL1, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL1", "string-literal1"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL2, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL2", "string-literal2"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG1, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG1", "string-literal-long1"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG2, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG2", "string-literal-long2"}, {TRACKER_SPARQL_TOKEN_TYPE_SUM, "TRACKER_SPARQL_TOKEN_TYPE_SUM", "sum"}, {TRACKER_SPARQL_TOKEN_TYPE_TRUE, "TRACKER_SPARQL_TOKEN_TYPE_TRUE", "true"}, {TRACKER_SPARQL_TOKEN_TYPE_UNION, "TRACKER_SPARQL_TOKEN_TYPE_UNION", "union"}, {TRACKER_SPARQL_TOKEN_TYPE_VAR, "TRACKER_SPARQL_TOKEN_TYPE_VAR", "var"}, {TRACKER_SPARQL_TOKEN_TYPE_WHERE, "TRACKER_SPARQL_TOKEN_TYPE_WHERE", "where"}, {TRACKER_SPARQL_TOKEN_TYPE_WITH, "TRACKER_SPARQL_TOKEN_TYPE_WITH", "with"}, {0, NULL, NULL}};
 
2679
                static const GEnumValue values[] = {{TRACKER_SPARQL_TOKEN_TYPE_NONE, "TRACKER_SPARQL_TOKEN_TYPE_NONE", "none"}, {TRACKER_SPARQL_TOKEN_TYPE_A, "TRACKER_SPARQL_TOKEN_TYPE_A", "a"}, {TRACKER_SPARQL_TOKEN_TYPE_AS, "TRACKER_SPARQL_TOKEN_TYPE_AS", "as"}, {TRACKER_SPARQL_TOKEN_TYPE_ASC, "TRACKER_SPARQL_TOKEN_TYPE_ASC", "asc"}, {TRACKER_SPARQL_TOKEN_TYPE_ASK, "TRACKER_SPARQL_TOKEN_TYPE_ASK", "ask"}, {TRACKER_SPARQL_TOKEN_TYPE_ATBASE, "TRACKER_SPARQL_TOKEN_TYPE_ATBASE", "atbase"}, {TRACKER_SPARQL_TOKEN_TYPE_ATPREFIX, "TRACKER_SPARQL_TOKEN_TYPE_ATPREFIX", "atprefix"}, {TRACKER_SPARQL_TOKEN_TYPE_AVG, "TRACKER_SPARQL_TOKEN_TYPE_AVG", "avg"}, {TRACKER_SPARQL_TOKEN_TYPE_BASE, "TRACKER_SPARQL_TOKEN_TYPE_BASE", "base"}, {TRACKER_SPARQL_TOKEN_TYPE_BLANK_NODE, "TRACKER_SPARQL_TOKEN_TYPE_BLANK_NODE", "blank-node"}, {TRACKER_SPARQL_TOKEN_TYPE_BOUND, "TRACKER_SPARQL_TOKEN_TYPE_BOUND", "bound"}, {TRACKER_SPARQL_TOKEN_TYPE_BY, "TRACKER_SPARQL_TOKEN_TYPE_BY", "by"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACE, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACE", "close-brace"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACKET, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_BRACKET", "close-bracket"}, {TRACKER_SPARQL_TOKEN_TYPE_CLOSE_PARENS, "TRACKER_SPARQL_TOKEN_TYPE_CLOSE_PARENS", "close-parens"}, {TRACKER_SPARQL_TOKEN_TYPE_COALESCE, "TRACKER_SPARQL_TOKEN_TYPE_COALESCE", "coalesce"}, {TRACKER_SPARQL_TOKEN_TYPE_COLON, "TRACKER_SPARQL_TOKEN_TYPE_COLON", "colon"}, {TRACKER_SPARQL_TOKEN_TYPE_COMMA, "TRACKER_SPARQL_TOKEN_TYPE_COMMA", "comma"}, {TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT, "TRACKER_SPARQL_TOKEN_TYPE_CONSTRUCT", "construct"}, {TRACKER_SPARQL_TOKEN_TYPE_COUNT, "TRACKER_SPARQL_TOKEN_TYPE_COUNT", "count"}, {TRACKER_SPARQL_TOKEN_TYPE_DATA, "TRACKER_SPARQL_TOKEN_TYPE_DATA", "data"}, {TRACKER_SPARQL_TOKEN_TYPE_DATATYPE, "TRACKER_SPARQL_TOKEN_TYPE_DATATYPE", "datatype"}, {TRACKER_SPARQL_TOKEN_TYPE_DECIMAL, "TRACKER_SPARQL_TOKEN_TYPE_DECIMAL", "decimal"}, {TRACKER_SPARQL_TOKEN_TYPE_DELETE, "TRACKER_SPARQL_TOKEN_TYPE_DELETE", "delete"}, {TRACKER_SPARQL_TOKEN_TYPE_DESC, "TRACKER_SPARQL_TOKEN_TYPE_DESC", "desc"}, {TRACKER_SPARQL_TOKEN_TYPE_DESCRIBE, "TRACKER_SPARQL_TOKEN_TYPE_DESCRIBE", "describe"}, {TRACKER_SPARQL_TOKEN_TYPE_DISTINCT, "TRACKER_SPARQL_TOKEN_TYPE_DISTINCT", "distinct"}, {TRACKER_SPARQL_TOKEN_TYPE_DIV, "TRACKER_SPARQL_TOKEN_TYPE_DIV", "div"}, {TRACKER_SPARQL_TOKEN_TYPE_DOT, "TRACKER_SPARQL_TOKEN_TYPE_DOT", "dot"}, {TRACKER_SPARQL_TOKEN_TYPE_DOUBLE, "TRACKER_SPARQL_TOKEN_TYPE_DOUBLE", "double"}, {TRACKER_SPARQL_TOKEN_TYPE_DOUBLE_CIRCUMFLEX, "TRACKER_SPARQL_TOKEN_TYPE_DOUBLE_CIRCUMFLEX", "double-circumflex"}, {TRACKER_SPARQL_TOKEN_TYPE_DROP, "TRACKER_SPARQL_TOKEN_TYPE_DROP", "drop"}, {TRACKER_SPARQL_TOKEN_TYPE_EOF, "TRACKER_SPARQL_TOKEN_TYPE_EOF", "eof"}, {TRACKER_SPARQL_TOKEN_TYPE_EXISTS, "TRACKER_SPARQL_TOKEN_TYPE_EXISTS", "exists"}, {TRACKER_SPARQL_TOKEN_TYPE_FALSE, "TRACKER_SPARQL_TOKEN_TYPE_FALSE", "false"}, {TRACKER_SPARQL_TOKEN_TYPE_FILTER, "TRACKER_SPARQL_TOKEN_TYPE_FILTER", "filter"}, {TRACKER_SPARQL_TOKEN_TYPE_FROM, "TRACKER_SPARQL_TOKEN_TYPE_FROM", "from"}, {TRACKER_SPARQL_TOKEN_TYPE_GRAPH, "TRACKER_SPARQL_TOKEN_TYPE_GRAPH", "graph"}, {TRACKER_SPARQL_TOKEN_TYPE_GROUP, "TRACKER_SPARQL_TOKEN_TYPE_GROUP", "group"}, {TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT, "TRACKER_SPARQL_TOKEN_TYPE_GROUP_CONCAT", "group-concat"}, {TRACKER_SPARQL_TOKEN_TYPE_HAVING, "TRACKER_SPARQL_TOKEN_TYPE_HAVING", "having"}, {TRACKER_SPARQL_TOKEN_TYPE_IF, "TRACKER_SPARQL_TOKEN_TYPE_IF", "if"}, {TRACKER_SPARQL_TOKEN_TYPE_INSERT, "TRACKER_SPARQL_TOKEN_TYPE_INSERT", "insert"}, {TRACKER_SPARQL_TOKEN_TYPE_INTEGER, "TRACKER_SPARQL_TOKEN_TYPE_INTEGER", "integer"}, {TRACKER_SPARQL_TOKEN_TYPE_INTO, "TRACKER_SPARQL_TOKEN_TYPE_INTO", "into"}, {TRACKER_SPARQL_TOKEN_TYPE_IRI_REF, "TRACKER_SPARQL_TOKEN_TYPE_IRI_REF", "iri-ref"}, {TRACKER_SPARQL_TOKEN_TYPE_ISBLANK, "TRACKER_SPARQL_TOKEN_TYPE_ISBLANK", "isblank"}, {TRACKER_SPARQL_TOKEN_TYPE_ISIRI, "TRACKER_SPARQL_TOKEN_TYPE_ISIRI", "isiri"}, {TRACKER_SPARQL_TOKEN_TYPE_ISLITERAL, "TRACKER_SPARQL_TOKEN_TYPE_ISLITERAL", "isliteral"}, {TRACKER_SPARQL_TOKEN_TYPE_ISURI, "TRACKER_SPARQL_TOKEN_TYPE_ISURI", "isuri"}, {TRACKER_SPARQL_TOKEN_TYPE_LANG, "TRACKER_SPARQL_TOKEN_TYPE_LANG", "lang"}, {TRACKER_SPARQL_TOKEN_TYPE_LANGMATCHES, "TRACKER_SPARQL_TOKEN_TYPE_LANGMATCHES", "langmatches"}, {TRACKER_SPARQL_TOKEN_TYPE_LIMIT, "TRACKER_SPARQL_TOKEN_TYPE_LIMIT", "limit"}, {TRACKER_SPARQL_TOKEN_TYPE_MAX, "TRACKER_SPARQL_TOKEN_TYPE_MAX", "max"}, {TRACKER_SPARQL_TOKEN_TYPE_MIN, "TRACKER_SPARQL_TOKEN_TYPE_MIN", "min"}, {TRACKER_SPARQL_TOKEN_TYPE_MINUS, "TRACKER_SPARQL_TOKEN_TYPE_MINUS", "minus"}, {TRACKER_SPARQL_TOKEN_TYPE_NAMED, "TRACKER_SPARQL_TOKEN_TYPE_NAMED", "named"}, {TRACKER_SPARQL_TOKEN_TYPE_NOT, "TRACKER_SPARQL_TOKEN_TYPE_NOT", "not"}, {TRACKER_SPARQL_TOKEN_TYPE_NULL, "TRACKER_SPARQL_TOKEN_TYPE_NULL", "null"}, {TRACKER_SPARQL_TOKEN_TYPE_OFFSET, "TRACKER_SPARQL_TOKEN_TYPE_OFFSET", "offset"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_AND, "TRACKER_SPARQL_TOKEN_TYPE_OP_AND", "op-and"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_EQ, "TRACKER_SPARQL_TOKEN_TYPE_OP_EQ", "op-eq"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_GE, "TRACKER_SPARQL_TOKEN_TYPE_OP_GE", "op-ge"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_GT, "TRACKER_SPARQL_TOKEN_TYPE_OP_GT", "op-gt"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_LE, "TRACKER_SPARQL_TOKEN_TYPE_OP_LE", "op-le"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_LT, "TRACKER_SPARQL_TOKEN_TYPE_OP_LT", "op-lt"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_NE, "TRACKER_SPARQL_TOKEN_TYPE_OP_NE", "op-ne"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_NEG, "TRACKER_SPARQL_TOKEN_TYPE_OP_NEG", "op-neg"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_OR, "TRACKER_SPARQL_TOKEN_TYPE_OP_OR", "op-or"}, {TRACKER_SPARQL_TOKEN_TYPE_OP_IN, "TRACKER_SPARQL_TOKEN_TYPE_OP_IN", "op-in"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACE, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACE", "open-brace"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACKET, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_BRACKET", "open-bracket"}, {TRACKER_SPARQL_TOKEN_TYPE_OPEN_PARENS, "TRACKER_SPARQL_TOKEN_TYPE_OPEN_PARENS", "open-parens"}, {TRACKER_SPARQL_TOKEN_TYPE_OPTIONAL, "TRACKER_SPARQL_TOKEN_TYPE_OPTIONAL", "optional"}, {TRACKER_SPARQL_TOKEN_TYPE_OR, "TRACKER_SPARQL_TOKEN_TYPE_OR", "or"}, {TRACKER_SPARQL_TOKEN_TYPE_ORDER, "TRACKER_SPARQL_TOKEN_TYPE_ORDER", "order"}, {TRACKER_SPARQL_TOKEN_TYPE_PLUS, "TRACKER_SPARQL_TOKEN_TYPE_PLUS", "plus"}, {TRACKER_SPARQL_TOKEN_TYPE_PN_PREFIX, "TRACKER_SPARQL_TOKEN_TYPE_PN_PREFIX", "pn-prefix"}, {TRACKER_SPARQL_TOKEN_TYPE_PREFIX, "TRACKER_SPARQL_TOKEN_TYPE_PREFIX", "prefix"}, {TRACKER_SPARQL_TOKEN_TYPE_REDUCED, "TRACKER_SPARQL_TOKEN_TYPE_REDUCED", "reduced"}, {TRACKER_SPARQL_TOKEN_TYPE_REGEX, "TRACKER_SPARQL_TOKEN_TYPE_REGEX", "regex"}, {TRACKER_SPARQL_TOKEN_TYPE_REPLACE, "TRACKER_SPARQL_TOKEN_TYPE_REPLACE", "replace"}, {TRACKER_SPARQL_TOKEN_TYPE_SAMETERM, "TRACKER_SPARQL_TOKEN_TYPE_SAMETERM", "sameterm"}, {TRACKER_SPARQL_TOKEN_TYPE_SELECT, "TRACKER_SPARQL_TOKEN_TYPE_SELECT", "select"}, {TRACKER_SPARQL_TOKEN_TYPE_SEMICOLON, "TRACKER_SPARQL_TOKEN_TYPE_SEMICOLON", "semicolon"}, {TRACKER_SPARQL_TOKEN_TYPE_SILENT, "TRACKER_SPARQL_TOKEN_TYPE_SILENT", "silent"}, {TRACKER_SPARQL_TOKEN_TYPE_STAR, "TRACKER_SPARQL_TOKEN_TYPE_STAR", "star"}, {TRACKER_SPARQL_TOKEN_TYPE_STR, "TRACKER_SPARQL_TOKEN_TYPE_STR", "str"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL1, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL1", "string-literal1"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL2, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL2", "string-literal2"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG1, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG1", "string-literal-long1"}, {TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG2, "TRACKER_SPARQL_TOKEN_TYPE_STRING_LITERAL_LONG2", "string-literal-long2"}, {TRACKER_SPARQL_TOKEN_TYPE_SUM, "TRACKER_SPARQL_TOKEN_TYPE_SUM", "sum"}, {TRACKER_SPARQL_TOKEN_TYPE_TRUE, "TRACKER_SPARQL_TOKEN_TYPE_TRUE", "true"}, {TRACKER_SPARQL_TOKEN_TYPE_UNION, "TRACKER_SPARQL_TOKEN_TYPE_UNION", "union"}, {TRACKER_SPARQL_TOKEN_TYPE_VAR, "TRACKER_SPARQL_TOKEN_TYPE_VAR", "var"}, {TRACKER_SPARQL_TOKEN_TYPE_WHERE, "TRACKER_SPARQL_TOKEN_TYPE_WHERE", "where"}, {TRACKER_SPARQL_TOKEN_TYPE_WITH, "TRACKER_SPARQL_TOKEN_TYPE_WITH", "with"}, {0, NULL, NULL}};
2634
2680
                GType tracker_sparql_token_type_type_id;
2635
2681
                tracker_sparql_token_type_type_id = g_enum_register_static ("TrackerSparqlTokenType", values);
2636
2682
                g_once_init_leave (&tracker_sparql_token_type_type_id__volatile, tracker_sparql_token_type_type_id);