LLVMFuzzerTestOneInput: 21| 5.50k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 22| 5.50k| std::string input(reinterpret_cast(data), size); 23| 5.50k| SQLParserResult res; 24| 5.50k| SQLParser::parse(input, &res); 25| 5.50k| return 0; 26| 5.50k|} _ZN4hsql9SQLParser5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15SQLParserResultE: 13| 5.50k|bool SQLParser::parse(const std::string& sql, SQLParserResult* result) { 14| 5.50k| yyscan_t scanner; 15| 5.50k| YY_BUFFER_STATE state; 16| | 17| 5.50k| if (hsql_lex_init(&scanner)) { ------------------ | Branch (17:7): [True: 0, False: 5.50k] ------------------ 18| | // Couldn't initialize the lexer. 19| 0| fprintf(stderr, "SQLParser: Error when initializing lexer!\n"); 20| 0| return false; 21| 0| } 22| 5.50k| const char* text = sql.c_str(); 23| 5.50k| state = hsql__scan_string(text, scanner); 24| | 25| | // Parse the tokens. 26| | // If parsing fails, the result will contain an error object. 27| 5.50k| int ret = hsql_parse(result, scanner); 28| 5.50k| bool success = (ret == 0); 29| 5.50k| result->setIsValid(success); 30| | 31| 5.50k| hsql__delete_buffer(state, scanner); 32| 5.50k| hsql_lex_destroy(scanner); 33| | 34| 5.50k| return true; 35| 5.50k|} _ZN4hsql15SQLParserResultC2Ev: 7| 5.50k|SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) {} _ZN4hsql15SQLParserResultD2Ev: 24| 5.50k|SQLParserResult::~SQLParserResult() { reset(); } _ZN4hsql15SQLParserResult12addStatementEPNS_12SQLStatementE: 26| 44.4k|void SQLParserResult::addStatement(SQLStatement* stmt) { statements_.push_back(stmt); } _ZNK4hsql15SQLParserResult8errorMsgEv: 36| 4.56k|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 11.1k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.61k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.61k| errorMsg_ = errorMsg; 46| 5.61k| errorLine_ = errorLine; 47| 5.61k| errorColumn_ = errorColumn; 48| 5.61k|} _ZN4hsql15SQLParserResult5resetEv: 60| 5.50k|void SQLParserResult::reset() { 61| 44.4k| for (SQLStatement* statement : statements_) { ------------------ | Branch (61:32): [True: 44.4k, False: 5.50k] ------------------ 62| 44.4k| delete statement; 63| 44.4k| } 64| 5.50k| statements_.clear(); 65| | 66| 5.50k| isValid_ = false; 67| | 68| 5.50k| free(errorMsg_); 69| 5.50k| errorMsg_ = nullptr; 70| 5.50k| errorLine_ = -1; 71| 5.50k| errorColumn_ = -1; 72| 5.50k|} _ZN4hsql15SQLParserResult12addParameterEPNS_4ExprE: 75| 123k|void SQLParserResult::addParameter(Expr* parameter) { 76| 123k| parameters_.push_back(parameter); 77| 123k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 123k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 892M| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 97| 5.61k| int yyerror(YYLTYPE * llocp, SQLParserResult * result, yyscan_t scanner, const char* msg) { 98| 5.61k| result->setIsValid(false); 99| 5.61k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 100| 5.61k| return 0; 101| 5.61k| } _Z10hsql_parsePN4hsql15SQLParserResultEPv: 2886| 5.50k|{ 2887| |/* The lookahead symbol. */ 2888| 5.50k|int yychar; 2889| | 2890| | 2891| |/* The semantic value of the lookahead symbol. */ 2892| |/* Default value used for initialization, for pacifying older GCCs 2893| | or non-GCC compilers. */ 2894| 5.50k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 564| 5.50k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2895| 5.50k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 11| 5.50k|#define YYSTYPE HSQL_STYPE ------------------ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 564| 5.50k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2896| | 2897| |/* Location data for the lookahead symbol. */ 2898| 5.50k|static YYLTYPE yyloc_default 2899| |# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL 2900| | = { 1, 1, 1, 1 } 2901| |# endif 2902| 5.50k|; 2903| 5.50k|YYLTYPE yylloc = yyloc_default; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2904| | 2905| | /* Number of syntax errors so far. */ 2906| 5.50k| int yynerrs; 2907| | 2908| 5.50k| int yystate; 2909| | /* Number of tokens to shift before error messages enabled. */ 2910| 5.50k| int yyerrstatus; 2911| | 2912| | /* The stacks and their tools: 2913| | 'yyss': related to states. 2914| | 'yyvs': related to semantic values. 2915| | 'yyls': related to locations. 2916| | 2917| | Refer to the stacks through separate pointers, to allow yyoverflow 2918| | to reallocate them elsewhere. */ 2919| | 2920| | /* The state stack. */ 2921| 5.50k| yytype_int16 yyssa[YYINITDEPTH]; 2922| 5.50k| yytype_int16 *yyss; 2923| 5.50k| yytype_int16 *yyssp; 2924| | 2925| | /* The semantic value stack. */ 2926| 5.50k| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 11| 5.50k|#define YYSTYPE HSQL_STYPE ------------------ 2927| 5.50k| YYSTYPE *yyvs; ------------------ | | 11| 5.50k|#define YYSTYPE HSQL_STYPE ------------------ 2928| 5.50k| YYSTYPE *yyvsp; ------------------ | | 11| 5.50k|#define YYSTYPE HSQL_STYPE ------------------ 2929| | 2930| | /* The location stack. */ 2931| 5.50k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2932| 5.50k| YYLTYPE *yyls; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2933| 5.50k| YYLTYPE *yylsp; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2934| | 2935| | /* The locations where the error started and ended. */ 2936| 5.50k| YYLTYPE yyerror_range[3]; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2937| | 2938| 5.50k| YYSIZE_T yystacksize; ------------------ | | 496| 5.50k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2939| | 2940| 5.50k| int yyn; 2941| 5.50k| int yyresult; 2942| | /* Lookahead token as an internal (translated) token number. */ 2943| 5.50k| int yytoken = 0; 2944| | /* The variables used to return semantic value and location from the 2945| | action routines. */ 2946| 5.50k| YYSTYPE yyval; ------------------ | | 11| 5.50k|#define YYSTYPE HSQL_STYPE ------------------ 2947| 5.50k| YYLTYPE yyloc; ------------------ | | 12| 5.50k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.50k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2948| | 2949| 5.50k|#if YYERROR_VERBOSE 2950| | /* Buffer for error messages, and its allocated size. */ 2951| 5.50k| char yymsgbuf[128]; 2952| 5.50k| char *yymsg = yymsgbuf; 2953| 5.50k| YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 496| 5.50k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2954| 5.50k|#endif 2955| | 2956| 5.50k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 2957| | 2958| | /* The number of symbols on the RHS of the reduced rule. 2959| | Keep to zero when no symbol should be popped. */ 2960| 5.50k| int yylen = 0; 2961| | 2962| 5.50k| yyssp = yyss = yyssa; 2963| 5.50k| yyvsp = yyvs = yyvsa; 2964| 5.50k| yylsp = yyls = yylsa; 2965| 5.50k| yystacksize = YYINITDEPTH; ------------------ | | 1688| 5.50k|# define YYINITDEPTH 200 ------------------ 2966| | 2967| 5.50k| YYDPRINTF ((stderr, "Starting parse\n")); 2968| | 2969| 5.50k| yystate = 0; 2970| 5.50k| yyerrstatus = 0; 2971| 5.50k| yynerrs = 0; ------------------ | | 69| 5.50k|#define yynerrs hsql_nerrs ------------------ 2972| 5.50k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 1453| 5.50k|#define YYEMPTY (-2) ------------------ 2973| | 2974| |/* User initialization code. */ 2975| 5.50k|#line 81 "bison_parser.y" /* yacc.c:1429 */ 2976| 5.50k|{ 2977| | // Initialize 2978| 5.50k| yylloc.first_column = 0; 2979| 5.50k| yylloc.last_column = 0; 2980| 5.50k| yylloc.first_line = 0; 2981| 5.50k| yylloc.last_line = 0; 2982| 5.50k| yylloc.total_column = 0; 2983| 5.50k| yylloc.string_length = 0; 2984| 5.50k|} 2985| | 2986| 5.50k|#line 2987 "bison_parser.cpp" /* yacc.c:1429 */ 2987| 5.50k| yylsp[0] = yylloc; 2988| 5.50k| goto yysetstate; 2989| | 2990| |/*------------------------------------------------------------. 2991| || yynewstate -- Push a new state, which is found in yystate. | 2992| |`------------------------------------------------------------*/ 2993| 14.0M| yynewstate: 2994| | /* In all cases, when you get here, the value and location stacks 2995| | have just been pushed. So pushing a state here evens the stacks. */ 2996| 14.0M| yyssp++; 2997| | 2998| 14.0M| yysetstate: 2999| 14.0M| *yyssp = yystate; 3000| | 3001| 14.0M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3001:7): [True: 21, False: 14.0M] ------------------ 3002| 21| { 3003| | /* Get the current used size of the three stacks, in elements. */ 3004| 21| YYSIZE_T yysize = yyssp - yyss + 1; ------------------ | | 496| 21|# define YYSIZE_T __SIZE_TYPE__ ------------------ 3005| | 3006| |#ifdef yyoverflow 3007| | { 3008| | /* Give user a chance to reallocate the stack. Use copies of 3009| | these so that the &'s don't force the real ones into 3010| | memory. */ 3011| | YYSTYPE *yyvs1 = yyvs; 3012| | yytype_int16 *yyss1 = yyss; 3013| | YYLTYPE *yyls1 = yyls; 3014| | 3015| | /* Each stack pointer address is followed by the size of the 3016| | data in use in that stack, in bytes. This used to be a 3017| | conditional around just the two extra args, but that might 3018| | be undefined if yyoverflow is a macro. */ 3019| | yyoverflow (YY_("memory exhausted"), 3020| | &yyss1, yysize * sizeof (*yyssp), 3021| | &yyvs1, yysize * sizeof (*yyvsp), 3022| | &yyls1, yysize * sizeof (*yylsp), 3023| | &yystacksize); 3024| | 3025| | yyls = yyls1; 3026| | yyss = yyss1; 3027| | yyvs = yyvs1; 3028| | } 3029| |#else /* no yyoverflow */ 3030| 21|# ifndef YYSTACK_RELOCATE 3031| 21| goto yyexhaustedlab; 3032| |# else 3033| | /* Extend the stack our own way. */ 3034| | if (YYMAXDEPTH <= yystacksize) 3035| | goto yyexhaustedlab; 3036| | yystacksize *= 2; 3037| | if (YYMAXDEPTH < yystacksize) 3038| | yystacksize = YYMAXDEPTH; 3039| | 3040| | { 3041| | yytype_int16 *yyss1 = yyss; 3042| | union yyalloc *yyptr = 3043| | (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 3044| | if (! yyptr) 3045| | goto yyexhaustedlab; 3046| | YYSTACK_RELOCATE (yyss_alloc, yyss); 3047| | YYSTACK_RELOCATE (yyvs_alloc, yyvs); 3048| | YYSTACK_RELOCATE (yyls_alloc, yyls); 3049| |# undef YYSTACK_RELOCATE 3050| | if (yyss1 != yyssa) 3051| | YYSTACK_FREE (yyss1); 3052| | } 3053| |# endif 3054| 0|#endif /* no yyoverflow */ 3055| | 3056| 0| yyssp = yyss + yysize - 1; 3057| 0| yyvsp = yyvs + yysize - 1; 3058| 0| yylsp = yyls + yysize - 1; 3059| | 3060| 0| YYDPRINTF ((stderr, "Stack size increased to %lu\n", 3061| 0| (unsigned long int) yystacksize)); 3062| | 3063| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3063:11): [True: 0, False: 0] ------------------ 3064| 0| YYABORT; ------------------ | | 1457| 0|#define YYABORT goto yyabortlab ------------------ 3065| 0| } 3066| | 3067| 14.0M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3068| | 3069| 14.0M| if (yystate == YYFINAL) ------------------ | | 706| 14.0M|#define YYFINAL 69 ------------------ | Branch (3069:7): [True: 1.40k, False: 14.0M] ------------------ 3070| 1.40k| YYACCEPT; ------------------ | | 1456| 1.40k|#define YYACCEPT goto yyacceptlab ------------------ 3071| | 3072| 14.0M| goto yybackup; 3073| | 3074| |/*-----------. 3075| || yybackup. | 3076| |`-----------*/ 3077| 14.0M|yybackup: 3078| | 3079| | /* Do appropriate processing given the current state. Read a 3080| | lookahead token if we need one and don't already have one. */ 3081| | 3082| | /* First try to decide what to do without reference to lookahead token. */ 3083| 14.0M| yyn = yypact[yystate]; 3084| 14.0M| if (yypact_value_is_default (yyn)) ------------------ | | 923| 14.0M| (!!((Yystate) == (-529))) | | ------------------ | | | Branch (923:3): [True: 7.22M, False: 6.80M] | | ------------------ ------------------ 3085| 7.22M| goto yydefault; 3086| | 3087| | /* Not known => get a lookahead token if don't already have one. */ 3088| | 3089| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 3090| 6.80M| if (yychar == YYEMPTY) ------------------ | | 1453| 6.80M|#define YYEMPTY (-2) ------------------ | Branch (3090:7): [True: 3.77M, False: 3.02M] ------------------ 3091| 3.77M| { 3092| 3.77M| YYDPRINTF ((stderr, "Reading a token: ")); 3093| 3.77M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 66| 3.77M|#define yylex hsql_lex ------------------ 3094| 3.77M| } 3095| | 3096| 6.80M| if (yychar <= YYEOF) ------------------ | | 1454| 6.80M|#define YYEOF 0 ------------------ | Branch (3096:7): [True: 24.0k, False: 6.78M] ------------------ 3097| 24.0k| { 3098| 24.0k| yychar = yytoken = YYEOF; ------------------ | | 1454| 24.0k|#define YYEOF 0 ------------------ 3099| 24.0k| YYDPRINTF ((stderr, "Now at end of input.\n")); 3100| 24.0k| } 3101| 6.78M| else 3102| 6.78M| { 3103| 6.78M| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 6.78M| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 6.78M|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 6.78M, False: 0] | | ------------------ ------------------ 3104| 6.78M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3105| 6.78M| } 3106| | 3107| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3108| | detect an error, take that action. */ 3109| 6.80M| yyn += yytoken; 3110| 6.80M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 708| 6.80M|#define YYLAST 856 ------------------ | Branch (3110:7): [True: 4.76k, False: 6.80M] | Branch (3110:18): [True: 5.21k, False: 6.79M] | Branch (3110:34): [True: 2.80M, False: 3.99M] ------------------ 3111| 2.81M| goto yydefault; 3112| 3.99M| yyn = yytable[yyn]; 3113| 3.99M| if (yyn <= 0) ------------------ | Branch (3113:7): [True: 217k, False: 3.77M] ------------------ 3114| 217k| { 3115| 217k| if (yytable_value_is_error (yyn)) ------------------ | | 928| 217k| (!!((Yytable_value) == (-355))) | | ------------------ | | | Branch (928:3): [True: 16, False: 217k] | | ------------------ ------------------ 3116| 16| goto yyerrlab; 3117| 217k| yyn = -yyn; 3118| 217k| goto yyreduce; 3119| 217k| } 3120| | 3121| | /* Count tokens shifted since error; after three, turn off error 3122| | status. */ 3123| 3.77M| if (yyerrstatus) ------------------ | Branch (3123:7): [True: 0, False: 3.77M] ------------------ 3124| 0| yyerrstatus--; 3125| | 3126| | /* Shift the lookahead token. */ 3127| 3.77M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3128| | 3129| | /* Discard the shifted token. */ 3130| 3.77M| yychar = YYEMPTY; ------------------ | | 1453| 3.77M|#define YYEMPTY (-2) ------------------ 3131| | 3132| 3.77M| yystate = yyn; 3133| 3.77M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3134| 3.77M| *++yyvsp = yylval; 3135| 3.77M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3136| 3.77M| *++yylsp = yylloc; 3137| 3.77M| goto yynewstate; 3138| | 3139| | 3140| |/*-----------------------------------------------------------. 3141| || yydefault -- do the default action for the current state. | 3142| |`-----------------------------------------------------------*/ 3143| 10.0M|yydefault: 3144| 10.0M| yyn = yydefact[yystate]; 3145| 10.0M| if (yyn == 0) ------------------ | Branch (3145:7): [True: 3.39k, False: 10.0M] ------------------ 3146| 3.39k| goto yyerrlab; 3147| 10.0M| goto yyreduce; 3148| | 3149| | 3150| |/*-----------------------------. 3151| || yyreduce -- Do a reduction. | 3152| |`-----------------------------*/ 3153| 10.2M|yyreduce: 3154| | /* yyn is the number of a rule to reduce with. */ 3155| 10.2M| yylen = yyr2[yyn]; 3156| | 3157| | /* If YYLEN is nonzero, implement the default value of the action: 3158| | '$$ = $1'. 3159| | 3160| | Otherwise, the following line sets YYVAL to garbage. 3161| | This behavior is undocumented and Bison 3162| | users should not rely upon it. Assigning to YYVAL 3163| | unconditionally makes the parser a bit smaller, and it avoids a 3164| | GCC warning that YYVAL may be used uninitialized. */ 3165| 10.2M| yyval = yyvsp[1-yylen]; 3166| | 3167| | /* Default location. */ 3168| 10.2M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1491| 10.2M| do \ | | 1492| 10.2M| if (N) \ | | ------------------ | | | Branch (1492:11): [True: 9.27M, False: 979k] | | ------------------ | | 1493| 10.2M| { \ | | 1494| 9.27M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1509| 9.27M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1495| 9.27M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1509| 9.27M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1496| 9.27M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1509| 9.27M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1497| 9.27M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1509| 9.27M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1498| 9.27M| } \ | | 1499| 10.2M| else \ | | 1500| 10.2M| { \ | | 1501| 979k| (Current).first_line = (Current).last_line = \ | | 1502| 979k| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1509| 979k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1503| 979k| (Current).first_column = (Current).last_column = \ | | 1504| 979k| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1509| 979k|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1505| 979k| } \ | | 1506| 10.2M| while (0) | | ------------------ | | | Branch (1506:12): [Folded, False: 10.2M] | | ------------------ ------------------ 3169| 10.2M| YY_REDUCE_PRINT (yyn); 3170| 10.2M| switch (yyn) 3171| 10.2M| { 3172| 1.66k| case 2: ------------------ | Branch (3172:9): [True: 1.66k, False: 10.2M] ------------------ 3173| 1.66k|#line 343 "bison_parser.y" /* yacc.c:1646 */ 3174| 1.66k| { 3175| 44.4k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3175:27): [True: 44.4k, False: 1.66k] ------------------ 3176| | // Transfers ownership of the statement. 3177| 44.4k| result->addStatement(stmt); 3178| 44.4k| } 3179| | 3180| 1.66k| unsigned param_id = 0; 3181| 123k| for (void* param : yyloc.param_list) { ------------------ | Branch (3181:20): [True: 123k, False: 1.66k] ------------------ 3182| 123k| if (param) { ------------------ | Branch (3182:9): [True: 123k, False: 0] ------------------ 3183| 123k| Expr* expr = (Expr*)param; 3184| 123k| expr->ival = param_id; 3185| 123k| result->addParameter(expr); 3186| 123k| ++param_id; 3187| 123k| } 3188| 123k| } 3189| 1.66k| delete (yyvsp[-1].stmt_vec); 3190| 1.66k| } 3191| 1.66k|#line 3192 "bison_parser.cpp" /* yacc.c:1646 */ 3192| 1.66k| break; 3193| | 3194| 2.21k| case 3: ------------------ | Branch (3194:3): [True: 2.21k, False: 10.2M] ------------------ 3195| 2.21k|#line 362 "bison_parser.y" /* yacc.c:1646 */ 3196| 2.21k| { 3197| 2.21k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3198| 2.21k| yylloc.string_length = 0; 3199| 2.21k| (yyval.stmt_vec) = new std::vector(); 3200| 2.21k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3201| 2.21k|} 3202| 2.21k|#line 3203 "bison_parser.cpp" /* yacc.c:1646 */ 3203| 2.21k| break; 3204| | 3205| 78.5k| case 4: ------------------ | Branch (3205:3): [True: 78.5k, False: 10.1M] ------------------ 3206| 78.5k|#line 368 "bison_parser.y" /* yacc.c:1646 */ 3207| 78.5k| { 3208| 78.5k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3209| 78.5k| yylloc.string_length = 0; 3210| 78.5k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3211| 78.5k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3212| 78.5k|} 3213| 78.5k|#line 3214 "bison_parser.cpp" /* yacc.c:1646 */ 3214| 78.5k| break; 3215| | 3216| 1.45k| case 5: ------------------ | Branch (3216:3): [True: 1.45k, False: 10.2M] ------------------ 3217| 1.45k|#line 375 "bison_parser.y" /* yacc.c:1646 */ 3218| 1.45k| { 3219| 1.45k| (yyval.statement) = (yyvsp[-1].prep_stmt); 3220| 1.45k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3221| 1.45k|} 3222| 1.45k|#line 3223 "bison_parser.cpp" /* yacc.c:1646 */ 3223| 1.45k| break; 3224| | 3225| 57.1k| case 6: ------------------ | Branch (3225:3): [True: 57.1k, False: 10.1M] ------------------ 3226| 57.1k|#line 379 "bison_parser.y" /* yacc.c:1646 */ 3227| 57.1k| { 3228| 57.1k| (yyval.statement) = (yyvsp[-1].statement); 3229| 57.1k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3230| 57.1k|} 3231| 57.1k|#line 3232 "bison_parser.cpp" /* yacc.c:1646 */ 3232| 57.1k| break; 3233| | 3234| 7.58k| case 7: ------------------ | Branch (3234:3): [True: 7.58k, False: 10.2M] ------------------ 3235| 7.58k|#line 383 "bison_parser.y" /* yacc.c:1646 */ 3236| 7.58k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3237| 7.58k|#line 3238 "bison_parser.cpp" /* yacc.c:1646 */ 3238| 7.58k| break; 3239| | 3240| 7.57k| case 8: ------------------ | Branch (3240:3): [True: 7.57k, False: 10.2M] ------------------ 3241| 7.57k|#line 384 "bison_parser.y" /* yacc.c:1646 */ 3242| 7.57k| { (yyval.statement) = (yyvsp[0].import_stmt); } 3243| 7.57k|#line 3244 "bison_parser.cpp" /* yacc.c:1646 */ 3244| 7.57k| break; 3245| | 3246| 6.95k| case 9: ------------------ | Branch (3246:3): [True: 6.95k, False: 10.2M] ------------------ 3247| 6.95k|#line 385 "bison_parser.y" /* yacc.c:1646 */ 3248| 6.95k| { (yyval.statement) = (yyvsp[0].export_stmt); } 3249| 6.95k|#line 3250 "bison_parser.cpp" /* yacc.c:1646 */ 3250| 6.95k| break; 3251| | 3252| 23.8k| case 10: ------------------ | Branch (3252:3): [True: 23.8k, False: 10.2M] ------------------ 3253| 23.8k|#line 387 "bison_parser.y" /* yacc.c:1646 */ 3254| 23.8k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3255| 23.8k|#line 3256 "bison_parser.cpp" /* yacc.c:1646 */ 3256| 23.8k| break; 3257| | 3258| 8.05k| case 11: ------------------ | Branch (3258:3): [True: 8.05k, False: 10.2M] ------------------ 3259| 8.05k|#line 388 "bison_parser.y" /* yacc.c:1646 */ 3260| 8.05k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3261| 8.05k|#line 3262 "bison_parser.cpp" /* yacc.c:1646 */ 3262| 8.05k| break; 3263| | 3264| 3.70k| case 12: ------------------ | Branch (3264:3): [True: 3.70k, False: 10.2M] ------------------ 3265| 3.70k|#line 389 "bison_parser.y" /* yacc.c:1646 */ 3266| 3.70k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3267| 3.70k|#line 3268 "bison_parser.cpp" /* yacc.c:1646 */ 3268| 3.70k| break; 3269| | 3270| 1.70k| case 13: ------------------ | Branch (3270:3): [True: 1.70k, False: 10.2M] ------------------ 3271| 1.70k|#line 390 "bison_parser.y" /* yacc.c:1646 */ 3272| 1.70k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3273| 1.70k|#line 3274 "bison_parser.cpp" /* yacc.c:1646 */ 3274| 1.70k| break; 3275| | 3276| 349| case 14: ------------------ | Branch (3276:3): [True: 349, False: 10.2M] ------------------ 3277| 349|#line 391 "bison_parser.y" /* yacc.c:1646 */ 3278| 349| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3279| 349|#line 3280 "bison_parser.cpp" /* yacc.c:1646 */ 3280| 349| break; 3281| | 3282| 1.91k| case 15: ------------------ | Branch (3282:3): [True: 1.91k, False: 10.2M] ------------------ 3283| 1.91k|#line 392 "bison_parser.y" /* yacc.c:1646 */ 3284| 1.91k| { (yyval.statement) = (yyvsp[0].update_stmt); } 3285| 1.91k|#line 3286 "bison_parser.cpp" /* yacc.c:1646 */ 3286| 1.91k| break; 3287| | 3288| 4.07k| case 16: ------------------ | Branch (3288:3): [True: 4.07k, False: 10.2M] ------------------ 3289| 4.07k|#line 393 "bison_parser.y" /* yacc.c:1646 */ 3290| 4.07k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3291| 4.07k|#line 3292 "bison_parser.cpp" /* yacc.c:1646 */ 3292| 4.07k| break; 3293| | 3294| 0| case 17: ------------------ | Branch (3294:3): [True: 0, False: 10.2M] ------------------ 3295| 0|#line 394 "bison_parser.y" /* yacc.c:1646 */ 3296| 0| { (yyval.statement) = (yyvsp[0].alter_stmt); } 3297| 0|#line 3298 "bison_parser.cpp" /* yacc.c:1646 */ 3298| 0| break; 3299| | 3300| 4.01k| case 18: ------------------ | Branch (3300:3): [True: 4.01k, False: 10.2M] ------------------ 3301| 4.01k|#line 395 "bison_parser.y" /* yacc.c:1646 */ 3302| 4.01k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3303| 4.01k|#line 3304 "bison_parser.cpp" /* yacc.c:1646 */ 3304| 4.01k| break; 3305| | 3306| 9.54k| case 19: ------------------ | Branch (3306:3): [True: 9.54k, False: 10.2M] ------------------ 3307| 9.54k|#line 396 "bison_parser.y" /* yacc.c:1646 */ 3308| 9.54k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3309| 9.54k|#line 3310 "bison_parser.cpp" /* yacc.c:1646 */ 3310| 9.54k| break; 3311| | 3312| 896| case 20: ------------------ | Branch (3312:3): [True: 896, False: 10.2M] ------------------ 3313| 896|#line 402 "bison_parser.y" /* yacc.c:1646 */ 3314| 896| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3315| 896|#line 3316 "bison_parser.cpp" /* yacc.c:1646 */ 3316| 896| break; 3317| | 3318| 57.7k| case 21: ------------------ | Branch (3318:3): [True: 57.7k, False: 10.1M] ------------------ 3319| 57.7k|#line 403 "bison_parser.y" /* yacc.c:1646 */ 3320| 57.7k| { (yyval.expr_vec) = nullptr; } 3321| 57.7k|#line 3322 "bison_parser.cpp" /* yacc.c:1646 */ 3322| 57.7k| break; 3323| | 3324| 934| case 22: ------------------ | Branch (3324:3): [True: 934, False: 10.2M] ------------------ 3325| 934|#line 405 "bison_parser.y" /* yacc.c:1646 */ 3326| 934| { 3327| 934| (yyval.expr_vec) = new std::vector(); 3328| 934| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3329| 934|} 3330| 934|#line 3331 "bison_parser.cpp" /* yacc.c:1646 */ 3331| 934| break; 3332| | 3333| 2.22k| case 23: ------------------ | Branch (3333:3): [True: 2.22k, False: 10.2M] ------------------ 3334| 2.22k|#line 409 "bison_parser.y" /* yacc.c:1646 */ 3335| 2.22k| { 3336| 2.22k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3337| 2.22k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3338| 2.22k|} 3339| 2.22k|#line 3340 "bison_parser.cpp" /* yacc.c:1646 */ 3340| 2.22k| break; 3341| | 3342| 2.84k| case 24: ------------------ | Branch (3342:3): [True: 2.84k, False: 10.2M] ------------------ 3343| 2.84k|#line 414 "bison_parser.y" /* yacc.c:1646 */ 3344| 2.84k| { 3345| 2.84k| (yyval.expr) = Expr::make(kExprHint); 3346| 2.84k| (yyval.expr)->name = (yyvsp[0].sval); 3347| 2.84k|} 3348| 2.84k|#line 3349 "bison_parser.cpp" /* yacc.c:1646 */ 3349| 2.84k| break; 3350| | 3351| 319| case 25: ------------------ | Branch (3351:3): [True: 319, False: 10.2M] ------------------ 3352| 319|#line 418 "bison_parser.y" /* yacc.c:1646 */ 3353| 319| { 3354| 319| (yyval.expr) = Expr::make(kExprHint); 3355| 319| (yyval.expr)->name = (yyvsp[-3].sval); 3356| 319| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3357| 319|} 3358| 319|#line 3359 "bison_parser.cpp" /* yacc.c:1646 */ 3359| 319| break; 3360| | 3361| 4.62k| case 26: ------------------ | Branch (3361:3): [True: 4.62k, False: 10.2M] ------------------ 3362| 4.62k|#line 428 "bison_parser.y" /* yacc.c:1646 */ 3363| 4.62k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3364| 4.62k|#line 3365 "bison_parser.cpp" /* yacc.c:1646 */ 3365| 4.62k| break; 3366| | 3367| 2.27k| case 27: ------------------ | Branch (3367:3): [True: 2.27k, False: 10.2M] ------------------ 3368| 2.27k|#line 429 "bison_parser.y" /* yacc.c:1646 */ 3369| 2.27k| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3370| 2.27k|#line 3371 "bison_parser.cpp" /* yacc.c:1646 */ 3371| 2.27k| break; 3372| | 3373| 2.64k| case 28: ------------------ | Branch (3373:3): [True: 2.64k, False: 10.2M] ------------------ 3374| 2.64k|#line 430 "bison_parser.y" /* yacc.c:1646 */ 3375| 2.64k| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3376| 2.64k|#line 3377 "bison_parser.cpp" /* yacc.c:1646 */ 3377| 2.64k| break; 3378| | 3379| 1.45k| case 31: ------------------ | Branch (3379:3): [True: 1.45k, False: 10.2M] ------------------ 3380| 1.45k|#line 438 "bison_parser.y" /* yacc.c:1646 */ 3381| 1.45k| { 3382| 1.45k| (yyval.prep_stmt) = new PrepareStatement(); 3383| 1.45k| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3384| 1.45k| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3385| 1.45k|} 3386| 1.45k|#line 3387 "bison_parser.cpp" /* yacc.c:1646 */ 3387| 1.45k| break; 3388| | 3389| 3.50k| case 33: ------------------ | Branch (3389:3): [True: 3.50k, False: 10.2M] ------------------ 3390| 3.50k|#line 446 "bison_parser.y" /* yacc.c:1646 */ 3391| 3.50k| { 3392| 3.50k| (yyval.exec_stmt) = new ExecuteStatement(); 3393| 3.50k| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3394| 3.50k|} 3395| 3.50k|#line 3396 "bison_parser.cpp" /* yacc.c:1646 */ 3396| 3.50k| break; 3397| | 3398| 511| case 34: ------------------ | Branch (3398:3): [True: 511, False: 10.2M] ------------------ 3399| 511|#line 450 "bison_parser.y" /* yacc.c:1646 */ 3400| 511| { 3401| 511| (yyval.exec_stmt) = new ExecuteStatement(); 3402| 511| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3403| 511| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3404| 511|} 3405| 511|#line 3406 "bison_parser.cpp" /* yacc.c:1646 */ 3406| 511| break; 3407| | 3408| 0| case 35: ------------------ | Branch (3408:3): [True: 0, False: 10.2M] ------------------ 3409| 0|#line 462 "bison_parser.y" /* yacc.c:1646 */ 3410| 0| { 3411| 0| (yyval.import_stmt) = new ImportStatement((yyvsp[-4].import_type_t)); 3412| 0| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3413| 0| (yyval.import_stmt)->schema = (yyvsp[0].table_name).schema; 3414| 0| (yyval.import_stmt)->tableName = (yyvsp[0].table_name).name; 3415| 0|} 3416| 0|#line 3417 "bison_parser.cpp" /* yacc.c:1646 */ 3417| 0| break; 3418| | 3419| 7.57k| case 36: ------------------ | Branch (3419:3): [True: 7.57k, False: 10.2M] ------------------ 3420| 7.57k|#line 468 "bison_parser.y" /* yacc.c:1646 */ 3421| 7.57k| { 3422| 7.57k| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_export_option_t)->format); 3423| 7.57k| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3424| 7.57k| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3425| 7.57k| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3426| 7.57k| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3427| 7.57k| if ((yyvsp[-1].import_export_option_t)->encoding) { ------------------ | Branch (3427:7): [True: 194, False: 7.37k] ------------------ 3428| 194| (yyval.import_stmt)->encoding = (yyvsp[-1].import_export_option_t)->encoding; 3429| 194| (yyvsp[-1].import_export_option_t)->encoding = nullptr; 3430| 194| } 3431| 7.57k| if ((yyvsp[-1].import_export_option_t)->csv_options) { ------------------ | Branch (3431:7): [True: 196, False: 7.37k] ------------------ 3432| 196| (yyval.import_stmt)->csv_options = (yyvsp[-1].import_export_option_t)->csv_options; 3433| 196| (yyvsp[-1].import_export_option_t)->csv_options = nullptr; 3434| 196| } 3435| 7.57k| delete (yyvsp[-1].import_export_option_t); 3436| 7.57k|} 3437| 7.57k|#line 3438 "bison_parser.cpp" /* yacc.c:1646 */ 3438| 7.57k| break; 3439| | 3440| 1.71k| case 37: ------------------ | Branch (3440:3): [True: 1.71k, False: 10.2M] ------------------ 3441| 1.71k|#line 485 "bison_parser.y" /* yacc.c:1646 */ 3442| 1.71k| { 3443| 1.71k| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3443:7): [True: 782, False: 936] ------------------ 3444| 782| (yyval.import_type_t) = kImportCSV; 3445| 936| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3445:14): [True: 200, False: 736] ------------------ 3446| 200| (yyval.import_type_t) = kImportTbl; 3447| 736| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3447:14): [True: 67, False: 669] | Branch (3447:60): [True: 556, False: 113] ------------------ 3448| 623| (yyval.import_type_t) = kImportBinary; 3449| 623| } else { 3450| 113| free((yyvsp[0].sval)); 3451| 113| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 67| 113|#define yyerror hsql_error ------------------ 3452| 113| YYERROR; ------------------ | | 1458| 113|#define YYERROR goto yyerrorlab ------------------ 3453| 113| } 3454| 1.60k| free((yyvsp[0].sval)); 3455| 1.60k|} 3456| 0|#line 3457 "bison_parser.cpp" /* yacc.c:1646 */ 3457| 0| break; 3458| | 3459| 14.7k| case 38: ------------------ | Branch (3459:3): [True: 14.7k, False: 10.2M] ------------------ 3460| 14.7k|#line 500 "bison_parser.y" /* yacc.c:1646 */ 3461| 14.7k| { (yyval.sval) = (yyvsp[0].sval); } 3462| 14.7k|#line 3463 "bison_parser.cpp" /* yacc.c:1646 */ 3463| 14.7k| break; 3464| | 3465| 66| case 39: ------------------ | Branch (3465:3): [True: 66, False: 10.2M] ------------------ 3466| 66|#line 502 "bison_parser.y" /* yacc.c:1646 */ 3467| 66| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3468| 66|#line 3469 "bison_parser.cpp" /* yacc.c:1646 */ 3469| 66| break; 3470| | 3471| 3.32k| case 40: ------------------ | Branch (3471:3): [True: 3.32k, False: 10.2M] ------------------ 3472| 3.32k|#line 503 "bison_parser.y" /* yacc.c:1646 */ 3473| 3.32k| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3474| 3.32k|#line 3475 "bison_parser.cpp" /* yacc.c:1646 */ 3475| 3.32k| break; 3476| | 3477| 11.1k| case 41: ------------------ | Branch (3477:3): [True: 11.1k, False: 10.2M] ------------------ 3478| 11.1k|#line 504 "bison_parser.y" /* yacc.c:1646 */ 3479| 11.1k| { (yyval.import_export_option_t) = new ImportExportOptions{}; } 3480| 11.1k|#line 3481 "bison_parser.cpp" /* yacc.c:1646 */ 3481| 11.1k| break; 3482| | 3483| 562| case 42: ------------------ | Branch (3483:3): [True: 562, False: 10.2M] ------------------ 3484| 562|#line 506 "bison_parser.y" /* yacc.c:1646 */ 3485| 562| { 3486| 562| if ((yyvsp[-3].import_export_option_t)->format != kImportAuto) { ------------------ | Branch (3486:7): [True: 6, False: 556] ------------------ 3487| 6| delete (yyvsp[-3].import_export_option_t); 3488| 6| yyerror(&yyloc, result, scanner, "File type must only be provided once."); ------------------ | | 67| 6|#define yyerror hsql_error ------------------ 3489| 6| YYERROR; ------------------ | | 1458| 6|#define YYERROR goto yyerrorlab ------------------ 3490| 6| } 3491| 556| if ((yyvsp[-3].import_export_option_t)->csv_options && (yyvsp[0].import_type_t) != kImportCSV && (yyvsp[0].import_type_t) != kImportAuto) { ------------------ | Branch (3491:7): [True: 490, False: 66] | Branch (3491:58): [True: 2, False: 488] | Branch (3491:100): [True: 2, False: 0] ------------------ 3492| 2| delete (yyvsp[-3].import_export_option_t); 3493| 2| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) are only allowed for CSV files."); ------------------ | | 67| 2|#define yyerror hsql_error ------------------ 3494| 2| YYERROR; ------------------ | | 1458| 2|#define YYERROR goto yyerrorlab ------------------ 3495| 2| } 3496| 554| (yyvsp[-3].import_export_option_t)->format = (yyvsp[0].import_type_t); 3497| 554| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3498| 554|} 3499| 0|#line 3500 "bison_parser.cpp" /* yacc.c:1646 */ 3500| 0| break; 3501| | 3502| 1.04k| case 43: ------------------ | Branch (3502:3): [True: 1.04k, False: 10.2M] ------------------ 3503| 1.04k|#line 520 "bison_parser.y" /* yacc.c:1646 */ 3504| 1.04k| { 3505| 1.04k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3506| 1.04k| (yyval.import_export_option_t)->format = (yyvsp[0].import_type_t); 3507| 1.04k|} 3508| 1.04k|#line 3509 "bison_parser.cpp" /* yacc.c:1646 */ 3509| 1.04k| break; 3510| | 3511| 486| case 44: ------------------ | Branch (3511:3): [True: 486, False: 10.2M] ------------------ 3512| 486|#line 524 "bison_parser.y" /* yacc.c:1646 */ 3513| 486| { 3514| 486| if ((yyvsp[-3].import_export_option_t)->encoding) { ------------------ | Branch (3514:7): [True: 1, False: 485] ------------------ 3515| 1| delete (yyvsp[-3].import_export_option_t); 3516| 1| free((yyvsp[0].sval)); 3517| 1| yyerror(&yyloc, result, scanner, "Encoding type must only be provided once."); ------------------ | | 67| 1|#define yyerror hsql_error ------------------ 3518| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 3519| 1| } 3520| 485| (yyvsp[-3].import_export_option_t)->encoding = (yyvsp[0].sval); 3521| 485| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3522| 485|} 3523| 0|#line 3524 "bison_parser.cpp" /* yacc.c:1646 */ 3524| 0| break; 3525| | 3526| 1.00k| case 45: ------------------ | Branch (3526:3): [True: 1.00k, False: 10.2M] ------------------ 3527| 1.00k|#line 534 "bison_parser.y" /* yacc.c:1646 */ 3528| 1.00k| { 3529| 1.00k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3530| 1.00k| (yyval.import_export_option_t)->encoding = (yyvsp[0].sval); 3531| 1.00k|} 3532| 1.00k|#line 3533 "bison_parser.cpp" /* yacc.c:1646 */ 3533| 1.00k| break; 3534| | 3535| 424| case 46: ------------------ | Branch (3535:3): [True: 424, False: 10.2M] ------------------ 3536| 424|#line 538 "bison_parser.y" /* yacc.c:1646 */ 3537| 424| { 3538| 424| if ((yyvsp[-2].import_export_option_t)->format != kImportAuto && (yyvsp[-2].import_export_option_t)->format != kImportCSV) { ------------------ | Branch (3538:7): [True: 217, False: 207] | Branch (3538:68): [True: 1, False: 216] ------------------ 3539| 1| delete (yyvsp[-2].import_export_option_t); 3540| 1| free((yyvsp[0].csv_option_t)->second); 3541| 1| delete (yyvsp[0].csv_option_t); 3542| 1| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) are only allowed for CSV files."); ------------------ | | 67| 1|#define yyerror hsql_error ------------------ 3543| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 3544| 1| } 3545| | 3546| 423| if ((yyvsp[-2].import_export_option_t)->csv_options == nullptr) { ------------------ | Branch (3546:7): [True: 209, False: 214] ------------------ 3547| 209| (yyvsp[-2].import_export_option_t)->csv_options = new CsvOptions{}; 3548| 209| } 3549| | 3550| 423| if (!(yyvsp[-2].import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t))) { ------------------ | Branch (3550:7): [True: 13, False: 410] ------------------ 3551| 13| free((yyvsp[0].csv_option_t)->second); 3552| 13| delete (yyvsp[0].csv_option_t); 3553| 13| delete (yyvsp[-2].import_export_option_t); 3554| 13| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) cannot be provided more than once."); ------------------ | | 67| 13|#define yyerror hsql_error ------------------ 3555| 13| YYERROR; ------------------ | | 1458| 13|#define YYERROR goto yyerrorlab ------------------ 3556| 13| } 3557| | 3558| 410| delete (yyvsp[0].csv_option_t); 3559| 410| (yyval.import_export_option_t) = (yyvsp[-2].import_export_option_t); 3560| 410|} 3561| 0|#line 3562 "bison_parser.cpp" /* yacc.c:1646 */ 3562| 0| break; 3563| | 3564| 1.41k| case 47: ------------------ | Branch (3564:3): [True: 1.41k, False: 10.2M] ------------------ 3565| 1.41k|#line 562 "bison_parser.y" /* yacc.c:1646 */ 3566| 1.41k| { 3567| 1.41k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3568| 1.41k| (yyval.import_export_option_t)->csv_options = new CsvOptions{}; 3569| 1.41k| (yyval.import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t)); 3570| | 3571| 1.41k| delete (yyvsp[0].csv_option_t); 3572| 1.41k|} 3573| 1.41k|#line 3574 "bison_parser.cpp" /* yacc.c:1646 */ 3574| 1.41k| break; 3575| | 3576| 942| case 48: ------------------ | Branch (3576:3): [True: 942, False: 10.2M] ------------------ 3577| 942|#line 570 "bison_parser.y" /* yacc.c:1646 */ 3578| 942| { 3579| 942| if (strcasecmp((yyvsp[-1].sval), "DELIMITER") == 0) { ------------------ | Branch (3579:7): [True: 334, False: 608] ------------------ 3580| 334| (yyval.csv_option_t) = new std::pair(CsvOptionType::Delimiter, (yyvsp[0].sval)); 3581| 608| } else if (strcasecmp((yyvsp[-1].sval), "QUOTE") == 0) { ------------------ | Branch (3581:14): [True: 503, False: 105] ------------------ 3582| 503| (yyval.csv_option_t) = new std::pair(CsvOptionType::Quote, (yyvsp[0].sval)); 3583| 503| } else { 3584| 105| free((yyvsp[-1].sval)); 3585| 105| free((yyvsp[0].sval)); 3586| 105| yyerror(&yyloc, result, scanner, "Unknown CSV option."); ------------------ | | 67| 105|#define yyerror hsql_error ------------------ 3587| 105| YYERROR; ------------------ | | 1458| 105|#define YYERROR goto yyerrorlab ------------------ 3588| 105| } 3589| 837| free((yyvsp[-1].sval)); 3590| 837|} 3591| 0|#line 3592 "bison_parser.cpp" /* yacc.c:1646 */ 3592| 0| break; 3593| | 3594| 1.00k| case 49: ------------------ | Branch (3594:3): [True: 1.00k, False: 10.2M] ------------------ 3595| 1.00k|#line 583 "bison_parser.y" /* yacc.c:1646 */ 3596| 1.00k| { (yyval.csv_option_t) = new std::pair(CsvOptionType::Null, (yyvsp[0].sval)); } 3597| 1.00k|#line 3598 "bison_parser.cpp" /* yacc.c:1646 */ 3598| 1.00k| break; 3599| | 3600| 6.37k| case 50: ------------------ | Branch (3600:3): [True: 6.37k, False: 10.2M] ------------------ 3601| 6.37k|#line 590 "bison_parser.y" /* yacc.c:1646 */ 3602| 6.37k| { 3603| 6.37k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3604| 6.37k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3605| 6.37k| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3606| 6.37k| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3607| 6.37k| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3607:7): [True: 1.08k, False: 5.28k] ------------------ 3608| 1.08k| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3609| 1.08k| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3610| 1.08k| } 3611| 6.37k| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3611:7): [True: 1.04k, False: 5.33k] ------------------ 3612| 1.04k| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3613| 1.04k| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3614| 1.04k| } 3615| 6.37k| delete (yyvsp[0].import_export_option_t); 3616| 6.37k|} 3617| 6.37k|#line 3618 "bison_parser.cpp" /* yacc.c:1646 */ 3618| 6.37k| break; 3619| | 3620| 580| case 51: ------------------ | Branch (3620:3): [True: 580, False: 10.2M] ------------------ 3621| 580|#line 605 "bison_parser.y" /* yacc.c:1646 */ 3622| 580| { 3623| 580| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3624| 580| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3625| 580| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3626| 580| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3626:7): [True: 197, False: 383] ------------------ 3627| 197| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3628| 197| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3629| 197| } 3630| 580| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3630:7): [True: 340, False: 240] ------------------ 3631| 340| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3632| 340| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3633| 340| } 3634| 580| delete (yyvsp[0].import_export_option_t); 3635| 580|} 3636| 580|#line 3637 "bison_parser.cpp" /* yacc.c:1646 */ 3637| 580| break; 3638| | 3639| 1.58k| case 52: ------------------ | Branch (3639:3): [True: 1.58k, False: 10.2M] ------------------ 3640| 1.58k|#line 625 "bison_parser.y" /* yacc.c:1646 */ 3641| 1.58k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3642| 1.58k|#line 3643 "bison_parser.cpp" /* yacc.c:1646 */ 3643| 1.58k| break; 3644| | 3645| 1.12k| case 53: ------------------ | Branch (3645:3): [True: 1.12k, False: 10.2M] ------------------ 3646| 1.12k|#line 626 "bison_parser.y" /* yacc.c:1646 */ 3647| 1.12k| { 3648| 1.12k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3649| 1.12k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3650| 1.12k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3651| 1.12k|} 3652| 1.12k|#line 3653 "bison_parser.cpp" /* yacc.c:1646 */ 3653| 1.12k| break; 3654| | 3655| 4.87k| case 54: ------------------ | Branch (3655:3): [True: 4.87k, False: 10.2M] ------------------ 3656| 4.87k|#line 631 "bison_parser.y" /* yacc.c:1646 */ 3657| 4.87k| { 3658| 4.87k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3659| 4.87k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3660| 4.87k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3661| 4.87k|} 3662| 4.87k|#line 3663 "bison_parser.cpp" /* yacc.c:1646 */ 3663| 4.87k| break; 3664| | 3665| 0| case 55: ------------------ | Branch (3665:3): [True: 0, False: 10.2M] ------------------ 3666| 0|#line 642 "bison_parser.y" /* yacc.c:1646 */ 3667| 0| { 3668| 0| (yyval.create_stmt) = new CreateStatement(kCreateTableFromTbl); 3669| 0| (yyval.create_stmt)->ifNotExists = (yyvsp[-5].bval); 3670| 0| (yyval.create_stmt)->schema = (yyvsp[-4].table_name).schema; 3671| 0| (yyval.create_stmt)->tableName = (yyvsp[-4].table_name).name; 3672| 0| if (strcasecmp((yyvsp[-2].sval), "tbl") != 0) { ------------------ | Branch (3672:7): [True: 0, False: 0] ------------------ 3673| 0| free((yyvsp[-2].sval)); 3674| 0| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 67| 0|#define yyerror hsql_error ------------------ 3675| 0| YYERROR; ------------------ | | 1458| 0|#define YYERROR goto yyerrorlab ------------------ 3676| 0| } 3677| 0| free((yyvsp[-2].sval)); 3678| 0| (yyval.create_stmt)->filePath = (yyvsp[0].sval); 3679| 0|} 3680| 0|#line 3681 "bison_parser.cpp" /* yacc.c:1646 */ 3681| 0| break; 3682| | 3683| 4.56k| case 56: ------------------ | Branch (3683:3): [True: 4.56k, False: 10.2M] ------------------ 3684| 4.56k|#line 655 "bison_parser.y" /* yacc.c:1646 */ 3685| 4.56k| { 3686| 4.56k| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3687| 4.56k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3688| 4.56k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3689| 4.56k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3690| 4.56k| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3691| 4.56k| delete (yyvsp[-1].table_element_vec); 3692| 4.56k| if (result->errorMsg()) { ------------------ | Branch (3692:7): [True: 1, False: 4.56k] ------------------ 3693| 1| delete (yyval.create_stmt); 3694| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 3695| 1| } 3696| 4.56k|} 3697| 4.56k|#line 3698 "bison_parser.cpp" /* yacc.c:1646 */ 3698| 4.56k| break; 3699| | 3700| 4.56k| case 57: ------------------ | Branch (3700:3): [True: 82, False: 10.2M] ------------------ 3701| 82|#line 667 "bison_parser.y" /* yacc.c:1646 */ 3702| 82| { 3703| 82| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3704| 82| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3705| 82| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3706| 82| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3707| 82| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3708| 82|} 3709| 82|#line 3710 "bison_parser.cpp" /* yacc.c:1646 */ 3710| 82| break; 3711| | 3712| 1.16k| case 58: ------------------ | Branch (3712:3): [True: 1.16k, False: 10.2M] ------------------ 3713| 1.16k|#line 674 "bison_parser.y" /* yacc.c:1646 */ 3714| 1.16k| { 3715| 1.16k| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3716| 1.16k| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3717| 1.16k| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3718| 1.16k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3719| 1.16k| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3720| 1.16k|} 3721| 1.16k|#line 3722 "bison_parser.cpp" /* yacc.c:1646 */ 3722| 1.16k| break; 3723| | 3724| 2.23k| case 59: ------------------ | Branch (3724:3): [True: 2.23k, False: 10.2M] ------------------ 3725| 2.23k|#line 681 "bison_parser.y" /* yacc.c:1646 */ 3726| 2.23k| { 3727| 2.23k| (yyval.create_stmt) = new CreateStatement(kCreateView); 3728| 2.23k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3729| 2.23k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3730| 2.23k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3731| 2.23k| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3732| 2.23k| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3733| 2.23k|} 3734| 2.23k|#line 3735 "bison_parser.cpp" /* yacc.c:1646 */ 3735| 2.23k| break; 3736| | 3737| 67| case 60: ------------------ | Branch (3737:3): [True: 67, False: 10.2M] ------------------ 3738| 67|#line 690 "bison_parser.y" /* yacc.c:1646 */ 3739| 67| { (yyval.bval) = true; } 3740| 67|#line 3741 "bison_parser.cpp" /* yacc.c:1646 */ 3741| 67| break; 3742| | 3743| 8.60k| case 61: ------------------ | Branch (3743:3): [True: 8.60k, False: 10.2M] ------------------ 3744| 8.60k|#line 691 "bison_parser.y" /* yacc.c:1646 */ 3745| 8.60k| { (yyval.bval) = false; } 3746| 8.60k|#line 3747 "bison_parser.cpp" /* yacc.c:1646 */ 3747| 8.60k| break; 3748| | 3749| 5.11k| case 62: ------------------ | Branch (3749:3): [True: 5.11k, False: 10.2M] ------------------ 3750| 5.11k|#line 693 "bison_parser.y" /* yacc.c:1646 */ 3751| 5.11k| { 3752| 5.11k| (yyval.table_element_vec) = new std::vector(); 3753| 5.11k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3754| 5.11k|} 3755| 5.11k|#line 3756 "bison_parser.cpp" /* yacc.c:1646 */ 3756| 5.11k| break; 3757| | 3758| 17.2k| case 63: ------------------ | Branch (3758:3): [True: 17.2k, False: 10.2M] ------------------ 3759| 17.2k|#line 697 "bison_parser.y" /* yacc.c:1646 */ 3760| 17.2k| { 3761| 17.2k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3762| 17.2k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3763| 17.2k|} 3764| 17.2k|#line 3765 "bison_parser.cpp" /* yacc.c:1646 */ 3765| 17.2k| break; 3766| | 3767| 20.6k| case 64: ------------------ | Branch (3767:3): [True: 20.6k, False: 10.2M] ------------------ 3768| 20.6k|#line 702 "bison_parser.y" /* yacc.c:1646 */ 3769| 20.6k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3770| 20.6k|#line 3771 "bison_parser.cpp" /* yacc.c:1646 */ 3771| 20.6k| break; 3772| | 3773| 1.77k| case 65: ------------------ | Branch (3773:3): [True: 1.77k, False: 10.2M] ------------------ 3774| 1.77k|#line 703 "bison_parser.y" /* yacc.c:1646 */ 3775| 1.77k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3776| 1.77k|#line 3777 "bison_parser.cpp" /* yacc.c:1646 */ 3777| 1.77k| break; 3778| | 3779| 20.6k| case 66: ------------------ | Branch (3779:3): [True: 20.6k, False: 10.2M] ------------------ 3780| 20.6k|#line 705 "bison_parser.y" /* yacc.c:1646 */ 3781| 20.6k| { 3782| 20.6k| (yyval.column_t) = new ColumnDefinition((yyvsp[-2].sval), (yyvsp[-1].column_type_t), (yyvsp[0].column_constraints_t)->constraints, (yyvsp[0].column_constraints_t)->references); 3783| 20.6k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3783:7): [True: 1.51k, False: 19.0k] ------------------ 3784| 1.51k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 67| 1.51k|#define yyerror hsql_error ------------------ 3785| 1.51k| } 3786| 20.6k| delete (yyvsp[0].column_constraints_t); 3787| 20.6k|} 3788| 20.6k|#line 3789 "bison_parser.cpp" /* yacc.c:1646 */ 3789| 20.6k| break; 3790| | 3791| 781| case 67: ------------------ | Branch (3791:3): [True: 781, False: 10.2M] ------------------ 3792| 781|#line 713 "bison_parser.y" /* yacc.c:1646 */ 3793| 781| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3794| 781|#line 3795 "bison_parser.cpp" /* yacc.c:1646 */ 3795| 781| break; 3796| | 3797| 622| case 68: ------------------ | Branch (3797:3): [True: 622, False: 10.2M] ------------------ 3798| 622|#line 714 "bison_parser.y" /* yacc.c:1646 */ 3799| 622| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3800| 622|#line 3801 "bison_parser.cpp" /* yacc.c:1646 */ 3801| 622| break; 3802| | 3803| 483| case 69: ------------------ | Branch (3803:3): [True: 483, False: 10.2M] ------------------ 3804| 483|#line 715 "bison_parser.y" /* yacc.c:1646 */ 3805| 483| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3806| 483|#line 3807 "bison_parser.cpp" /* yacc.c:1646 */ 3807| 483| break; 3808| | 3809| 0| case 70: ------------------ | Branch (3809:3): [True: 0, False: 10.2M] ------------------ 3810| 0|#line 716 "bison_parser.y" /* yacc.c:1646 */ 3811| 0| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3812| 0|#line 3813 "bison_parser.cpp" /* yacc.c:1646 */ 3813| 0| break; 3814| | 3815| 3.38k| case 71: ------------------ | Branch (3815:3): [True: 3.38k, False: 10.2M] ------------------ 3816| 3.38k|#line 717 "bison_parser.y" /* yacc.c:1646 */ 3817| 3.38k| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3818| 3.38k|#line 3819 "bison_parser.cpp" /* yacc.c:1646 */ 3819| 3.38k| break; 3820| | 3821| 555| case 72: ------------------ | Branch (3821:3): [True: 555, False: 10.2M] ------------------ 3822| 555|#line 718 "bison_parser.y" /* yacc.c:1646 */ 3823| 555| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3824| 555|#line 3825 "bison_parser.cpp" /* yacc.c:1646 */ 3825| 555| break; 3826| | 3827| 1.12k| case 73: ------------------ | Branch (3827:3): [True: 1.12k, False: 10.2M] ------------------ 3828| 1.12k|#line 719 "bison_parser.y" /* yacc.c:1646 */ 3829| 1.12k| { 3830| 1.12k| (yyval.column_type_t) = ColumnType{DataType::DECIMAL, 0, (yyvsp[0].ival_pair)->first, (yyvsp[0].ival_pair)->second}; 3831| 1.12k| delete (yyvsp[0].ival_pair); 3832| 1.12k|} 3833| 1.12k|#line 3834 "bison_parser.cpp" /* yacc.c:1646 */ 3834| 1.12k| break; 3835| | 3836| 885| case 74: ------------------ | Branch (3836:3): [True: 885, False: 10.2M] ------------------ 3837| 885|#line 723 "bison_parser.y" /* yacc.c:1646 */ 3838| 885| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3839| 885|#line 3840 "bison_parser.cpp" /* yacc.c:1646 */ 3840| 885| break; 3841| | 3842| 691| case 75: ------------------ | Branch (3842:3): [True: 691, False: 10.2M] ------------------ 3843| 691|#line 724 "bison_parser.y" /* yacc.c:1646 */ 3844| 691| { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } 3845| 691|#line 3846 "bison_parser.cpp" /* yacc.c:1646 */ 3846| 691| break; 3847| | 3848| 6.96k| case 76: ------------------ | Branch (3848:3): [True: 6.96k, False: 10.2M] ------------------ 3849| 6.96k|#line 725 "bison_parser.y" /* yacc.c:1646 */ 3850| 6.96k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3851| 6.96k|#line 3852 "bison_parser.cpp" /* yacc.c:1646 */ 3852| 6.96k| break; 3853| | 3854| 669| case 77: ------------------ | Branch (3854:3): [True: 669, False: 10.2M] ------------------ 3855| 669|#line 726 "bison_parser.y" /* yacc.c:1646 */ 3856| 669| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3857| 669|#line 3858 "bison_parser.cpp" /* yacc.c:1646 */ 3858| 669| break; 3859| | 3860| 1.03k| case 78: ------------------ | Branch (3860:3): [True: 1.03k, False: 10.2M] ------------------ 3861| 1.03k|#line 727 "bison_parser.y" /* yacc.c:1646 */ 3862| 1.03k| { (yyval.column_type_t) = ColumnType{DataType::LONG}; } 3863| 1.03k|#line 3864 "bison_parser.cpp" /* yacc.c:1646 */ 3864| 1.03k| break; 3865| | 3866| 568| case 79: ------------------ | Branch (3866:3): [True: 568, False: 10.2M] ------------------ 3867| 568|#line 728 "bison_parser.y" /* yacc.c:1646 */ 3868| 568| { (yyval.column_type_t) = ColumnType{DataType::REAL}; } 3869| 568|#line 3870 "bison_parser.cpp" /* yacc.c:1646 */ 3870| 568| break; 3871| | 3872| 534| case 80: ------------------ | Branch (3872:3): [True: 534, False: 10.2M] ------------------ 3873| 534|#line 729 "bison_parser.y" /* yacc.c:1646 */ 3874| 534| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3875| 534|#line 3876 "bison_parser.cpp" /* yacc.c:1646 */ 3876| 534| break; 3877| | 3878| 402| case 81: ------------------ | Branch (3878:3): [True: 402, False: 10.2M] ------------------ 3879| 402|#line 730 "bison_parser.y" /* yacc.c:1646 */ 3880| 402| { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } 3881| 402|#line 3882 "bison_parser.cpp" /* yacc.c:1646 */ 3882| 402| break; 3883| | 3884| 967| case 82: ------------------ | Branch (3884:3): [True: 967, False: 10.2M] ------------------ 3885| 967|#line 731 "bison_parser.y" /* yacc.c:1646 */ 3886| 967| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3887| 967|#line 3888 "bison_parser.cpp" /* yacc.c:1646 */ 3888| 967| break; 3889| | 3890| 628| case 83: ------------------ | Branch (3890:3): [True: 628, False: 10.2M] ------------------ 3891| 628|#line 732 "bison_parser.y" /* yacc.c:1646 */ 3892| 628| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3893| 628|#line 3894 "bison_parser.cpp" /* yacc.c:1646 */ 3894| 628| break; 3895| | 3896| 723| case 84: ------------------ | Branch (3896:3): [True: 723, False: 10.2M] ------------------ 3897| 723|#line 733 "bison_parser.y" /* yacc.c:1646 */ 3898| 723| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3899| 723|#line 3900 "bison_parser.cpp" /* yacc.c:1646 */ 3900| 723| break; 3901| | 3902| 280| case 85: ------------------ | Branch (3902:3): [True: 280, False: 10.2M] ------------------ 3903| 280|#line 735 "bison_parser.y" /* yacc.c:1646 */ 3904| 280| { (yyval.ival) = (yyvsp[-1].ival); } 3905| 280|#line 3906 "bison_parser.cpp" /* yacc.c:1646 */ 3906| 280| break; 3907| | 3908| 687| case 86: ------------------ | Branch (3908:3): [True: 687, False: 10.2M] ------------------ 3909| 687|#line 736 "bison_parser.y" /* yacc.c:1646 */ 3910| 687| { (yyval.ival) = 0; } 3911| 687|#line 3912 "bison_parser.cpp" /* yacc.c:1646 */ 3912| 687| break; 3913| | 3914| 334| case 87: ------------------ | Branch (3914:3): [True: 334, False: 10.2M] ------------------ 3915| 334|#line 738 "bison_parser.y" /* yacc.c:1646 */ 3916| 334| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3917| 334|#line 3918 "bison_parser.cpp" /* yacc.c:1646 */ 3918| 334| break; 3919| | 3920| 304| case 88: ------------------ | Branch (3920:3): [True: 304, False: 10.2M] ------------------ 3921| 304|#line 739 "bison_parser.y" /* yacc.c:1646 */ 3922| 304| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3923| 304|#line 3924 "bison_parser.cpp" /* yacc.c:1646 */ 3924| 304| break; 3925| | 3926| 485| case 89: ------------------ | Branch (3926:3): [True: 485, False: 10.2M] ------------------ 3927| 485|#line 740 "bison_parser.y" /* yacc.c:1646 */ 3928| 485| { (yyval.ival_pair) = new std::pair{0, 0}; } 3929| 485|#line 3930 "bison_parser.cpp" /* yacc.c:1646 */ 3930| 485| break; 3931| | 3932| 2.95k| case 90: ------------------ | Branch (3932:3): [True: 2.95k, False: 10.2M] ------------------ 3933| 2.95k|#line 742 "bison_parser.y" /* yacc.c:1646 */ 3934| 2.95k| { (yyval.column_constraints_t) = (yyvsp[0].column_constraints_t); } 3935| 2.95k|#line 3936 "bison_parser.cpp" /* yacc.c:1646 */ 3936| 2.95k| break; 3937| | 3938| 17.6k| case 91: ------------------ | Branch (3938:3): [True: 17.6k, False: 10.2M] ------------------ 3939| 17.6k|#line 743 "bison_parser.y" /* yacc.c:1646 */ 3940| 17.6k| { (yyval.column_constraints_t) = new ColumnConstraints(); } 3941| 17.6k|#line 3942 "bison_parser.cpp" /* yacc.c:1646 */ 3942| 17.6k| break; 3943| | 3944| 2.96k| case 92: ------------------ | Branch (3944:3): [True: 2.96k, False: 10.2M] ------------------ 3945| 2.96k|#line 745 "bison_parser.y" /* yacc.c:1646 */ 3946| 2.96k| { 3947| 2.96k| (yyval.column_constraints_t) = new ColumnConstraints(); 3948| 2.96k| (yyval.column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3949| 2.96k|} 3950| 2.96k|#line 3951 "bison_parser.cpp" /* yacc.c:1646 */ 3951| 2.96k| break; 3952| | 3953| 5.21k| case 93: ------------------ | Branch (3953:3): [True: 5.21k, False: 10.2M] ------------------ 3954| 5.21k|#line 749 "bison_parser.y" /* yacc.c:1646 */ 3955| 5.21k| { 3956| 5.21k| (yyvsp[-1].column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3957| 5.21k| (yyval.column_constraints_t) = (yyvsp[-1].column_constraints_t); 3958| 5.21k|} 3959| 5.21k|#line 3960 "bison_parser.cpp" /* yacc.c:1646 */ 3960| 5.21k| break; 3961| | 3962| 0| case 94: ------------------ | Branch (3962:3): [True: 0, False: 10.2M] ------------------ 3963| 0|#line 753 "bison_parser.y" /* yacc.c:1646 */ 3964| 0| { 3965| 0| (yyval.column_constraints_t) = new ColumnConstraints(); 3966| 0| (yyval.column_constraints_t)->constraints->insert(ConstraintType::ForeignKey); 3967| 0| (yyval.column_constraints_t)->references->emplace_back((yyvsp[0].references_spec_t)); 3968| 0|} 3969| 0|#line 3970 "bison_parser.cpp" /* yacc.c:1646 */ 3970| 0| break; 3971| | 3972| 0| case 95: ------------------ | Branch (3972:3): [True: 0, False: 10.2M] ------------------ 3973| 0|#line 758 "bison_parser.y" /* yacc.c:1646 */ 3974| 0| { 3975| | // Multiple foreign keys for the same column could be possible, so we do not raise an error in that case. 3976| | // Think of foreign keys referenced on multiple levels (returned item references sold item references items). 3977| 0| (yyvsp[-1].column_constraints_t)->constraints->insert(ConstraintType::ForeignKey); 3978| 0| (yyvsp[-1].column_constraints_t)->references->emplace_back((yyvsp[0].references_spec_t)); 3979| 0| (yyval.column_constraints_t) = (yyvsp[-1].column_constraints_t); 3980| 0|} 3981| 0|#line 3982 "bison_parser.cpp" /* yacc.c:1646 */ 3982| 0| break; 3983| | 3984| 1.62k| case 96: ------------------ | Branch (3984:3): [True: 1.62k, False: 10.2M] ------------------ 3985| 1.62k|#line 766 "bison_parser.y" /* yacc.c:1646 */ 3986| 1.62k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3987| 1.62k|#line 3988 "bison_parser.cpp" /* yacc.c:1646 */ 3988| 1.62k| break; 3989| | 3990| 2.01k| case 97: ------------------ | Branch (3990:3): [True: 2.01k, False: 10.2M] ------------------ 3991| 2.01k|#line 767 "bison_parser.y" /* yacc.c:1646 */ 3992| 2.01k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3993| 2.01k|#line 3994 "bison_parser.cpp" /* yacc.c:1646 */ 3994| 2.01k| break; 3995| | 3996| 2.65k| case 98: ------------------ | Branch (3996:3): [True: 2.65k, False: 10.2M] ------------------ 3997| 2.65k|#line 768 "bison_parser.y" /* yacc.c:1646 */ 3998| 2.65k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3999| 2.65k|#line 4000 "bison_parser.cpp" /* yacc.c:1646 */ 4000| 2.65k| break; 4001| | 4002| 1.88k| case 99: ------------------ | Branch (4002:3): [True: 1.88k, False: 10.2M] ------------------ 4003| 1.88k|#line 769 "bison_parser.y" /* yacc.c:1646 */ 4004| 1.88k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 4005| 1.88k|#line 4006 "bison_parser.cpp" /* yacc.c:1646 */ 4006| 1.88k| break; 4007| | 4008| 237| case 100: ------------------ | Branch (4008:3): [True: 237, False: 10.2M] ------------------ 4009| 237|#line 771 "bison_parser.y" /* yacc.c:1646 */ 4010| 237| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 4011| 237|#line 4012 "bison_parser.cpp" /* yacc.c:1646 */ 4012| 237| break; 4013| | 4014| 1.53k| case 101: ------------------ | Branch (4014:3): [True: 1.53k, False: 10.2M] ------------------ 4015| 1.53k|#line 772 "bison_parser.y" /* yacc.c:1646 */ 4016| 1.53k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 4017| 1.53k|#line 4018 "bison_parser.cpp" /* yacc.c:1646 */ 4018| 1.53k| break; 4019| | 4020| 0| case 102: ------------------ | Branch (4020:3): [True: 0, False: 10.2M] ------------------ 4021| 0|#line 773 "bison_parser.y" /* yacc.c:1646 */ 4022| 0| { (yyval.table_constraint_t) = new ForeignKeyConstraint((yyvsp[-2].str_vec), (yyvsp[0].references_spec_t)); } 4023| 0|#line 4024 "bison_parser.cpp" /* yacc.c:1646 */ 4024| 0| break; 4025| | 4026| 0| case 103: ------------------ | Branch (4026:3): [True: 0, False: 10.2M] ------------------ 4027| 0|#line 775 "bison_parser.y" /* yacc.c:1646 */ 4028| 0| { (yyval.references_spec_t) = new ReferencesSpecification((yyvsp[-1].table_name).schema, (yyvsp[-1].table_name).name, (yyvsp[0].str_vec)); } 4029| 0|#line 4030 "bison_parser.cpp" /* yacc.c:1646 */ 4030| 0| break; 4031| | 4032| 1.07k| case 104: ------------------ | Branch (4032:3): [True: 1.07k, False: 10.2M] ------------------ 4033| 1.07k|#line 783 "bison_parser.y" /* yacc.c:1646 */ 4034| 1.07k| { 4035| 1.07k| (yyval.drop_stmt) = new DropStatement(kDropTable); 4036| 1.07k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4037| 1.07k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4038| 1.07k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4039| 1.07k|} 4040| 1.07k|#line 4041 "bison_parser.cpp" /* yacc.c:1646 */ 4041| 1.07k| break; 4042| | 4043| 1.58k| case 105: ------------------ | Branch (4043:3): [True: 1.58k, False: 10.2M] ------------------ 4044| 1.58k|#line 789 "bison_parser.y" /* yacc.c:1646 */ 4045| 1.58k| { 4046| 1.58k| (yyval.drop_stmt) = new DropStatement(kDropView); 4047| 1.58k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4048| 1.58k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4049| 1.58k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4050| 1.58k|} 4051| 1.58k|#line 4052 "bison_parser.cpp" /* yacc.c:1646 */ 4052| 1.58k| break; 4053| | 4054| 854| case 106: ------------------ | Branch (4054:3): [True: 854, False: 10.2M] ------------------ 4055| 854|#line 795 "bison_parser.y" /* yacc.c:1646 */ 4056| 854| { 4057| 854| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 4058| 854| (yyval.drop_stmt)->ifExists = false; 4059| 854| (yyval.drop_stmt)->name = (yyvsp[0].sval); 4060| 854|} 4061| 854|#line 4062 "bison_parser.cpp" /* yacc.c:1646 */ 4062| 854| break; 4063| | 4064| 563| case 107: ------------------ | Branch (4064:3): [True: 563, False: 10.2M] ------------------ 4065| 563|#line 801 "bison_parser.y" /* yacc.c:1646 */ 4066| 563| { 4067| 563| (yyval.drop_stmt) = new DropStatement(kDropIndex); 4068| 563| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4069| 563| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 4070| 563|} 4071| 563|#line 4072 "bison_parser.cpp" /* yacc.c:1646 */ 4072| 563| break; 4073| | 4074| 450| case 108: ------------------ | Branch (4074:3): [True: 450, False: 10.2M] ------------------ 4075| 450|#line 807 "bison_parser.y" /* yacc.c:1646 */ 4076| 450| { (yyval.bval) = true; } 4077| 450|#line 4078 "bison_parser.cpp" /* yacc.c:1646 */ 4078| 450| break; 4079| | 4080| 2.79k| case 109: ------------------ | Branch (4080:3): [True: 2.79k, False: 10.2M] ------------------ 4081| 2.79k|#line 808 "bison_parser.y" /* yacc.c:1646 */ 4082| 2.79k| { (yyval.bval) = false; } 4083| 2.79k|#line 4084 "bison_parser.cpp" /* yacc.c:1646 */ 4084| 2.79k| break; 4085| | 4086| 0| case 110: ------------------ | Branch (4086:3): [True: 0, False: 10.2M] ------------------ 4087| 0|#line 815 "bison_parser.y" /* yacc.c:1646 */ 4088| 0| { 4089| 0| (yyval.alter_stmt) = new AlterStatement((yyvsp[-1].table_name).name, (yyvsp[0].alter_action_t)); 4090| 0| (yyval.alter_stmt)->ifTableExists = (yyvsp[-2].bval); 4091| 0| (yyval.alter_stmt)->schema = (yyvsp[-1].table_name).schema; 4092| 0|} 4093| 0|#line 4094 "bison_parser.cpp" /* yacc.c:1646 */ 4094| 0| break; 4095| | 4096| 0| case 111: ------------------ | Branch (4096:3): [True: 0, False: 10.2M] ------------------ 4097| 0|#line 821 "bison_parser.y" /* yacc.c:1646 */ 4098| 0| { (yyval.alter_action_t) = (yyvsp[0].drop_action_t); } 4099| 0|#line 4100 "bison_parser.cpp" /* yacc.c:1646 */ 4100| 0| break; 4101| | 4102| 0| case 112: ------------------ | Branch (4102:3): [True: 0, False: 10.2M] ------------------ 4103| 0|#line 823 "bison_parser.y" /* yacc.c:1646 */ 4104| 0| { 4105| 0| (yyval.drop_action_t) = new DropColumnAction((yyvsp[0].sval)); 4106| 0| (yyval.drop_action_t)->ifExists = (yyvsp[-1].bval); 4107| 0|} 4108| 0|#line 4109 "bison_parser.cpp" /* yacc.c:1646 */ 4109| 0| break; 4110| | 4111| 1.70k| case 113: ------------------ | Branch (4111:3): [True: 1.70k, False: 10.2M] ------------------ 4112| 1.70k|#line 833 "bison_parser.y" /* yacc.c:1646 */ 4113| 1.70k| { 4114| 1.70k| (yyval.delete_stmt) = new DeleteStatement(); 4115| 1.70k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 4116| 1.70k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 4117| 1.70k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 4118| 1.70k|} 4119| 1.70k|#line 4120 "bison_parser.cpp" /* yacc.c:1646 */ 4120| 1.70k| break; 4121| | 4122| 349| case 114: ------------------ | Branch (4122:3): [True: 349, False: 10.2M] ------------------ 4123| 349|#line 840 "bison_parser.y" /* yacc.c:1646 */ 4124| 349| { 4125| 349| (yyval.delete_stmt) = new DeleteStatement(); 4126| 349| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 4127| 349| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 4128| 349|} 4129| 349|#line 4130 "bison_parser.cpp" /* yacc.c:1646 */ 4130| 349| break; 4131| | 4132| 584| case 115: ------------------ | Branch (4132:3): [True: 584, False: 10.2M] ------------------ 4133| 584|#line 851 "bison_parser.y" /* yacc.c:1646 */ 4134| 584| { 4135| 584| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 4136| 584| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 4137| 584| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 4138| 584| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 4139| 584| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 4140| 584|} 4141| 584|#line 4142 "bison_parser.cpp" /* yacc.c:1646 */ 4142| 584| break; 4143| | 4144| 3.12k| case 116: ------------------ | Branch (4144:3): [True: 3.12k, False: 10.2M] ------------------ 4145| 3.12k|#line 858 "bison_parser.y" /* yacc.c:1646 */ 4146| 3.12k| { 4147| 3.12k| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 4148| 3.12k| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 4149| 3.12k| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 4150| 3.12k| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 4151| 3.12k| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 4152| 3.12k|} 4153| 3.12k|#line 4154 "bison_parser.cpp" /* yacc.c:1646 */ 4154| 3.12k| break; 4155| | 4156| 1.07k| case 117: ------------------ | Branch (4156:3): [True: 1.07k, False: 10.2M] ------------------ 4157| 1.07k|#line 866 "bison_parser.y" /* yacc.c:1646 */ 4158| 1.07k| { (yyval.str_vec) = (yyvsp[-1].str_vec); } 4159| 1.07k|#line 4160 "bison_parser.cpp" /* yacc.c:1646 */ 4160| 1.07k| break; 4161| | 4162| 4.89k| case 118: ------------------ | Branch (4162:3): [True: 4.89k, False: 10.2M] ------------------ 4163| 4.89k|#line 867 "bison_parser.y" /* yacc.c:1646 */ 4164| 4.89k| { (yyval.str_vec) = nullptr; } 4165| 4.89k|#line 4166 "bison_parser.cpp" /* yacc.c:1646 */ 4166| 4.89k| break; 4167| | 4168| 1.91k| case 119: ------------------ | Branch (4168:3): [True: 1.91k, False: 10.2M] ------------------ 4169| 1.91k|#line 874 "bison_parser.y" /* yacc.c:1646 */ 4170| 1.91k| { 4171| 1.91k| (yyval.update_stmt) = new UpdateStatement(); 4172| 1.91k| (yyval.update_stmt)->table = (yyvsp[-3].table); 4173| 1.91k| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4174| 1.91k| (yyval.update_stmt)->where = (yyvsp[0].expr); 4175| 1.91k|} 4176| 1.91k|#line 4177 "bison_parser.cpp" /* yacc.c:1646 */ 4177| 1.91k| break; 4178| | 4179| 1.92k| case 120: ------------------ | Branch (4179:3): [True: 1.92k, False: 10.2M] ------------------ 4180| 1.92k|#line 881 "bison_parser.y" /* yacc.c:1646 */ 4181| 1.92k| { 4182| 1.92k| (yyval.update_vec) = new std::vector(); 4183| 1.92k| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4184| 1.92k|} 4185| 1.92k|#line 4186 "bison_parser.cpp" /* yacc.c:1646 */ 4186| 1.92k| break; 4187| | 4188| 1.52k| case 121: ------------------ | Branch (4188:3): [True: 1.52k, False: 10.2M] ------------------ 4189| 1.52k|#line 885 "bison_parser.y" /* yacc.c:1646 */ 4190| 1.52k| { 4191| 1.52k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4192| 1.52k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4193| 1.52k|} 4194| 1.52k|#line 4195 "bison_parser.cpp" /* yacc.c:1646 */ 4195| 1.52k| break; 4196| | 4197| 3.45k| case 122: ------------------ | Branch (4197:3): [True: 3.45k, False: 10.2M] ------------------ 4198| 3.45k|#line 890 "bison_parser.y" /* yacc.c:1646 */ 4199| 3.45k| { 4200| 3.45k| (yyval.update_t) = new UpdateClause(); 4201| 3.45k| (yyval.update_t)->column = (yyvsp[-2].sval); 4202| 3.45k| (yyval.update_t)->value = (yyvsp[0].expr); 4203| 3.45k|} 4204| 3.45k|#line 4205 "bison_parser.cpp" /* yacc.c:1646 */ 4205| 3.45k| break; 4206| | 4207| 537| case 123: ------------------ | Branch (4207:3): [True: 537, False: 10.2M] ------------------ 4208| 537|#line 900 "bison_parser.y" /* yacc.c:1646 */ 4209| 537| { 4210| 537| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4211| 537| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4212| 537|} 4213| 537|#line 4214 "bison_parser.cpp" /* yacc.c:1646 */ 4214| 537| break; 4215| | 4216| 24.2k| case 124: ------------------ | Branch (4216:3): [True: 24.2k, False: 10.2M] ------------------ 4217| 24.2k|#line 904 "bison_parser.y" /* yacc.c:1646 */ 4218| 24.2k| { 4219| 24.2k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4220| 24.2k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4221| 24.2k|} 4222| 24.2k|#line 4223 "bison_parser.cpp" /* yacc.c:1646 */ 4223| 24.2k| break; 4224| | 4225| 2.08k| case 125: ------------------ | Branch (4225:3): [True: 2.08k, False: 10.2M] ------------------ 4226| 2.08k|#line 908 "bison_parser.y" /* yacc.c:1646 */ 4227| 2.08k| { 4228| 2.08k| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4229| 2.08k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4229:7): [True: 1.78k, False: 295] ------------------ 4230| 1.78k| (yyval.select_stmt)->setOperations = new std::vector(); 4231| 1.78k| } 4232| 2.08k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4233| 2.08k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4234| 2.08k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4235| 2.08k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4236| 2.08k| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4237| 2.08k|} 4238| 2.08k|#line 4239 "bison_parser.cpp" /* yacc.c:1646 */ 4239| 2.08k| break; 4240| | 4241| 3.34k| case 128: ------------------ | Branch (4241:3): [True: 3.34k, False: 10.2M] ------------------ 4242| 3.34k|#line 922 "bison_parser.y" /* yacc.c:1646 */ 4243| 3.34k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4244| 3.34k|#line 4245 "bison_parser.cpp" /* yacc.c:1646 */ 4245| 3.34k| break; 4246| | 4247| 1.38k| case 129: ------------------ | Branch (4247:3): [True: 1.38k, False: 10.2M] ------------------ 4248| 1.38k|#line 923 "bison_parser.y" /* yacc.c:1646 */ 4249| 1.38k| { 4250| 1.38k| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4251| 1.38k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4251:7): [True: 1.38k, False: 0] ------------------ 4252| 1.38k| (yyval.select_stmt)->setOperations = new std::vector(); 4253| 1.38k| } 4254| 1.38k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4255| 1.38k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4256| 1.38k|} 4257| 1.38k|#line 4258 "bison_parser.cpp" /* yacc.c:1646 */ 4258| 1.38k| break; 4259| | 4260| 5.31k| case 130: ------------------ | Branch (4260:3): [True: 5.31k, False: 10.2M] ------------------ 4261| 5.31k|#line 932 "bison_parser.y" /* yacc.c:1646 */ 4262| 5.31k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4263| 5.31k|#line 4264 "bison_parser.cpp" /* yacc.c:1646 */ 4264| 5.31k| break; 4265| | 4266| 200| case 131: ------------------ | Branch (4266:3): [True: 200, False: 10.2M] ------------------ 4267| 200|#line 933 "bison_parser.y" /* yacc.c:1646 */ 4268| 200| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4269| 200|#line 4270 "bison_parser.cpp" /* yacc.c:1646 */ 4270| 200| break; 4271| | 4272| 33.2k| case 132: ------------------ | Branch (4272:3): [True: 33.2k, False: 10.2M] ------------------ 4273| 33.2k|#line 935 "bison_parser.y" /* yacc.c:1646 */ 4274| 33.2k| { 4275| 33.2k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4276| 33.2k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4277| | 4278| | // Limit could have been set by TOP. 4279| 33.2k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4279:7): [True: 4.81k, False: 28.4k] ------------------ 4280| 4.81k| delete (yyval.select_stmt)->limit; 4281| 4.81k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4282| 4.81k| } 4283| | 4284| 33.2k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4284:7): [True: 439, False: 32.8k] ------------------ 4285| 439| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4286| 439| } 4287| 33.2k|} 4288| 33.2k|#line 4289 "bison_parser.cpp" /* yacc.c:1646 */ 4289| 33.2k| break; 4290| | 4291| 1.18k| case 133: ------------------ | Branch (4291:3): [True: 1.18k, False: 10.2M] ------------------ 4292| 1.18k|#line 949 "bison_parser.y" /* yacc.c:1646 */ 4293| 1.18k| { 4294| 1.18k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4295| 1.18k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4295:7): [True: 1.18k, False: 0] ------------------ 4296| 1.18k| (yyval.select_stmt)->setOperations = new std::vector(); 4297| 1.18k| } 4298| 1.18k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4299| 1.18k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4300| 1.18k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4301| 1.18k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4302| 1.18k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4303| 1.18k|} 4304| 1.18k|#line 4305 "bison_parser.cpp" /* yacc.c:1646 */ 4305| 1.18k| break; 4306| | 4307| 5.77k| case 134: ------------------ | Branch (4307:3): [True: 5.77k, False: 10.2M] ------------------ 4308| 5.77k|#line 961 "bison_parser.y" /* yacc.c:1646 */ 4309| 5.77k| { 4310| 5.77k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4311| 5.77k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4312| 5.77k|} 4313| 5.77k|#line 4314 "bison_parser.cpp" /* yacc.c:1646 */ 4314| 5.77k| break; 4315| | 4316| 4.32k| case 135: ------------------ | Branch (4316:3): [True: 4.32k, False: 10.2M] ------------------ 4317| 4.32k|#line 966 "bison_parser.y" /* yacc.c:1646 */ 4318| 4.32k| { 4319| 4.32k| (yyval.set_operator_t) = new SetOperation(); 4320| 4.32k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4321| 4.32k|} 4322| 4.32k|#line 4323 "bison_parser.cpp" /* yacc.c:1646 */ 4323| 4.32k| break; 4324| | 4325| 634| case 136: ------------------ | Branch (4325:3): [True: 634, False: 10.2M] ------------------ 4326| 634|#line 970 "bison_parser.y" /* yacc.c:1646 */ 4327| 634| { 4328| 634| (yyval.set_operator_t) = new SetOperation(); 4329| 634| (yyval.set_operator_t)->setType = SetType::kSetIntersect; 4330| 634|} 4331| 634|#line 4332 "bison_parser.cpp" /* yacc.c:1646 */ 4332| 634| break; 4333| | 4334| 815| case 137: ------------------ | Branch (4334:3): [True: 815, False: 10.2M] ------------------ 4335| 815|#line 974 "bison_parser.y" /* yacc.c:1646 */ 4336| 815| { 4337| 815| (yyval.set_operator_t) = new SetOperation(); 4338| 815| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4339| 815|} 4340| 815|#line 4341 "bison_parser.cpp" /* yacc.c:1646 */ 4341| 815| break; 4342| | 4343| 393| case 138: ------------------ | Branch (4343:3): [True: 393, False: 10.2M] ------------------ 4344| 393|#line 979 "bison_parser.y" /* yacc.c:1646 */ 4345| 393| { (yyval.bval) = true; } 4346| 393|#line 4347 "bison_parser.cpp" /* yacc.c:1646 */ 4347| 393| break; 4348| | 4349| 5.38k| case 139: ------------------ | Branch (4349:3): [True: 5.38k, False: 10.2M] ------------------ 4350| 5.38k|#line 980 "bison_parser.y" /* yacc.c:1646 */ 4351| 5.38k| { (yyval.bval) = false; } 4352| 5.38k|#line 4353 "bison_parser.cpp" /* yacc.c:1646 */ 4353| 5.38k| break; 4354| | 4355| 40.8k| case 140: ------------------ | Branch (4355:3): [True: 40.8k, False: 10.2M] ------------------ 4356| 40.8k|#line 982 "bison_parser.y" /* yacc.c:1646 */ 4357| 40.8k| { 4358| 40.8k| (yyval.select_stmt) = new SelectStatement(); 4359| 40.8k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4360| 40.8k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4361| 40.8k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4362| 40.8k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4363| 40.8k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4364| 40.8k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4365| 40.8k|} 4366| 40.8k|#line 4367 "bison_parser.cpp" /* yacc.c:1646 */ 4367| 40.8k| break; 4368| | 4369| 518| case 141: ------------------ | Branch (4369:3): [True: 518, False: 10.2M] ------------------ 4370| 518|#line 992 "bison_parser.y" /* yacc.c:1646 */ 4371| 518| { (yyval.bval) = true; } 4372| 518|#line 4373 "bison_parser.cpp" /* yacc.c:1646 */ 4373| 518| break; 4374| | 4375| 47.2k| case 142: ------------------ | Branch (4375:3): [True: 47.2k, False: 10.2M] ------------------ 4376| 47.2k|#line 993 "bison_parser.y" /* yacc.c:1646 */ 4377| 47.2k| { (yyval.bval) = false; } 4378| 47.2k|#line 4379 "bison_parser.cpp" /* yacc.c:1646 */ 4379| 47.2k| break; 4380| | 4381| 3.01k| case 144: ------------------ | Branch (4381:3): [True: 3.01k, False: 10.2M] ------------------ 4382| 3.01k|#line 997 "bison_parser.y" /* yacc.c:1646 */ 4383| 3.01k| { (yyval.table) = (yyvsp[0].table); } 4384| 3.01k|#line 4385 "bison_parser.cpp" /* yacc.c:1646 */ 4385| 3.01k| break; 4386| | 4387| 38.0k| case 145: ------------------ | Branch (4387:3): [True: 38.0k, False: 10.2M] ------------------ 4388| 38.0k|#line 998 "bison_parser.y" /* yacc.c:1646 */ 4389| 38.0k| { (yyval.table) = nullptr; } 4390| 38.0k|#line 4391 "bison_parser.cpp" /* yacc.c:1646 */ 4391| 38.0k| break; 4392| | 4393| 3.01k| case 146: ------------------ | Branch (4393:3): [True: 3.01k, False: 10.2M] ------------------ 4394| 3.01k|#line 1000 "bison_parser.y" /* yacc.c:1646 */ 4395| 3.01k| { (yyval.table) = (yyvsp[0].table); } 4396| 3.01k|#line 4397 "bison_parser.cpp" /* yacc.c:1646 */ 4397| 3.01k| break; 4398| | 4399| 1.85k| case 147: ------------------ | Branch (4399:3): [True: 1.85k, False: 10.2M] ------------------ 4400| 1.85k|#line 1002 "bison_parser.y" /* yacc.c:1646 */ 4401| 1.85k| { (yyval.expr) = (yyvsp[0].expr); } 4402| 1.85k|#line 4403 "bison_parser.cpp" /* yacc.c:1646 */ 4403| 1.85k| break; 4404| | 4405| 50.3k| case 148: ------------------ | Branch (4405:3): [True: 50.3k, False: 10.2M] ------------------ 4406| 50.3k|#line 1003 "bison_parser.y" /* yacc.c:1646 */ 4407| 50.3k| { (yyval.expr) = nullptr; } 4408| 50.3k|#line 4409 "bison_parser.cpp" /* yacc.c:1646 */ 4409| 50.3k| break; 4410| | 4411| 3.52k| case 149: ------------------ | Branch (4411:3): [True: 3.52k, False: 10.2M] ------------------ 4412| 3.52k|#line 1005 "bison_parser.y" /* yacc.c:1646 */ 4413| 3.52k| { 4414| 3.52k| (yyval.group_t) = new GroupByDescription(); 4415| 3.52k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4416| 3.52k| (yyval.group_t)->having = (yyvsp[0].expr); 4417| 3.52k|} 4418| 3.52k|#line 4419 "bison_parser.cpp" /* yacc.c:1646 */ 4419| 3.52k| break; 4420| | 4421| 37.3k| case 150: ------------------ | Branch (4421:3): [True: 37.3k, False: 10.2M] ------------------ 4422| 37.3k|#line 1010 "bison_parser.y" /* yacc.c:1646 */ 4423| 37.3k| { (yyval.group_t) = nullptr; } 4424| 37.3k|#line 4425 "bison_parser.cpp" /* yacc.c:1646 */ 4425| 37.3k| break; 4426| | 4427| 813| case 151: ------------------ | Branch (4427:3): [True: 813, False: 10.2M] ------------------ 4428| 813|#line 1012 "bison_parser.y" /* yacc.c:1646 */ 4429| 813| { (yyval.expr) = (yyvsp[0].expr); } 4430| 813|#line 4431 "bison_parser.cpp" /* yacc.c:1646 */ 4431| 813| break; 4432| | 4433| 2.71k| case 152: ------------------ | Branch (4433:3): [True: 2.71k, False: 10.2M] ------------------ 4434| 2.71k|#line 1013 "bison_parser.y" /* yacc.c:1646 */ 4435| 2.71k| { (yyval.expr) = nullptr; } 4436| 2.71k|#line 4437 "bison_parser.cpp" /* yacc.c:1646 */ 4437| 2.71k| break; 4438| | 4439| 2.64k| case 153: ------------------ | Branch (4439:3): [True: 2.64k, False: 10.2M] ------------------ 4440| 2.64k|#line 1015 "bison_parser.y" /* yacc.c:1646 */ 4441| 2.64k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4442| 2.64k|#line 4443 "bison_parser.cpp" /* yacc.c:1646 */ 4443| 2.64k| break; 4444| | 4445| 40.2k| case 154: ------------------ | Branch (4445:3): [True: 40.2k, False: 10.2M] ------------------ 4446| 40.2k|#line 1016 "bison_parser.y" /* yacc.c:1646 */ 4447| 40.2k| { (yyval.order_vec) = nullptr; } 4448| 40.2k|#line 4449 "bison_parser.cpp" /* yacc.c:1646 */ 4449| 40.2k| break; 4450| | 4451| 2.79k| case 155: ------------------ | Branch (4451:3): [True: 2.79k, False: 10.2M] ------------------ 4452| 2.79k|#line 1018 "bison_parser.y" /* yacc.c:1646 */ 4453| 2.79k| { 4454| 2.79k| (yyval.order_vec) = new std::vector(); 4455| 2.79k| (yyval.order_vec)->push_back((yyvsp[0].order)); 4456| 2.79k|} 4457| 2.79k|#line 4458 "bison_parser.cpp" /* yacc.c:1646 */ 4458| 2.79k| break; 4459| | 4460| 6.83k| case 156: ------------------ | Branch (4460:3): [True: 6.83k, False: 10.2M] ------------------ 4461| 6.83k|#line 1022 "bison_parser.y" /* yacc.c:1646 */ 4462| 6.83k| { 4463| 6.83k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4464| 6.83k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4465| 6.83k|} 4466| 6.83k|#line 4467 "bison_parser.cpp" /* yacc.c:1646 */ 4467| 6.83k| break; 4468| | 4469| 9.62k| case 157: ------------------ | Branch (4469:3): [True: 9.62k, False: 10.2M] ------------------ 4470| 9.62k|#line 1027 "bison_parser.y" /* yacc.c:1646 */ 4471| 9.62k| { (yyval.order) = new OrderDescription((yyvsp[-1].order_type), (yyvsp[-2].expr), (yyvsp[0].null_ordering_t)); } 4472| 9.62k|#line 4473 "bison_parser.cpp" /* yacc.c:1646 */ 4473| 9.62k| break; 4474| | 4475| 606| case 158: ------------------ | Branch (4475:3): [True: 606, False: 10.2M] ------------------ 4476| 606|#line 1029 "bison_parser.y" /* yacc.c:1646 */ 4477| 606| { (yyval.order_type) = kOrderAsc; } 4478| 606|#line 4479 "bison_parser.cpp" /* yacc.c:1646 */ 4479| 606| break; 4480| | 4481| 600| case 159: ------------------ | Branch (4481:3): [True: 600, False: 10.2M] ------------------ 4482| 600|#line 1030 "bison_parser.y" /* yacc.c:1646 */ 4483| 600| { (yyval.order_type) = kOrderDesc; } 4484| 600|#line 4485 "bison_parser.cpp" /* yacc.c:1646 */ 4485| 600| break; 4486| | 4487| 8.55k| case 160: ------------------ | Branch (4487:3): [True: 8.55k, False: 10.2M] ------------------ 4488| 8.55k|#line 1031 "bison_parser.y" /* yacc.c:1646 */ 4489| 8.55k| { (yyval.order_type) = kOrderAsc; } 4490| 8.55k|#line 4491 "bison_parser.cpp" /* yacc.c:1646 */ 4491| 8.55k| break; 4492| | 4493| 9.23k| case 161: ------------------ | Branch (4493:3): [True: 9.23k, False: 10.2M] ------------------ 4494| 9.23k|#line 1033 "bison_parser.y" /* yacc.c:1646 */ 4495| 9.23k| { (yyval.null_ordering_t) = NullOrdering::Undefined; } 4496| 9.23k|#line 4497 "bison_parser.cpp" /* yacc.c:1646 */ 4497| 9.23k| break; 4498| | 4499| 517| case 162: ------------------ | Branch (4499:3): [True: 517, False: 10.2M] ------------------ 4500| 517|#line 1034 "bison_parser.y" /* yacc.c:1646 */ 4501| 517| { 4502| 517| auto null_ordering = NullOrdering::Undefined; 4503| 517| if (strcasecmp((yyvsp[-1].sval), "nulls") == 0) { ------------------ | Branch (4503:7): [True: 463, False: 54] ------------------ 4504| 463| if (strcasecmp((yyvsp[0].sval), "first") == 0) { ------------------ | Branch (4504:9): [True: 195, False: 268] ------------------ 4505| 195| null_ordering = NullOrdering::First; 4506| 268| } else if (strcasecmp((yyvsp[0].sval), "last") == 0) { ------------------ | Branch (4506:16): [True: 196, False: 72] ------------------ 4507| 196| null_ordering = NullOrdering::Last; 4508| 196| } 4509| 463| } 4510| 517| free((yyvsp[-1].sval)); 4511| 517| free((yyvsp[0].sval)); 4512| | 4513| 517| if (null_ordering == NullOrdering::Undefined) { ------------------ | Branch (4513:7): [True: 126, False: 391] ------------------ 4514| 126| yyerror(&yyloc, result, scanner, "Expected NULLS FIRST or NULLS LAST ordering."); ------------------ | | 67| 126|#define yyerror hsql_error ------------------ 4515| 126| YYERROR; ------------------ | | 1458| 126|#define YYERROR goto yyerrorlab ------------------ 4516| 126| } 4517| | 4518| 391| (yyval.null_ordering_t) = null_ordering; 4519| 391|} 4520| 0|#line 4521 "bison_parser.cpp" /* yacc.c:1646 */ 4521| 0| break; 4522| | 4523| 3.61k| case 163: ------------------ | Branch (4523:3): [True: 3.61k, False: 10.2M] ------------------ 4524| 3.61k|#line 1056 "bison_parser.y" /* yacc.c:1646 */ 4525| 3.61k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4526| 3.61k|#line 4527 "bison_parser.cpp" /* yacc.c:1646 */ 4527| 3.61k| break; 4528| | 4529| 39.3k| case 164: ------------------ | Branch (4529:3): [True: 39.3k, False: 10.2M] ------------------ 4530| 39.3k|#line 1057 "bison_parser.y" /* yacc.c:1646 */ 4531| 39.3k| { (yyval.limit) = nullptr; } 4532| 39.3k|#line 4533 "bison_parser.cpp" /* yacc.c:1646 */ 4533| 39.3k| break; 4534| | 4535| 1.96k| case 165: ------------------ | Branch (4535:3): [True: 1.96k, False: 10.2M] ------------------ 4536| 1.96k|#line 1059 "bison_parser.y" /* yacc.c:1646 */ 4537| 1.96k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4538| 1.96k|#line 4539 "bison_parser.cpp" /* yacc.c:1646 */ 4539| 1.96k| break; 4540| | 4541| 1.92k| case 166: ------------------ | Branch (4541:3): [True: 1.92k, False: 10.2M] ------------------ 4542| 1.92k|#line 1060 "bison_parser.y" /* yacc.c:1646 */ 4543| 1.92k| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4544| 1.92k|#line 4545 "bison_parser.cpp" /* yacc.c:1646 */ 4545| 1.92k| break; 4546| | 4547| 445| case 167: ------------------ | Branch (4547:3): [True: 445, False: 10.2M] ------------------ 4548| 445|#line 1061 "bison_parser.y" /* yacc.c:1646 */ 4549| 445| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4550| 445|#line 4551 "bison_parser.cpp" /* yacc.c:1646 */ 4551| 445| break; 4552| | 4553| 1.78k| case 168: ------------------ | Branch (4553:3): [True: 1.78k, False: 10.2M] ------------------ 4554| 1.78k|#line 1062 "bison_parser.y" /* yacc.c:1646 */ 4555| 1.78k| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4556| 1.78k|#line 4557 "bison_parser.cpp" /* yacc.c:1646 */ 4557| 1.78k| break; 4558| | 4559| 303| case 169: ------------------ | Branch (4559:3): [True: 303, False: 10.2M] ------------------ 4560| 303|#line 1063 "bison_parser.y" /* yacc.c:1646 */ 4561| 303| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4562| 303|#line 4563 "bison_parser.cpp" /* yacc.c:1646 */ 4563| 303| break; 4564| | 4565| 30.1k| case 170: ------------------ | Branch (4565:3): [True: 30.1k, False: 10.2M] ------------------ 4566| 30.1k|#line 1064 "bison_parser.y" /* yacc.c:1646 */ 4567| 30.1k| { (yyval.limit) = nullptr; } 4568| 30.1k|#line 4569 "bison_parser.cpp" /* yacc.c:1646 */ 4569| 30.1k| break; 4570| | 4571| 50.8k| case 171: ------------------ | Branch (4571:3): [True: 50.8k, False: 10.2M] ------------------ 4572| 50.8k|#line 1069 "bison_parser.y" /* yacc.c:1646 */ 4573| 50.8k| { 4574| 50.8k| (yyval.expr_vec) = new std::vector(); 4575| 50.8k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4576| 50.8k|} 4577| 50.8k|#line 4578 "bison_parser.cpp" /* yacc.c:1646 */ 4578| 50.8k| break; 4579| | 4580| 116k| case 172: ------------------ | Branch (4580:3): [True: 116k, False: 10.1M] ------------------ 4581| 116k|#line 1073 "bison_parser.y" /* yacc.c:1646 */ 4582| 116k| { 4583| 116k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4584| 116k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4585| 116k|} 4586| 116k|#line 4587 "bison_parser.cpp" /* yacc.c:1646 */ 4587| 116k| break; 4588| | 4589| 302| case 173: ------------------ | Branch (4589:3): [True: 302, False: 10.2M] ------------------ 4590| 302|#line 1079 "bison_parser.y" /* yacc.c:1646 */ 4591| 302| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4592| 302|#line 4593 "bison_parser.cpp" /* yacc.c:1646 */ 4593| 302| break; 4594| | 4595| 254| case 174: ------------------ | Branch (4595:3): [True: 254, False: 10.2M] ------------------ 4596| 254|#line 1080 "bison_parser.y" /* yacc.c:1646 */ 4597| 254| { (yyval.expr_vec) = nullptr; } 4598| 254|#line 4599 "bison_parser.cpp" /* yacc.c:1646 */ 4599| 254| break; 4600| | 4601| 1.23k| case 175: ------------------ | Branch (4601:3): [True: 1.23k, False: 10.2M] ------------------ 4602| 1.23k|#line 1082 "bison_parser.y" /* yacc.c:1646 */ 4603| 1.23k| { 4604| 1.23k| (yyval.expr_vec) = new std::vector(); 4605| 1.23k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4606| 1.23k|} 4607| 1.23k|#line 4608 "bison_parser.cpp" /* yacc.c:1646 */ 4608| 1.23k| break; 4609| | 4610| 2.52k| case 176: ------------------ | Branch (4610:3): [True: 2.52k, False: 10.2M] ------------------ 4611| 2.52k|#line 1086 "bison_parser.y" /* yacc.c:1646 */ 4612| 2.52k| { 4613| 2.52k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4614| 2.52k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4615| 2.52k|} 4616| 2.52k|#line 4617 "bison_parser.cpp" /* yacc.c:1646 */ 4617| 2.52k| break; 4618| | 4619| 194| case 178: ------------------ | Branch (4619:3): [True: 194, False: 10.2M] ------------------ 4620| 194|#line 1091 "bison_parser.y" /* yacc.c:1646 */ 4621| 194| { 4622| 194| (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); 4623| 194|} 4624| 194|#line 4625 "bison_parser.cpp" /* yacc.c:1646 */ 4625| 194| break; 4626| | 4627| 3.01k| case 179: ------------------ | Branch (4627:3): [True: 3.01k, False: 10.2M] ------------------ 4628| 3.01k|#line 1095 "bison_parser.y" /* yacc.c:1646 */ 4629| 3.01k| { 4630| 3.01k| if ((yyvsp[0].expr)->type == ExprType::kExprParameter) { ------------------ | Branch (4630:7): [True: 1, False: 3.01k] ------------------ 4631| 1| delete (yyvsp[0].expr); 4632| 1| yyerror(&yyloc, result, scanner, "Parameter ? is not a valid literal."); ------------------ | | 67| 1|#define yyerror hsql_error ------------------ 4633| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 4634| 1| } 4635| 3.01k| (yyval.expr) = (yyvsp[0].expr); 4636| 3.01k|} 4637| 0|#line 4638 "bison_parser.cpp" /* yacc.c:1646 */ 4638| 0| break; 4639| | 4640| 555| case 180: ------------------ | Branch (4640:3): [True: 555, False: 10.2M] ------------------ 4641| 555|#line 1103 "bison_parser.y" /* yacc.c:1646 */ 4642| 555| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4643| 555|#line 4644 "bison_parser.cpp" /* yacc.c:1646 */ 4644| 555| break; 4645| | 4646| 195| case 181: ------------------ | Branch (4646:3): [True: 195, False: 10.2M] ------------------ 4647| 195|#line 1104 "bison_parser.y" /* yacc.c:1646 */ 4648| 195| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4649| 195|#line 4650 "bison_parser.cpp" /* yacc.c:1646 */ 4650| 195| break; 4651| | 4652| 167k| case 182: ------------------ | Branch (4652:3): [True: 167k, False: 10.0M] ------------------ 4653| 167k|#line 1106 "bison_parser.y" /* yacc.c:1646 */ 4654| 167k| { 4655| 167k| (yyval.expr) = (yyvsp[-1].expr); 4656| 167k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4656:7): [True: 12.9k, False: 154k] ------------------ 4657| 12.9k| (yyval.expr)->alias = (yyvsp[0].alias_t)->name; 4658| 12.9k| (yyvsp[0].alias_t)->name = nullptr; 4659| 12.9k| delete (yyvsp[0].alias_t); 4660| 12.9k| } 4661| 167k|} 4662| 167k|#line 4663 "bison_parser.cpp" /* yacc.c:1646 */ 4663| 167k| break; 4664| | 4665| 923| case 188: ------------------ | Branch (4665:3): [True: 923, False: 10.2M] ------------------ 4666| 923|#line 1117 "bison_parser.y" /* yacc.c:1646 */ 4667| 923| { (yyval.expr) = (yyvsp[-1].expr); } 4668| 923|#line 4669 "bison_parser.cpp" /* yacc.c:1646 */ 4669| 923| break; 4670| | 4671| 350| case 198: ------------------ | Branch (4671:3): [True: 350, False: 10.2M] ------------------ 4672| 350|#line 1119 "bison_parser.y" /* yacc.c:1646 */ 4673| 350| { 4674| 350| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4675| 350|} 4676| 350|#line 4677 "bison_parser.cpp" /* yacc.c:1646 */ 4677| 350| break; 4678| | 4679| 7.20k| case 201: ------------------ | Branch (4679:3): [True: 7.20k, False: 10.2M] ------------------ 4680| 7.20k|#line 1125 "bison_parser.y" /* yacc.c:1646 */ 4681| 7.20k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4682| 7.20k|#line 4683 "bison_parser.cpp" /* yacc.c:1646 */ 4683| 7.20k| break; 4684| | 4685| 1.95k| case 202: ------------------ | Branch (4685:3): [True: 1.95k, False: 10.2M] ------------------ 4686| 1.95k|#line 1126 "bison_parser.y" /* yacc.c:1646 */ 4687| 1.95k| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4688| 1.95k|#line 4689 "bison_parser.cpp" /* yacc.c:1646 */ 4689| 1.95k| break; 4690| | 4691| 765| case 203: ------------------ | Branch (4691:3): [True: 765, False: 10.2M] ------------------ 4692| 765|#line 1127 "bison_parser.y" /* yacc.c:1646 */ 4693| 765| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } 4694| 765|#line 4695 "bison_parser.cpp" /* yacc.c:1646 */ 4695| 765| break; 4696| | 4697| 412| case 204: ------------------ | Branch (4697:3): [True: 412, False: 10.2M] ------------------ 4698| 412|#line 1128 "bison_parser.y" /* yacc.c:1646 */ 4699| 412| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } 4700| 412|#line 4701 "bison_parser.cpp" /* yacc.c:1646 */ 4701| 412| break; 4702| | 4703| 194| case 205: ------------------ | Branch (4703:3): [True: 194, False: 10.2M] ------------------ 4704| 194|#line 1129 "bison_parser.y" /* yacc.c:1646 */ 4705| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } 4706| 194|#line 4707 "bison_parser.cpp" /* yacc.c:1646 */ 4707| 194| break; 4708| | 4709| 19.4k| case 207: ------------------ | Branch (4709:3): [True: 19.4k, False: 10.2M] ------------------ 4710| 19.4k|#line 1131 "bison_parser.y" /* yacc.c:1646 */ 4711| 19.4k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4712| 19.4k|#line 4713 "bison_parser.cpp" /* yacc.c:1646 */ 4713| 19.4k| break; 4714| | 4715| 7.39k| case 208: ------------------ | Branch (4715:3): [True: 7.39k, False: 10.2M] ------------------ 4716| 7.39k|#line 1132 "bison_parser.y" /* yacc.c:1646 */ 4717| 7.39k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4718| 7.39k|#line 4719 "bison_parser.cpp" /* yacc.c:1646 */ 4719| 7.39k| break; 4720| | 4721| 149k| case 209: ------------------ | Branch (4721:3): [True: 149k, False: 10.1M] ------------------ 4722| 149k|#line 1133 "bison_parser.y" /* yacc.c:1646 */ 4723| 149k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4724| 149k|#line 4725 "bison_parser.cpp" /* yacc.c:1646 */ 4725| 149k| break; 4726| | 4727| 834k| case 210: ------------------ | Branch (4727:3): [True: 834k, False: 9.41M] ------------------ 4728| 834k|#line 1134 "bison_parser.y" /* yacc.c:1646 */ 4729| 834k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4730| 834k|#line 4731 "bison_parser.cpp" /* yacc.c:1646 */ 4731| 834k| break; 4732| | 4733| 8.88k| case 211: ------------------ | Branch (4733:3): [True: 8.88k, False: 10.2M] ------------------ 4734| 8.88k|#line 1135 "bison_parser.y" /* yacc.c:1646 */ 4735| 8.88k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4736| 8.88k|#line 4737 "bison_parser.cpp" /* yacc.c:1646 */ 4737| 8.88k| break; 4738| | 4739| 4.58k| case 212: ------------------ | Branch (4739:3): [True: 4.58k, False: 10.2M] ------------------ 4740| 4.58k|#line 1136 "bison_parser.y" /* yacc.c:1646 */ 4741| 4.58k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4742| 4.58k|#line 4743 "bison_parser.cpp" /* yacc.c:1646 */ 4743| 4.58k| break; 4744| | 4745| 331| case 213: ------------------ | Branch (4745:3): [True: 331, False: 10.2M] ------------------ 4746| 331|#line 1137 "bison_parser.y" /* yacc.c:1646 */ 4747| 331| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4748| 331|#line 4749 "bison_parser.cpp" /* yacc.c:1646 */ 4749| 331| break; 4750| | 4751| 194| case 214: ------------------ | Branch (4751:3): [True: 194, False: 10.2M] ------------------ 4752| 194|#line 1138 "bison_parser.y" /* yacc.c:1646 */ 4753| 194| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4754| 194|#line 4755 "bison_parser.cpp" /* yacc.c:1646 */ 4755| 194| break; 4756| | 4757| 696| case 215: ------------------ | Branch (4757:3): [True: 696, False: 10.2M] ------------------ 4758| 696|#line 1139 "bison_parser.y" /* yacc.c:1646 */ 4759| 696| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4760| 696|#line 4761 "bison_parser.cpp" /* yacc.c:1646 */ 4761| 696| break; 4762| | 4763| 2.52k| case 216: ------------------ | Branch (4763:3): [True: 2.52k, False: 10.2M] ------------------ 4764| 2.52k|#line 1140 "bison_parser.y" /* yacc.c:1646 */ 4765| 2.52k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4766| 2.52k|#line 4767 "bison_parser.cpp" /* yacc.c:1646 */ 4767| 2.52k| break; 4768| | 4769| 853| case 217: ------------------ | Branch (4769:3): [True: 853, False: 10.2M] ------------------ 4770| 853|#line 1142 "bison_parser.y" /* yacc.c:1646 */ 4771| 853| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4772| 853|#line 4773 "bison_parser.cpp" /* yacc.c:1646 */ 4773| 853| break; 4774| | 4775| 568| case 218: ------------------ | Branch (4775:3): [True: 568, False: 10.2M] ------------------ 4776| 568|#line 1143 "bison_parser.y" /* yacc.c:1646 */ 4777| 568| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } 4778| 568|#line 4779 "bison_parser.cpp" /* yacc.c:1646 */ 4779| 568| break; 4780| | 4781| 365| case 219: ------------------ | Branch (4781:3): [True: 365, False: 10.2M] ------------------ 4782| 365|#line 1145 "bison_parser.y" /* yacc.c:1646 */ 4783| 365| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4784| 365|#line 4785 "bison_parser.cpp" /* yacc.c:1646 */ 4785| 365| break; 4786| | 4787| 198| case 220: ------------------ | Branch (4787:3): [True: 198, False: 10.2M] ------------------ 4788| 198|#line 1146 "bison_parser.y" /* yacc.c:1646 */ 4789| 198| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4790| 198|#line 4791 "bison_parser.cpp" /* yacc.c:1646 */ 4791| 198| break; 4792| | 4793| 308| case 221: ------------------ | Branch (4793:3): [True: 308, False: 10.2M] ------------------ 4794| 308|#line 1147 "bison_parser.y" /* yacc.c:1646 */ 4795| 308| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4796| 308|#line 4797 "bison_parser.cpp" /* yacc.c:1646 */ 4797| 308| break; 4798| | 4799| 218| case 222: ------------------ | Branch (4799:3): [True: 218, False: 10.2M] ------------------ 4800| 218|#line 1148 "bison_parser.y" /* yacc.c:1646 */ 4801| 218| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4802| 218|#line 4803 "bison_parser.cpp" /* yacc.c:1646 */ 4803| 218| break; 4804| | 4805| 303| case 223: ------------------ | Branch (4805:3): [True: 303, False: 10.2M] ------------------ 4806| 303|#line 1152 "bison_parser.y" /* yacc.c:1646 */ 4807| 303| { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } 4808| 303|#line 4809 "bison_parser.cpp" /* yacc.c:1646 */ 4809| 303| break; 4810| | 4811| 206| case 224: ------------------ | Branch (4811:3): [True: 206, False: 10.2M] ------------------ 4812| 206|#line 1153 "bison_parser.y" /* yacc.c:1646 */ 4813| 206| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4814| 206|#line 4815 "bison_parser.cpp" /* yacc.c:1646 */ 4815| 206| break; 4816| | 4817| 688| case 225: ------------------ | Branch (4817:3): [True: 688, False: 10.2M] ------------------ 4818| 688|#line 1154 "bison_parser.y" /* yacc.c:1646 */ 4819| 688| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4820| 688|#line 4821 "bison_parser.cpp" /* yacc.c:1646 */ 4821| 688| break; 4822| | 4823| 565| case 226: ------------------ | Branch (4823:3): [True: 565, False: 10.2M] ------------------ 4824| 565|#line 1155 "bison_parser.y" /* yacc.c:1646 */ 4825| 565| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4826| 565|#line 4827 "bison_parser.cpp" /* yacc.c:1646 */ 4827| 565| break; 4828| | 4829| 1.99k| case 227: ------------------ | Branch (4829:3): [True: 1.99k, False: 10.2M] ------------------ 4830| 1.99k|#line 1157 "bison_parser.y" /* yacc.c:1646 */ 4831| 1.99k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4832| 1.99k|#line 4833 "bison_parser.cpp" /* yacc.c:1646 */ 4833| 1.99k| break; 4834| | 4835| 1.36k| case 228: ------------------ | Branch (4835:3): [True: 1.36k, False: 10.2M] ------------------ 4836| 1.36k|#line 1158 "bison_parser.y" /* yacc.c:1646 */ 4837| 1.36k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4838| 1.36k|#line 4839 "bison_parser.cpp" /* yacc.c:1646 */ 4839| 1.36k| break; 4840| | 4841| 458| case 229: ------------------ | Branch (4841:3): [True: 458, False: 10.2M] ------------------ 4842| 458|#line 1160 "bison_parser.y" /* yacc.c:1646 */ 4843| 458| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4844| 458|#line 4845 "bison_parser.cpp" /* yacc.c:1646 */ 4845| 458| break; 4846| | 4847| 295| case 230: ------------------ | Branch (4847:3): [True: 295, False: 10.2M] ------------------ 4848| 295|#line 1161 "bison_parser.y" /* yacc.c:1646 */ 4849| 295| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4850| 295|#line 4851 "bison_parser.cpp" /* yacc.c:1646 */ 4851| 295| break; 4852| | 4853| 2.81k| case 231: ------------------ | Branch (4853:3): [True: 2.81k, False: 10.2M] ------------------ 4854| 2.81k|#line 1163 "bison_parser.y" /* yacc.c:1646 */ 4855| 2.81k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4856| 2.81k|#line 4857 "bison_parser.cpp" /* yacc.c:1646 */ 4857| 2.81k| break; 4858| | 4859| 509| case 232: ------------------ | Branch (4859:3): [True: 509, False: 10.2M] ------------------ 4860| 509|#line 1164 "bison_parser.y" /* yacc.c:1646 */ 4861| 509| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4862| 509|#line 4863 "bison_parser.cpp" /* yacc.c:1646 */ 4863| 509| break; 4864| | 4865| 1.45k| case 233: ------------------ | Branch (4865:3): [True: 1.45k, False: 10.2M] ------------------ 4866| 1.45k|#line 1165 "bison_parser.y" /* yacc.c:1646 */ 4867| 1.45k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4868| 1.45k|#line 4869 "bison_parser.cpp" /* yacc.c:1646 */ 4869| 1.45k| break; 4870| | 4871| 3.02k| case 234: ------------------ | Branch (4871:3): [True: 3.02k, False: 10.2M] ------------------ 4872| 3.02k|#line 1166 "bison_parser.y" /* yacc.c:1646 */ 4873| 3.02k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4874| 3.02k|#line 4875 "bison_parser.cpp" /* yacc.c:1646 */ 4875| 3.02k| break; 4876| | 4877| 5.60k| case 235: ------------------ | Branch (4877:3): [True: 5.60k, False: 10.2M] ------------------ 4878| 5.60k|#line 1167 "bison_parser.y" /* yacc.c:1646 */ 4879| 5.60k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4880| 5.60k|#line 4881 "bison_parser.cpp" /* yacc.c:1646 */ 4881| 5.60k| break; 4882| | 4883| 442| case 236: ------------------ | Branch (4883:3): [True: 442, False: 10.2M] ------------------ 4884| 442|#line 1168 "bison_parser.y" /* yacc.c:1646 */ 4885| 442| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4886| 442|#line 4887 "bison_parser.cpp" /* yacc.c:1646 */ 4887| 442| break; 4888| | 4889| 690| case 237: ------------------ | Branch (4889:3): [True: 690, False: 10.2M] ------------------ 4890| 690|#line 1169 "bison_parser.y" /* yacc.c:1646 */ 4891| 690| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4892| 690|#line 4893 "bison_parser.cpp" /* yacc.c:1646 */ 4893| 690| break; 4894| | 4895| 4.61k| case 238: ------------------ | Branch (4895:3): [True: 4.61k, False: 10.2M] ------------------ 4896| 4.61k|#line 1173 "bison_parser.y" /* yacc.c:1646 */ 4897| 4.61k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4898| 4.61k|#line 4899 "bison_parser.cpp" /* yacc.c:1646 */ 4899| 4.61k| break; 4900| | 4901| 3.22k| case 239: ------------------ | Branch (4901:3): [True: 3.22k, False: 10.2M] ------------------ 4902| 3.22k|#line 1174 "bison_parser.y" /* yacc.c:1646 */ 4903| 3.22k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4904| 3.22k|#line 4905 "bison_parser.cpp" /* yacc.c:1646 */ 4905| 3.22k| break; 4906| | 4907| 206| case 240: ------------------ | Branch (4907:3): [True: 206, False: 10.2M] ------------------ 4908| 206|#line 1175 "bison_parser.y" /* yacc.c:1646 */ 4909| 206| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), (yyvsp[-5].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4910| 206|#line 4911 "bison_parser.cpp" /* yacc.c:1646 */ 4911| 206| break; 4912| | 4913| 201| case 241: ------------------ | Branch (4913:3): [True: 201, False: 10.2M] ------------------ 4914| 201|#line 1176 "bison_parser.y" /* yacc.c:1646 */ 4915| 201| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-7].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4916| 201|#line 4917 "bison_parser.cpp" /* yacc.c:1646 */ 4917| 201| break; 4918| | 4919| 5.81k| case 242: ------------------ | Branch (4919:3): [True: 5.81k, False: 10.2M] ------------------ 4920| 5.81k|#line 1180 "bison_parser.y" /* yacc.c:1646 */ 4921| 5.81k| { (yyval.window_description) = new WindowDescription((yyvsp[-3].expr_vec), (yyvsp[-2].order_vec), (yyvsp[-1].frame_description)); } 4922| 5.81k|#line 4923 "bison_parser.cpp" /* yacc.c:1646 */ 4923| 5.81k| break; 4924| | 4925| 2.42k| case 243: ------------------ | Branch (4925:3): [True: 2.42k, False: 10.2M] ------------------ 4926| 2.42k|#line 1181 "bison_parser.y" /* yacc.c:1646 */ 4927| 2.42k| { (yyval.window_description) = nullptr; } 4928| 2.42k|#line 4929 "bison_parser.cpp" /* yacc.c:1646 */ 4929| 2.42k| break; 4930| | 4931| 671| case 244: ------------------ | Branch (4931:3): [True: 671, False: 10.2M] ------------------ 4932| 671|#line 1183 "bison_parser.y" /* yacc.c:1646 */ 4933| 671| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4934| 671|#line 4935 "bison_parser.cpp" /* yacc.c:1646 */ 4935| 671| break; 4936| | 4937| 5.36k| case 245: ------------------ | Branch (4937:3): [True: 5.36k, False: 10.2M] ------------------ 4938| 5.36k|#line 1184 "bison_parser.y" /* yacc.c:1646 */ 4939| 5.36k| { (yyval.expr_vec) = nullptr; } 4940| 5.36k|#line 4941 "bison_parser.cpp" /* yacc.c:1646 */ 4941| 5.36k| break; 4942| | 4943| 3.37k| case 246: ------------------ | Branch (4943:3): [True: 3.37k, False: 10.2M] ------------------ 4944| 3.37k|#line 1189 "bison_parser.y" /* yacc.c:1646 */ 4945| 3.37k| { (yyval.frame_description) = new FrameDescription{(yyvsp[-1].frame_type), (yyvsp[0].frame_bound), new FrameBound{0, kCurrentRow, false}}; } 4946| 3.37k|#line 4947 "bison_parser.cpp" /* yacc.c:1646 */ 4947| 3.37k| break; 4948| | 4949| 194| case 247: ------------------ | Branch (4949:3): [True: 194, False: 10.2M] ------------------ 4950| 194|#line 1190 "bison_parser.y" /* yacc.c:1646 */ 4951| 194| { (yyval.frame_description) = new FrameDescription{(yyvsp[-4].frame_type), (yyvsp[-2].frame_bound), (yyvsp[0].frame_bound)}; } 4952| 194|#line 4953 "bison_parser.cpp" /* yacc.c:1646 */ 4953| 194| break; 4954| | 4955| 2.31k| case 248: ------------------ | Branch (4955:3): [True: 2.31k, False: 10.2M] ------------------ 4956| 2.31k|#line 1191 "bison_parser.y" /* yacc.c:1646 */ 4957| 2.31k| { 4958| 2.31k| (yyval.frame_description) = new FrameDescription{kRange, new FrameBound{0, kPreceding, true}, new FrameBound{0, kCurrentRow, false}}; 4959| 2.31k|} 4960| 2.31k|#line 4961 "bison_parser.cpp" /* yacc.c:1646 */ 4961| 2.31k| break; 4962| | 4963| 1.31k| case 249: ------------------ | Branch (4963:3): [True: 1.31k, False: 10.2M] ------------------ 4964| 1.31k|#line 1195 "bison_parser.y" /* yacc.c:1646 */ 4965| 1.31k| { (yyval.frame_type) = kRange; } 4966| 1.31k|#line 4967 "bison_parser.cpp" /* yacc.c:1646 */ 4967| 1.31k| break; 4968| | 4969| 1.53k| case 250: ------------------ | Branch (4969:3): [True: 1.53k, False: 10.2M] ------------------ 4970| 1.53k|#line 1196 "bison_parser.y" /* yacc.c:1646 */ 4971| 1.53k| { (yyval.frame_type) = kRows; } 4972| 1.53k|#line 4973 "bison_parser.cpp" /* yacc.c:1646 */ 4973| 1.53k| break; 4974| | 4975| 767| case 251: ------------------ | Branch (4975:3): [True: 767, False: 10.2M] ------------------ 4976| 767|#line 1197 "bison_parser.y" /* yacc.c:1646 */ 4977| 767| { (yyval.frame_type) = kGroups; } 4978| 767|#line 4979 "bison_parser.cpp" /* yacc.c:1646 */ 4979| 767| break; 4980| | 4981| 563| case 252: ------------------ | Branch (4981:3): [True: 563, False: 10.2M] ------------------ 4982| 563|#line 1199 "bison_parser.y" /* yacc.c:1646 */ 4983| 563| { (yyval.frame_bound) = new FrameBound{0, kPreceding, true}; } 4984| 563|#line 4985 "bison_parser.cpp" /* yacc.c:1646 */ 4985| 563| break; 4986| | 4987| 892| case 253: ------------------ | Branch (4987:3): [True: 892, False: 10.2M] ------------------ 4988| 892|#line 1200 "bison_parser.y" /* yacc.c:1646 */ 4989| 892| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kPreceding, false}; } 4990| 892|#line 4991 "bison_parser.cpp" /* yacc.c:1646 */ 4991| 892| break; 4992| | 4993| 387| case 254: ------------------ | Branch (4993:3): [True: 387, False: 10.2M] ------------------ 4994| 387|#line 1201 "bison_parser.y" /* yacc.c:1646 */ 4995| 387| { (yyval.frame_bound) = new FrameBound{0, kFollowing, true}; } 4996| 387|#line 4997 "bison_parser.cpp" /* yacc.c:1646 */ 4997| 387| break; 4998| | 4999| 1.92k| case 255: ------------------ | Branch (4999:3): [True: 1.92k, False: 10.2M] ------------------ 5000| 1.92k|#line 1202 "bison_parser.y" /* yacc.c:1646 */ 5001| 1.92k| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kFollowing, false}; } 5002| 1.92k|#line 5003 "bison_parser.cpp" /* yacc.c:1646 */ 5003| 1.92k| break; 5004| | 5005| 0| case 256: ------------------ | Branch (5005:3): [True: 0, False: 10.2M] ------------------ 5006| 0|#line 1203 "bison_parser.y" /* yacc.c:1646 */ 5007| 0| { (yyval.frame_bound) = new FrameBound{0, kCurrentRow, false}; } 5008| 0|#line 5009 "bison_parser.cpp" /* yacc.c:1646 */ 5009| 0| break; 5010| | 5011| 529| case 257: ------------------ | Branch (5011:3): [True: 529, False: 10.2M] ------------------ 5012| 529|#line 1205 "bison_parser.y" /* yacc.c:1646 */ 5013| 529| { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } 5014| 529|#line 5015 "bison_parser.cpp" /* yacc.c:1646 */ 5015| 529| break; 5016| | 5017| 195| case 258: ------------------ | Branch (5017:3): [True: 195, False: 10.2M] ------------------ 5018| 195|#line 1207 "bison_parser.y" /* yacc.c:1646 */ 5019| 195| { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } 5020| 195|#line 5021 "bison_parser.cpp" /* yacc.c:1646 */ 5021| 195| break; 5022| | 5023| 761| case 259: ------------------ | Branch (5023:3): [True: 761, False: 10.2M] ------------------ 5024| 761|#line 1209 "bison_parser.y" /* yacc.c:1646 */ 5025| 761| { (yyval.datetime_field) = kDatetimeSecond; } 5026| 761|#line 5027 "bison_parser.cpp" /* yacc.c:1646 */ 5027| 761| break; 5028| | 5029| 1.08k| case 260: ------------------ | Branch (5029:3): [True: 1.08k, False: 10.2M] ------------------ 5030| 1.08k|#line 1210 "bison_parser.y" /* yacc.c:1646 */ 5031| 1.08k| { (yyval.datetime_field) = kDatetimeMinute; } 5032| 1.08k|#line 5033 "bison_parser.cpp" /* yacc.c:1646 */ 5033| 1.08k| break; 5034| | 5035| 862| case 261: ------------------ | Branch (5035:3): [True: 862, False: 10.2M] ------------------ 5036| 862|#line 1211 "bison_parser.y" /* yacc.c:1646 */ 5037| 862| { (yyval.datetime_field) = kDatetimeHour; } 5038| 862|#line 5039 "bison_parser.cpp" /* yacc.c:1646 */ 5039| 862| break; 5040| | 5041| 1.93k| case 262: ------------------ | Branch (5041:3): [True: 1.93k, False: 10.2M] ------------------ 5042| 1.93k|#line 1212 "bison_parser.y" /* yacc.c:1646 */ 5043| 1.93k| { (yyval.datetime_field) = kDatetimeDay; } 5044| 1.93k|#line 5045 "bison_parser.cpp" /* yacc.c:1646 */ 5045| 1.93k| break; 5046| | 5047| 717| case 263: ------------------ | Branch (5047:3): [True: 717, False: 10.2M] ------------------ 5048| 717|#line 1213 "bison_parser.y" /* yacc.c:1646 */ 5049| 717| { (yyval.datetime_field) = kDatetimeMonth; } 5050| 717|#line 5051 "bison_parser.cpp" /* yacc.c:1646 */ 5051| 717| break; 5052| | 5053| 516| case 264: ------------------ | Branch (5053:3): [True: 516, False: 10.2M] ------------------ 5054| 516|#line 1214 "bison_parser.y" /* yacc.c:1646 */ 5055| 516| { (yyval.datetime_field) = kDatetimeYear; } 5056| 516|#line 5057 "bison_parser.cpp" /* yacc.c:1646 */ 5057| 516| break; 5058| | 5059| 845| case 265: ------------------ | Branch (5059:3): [True: 845, False: 10.2M] ------------------ 5060| 845|#line 1216 "bison_parser.y" /* yacc.c:1646 */ 5061| 845| { (yyval.datetime_field) = kDatetimeSecond; } 5062| 845|#line 5063 "bison_parser.cpp" /* yacc.c:1646 */ 5063| 845| break; 5064| | 5065| 946| case 266: ------------------ | Branch (5065:3): [True: 946, False: 10.2M] ------------------ 5066| 946|#line 1217 "bison_parser.y" /* yacc.c:1646 */ 5067| 946| { (yyval.datetime_field) = kDatetimeMinute; } 5068| 946|#line 5069 "bison_parser.cpp" /* yacc.c:1646 */ 5069| 946| break; 5070| | 5071| 686| case 267: ------------------ | Branch (5071:3): [True: 686, False: 10.2M] ------------------ 5072| 686|#line 1218 "bison_parser.y" /* yacc.c:1646 */ 5073| 686| { (yyval.datetime_field) = kDatetimeHour; } 5074| 686|#line 5075 "bison_parser.cpp" /* yacc.c:1646 */ 5075| 686| break; 5076| | 5077| 524| case 268: ------------------ | Branch (5077:3): [True: 524, False: 10.2M] ------------------ 5078| 524|#line 1219 "bison_parser.y" /* yacc.c:1646 */ 5079| 524| { (yyval.datetime_field) = kDatetimeDay; } 5080| 524|#line 5081 "bison_parser.cpp" /* yacc.c:1646 */ 5081| 524| break; 5082| | 5083| 734| case 269: ------------------ | Branch (5083:3): [True: 734, False: 10.2M] ------------------ 5084| 734|#line 1220 "bison_parser.y" /* yacc.c:1646 */ 5085| 734| { (yyval.datetime_field) = kDatetimeMonth; } 5086| 734|#line 5087 "bison_parser.cpp" /* yacc.c:1646 */ 5087| 734| break; 5088| | 5089| 668| case 270: ------------------ | Branch (5089:3): [True: 668, False: 10.2M] ------------------ 5090| 668|#line 1221 "bison_parser.y" /* yacc.c:1646 */ 5091| 668| { (yyval.datetime_field) = kDatetimeYear; } 5092| 668|#line 5093 "bison_parser.cpp" /* yacc.c:1646 */ 5093| 668| break; 5094| | 5095| 514| case 273: ------------------ | Branch (5095:3): [True: 514, False: 10.2M] ------------------ 5096| 514|#line 1225 "bison_parser.y" /* yacc.c:1646 */ 5097| 514| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 5098| 514|#line 5099 "bison_parser.cpp" /* yacc.c:1646 */ 5099| 514| break; 5100| | 5101| 194| case 274: ------------------ | Branch (5101:3): [True: 194, False: 10.2M] ------------------ 5102| 194|#line 1227 "bison_parser.y" /* yacc.c:1646 */ 5103| 194| { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } 5104| 194|#line 5105 "bison_parser.cpp" /* yacc.c:1646 */ 5105| 194| break; 5106| | 5107| 487| case 275: ------------------ | Branch (5107:3): [True: 487, False: 10.2M] ------------------ 5108| 487|#line 1229 "bison_parser.y" /* yacc.c:1646 */ 5109| 487| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 5110| 487|#line 5111 "bison_parser.cpp" /* yacc.c:1646 */ 5111| 487| break; 5112| | 5113| 114k| case 276: ------------------ | Branch (5113:3): [True: 114k, False: 10.1M] ------------------ 5114| 114k|#line 1231 "bison_parser.y" /* yacc.c:1646 */ 5115| 114k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 5116| 114k|#line 5117 "bison_parser.cpp" /* yacc.c:1646 */ 5117| 114k| break; 5118| | 5119| 976| case 277: ------------------ | Branch (5119:3): [True: 976, False: 10.2M] ------------------ 5120| 976|#line 1232 "bison_parser.y" /* yacc.c:1646 */ 5121| 976| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 5122| 976|#line 5123 "bison_parser.cpp" /* yacc.c:1646 */ 5123| 976| break; 5124| | 5125| 968k| case 278: ------------------ | Branch (5125:3): [True: 968k, False: 9.28M] ------------------ 5126| 968k|#line 1233 "bison_parser.y" /* yacc.c:1646 */ 5127| 968k| { (yyval.expr) = Expr::makeStar(); } 5128| 968k|#line 5129 "bison_parser.cpp" /* yacc.c:1646 */ 5129| 968k| break; 5130| | 5131| 840| case 279: ------------------ | Branch (5131:3): [True: 840, False: 10.2M] ------------------ 5132| 840|#line 1234 "bison_parser.y" /* yacc.c:1646 */ 5133| 840| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 5134| 840|#line 5135 "bison_parser.cpp" /* yacc.c:1646 */ 5135| 840| break; 5136| | 5137| 3.78k| case 287: ------------------ | Branch (5137:3): [True: 3.78k, False: 10.2M] ------------------ 5138| 3.78k|#line 1238 "bison_parser.y" /* yacc.c:1646 */ 5139| 3.78k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 5140| 3.78k|#line 5141 "bison_parser.cpp" /* yacc.c:1646 */ 5141| 3.78k| break; 5142| | 5143| 649| case 288: ------------------ | Branch (5143:3): [True: 649, False: 10.2M] ------------------ 5144| 649|#line 1240 "bison_parser.y" /* yacc.c:1646 */ 5145| 649| { (yyval.expr) = Expr::makeLiteral(true); } 5146| 649|#line 5147 "bison_parser.cpp" /* yacc.c:1646 */ 5147| 649| break; 5148| | 5149| 674| case 289: ------------------ | Branch (5149:3): [True: 674, False: 10.2M] ------------------ 5150| 674|#line 1241 "bison_parser.y" /* yacc.c:1646 */ 5151| 674| { (yyval.expr) = Expr::makeLiteral(false); } 5152| 674|#line 5153 "bison_parser.cpp" /* yacc.c:1646 */ 5153| 674| break; 5154| | 5155| 1.13k| case 290: ------------------ | Branch (5155:3): [True: 1.13k, False: 10.2M] ------------------ 5156| 1.13k|#line 1243 "bison_parser.y" /* yacc.c:1646 */ 5157| 1.13k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 5158| 1.13k|#line 5159 "bison_parser.cpp" /* yacc.c:1646 */ 5159| 1.13k| break; 5160| | 5161| 11.6k| case 292: ------------------ | Branch (5161:3): [True: 11.6k, False: 10.2M] ------------------ 5162| 11.6k|#line 1246 "bison_parser.y" /* yacc.c:1646 */ 5163| 11.6k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 5164| 11.6k|#line 5165 "bison_parser.cpp" /* yacc.c:1646 */ 5165| 11.6k| break; 5166| | 5167| 2.30k| case 293: ------------------ | Branch (5167:3): [True: 2.30k, False: 10.2M] ------------------ 5168| 2.30k|#line 1248 "bison_parser.y" /* yacc.c:1646 */ 5169| 2.30k| { (yyval.expr) = Expr::makeNullLiteral(); } 5170| 2.30k|#line 5171 "bison_parser.cpp" /* yacc.c:1646 */ 5171| 2.30k| break; 5172| | 5173| 212| case 294: ------------------ | Branch (5173:3): [True: 212, False: 10.2M] ------------------ 5174| 212|#line 1250 "bison_parser.y" /* yacc.c:1646 */ 5175| 212| { 5176| 212| int day{0}, month{0}, year{0}, chars_parsed{0}; 5177| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5178| 212| if (sscanf((yyvsp[0].sval), "%4d-%2d-%2d%n", &day, &month, &year, &chars_parsed) != 3 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5178:7): [True: 4, False: 208] | Branch (5178:92): [True: 7, False: 201] ------------------ 5179| 11| free((yyvsp[0].sval)); 5180| 11| yyerror(&yyloc, result, scanner, "Found incorrect date format. Expected format: YYYY-MM-DD"); ------------------ | | 67| 11|#define yyerror hsql_error ------------------ 5181| 11| YYERROR; ------------------ | | 1458| 11|#define YYERROR goto yyerrorlab ------------------ 5182| 11| } 5183| 201| (yyval.expr) = Expr::makeDateLiteral((yyvsp[0].sval)); 5184| 201|} 5185| 0|#line 5186 "bison_parser.cpp" /* yacc.c:1646 */ 5186| 0| break; 5187| | 5188| 9.13k| case 295: ------------------ | Branch (5188:3): [True: 9.13k, False: 10.2M] ------------------ 5189| 9.13k|#line 1261 "bison_parser.y" /* yacc.c:1646 */ 5190| 9.13k| { (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].ival), (yyvsp[0].datetime_field)); } 5191| 9.13k|#line 5192 "bison_parser.cpp" /* yacc.c:1646 */ 5192| 9.13k| break; 5193| | 5194| 349| case 296: ------------------ | Branch (5194:3): [True: 349, False: 10.2M] ------------------ 5195| 349|#line 1262 "bison_parser.y" /* yacc.c:1646 */ 5196| 349| { 5197| 349| int duration{0}, chars_parsed{0}; 5198| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5199| 349| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (5199:7): [True: 2, False: 347] | Branch (5199:74): [True: 7, False: 340] ------------------ 5200| 9| free((yyvsp[-1].sval)); 5201| 9| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER"); ------------------ | | 67| 9|#define yyerror hsql_error ------------------ 5202| 9| YYERROR; ------------------ | | 1458| 9|#define YYERROR goto yyerrorlab ------------------ 5203| 9| } 5204| 340| free((yyvsp[-1].sval)); 5205| 340| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 5206| 340|} 5207| 0|#line 5208 "bison_parser.cpp" /* yacc.c:1646 */ 5208| 0| break; 5209| | 5210| 4.40k| case 297: ------------------ | Branch (5210:3): [True: 4.40k, False: 10.2M] ------------------ 5211| 4.40k|#line 1273 "bison_parser.y" /* yacc.c:1646 */ 5212| 4.40k| { 5213| 4.40k| int duration{0}, chars_parsed{0}; 5214| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 5215| 4.40k| char unit_string[8]; 5216| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5217| 4.40k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5217:7): [True: 6, False: 4.39k] | Branch (5217:90): [True: 6, False: 4.38k] ------------------ 5218| 12| free((yyvsp[0].sval)); 5219| 12| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER INTERVAL_QUALIIFIER"); ------------------ | | 67| 12|#define yyerror hsql_error ------------------ 5220| 12| YYERROR; ------------------ | | 1458| 12|#define YYERROR goto yyerrorlab ------------------ 5221| 12| } 5222| 4.38k| free((yyvsp[0].sval)); 5223| | 5224| 4.38k| DatetimeField unit; 5225| 4.38k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (5225:7): [True: 414, False: 3.97k] | Branch (5225:49): [True: 439, False: 3.53k] ------------------ 5226| 853| unit = kDatetimeSecond; 5227| 3.53k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (5227:14): [True: 205, False: 3.33k] | Branch (5227:56): [True: 195, False: 3.13k] ------------------ 5228| 400| unit = kDatetimeMinute; 5229| 3.13k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (5229:14): [True: 199, False: 2.93k] | Branch (5229:54): [True: 1.22k, False: 1.71k] ------------------ 5230| 1.42k| unit = kDatetimeHour; 5231| 1.71k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (5231:14): [True: 251, False: 1.46k] | Branch (5231:53): [True: 387, False: 1.07k] ------------------ 5232| 638| unit = kDatetimeDay; 5233| 1.07k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (5233:14): [True: 194, False: 883] | Branch (5233:55): [True: 198, False: 685] ------------------ 5234| 392| unit = kDatetimeMonth; 5235| 685| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (5235:14): [True: 194, False: 491] | Branch (5235:54): [True: 222, False: 269] ------------------ 5236| 416| unit = kDatetimeYear; 5237| 416| } else { 5238| 269| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 67| 269|#define yyerror hsql_error ------------------ 5239| 269| YYERROR; ------------------ | | 1458| 269|#define YYERROR goto yyerrorlab ------------------ 5240| 269| } 5241| 4.12k| (yyval.expr) = Expr::makeIntervalLiteral(duration, unit); 5242| 4.12k|} 5243| 0|#line 5244 "bison_parser.cpp" /* yacc.c:1646 */ 5244| 0| break; 5245| | 5246| 229k| case 298: ------------------ | Branch (5246:3): [True: 229k, False: 10.0M] ------------------ 5247| 229k|#line 1305 "bison_parser.y" /* yacc.c:1646 */ 5248| 229k| { 5249| 229k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 5250| 229k| (yyval.expr)->ival2 = yyloc.param_list.size(); 5251| 229k| yyloc.param_list.push_back((yyval.expr)); 5252| 229k|} 5253| 229k|#line 5254 "bison_parser.cpp" /* yacc.c:1646 */ 5254| 229k| break; 5255| | 5256| 1.60k| case 300: ------------------ | Branch (5256:3): [True: 1.60k, False: 10.2M] ------------------ 5257| 1.60k|#line 1314 "bison_parser.y" /* yacc.c:1646 */ 5258| 1.60k| { 5259| 1.60k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5260| 1.60k| auto tbl = new TableRef(kTableCrossProduct); 5261| 1.60k| tbl->list = (yyvsp[-2].table_vec); 5262| 1.60k| (yyval.table) = tbl; 5263| 1.60k|} 5264| 1.60k|#line 5265 "bison_parser.cpp" /* yacc.c:1646 */ 5265| 1.60k| break; 5266| | 5267| 685| case 304: ------------------ | Branch (5267:3): [True: 685, False: 10.2M] ------------------ 5268| 685|#line 1323 "bison_parser.y" /* yacc.c:1646 */ 5269| 685| { 5270| 685| auto tbl = new TableRef(kTableSelect); 5271| 685| tbl->select = (yyvsp[-2].select_stmt); 5272| 685| tbl->alias = (yyvsp[0].alias_t); 5273| 685| (yyval.table) = tbl; 5274| 685|} 5275| 685|#line 5276 "bison_parser.cpp" /* yacc.c:1646 */ 5276| 685| break; 5277| | 5278| 1.68k| case 305: ------------------ | Branch (5278:3): [True: 1.68k, False: 10.2M] ------------------ 5279| 1.68k|#line 1330 "bison_parser.y" /* yacc.c:1646 */ 5280| 1.68k| { 5281| 1.68k| (yyval.table_vec) = new std::vector(); 5282| 1.68k| (yyval.table_vec)->push_back((yyvsp[0].table)); 5283| 1.68k|} 5284| 1.68k|#line 5285 "bison_parser.cpp" /* yacc.c:1646 */ 5285| 1.68k| break; 5286| | 5287| 107k| case 306: ------------------ | Branch (5287:3): [True: 107k, False: 10.1M] ------------------ 5288| 107k|#line 1334 "bison_parser.y" /* yacc.c:1646 */ 5289| 107k| { 5290| 107k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5291| 107k| (yyval.table_vec) = (yyvsp[-2].table_vec); 5292| 107k|} 5293| 107k|#line 5294 "bison_parser.cpp" /* yacc.c:1646 */ 5294| 107k| break; 5295| | 5296| 224k| case 307: ------------------ | Branch (5296:3): [True: 224k, False: 10.0M] ------------------ 5297| 224k|#line 1339 "bison_parser.y" /* yacc.c:1646 */ 5298| 224k| { 5299| 224k| auto tbl = new TableRef(kTableName); 5300| 224k| tbl->schema = (yyvsp[-1].table_name).schema; 5301| 224k| tbl->name = (yyvsp[-1].table_name).name; 5302| 224k| tbl->alias = (yyvsp[0].alias_t); 5303| 224k| (yyval.table) = tbl; 5304| 224k|} 5305| 224k|#line 5306 "bison_parser.cpp" /* yacc.c:1646 */ 5306| 224k| break; 5307| | 5308| 1.94k| case 308: ------------------ | Branch (5308:3): [True: 1.94k, False: 10.2M] ------------------ 5309| 1.94k|#line 1347 "bison_parser.y" /* yacc.c:1646 */ 5310| 1.94k| { 5311| 1.94k| (yyval.table) = new TableRef(kTableName); 5312| 1.94k| (yyval.table)->schema = (yyvsp[0].table_name).schema; 5313| 1.94k| (yyval.table)->name = (yyvsp[0].table_name).name; 5314| 1.94k|} 5315| 1.94k|#line 5316 "bison_parser.cpp" /* yacc.c:1646 */ 5316| 1.94k| break; 5317| | 5318| 263k| case 309: ------------------ | Branch (5318:3): [True: 263k, False: 9.98M] ------------------ 5319| 263k|#line 1353 "bison_parser.y" /* yacc.c:1646 */ 5320| 263k| { 5321| 263k| (yyval.table_name).schema = nullptr; 5322| 263k| (yyval.table_name).name = (yyvsp[0].sval); 5323| 263k|} 5324| 263k|#line 5325 "bison_parser.cpp" /* yacc.c:1646 */ 5325| 263k| break; 5326| | 5327| 195| case 310: ------------------ | Branch (5327:3): [True: 195, False: 10.2M] ------------------ 5328| 195|#line 1357 "bison_parser.y" /* yacc.c:1646 */ 5329| 195| { 5330| 195| (yyval.table_name).schema = (yyvsp[-2].sval); 5331| 195| (yyval.table_name).name = (yyvsp[0].sval); 5332| 195|} 5333| 195|#line 5334 "bison_parser.cpp" /* yacc.c:1646 */ 5334| 195| break; 5335| | 5336| 231| case 311: ------------------ | Branch (5336:3): [True: 231, False: 10.2M] ------------------ 5337| 231|#line 1362 "bison_parser.y" /* yacc.c:1646 */ 5338| 231| { (yyval.sval) = (yyvsp[0].sval); } 5339| 231|#line 5340 "bison_parser.cpp" /* yacc.c:1646 */ 5340| 231| break; 5341| | 5342| 956| case 312: ------------------ | Branch (5342:3): [True: 956, False: 10.2M] ------------------ 5343| 956|#line 1363 "bison_parser.y" /* yacc.c:1646 */ 5344| 956| { (yyval.sval) = nullptr; } 5345| 956|#line 5346 "bison_parser.cpp" /* yacc.c:1646 */ 5346| 956| break; 5347| | 5348| 185| case 314: ------------------ | Branch (5348:3): [True: 185, False: 10.2M] ------------------ 5349| 185|#line 1365 "bison_parser.y" /* yacc.c:1646 */ 5350| 185| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5351| 185|#line 5352 "bison_parser.cpp" /* yacc.c:1646 */ 5352| 185| break; 5353| | 5354| 215k| case 316: ------------------ | Branch (5354:3): [True: 215k, False: 10.0M] ------------------ 5355| 215k|#line 1367 "bison_parser.y" /* yacc.c:1646 */ 5356| 215k| { (yyval.alias_t) = nullptr; } 5357| 215k|#line 5358 "bison_parser.cpp" /* yacc.c:1646 */ 5358| 215k| break; 5359| | 5360| 279| case 317: ------------------ | Branch (5360:3): [True: 279, False: 10.2M] ------------------ 5361| 279|#line 1369 "bison_parser.y" /* yacc.c:1646 */ 5362| 279| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5363| 279|#line 5364 "bison_parser.cpp" /* yacc.c:1646 */ 5364| 279| break; 5365| | 5366| 21.6k| case 318: ------------------ | Branch (5366:3): [True: 21.6k, False: 10.2M] ------------------ 5367| 21.6k|#line 1370 "bison_parser.y" /* yacc.c:1646 */ 5368| 21.6k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5369| 21.6k|#line 5370 "bison_parser.cpp" /* yacc.c:1646 */ 5370| 21.6k| break; 5371| | 5372| 154k| case 320: ------------------ | Branch (5372:3): [True: 154k, False: 10.0M] ------------------ 5373| 154k|#line 1372 "bison_parser.y" /* yacc.c:1646 */ 5374| 154k| { (yyval.alias_t) = nullptr; } 5375| 154k|#line 5376 "bison_parser.cpp" /* yacc.c:1646 */ 5376| 154k| break; 5377| | 5378| 439| case 321: ------------------ | Branch (5378:3): [True: 439, False: 10.2M] ------------------ 5379| 439|#line 1378 "bison_parser.y" /* yacc.c:1646 */ 5380| 439| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5381| 439|#line 5382 "bison_parser.cpp" /* yacc.c:1646 */ 5382| 439| break; 5383| | 5384| 34.0k| case 322: ------------------ | Branch (5384:3): [True: 34.0k, False: 10.2M] ------------------ 5385| 34.0k|#line 1379 "bison_parser.y" /* yacc.c:1646 */ 5386| 34.0k| { (yyval.locking_clause_vec) = nullptr; } 5387| 34.0k|#line 5388 "bison_parser.cpp" /* yacc.c:1646 */ 5388| 34.0k| break; 5389| | 5390| 463| case 323: ------------------ | Branch (5390:3): [True: 463, False: 10.2M] ------------------ 5391| 463|#line 1381 "bison_parser.y" /* yacc.c:1646 */ 5392| 463| { 5393| 463| (yyval.locking_clause_vec) = new std::vector(); 5394| 463| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5395| 463|} 5396| 463|#line 5397 "bison_parser.cpp" /* yacc.c:1646 */ 5397| 463| break; 5398| | 5399| 3.53k| case 324: ------------------ | Branch (5399:3): [True: 3.53k, False: 10.2M] ------------------ 5400| 3.53k|#line 1385 "bison_parser.y" /* yacc.c:1646 */ 5401| 3.53k| { 5402| 3.53k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5403| 3.53k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5404| 3.53k|} 5405| 3.53k|#line 5406 "bison_parser.cpp" /* yacc.c:1646 */ 5406| 3.53k| break; 5407| | 5408| 3.72k| case 325: ------------------ | Branch (5408:3): [True: 3.72k, False: 10.2M] ------------------ 5409| 3.72k|#line 1390 "bison_parser.y" /* yacc.c:1646 */ 5410| 3.72k| { 5411| 3.72k| (yyval.locking_t) = new LockingClause(); 5412| 3.72k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5413| 3.72k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5414| 3.72k| (yyval.locking_t)->tables = nullptr; 5415| 3.72k|} 5416| 3.72k|#line 5417 "bison_parser.cpp" /* yacc.c:1646 */ 5417| 3.72k| break; 5418| | 5419| 274| case 326: ------------------ | Branch (5419:3): [True: 274, False: 10.2M] ------------------ 5420| 274|#line 1396 "bison_parser.y" /* yacc.c:1646 */ 5421| 274| { 5422| 274| (yyval.locking_t) = new LockingClause(); 5423| 274| (yyval.locking_t)->rowLockMode = (yyvsp[-3].lock_mode_t); 5424| 274| (yyval.locking_t)->tables = (yyvsp[-1].str_vec); 5425| 274| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5426| 274|} 5427| 274|#line 5428 "bison_parser.cpp" /* yacc.c:1646 */ 5428| 274| break; 5429| | 5430| 842| case 327: ------------------ | Branch (5430:3): [True: 842, False: 10.2M] ------------------ 5431| 842|#line 1403 "bison_parser.y" /* yacc.c:1646 */ 5432| 842| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5433| 842|#line 5434 "bison_parser.cpp" /* yacc.c:1646 */ 5434| 842| break; 5435| | 5436| 0| case 328: ------------------ | Branch (5436:3): [True: 0, False: 10.2M] ------------------ 5437| 0|#line 1404 "bison_parser.y" /* yacc.c:1646 */ 5438| 0| { (yyval.lock_mode_t) = RowLockMode::ForNoKeyUpdate; } 5439| 0|#line 5440 "bison_parser.cpp" /* yacc.c:1646 */ 5440| 0| break; 5441| | 5442| 2.94k| case 329: ------------------ | Branch (5442:3): [True: 2.94k, False: 10.2M] ------------------ 5443| 2.94k|#line 1405 "bison_parser.y" /* yacc.c:1646 */ 5444| 2.94k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5445| 2.94k|#line 5446 "bison_parser.cpp" /* yacc.c:1646 */ 5446| 2.94k| break; 5447| | 5448| 217| case 330: ------------------ | Branch (5448:3): [True: 217, False: 10.2M] ------------------ 5449| 217|#line 1406 "bison_parser.y" /* yacc.c:1646 */ 5450| 217| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5451| 217|#line 5452 "bison_parser.cpp" /* yacc.c:1646 */ 5452| 217| break; 5453| | 5454| 0| case 331: ------------------ | Branch (5454:3): [True: 0, False: 10.2M] ------------------ 5455| 0|#line 1408 "bison_parser.y" /* yacc.c:1646 */ 5456| 0| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::SkipLocked; } 5457| 0|#line 5458 "bison_parser.cpp" /* yacc.c:1646 */ 5458| 0| break; 5459| | 5460| 777| case 332: ------------------ | Branch (5460:3): [True: 777, False: 10.2M] ------------------ 5461| 777|#line 1409 "bison_parser.y" /* yacc.c:1646 */ 5462| 777| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5463| 777|#line 5464 "bison_parser.cpp" /* yacc.c:1646 */ 5464| 777| break; 5465| | 5466| 3.22k| case 333: ------------------ | Branch (5466:3): [True: 3.22k, False: 10.2M] ------------------ 5467| 3.22k|#line 1410 "bison_parser.y" /* yacc.c:1646 */ 5468| 3.22k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5469| 3.22k|#line 5470 "bison_parser.cpp" /* yacc.c:1646 */ 5470| 3.22k| break; 5471| | 5472| 28.5k| case 335: ------------------ | Branch (5472:3): [True: 28.5k, False: 10.2M] ------------------ 5473| 28.5k|#line 1416 "bison_parser.y" /* yacc.c:1646 */ 5474| 28.5k| { (yyval.with_description_vec) = nullptr; } 5475| 28.5k|#line 5476 "bison_parser.cpp" /* yacc.c:1646 */ 5476| 28.5k| break; 5477| | 5478| 999| case 336: ------------------ | Branch (5478:3): [True: 999, False: 10.2M] ------------------ 5479| 999|#line 1418 "bison_parser.y" /* yacc.c:1646 */ 5480| 999| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5481| 999|#line 5482 "bison_parser.cpp" /* yacc.c:1646 */ 5482| 999| break; 5483| | 5484| 1.03k| case 337: ------------------ | Branch (5484:3): [True: 1.03k, False: 10.2M] ------------------ 5485| 1.03k|#line 1420 "bison_parser.y" /* yacc.c:1646 */ 5486| 1.03k| { 5487| 1.03k| (yyval.with_description_vec) = new std::vector(); 5488| 1.03k| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5489| 1.03k|} 5490| 1.03k|#line 5491 "bison_parser.cpp" /* yacc.c:1646 */ 5491| 1.03k| break; 5492| | 5493| 1.00k| case 338: ------------------ | Branch (5493:3): [True: 1.00k, False: 10.2M] ------------------ 5494| 1.00k|#line 1424 "bison_parser.y" /* yacc.c:1646 */ 5495| 1.00k| { 5496| 1.00k| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5497| 1.00k| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5498| 1.00k|} 5499| 1.00k|#line 5500 "bison_parser.cpp" /* yacc.c:1646 */ 5500| 1.00k| break; 5501| | 5502| 2.04k| case 339: ------------------ | Branch (5502:3): [True: 2.04k, False: 10.2M] ------------------ 5503| 2.04k|#line 1429 "bison_parser.y" /* yacc.c:1646 */ 5504| 2.04k| { 5505| 2.04k| (yyval.with_description_t) = new WithDescription(); 5506| 2.04k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5507| 2.04k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5508| 2.04k|} 5509| 2.04k|#line 5510 "bison_parser.cpp" /* yacc.c:1646 */ 5510| 2.04k| break; 5511| | 5512| 793| case 340: ------------------ | Branch (5512:3): [True: 793, False: 10.2M] ------------------ 5513| 793|#line 1439 "bison_parser.y" /* yacc.c:1646 */ 5514| 793| { 5515| 793| (yyval.table) = new TableRef(kTableJoin); 5516| 793| (yyval.table)->join = new JoinDefinition(); 5517| 793| (yyval.table)->join->type = kJoinNatural; 5518| 793| (yyval.table)->join->left = (yyvsp[-3].table); 5519| 793| (yyval.table)->join->right = (yyvsp[0].table); 5520| 793|} 5521| 793|#line 5522 "bison_parser.cpp" /* yacc.c:1646 */ 5522| 793| break; 5523| | 5524| 108k| case 341: ------------------ | Branch (5524:3): [True: 108k, False: 10.1M] ------------------ 5525| 108k|#line 1446 "bison_parser.y" /* yacc.c:1646 */ 5526| 108k| { 5527| 108k| (yyval.table) = new TableRef(kTableJoin); 5528| 108k| (yyval.table)->join = new JoinDefinition(); 5529| 108k| (yyval.table)->join->type = (JoinType)(yyvsp[-4].join_type); 5530| 108k| (yyval.table)->join->left = (yyvsp[-5].table); 5531| 108k| (yyval.table)->join->right = (yyvsp[-2].table); 5532| 108k| (yyval.table)->join->condition = (yyvsp[0].expr); 5533| 108k|} 5534| 108k|#line 5535 "bison_parser.cpp" /* yacc.c:1646 */ 5535| 108k| break; 5536| | 5537| 718| case 342: ------------------ | Branch (5537:3): [True: 718, False: 10.2M] ------------------ 5538| 718|#line 1454 "bison_parser.y" /* yacc.c:1646 */ 5539| 718| { 5540| 718| (yyval.table) = new TableRef(kTableJoin); 5541| 718| (yyval.table)->join = new JoinDefinition(); 5542| 718| (yyval.table)->join->type = (yyvsp[-6].join_type); 5543| 718| (yyval.table)->join->left = (yyvsp[-7].table); 5544| 718| (yyval.table)->join->right = (yyvsp[-4].table); 5545| 718| (yyval.table)->join->namedColumns = (yyvsp[-1].str_vec); 5546| 718|} 5547| 718|#line 5548 "bison_parser.cpp" /* yacc.c:1646 */ 5548| 718| break; 5549| | 5550| 700| case 343: ------------------ | Branch (5550:3): [True: 700, False: 10.2M] ------------------ 5551| 700|#line 1463 "bison_parser.y" /* yacc.c:1646 */ 5552| 700| { (yyval.join_type) = kJoinInner; } 5553| 700|#line 5554 "bison_parser.cpp" /* yacc.c:1646 */ 5554| 700| break; 5555| | 5556| 66| case 344: ------------------ | Branch (5556:3): [True: 66, False: 10.2M] ------------------ 5557| 66|#line 1464 "bison_parser.y" /* yacc.c:1646 */ 5558| 66| { (yyval.join_type) = kJoinLeft; } 5559| 66|#line 5560 "bison_parser.cpp" /* yacc.c:1646 */ 5560| 66| break; 5561| | 5562| 519| case 345: ------------------ | Branch (5562:3): [True: 519, False: 10.2M] ------------------ 5563| 519|#line 1465 "bison_parser.y" /* yacc.c:1646 */ 5564| 519| { (yyval.join_type) = kJoinLeft; } 5565| 519|#line 5566 "bison_parser.cpp" /* yacc.c:1646 */ 5566| 519| break; 5567| | 5568| 66| case 346: ------------------ | Branch (5568:3): [True: 66, False: 10.2M] ------------------ 5569| 66|#line 1466 "bison_parser.y" /* yacc.c:1646 */ 5570| 66| { (yyval.join_type) = kJoinRight; } 5571| 66|#line 5572 "bison_parser.cpp" /* yacc.c:1646 */ 5572| 66| break; 5573| | 5574| 468| case 347: ------------------ | Branch (5574:3): [True: 468, False: 10.2M] ------------------ 5575| 468|#line 1467 "bison_parser.y" /* yacc.c:1646 */ 5576| 468| { (yyval.join_type) = kJoinRight; } 5577| 468|#line 5578 "bison_parser.cpp" /* yacc.c:1646 */ 5578| 468| break; 5579| | 5580| 110| case 348: ------------------ | Branch (5580:3): [True: 110, False: 10.2M] ------------------ 5581| 110|#line 1468 "bison_parser.y" /* yacc.c:1646 */ 5582| 110| { (yyval.join_type) = kJoinFull; } 5583| 110|#line 5584 "bison_parser.cpp" /* yacc.c:1646 */ 5584| 110| break; 5585| | 5586| 836| case 349: ------------------ | Branch (5586:3): [True: 836, False: 10.2M] ------------------ 5587| 836|#line 1469 "bison_parser.y" /* yacc.c:1646 */ 5588| 836| { (yyval.join_type) = kJoinFull; } 5589| 836|#line 5590 "bison_parser.cpp" /* yacc.c:1646 */ 5590| 836| break; 5591| | 5592| 86| case 350: ------------------ | Branch (5592:3): [True: 86, False: 10.2M] ------------------ 5593| 86|#line 1470 "bison_parser.y" /* yacc.c:1646 */ 5594| 86| { (yyval.join_type) = kJoinFull; } 5595| 86|#line 5596 "bison_parser.cpp" /* yacc.c:1646 */ 5596| 86| break; 5597| | 5598| 671| case 351: ------------------ | Branch (5598:3): [True: 671, False: 10.2M] ------------------ 5599| 671|#line 1471 "bison_parser.y" /* yacc.c:1646 */ 5600| 671| { (yyval.join_type) = kJoinCross; } 5601| 671|#line 5602 "bison_parser.cpp" /* yacc.c:1646 */ 5602| 671| break; 5603| | 5604| 108k| case 352: ------------------ | Branch (5604:3): [True: 108k, False: 10.1M] ------------------ 5605| 108k|#line 1472 "bison_parser.y" /* yacc.c:1646 */ 5606| 108k| { (yyval.join_type) = kJoinInner; } 5607| 108k|#line 5608 "bison_parser.cpp" /* yacc.c:1646 */ 5608| 108k| break; 5609| | 5610| 5.22k| case 356: ------------------ | Branch (5610:3): [True: 5.22k, False: 10.2M] ------------------ 5611| 5.22k|#line 1483 "bison_parser.y" /* yacc.c:1646 */ 5612| 5.22k| { 5613| 5.22k| (yyval.str_vec) = new std::vector(); 5614| 5.22k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5615| 5.22k|} 5616| 5.22k|#line 5617 "bison_parser.cpp" /* yacc.c:1646 */ 5617| 5.22k| break; 5618| | 5619| 20.5k| case 357: ------------------ | Branch (5619:3): [True: 20.5k, False: 10.2M] ------------------ 5620| 20.5k|#line 1487 "bison_parser.y" /* yacc.c:1646 */ 5621| 20.5k| { 5622| 20.5k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5623| 20.5k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5624| 20.5k|} 5625| 20.5k|#line 5626 "bison_parser.cpp" /* yacc.c:1646 */ 5626| 20.5k| break; 5627| | 5628| | 5629| 0|#line 5630 "bison_parser.cpp" /* yacc.c:1646 */ 5630| 5.11M| default: break; ------------------ | Branch (5630:7): [True: 5.11M, False: 5.14M] ------------------ 5631| 10.2M| } 5632| | /* User semantic actions sometimes alter yychar, and that requires 5633| | that yytoken be updated with the new translation. We take the 5634| | approach of translating immediately before every use of yytoken. 5635| | One alternative is translating here after every semantic action, 5636| | but that translation would be missed if the semantic action invokes 5637| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5638| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5639| | incorrect destructor might then be invoked immediately. In the 5640| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5641| | to an incorrect destructor call or verbose syntax error message 5642| | before the lookahead is translated. */ 5643| 10.2M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5644| | 5645| 10.2M| YYPOPSTACK (yylen); ------------------ | | 2956| 10.2M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5646| 10.2M| yylen = 0; 5647| 10.2M| YY_STACK_PRINT (yyss, yyssp); 5648| | 5649| 10.2M| *++yyvsp = yyval; 5650| 10.2M| *++yylsp = yyloc; 5651| | 5652| | /* Now 'shift' the result of the reduction. Determine what state 5653| | that goes to, based on the state we popped back to and the rule 5654| | number reduced by. */ 5655| | 5656| 10.2M| yyn = yyr1[yyn]; 5657| | 5658| 10.2M| yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ------------------ | | 711| 10.2M|#define YYNTOKENS 199 ------------------ 5659| 10.2M| if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ------------------ | | 708| 15.2M|#define YYLAST 856 ------------------ | Branch (5659:7): [True: 5.02M, False: 5.22M] | Branch (5659:23): [True: 4.98M, False: 33.8k] | Branch (5659:44): [True: 2.76M, False: 2.22M] ------------------ 5660| 2.76M| yystate = yytable[yystate]; 5661| 7.49M| else 5662| 7.49M| yystate = yydefgoto[yyn - YYNTOKENS]; ------------------ | | 711| 7.49M|#define YYNTOKENS 199 ------------------ 5663| | 5664| 10.2M| goto yynewstate; 5665| | 5666| | 5667| |/*--------------------------------------. 5668| || yyerrlab -- here on detecting error. | 5669| |`--------------------------------------*/ 5670| 3.40k|yyerrlab: 5671| | /* Make sure we have latest lookahead translation. See comments at 5672| | user semantic actions for why this is necessary. */ 5673| 3.40k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 3.40k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 725| 6.81k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.40k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.40k, False: 0] | | ------------------ ------------------ | Branch (5673:13): [True: 0, False: 3.40k] ------------------ 5674| | 5675| | /* If not already recovering from an error, report this error. */ 5676| 3.40k| if (!yyerrstatus) ------------------ | Branch (5676:7): [True: 3.40k, False: 0] ------------------ 5677| 3.40k| { 5678| 3.40k| ++yynerrs; ------------------ | | 69| 3.40k|#define yynerrs hsql_nerrs ------------------ 5679| |#if ! YYERROR_VERBOSE 5680| | yyerror (&yylloc, result, scanner, YY_("syntax error")); 5681| |#else 5682| 3.40k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5683| 3.40k| yyssp, yytoken) 5684| 3.40k| { 5685| 3.40k| char const *yymsgp = YY_("syntax error"); ------------------ | | 517| 3.40k|# define YY_(Msgid) Msgid ------------------ 5686| 3.40k| int yysyntax_error_status; 5687| 3.40k| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 5682| 3.40k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 5683| 3.40k| yyssp, yytoken) ------------------ 5688| 3.40k| if (yysyntax_error_status == 0) ------------------ | Branch (5688:13): [True: 3.40k, False: 0] ------------------ 5689| 3.40k| yymsgp = yymsg; 5690| 0| else if (yysyntax_error_status == 1) ------------------ | Branch (5690:18): [True: 0, False: 0] ------------------ 5691| 0| { 5692| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5692:17): [True: 0, False: 0] ------------------ 5693| 0| YYSTACK_FREE (yymsg); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5694| 0| yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); ------------------ | | 614| 0|# define YYSTACK_ALLOC YYMALLOC | | ------------------ | | | | 628| 0|# define YYMALLOC malloc | | ------------------ ------------------ 5695| 0| if (!yymsg) ------------------ | Branch (5695:17): [True: 0, False: 0] ------------------ 5696| 0| { 5697| 0| yymsg = yymsgbuf; 5698| 0| yymsg_alloc = sizeof yymsgbuf; 5699| 0| yysyntax_error_status = 2; 5700| 0| } 5701| 0| else 5702| 0| { 5703| 0| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 5682| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 5683| 0| yyssp, yytoken) ------------------ 5704| 0| yymsgp = yymsg; 5705| 0| } 5706| 0| } 5707| 3.40k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 67| 3.40k|#define yyerror hsql_error ------------------ 5708| 3.40k| if (yysyntax_error_status == 2) ------------------ | Branch (5708:13): [True: 0, False: 3.40k] ------------------ 5709| 0| goto yyexhaustedlab; 5710| 3.40k| } 5711| 3.40k|# undef YYSYNTAX_ERROR 5712| 3.40k|#endif 5713| 3.40k| } 5714| | 5715| 3.40k| yyerror_range[1] = yylloc; 5716| | 5717| 3.40k| if (yyerrstatus == 3) ------------------ | Branch (5717:7): [True: 0, False: 3.40k] ------------------ 5718| 0| { 5719| | /* If just tried and failed to reuse lookahead token after an 5720| | error, discard it. */ 5721| | 5722| 0| if (yychar <= YYEOF) ------------------ | | 1454| 0|#define YYEOF 0 ------------------ | Branch (5722:11): [True: 0, False: 0] ------------------ 5723| 0| { 5724| | /* Return failure if at end of input. */ 5725| 0| if (yychar == YYEOF) ------------------ | | 1454| 0|#define YYEOF 0 ------------------ | Branch (5725:15): [True: 0, False: 0] ------------------ 5726| 0| YYABORT; ------------------ | | 1457| 0|#define YYABORT goto yyabortlab ------------------ 5727| 0| } 5728| 0| else 5729| 0| { 5730| 0| yydestruct ("Error: discarding", 5731| 0| yytoken, &yylval, &yylloc, result, scanner); 5732| 0| yychar = YYEMPTY; ------------------ | | 1453| 0|#define YYEMPTY (-2) ------------------ 5733| 0| } 5734| 0| } 5735| | 5736| | /* Else will try to reuse lookahead token after shifting the error 5737| | token. */ 5738| 3.40k| goto yyerrlab1; 5739| | 5740| | 5741| |/*---------------------------------------------------. 5742| || yyerrorlab -- error raised explicitly by YYERROR. | 5743| |`---------------------------------------------------*/ 5744| 3.40k|yyerrorlab: 5745| | 5746| | /* Pacify compilers like GCC when the user code never invokes 5747| | YYERROR and the label yyerrorlab therefore never appears in user 5748| | code. */ 5749| 670| if (/*CONSTCOND*/ 0) ------------------ | Branch (5749:21): [Folded, False: 670] ------------------ 5750| 0| goto yyerrorlab; 5751| | 5752| 670| yyerror_range[1] = yylsp[1-yylen]; 5753| | /* Do not reclaim the symbols of the rule whose action triggered 5754| | this YYERROR. */ 5755| 670| YYPOPSTACK (yylen); ------------------ | | 2956| 670|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5756| 670| yylen = 0; 5757| 670| YY_STACK_PRINT (yyss, yyssp); 5758| 670| yystate = *yyssp; 5759| 670| goto yyerrlab1; 5760| | 5761| | 5762| |/*-------------------------------------------------------------. 5763| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5764| |`-------------------------------------------------------------*/ 5765| 4.07k|yyerrlab1: 5766| 4.07k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5767| | 5768| 4.07k| for (;;) 5769| 49.9k| { 5770| 49.9k| yyn = yypact[yystate]; 5771| 49.9k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 49.9k| (!!((Yystate) == (-529))) ------------------ | Branch (5771:11): [True: 49.9k, False: 0] ------------------ 5772| 49.9k| { 5773| 49.9k| yyn += YYTERROR; ------------------ | | 1481| 49.9k|#define YYTERROR 1 ------------------ 5774| 49.9k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 708| 93.9k|#define YYLAST 856 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 1481| 44.0k|#define YYTERROR 1 ------------------ | Branch (5774:15): [True: 44.0k, False: 5.88k] | Branch (5774:27): [True: 44.0k, False: 0] | Branch (5774:44): [True: 0, False: 44.0k] ------------------ 5775| 0| { 5776| 0| yyn = yytable[yyn]; 5777| 0| if (0 < yyn) ------------------ | Branch (5777:19): [True: 0, False: 0] ------------------ 5778| 0| break; 5779| 0| } 5780| 49.9k| } 5781| | 5782| | /* Pop the current state because it cannot handle the error token. */ 5783| 49.9k| if (yyssp == yyss) ------------------ | Branch (5783:11): [True: 4.07k, False: 45.8k] ------------------ 5784| 4.07k| YYABORT; ------------------ | | 1457| 4.07k|#define YYABORT goto yyabortlab ------------------ 5785| | 5786| 45.8k| yyerror_range[1] = *yylsp; 5787| 45.8k| yydestruct ("Error: popping", 5788| 45.8k| yystos[yystate], yyvsp, yylsp, result, scanner); 5789| 45.8k| YYPOPSTACK (1); ------------------ | | 2956| 45.8k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5790| 45.8k| yystate = *yyssp; 5791| 45.8k| YY_STACK_PRINT (yyss, yyssp); 5792| 45.8k| } 5793| | 5794| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5795| 0| *++yyvsp = yylval; 5796| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 5797| | 5798| 0| yyerror_range[2] = yylloc; 5799| | /* Using YYLLOC is tempting, but would change the location of 5800| | the lookahead. YYLOC is available though. */ 5801| 0| YYLLOC_DEFAULT (yyloc, yyerror_range, 2); ------------------ | | 1491| 0| do \ | | 1492| 0| if (N) \ | | ------------------ | | | Branch (1492:11): [True: 0, Folded] | | ------------------ | | 1493| 0| { \ | | 1494| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1495| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1496| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1497| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1498| 0| } \ | | 1499| 0| else \ | | 1500| 0| { \ | | 1501| 0| (Current).first_line = (Current).last_line = \ | | 1502| 0| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1503| 0| (Current).first_column = (Current).last_column = \ | | 1504| 0| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1509| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1505| 0| } \ | | 1506| 0| while (0) | | ------------------ | | | Branch (1506:12): [Folded, False: 0] | | ------------------ ------------------ 5802| 0| *++yylsp = yyloc; 5803| | 5804| | /* Shift the error token. */ 5805| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 5806| | 5807| 0| yystate = yyn; 5808| 0| goto yynewstate; 5809| | 5810| | 5811| |/*-------------------------------------. 5812| || yyacceptlab -- YYACCEPT comes here. | 5813| |`-------------------------------------*/ 5814| 1.40k|yyacceptlab: 5815| 1.40k| yyresult = 0; 5816| 1.40k| goto yyreturn; 5817| | 5818| |/*-----------------------------------. 5819| || yyabortlab -- YYABORT comes here. | 5820| |`-----------------------------------*/ 5821| 4.07k|yyabortlab: 5822| 4.07k| yyresult = 1; 5823| 4.07k| goto yyreturn; 5824| | 5825| 0|#if !defined yyoverflow || YYERROR_VERBOSE 5826| |/*-------------------------------------------------. 5827| || yyexhaustedlab -- memory exhaustion comes here. | 5828| |`-------------------------------------------------*/ 5829| 21|yyexhaustedlab: 5830| 21| yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 67| 21|#define yyerror hsql_error ------------------ yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 517| 21|# define YY_(Msgid) Msgid ------------------ 5831| 21| yyresult = 2; 5832| | /* Fall through. */ 5833| 21|#endif 5834| | 5835| 5.50k|yyreturn: 5836| 5.50k| if (yychar != YYEMPTY) ------------------ | | 1453| 5.50k|#define YYEMPTY (-2) ------------------ | Branch (5836:7): [True: 3.69k, False: 1.80k] ------------------ 5837| 3.69k| { 5838| | /* Make sure we have latest lookahead translation. See comments at 5839| | user semantic actions for why this is necessary. */ 5840| 3.69k| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 3.69k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.69k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.69k, False: 0] | | ------------------ ------------------ 5841| 3.69k| yydestruct ("Cleanup: discarding lookahead", 5842| 3.69k| yytoken, &yylval, &yylloc, result, scanner); 5843| 3.69k| } 5844| | /* Do not reclaim the symbols of the rule whose action triggered 5845| | this YYABORT or YYACCEPT. */ 5846| 5.50k| YYPOPSTACK (yylen); ------------------ | | 2956| 5.50k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5847| 5.50k| YY_STACK_PRINT (yyss, yyssp); 5848| 12.4k| while (yyssp != yyss) ------------------ | Branch (5848:10): [True: 6.99k, False: 5.50k] ------------------ 5849| 6.99k| { 5850| 6.99k| yydestruct ("Cleanup: popping", 5851| 6.99k| yystos[*yyssp], yyvsp, yylsp, result, scanner); 5852| 6.99k| YYPOPSTACK (1); ------------------ | | 2956| 6.99k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5853| 6.99k| } 5854| 5.50k|#ifndef yyoverflow 5855| 5.50k| if (yyss != yyssa) ------------------ | Branch (5855:7): [True: 0, False: 5.50k] ------------------ 5856| 0| YYSTACK_FREE (yyss); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5857| 5.50k|#endif 5858| 5.50k|#if YYERROR_VERBOSE 5859| 5.50k| if (yymsg != yymsgbuf) ------------------ | Branch (5859:7): [True: 0, False: 5.50k] ------------------ 5860| 0| YYSTACK_FREE (yymsg); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5861| 5.50k|#endif 5862| 5.50k| return yyresult; 5863| 21|} bison_parser.cpp:_ZL14yysyntax_errorPmPPcPsi: 1800| 3.40k|{ 1801| 3.40k| YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 496| 3.40k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 108| 3.40k|# define YY_NULLPTR nullptr ------------------ 1802| 3.40k| YYSIZE_T yysize = yysize0; ------------------ | | 496| 3.40k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1803| 3.40k| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1804| | /* Internationalized format string. */ 1805| 3.40k| const char *yyformat = YY_NULLPTR; ------------------ | | 108| 3.40k|# define YY_NULLPTR nullptr ------------------ 1806| | /* Arguments of yyformat. */ 1807| 3.40k| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1808| | /* Number of reported tokens (one for the "unexpected", one per 1809| | "expected"). */ 1810| 3.40k| int yycount = 0; 1811| | 1812| | /* There are many possibilities here to consider: 1813| | - If this state is a consistent state with a default action, then 1814| | the only way this function was invoked is if the default action 1815| | is an error action. In that case, don't check for expected 1816| | tokens because there are none. 1817| | - The only way there can be no lookahead present (in yychar) is if 1818| | this state is a consistent state with a default action. Thus, 1819| | detecting the absence of a lookahead is sufficient to determine 1820| | that there is no unexpected or expected token to report. In that 1821| | case, just report a simple "syntax error". 1822| | - Don't assume there isn't a lookahead just because this state is a 1823| | consistent state with a default action. There might have been a 1824| | previous inconsistent state, consistent state with a non-default 1825| | action, or user semantic action that manipulated yychar. 1826| | - Of course, the expected token list depends on states to have 1827| | correct lookahead information, and it depends on the parser not 1828| | to perform extra reductions after fetching a lookahead from the 1829| | scanner and before detecting a syntax error. Thus, state merging 1830| | (from LALR or IELR) and default reductions corrupt the expected 1831| | token list. However, the list is correct for canonical LR with 1832| | one exception: it will still contain any token that will not be 1833| | accepted due to an error action in a later state. 1834| | */ 1835| 3.40k| if (yytoken != YYEMPTY) ------------------ | | 1453| 3.40k|#define YYEMPTY (-2) ------------------ | Branch (1835:7): [True: 3.40k, False: 0] ------------------ 1836| 3.40k| { 1837| 3.40k| int yyn = yypact[*yyssp]; 1838| 3.40k| yyarg[yycount++] = yytname[yytoken]; 1839| 3.40k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 3.40k| (!!((Yystate) == (-529))) ------------------ | Branch (1839:11): [True: 3.40k, False: 0] ------------------ 1840| 3.40k| { 1841| | /* Start YYX at -YYN if negative to avoid negative indexes in 1842| | YYCHECK. In other words, skip the first -YYN actions for 1843| | this state because they are default actions. */ 1844| 3.40k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1844:26): [True: 954, False: 2.45k] ------------------ 1845| | /* Stay within bounds of both yycheck and yytname. */ 1846| 3.40k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 708| 3.40k|#define YYLAST 856 ------------------ 1847| 3.40k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.40k|#define YYNTOKENS 199 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.29k|#define YYNTOKENS 199 ------------------ | Branch (1847:24): [True: 109, False: 3.29k] ------------------ 1848| 3.40k| int yyx; 1849| | 1850| 574k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1850:32): [True: 571k, False: 2.84k] ------------------ 1851| 571k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 1481| 579k|#define YYTERROR 1 ------------------ | Branch (1851:17): [True: 7.95k, False: 563k] | Branch (1851:46): [True: 7.95k, False: 0] ------------------ 1852| 7.95k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 928| 7.95k| (!!((Yytable_value) == (-355))) ------------------ | Branch (1852:20): [True: 7.87k, False: 75] ------------------ 1853| 7.87k| { 1854| 7.87k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1854:21): [True: 560, False: 7.31k] ------------------ 1855| 560| { 1856| 560| yycount = 1; 1857| 560| yysize = yysize0; 1858| 560| break; 1859| 560| } 1860| 7.31k| yyarg[yycount++] = yytname[yyx]; 1861| 7.31k| { 1862| 7.31k| YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 496| 7.31k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 108| 7.31k|# define YY_NULLPTR nullptr ------------------ 1863| 7.31k| if (! (yysize <= yysize1 ------------------ | Branch (1863:26): [True: 7.31k, False: 0] ------------------ 1864| 7.31k| && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 7.31k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 7.31k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1864:29): [True: 7.31k, False: 0] ------------------ 1865| 0| return 2; 1866| 7.31k| yysize = yysize1; 1867| 7.31k| } 1868| 7.31k| } 1869| 3.40k| } 1870| 3.40k| } 1871| | 1872| 3.40k| switch (yycount) ------------------ | Branch (1872:11): [True: 3.40k, False: 0] ------------------ 1873| 3.40k| { 1874| 0|# define YYCASE_(N, S) \ 1875| 0| case N: \ 1876| 0| yyformat = S; \ 1877| 0| break 1878| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1875| 0| case N: \ | | ------------------ | | | Branch (1875:7): [True: 0, False: 3.40k] | | ------------------ | | 1876| 0| yyformat = S; \ | | 1877| 0| break ------------------ 1879| 560| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1875| 560| case N: \ | | ------------------ | | | Branch (1875:7): [True: 560, False: 2.84k] | | ------------------ | | 1876| 560| yyformat = S; \ | | 1877| 560| break ------------------ 1880| 1.04k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1875| 1.04k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.04k, False: 2.35k] | | ------------------ | | 1876| 1.04k| yyformat = S; \ | | 1877| 1.04k| break ------------------ 1881| 1.49k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1875| 1.49k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.49k, False: 1.90k] | | ------------------ | | 1876| 1.49k| yyformat = S; \ | | 1877| 1.49k| break ------------------ 1882| 170| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1875| 170| case N: \ | | ------------------ | | | Branch (1875:7): [True: 170, False: 3.23k] | | ------------------ | | 1876| 170| yyformat = S; \ | | 1877| 170| break ------------------ 1883| 3.40k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1875| 130| case N: \ | | ------------------ | | | Branch (1875:7): [True: 130, False: 3.27k] | | ------------------ | | 1876| 130| yyformat = S; \ | | 1877| 130| break ------------------ 1884| 3.40k|# undef YYCASE_ 1885| 3.40k| } 1886| | 1887| 3.40k| { 1888| 3.40k| YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 496| 3.40k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 1707| 3.40k|# define yystrlen strlen ------------------ 1889| 3.40k| if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 3.40k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 3.40k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1889:12): [True: 3.40k, False: 0] | Branch (1889:33): [True: 3.40k, False: 0] ------------------ 1890| 0| return 2; 1891| 3.40k| yysize = yysize1; 1892| 3.40k| } 1893| | 1894| 3.40k| if (*yymsg_alloc < yysize) ------------------ | Branch (1894:7): [True: 0, False: 3.40k] ------------------ 1895| 0| { 1896| 0| *yymsg_alloc = 2 * yysize; 1897| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1897:14): [True: 0, False: 0] ------------------ 1898| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 0|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1898:17): [True: 0, False: 0] ------------------ 1899| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 617| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 0|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ 1900| 0| return 1; 1901| 0| } 1902| | 1903| | /* Avoid sprintf, as that infringes on the user's name space. 1904| | Don't have undefined behavior even if the translation 1905| | produced a string with the wrong number of "%s"s. */ 1906| 3.40k| { 1907| 3.40k| char *yyp = *yymsg; 1908| 3.40k| int yyi = 0; 1909| 140k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1909:12): [True: 136k, False: 3.40k] ------------------ 1910| 136k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1910:11): [True: 8.48k, False: 128k] | Branch (1910:26): [True: 8.48k, False: 0] | Branch (1910:48): [True: 8.48k, False: 0] ------------------ 1911| 8.48k| { 1912| 8.48k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1913| 8.48k| yyformat += 2; 1914| 8.48k| } 1915| 128k| else 1916| 128k| { 1917| 128k| yyp++; 1918| 128k| yyformat++; 1919| 128k| } 1920| 3.40k| } 1921| 3.40k| return 0; 1922| 3.40k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1751| 19.2k|{ 1752| 19.2k| if (*yystr == '"') ------------------ | Branch (1752:7): [True: 0, False: 19.2k] ------------------ 1753| 0| { 1754| 0| YYSIZE_T yyn = 0; ------------------ | | 496| 0|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1755| 0| char const *yyp = yystr; 1756| | 1757| 0| for (;;) 1758| 0| switch (*++yyp) 1759| 0| { 1760| 0| case '\'': ------------------ | Branch (1760:11): [True: 0, False: 0] ------------------ 1761| 0| case ',': ------------------ | Branch (1761:11): [True: 0, False: 0] ------------------ 1762| 0| goto do_not_strip_quotes; 1763| | 1764| 0| case '\\': ------------------ | Branch (1764:11): [True: 0, False: 0] ------------------ 1765| 0| if (*++yyp != '\\') ------------------ | Branch (1765:17): [True: 0, False: 0] ------------------ 1766| 0| goto do_not_strip_quotes; 1767| | /* Fall through. */ 1768| 0| default: ------------------ | Branch (1768:11): [True: 0, False: 0] ------------------ 1769| 0| if (yyres) ------------------ | Branch (1769:17): [True: 0, False: 0] ------------------ 1770| 0| yyres[yyn] = *yyp; 1771| 0| yyn++; 1772| 0| break; 1773| | 1774| 0| case '"': ------------------ | Branch (1774:11): [True: 0, False: 0] ------------------ 1775| 0| if (yyres) ------------------ | Branch (1775:17): [True: 0, False: 0] ------------------ 1776| 0| yyres[yyn] = '\0'; 1777| 0| return yyn; 1778| 0| } 1779| 0| do_not_strip_quotes: ; 1780| 0| } 1781| | 1782| 19.2k| if (! yyres) ------------------ | Branch (1782:7): [True: 10.7k, False: 8.48k] ------------------ 1783| 10.7k| return yystrlen (yystr); ------------------ | | 1707| 10.7k|# define yystrlen strlen ------------------ 1784| | 1785| 8.48k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1723| 8.48k|# define yystpcpy stpcpy ------------------ 1786| 19.2k|} bison_parser.cpp:_ZL10yydestructPKciP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 1931| 56.5k|{ 1932| 56.5k| YYUSE (yyvaluep); ------------------ | | 550| 56.5k|# define YYUSE(E) ((void) (E)) ------------------ 1933| 56.5k| YYUSE (yylocationp); ------------------ | | 550| 56.5k|# define YYUSE(E) ((void) (E)) ------------------ 1934| 56.5k| YYUSE (result); ------------------ | | 550| 56.5k|# define YYUSE(E) ((void) (E)) ------------------ 1935| 56.5k| YYUSE (scanner); ------------------ | | 550| 56.5k|# define YYUSE(E) ((void) (E)) ------------------ 1936| 56.5k| if (!yymsg) ------------------ | Branch (1936:7): [True: 0, False: 56.5k] ------------------ 1937| 0| yymsg = "Deleting"; 1938| 56.5k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1939| | 1940| 56.5k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1941| 56.5k| switch (yytype) 1942| 56.5k| { 1943| 2.56k| case 3: /* IDENTIFIER */ ------------------ | Branch (1943:11): [True: 2.56k, False: 53.9k] ------------------ 1944| 2.56k|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1945| 2.56k| { free(((*yyvaluep).sval)); } 1946| 2.56k|#line 1947 "bison_parser.cpp" /* yacc.c:1257 */ 1947| 2.56k| break; 1948| | 1949| 17| case 4: /* STRING */ ------------------ | Branch (1949:5): [True: 17, False: 56.5k] ------------------ 1950| 17|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1951| 17| { free(((*yyvaluep).sval)); } 1952| 17|#line 1953 "bison_parser.cpp" /* yacc.c:1257 */ 1953| 17| break; 1954| | 1955| 23| case 5: /* FLOATVAL */ ------------------ | Branch (1955:5): [True: 23, False: 56.5k] ------------------ 1956| 23|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1957| 23| { } 1958| 23|#line 1959 "bison_parser.cpp" /* yacc.c:1257 */ 1959| 23| break; 1960| | 1961| 45| case 6: /* INTVAL */ ------------------ | Branch (1961:5): [True: 45, False: 56.5k] ------------------ 1962| 45|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1963| 45| { } 1964| 45|#line 1965 "bison_parser.cpp" /* yacc.c:1257 */ 1965| 45| break; 1966| | 1967| 554| case 201: /* statement_list */ ------------------ | Branch (1967:5): [True: 554, False: 55.9k] ------------------ 1968| 554|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1969| 554| { 1970| 554| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (1970:7): [True: 554, False: 0] ------------------ 1971| 36.2k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (1971:19): [True: 36.2k, False: 554] ------------------ 1972| 36.2k| delete ptr; 1973| 36.2k| } 1974| 554| } 1975| 554| delete (((*yyvaluep).stmt_vec)); 1976| 554|} 1977| 554|#line 1978 "bison_parser.cpp" /* yacc.c:1257 */ 1978| 554| break; 1979| | 1980| 0| case 202: /* statement */ ------------------ | Branch (1980:5): [True: 0, False: 56.5k] ------------------ 1981| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1982| 0| { delete (((*yyvaluep).statement)); } 1983| 0|#line 1984 "bison_parser.cpp" /* yacc.c:1257 */ 1984| 0| break; 1985| | 1986| 53| case 203: /* preparable_statement */ ------------------ | Branch (1986:5): [True: 53, False: 56.4k] ------------------ 1987| 53|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1988| 53| { delete (((*yyvaluep).statement)); } 1989| 53|#line 1990 "bison_parser.cpp" /* yacc.c:1257 */ 1990| 53| break; 1991| | 1992| 0| case 204: /* opt_hints */ ------------------ | Branch (1992:5): [True: 0, False: 56.5k] ------------------ 1993| 0|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1994| 0| { 1995| 0| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (1995:7): [True: 0, False: 0] ------------------ 1996| 0| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (1996:19): [True: 0, False: 0] ------------------ 1997| 0| delete ptr; 1998| 0| } 1999| 0| } 2000| 0| delete (((*yyvaluep).expr_vec)); 2001| 0|} 2002| 0|#line 2003 "bison_parser.cpp" /* yacc.c:1257 */ 2003| 0| break; 2004| | 2005| 38| case 205: /* hint_list */ ------------------ | Branch (2005:5): [True: 38, False: 56.5k] ------------------ 2006| 38|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2007| 38| { 2008| 38| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2008:7): [True: 38, False: 0] ------------------ 2009| 831| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2009:19): [True: 831, False: 38] ------------------ 2010| 831| delete ptr; 2011| 831| } 2012| 38| } 2013| 38| delete (((*yyvaluep).expr_vec)); 2014| 38|} 2015| 38|#line 2016 "bison_parser.cpp" /* yacc.c:1257 */ 2016| 38| break; 2017| | 2018| 0| case 206: /* hint */ ------------------ | Branch (2018:5): [True: 0, False: 56.5k] ------------------ 2019| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2020| 0| { delete (((*yyvaluep).expr)); } 2021| 0|#line 2022 "bison_parser.cpp" /* yacc.c:1257 */ 2022| 0| break; 2023| | 2024| 0| case 207: /* transaction_statement */ ------------------ | Branch (2024:5): [True: 0, False: 56.5k] ------------------ 2025| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2026| 0| { delete (((*yyvaluep).transaction_stmt)); } 2027| 0|#line 2028 "bison_parser.cpp" /* yacc.c:1257 */ 2028| 0| break; 2029| | 2030| 1| case 209: /* prepare_statement */ ------------------ | Branch (2030:5): [True: 1, False: 56.5k] ------------------ 2031| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2032| 1| { delete (((*yyvaluep).prep_stmt)); } 2033| 1|#line 2034 "bison_parser.cpp" /* yacc.c:1257 */ 2034| 1| break; 2035| | 2036| 0| case 210: /* prepare_target_query */ ------------------ | Branch (2036:5): [True: 0, False: 56.5k] ------------------ 2037| 0|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2038| 0| { free(((*yyvaluep).sval)); } 2039| 0|#line 2040 "bison_parser.cpp" /* yacc.c:1257 */ 2040| 0| break; 2041| | 2042| 0| case 211: /* execute_statement */ ------------------ | Branch (2042:5): [True: 0, False: 56.5k] ------------------ 2043| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2044| 0| { delete (((*yyvaluep).exec_stmt)); } 2045| 0|#line 2046 "bison_parser.cpp" /* yacc.c:1257 */ 2046| 0| break; 2047| | 2048| 0| case 212: /* import_statement */ ------------------ | Branch (2048:5): [True: 0, False: 56.5k] ------------------ 2049| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2050| 0| { delete (((*yyvaluep).import_stmt)); } 2051| 0|#line 2052 "bison_parser.cpp" /* yacc.c:1257 */ 2052| 0| break; 2053| | 2054| 3| case 213: /* file_type */ ------------------ | Branch (2054:5): [True: 3, False: 56.5k] ------------------ 2055| 3|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2056| 3| { } 2057| 3|#line 2058 "bison_parser.cpp" /* yacc.c:1257 */ 2058| 3| break; 2059| | 2060| 198| case 214: /* file_path */ ------------------ | Branch (2060:5): [True: 198, False: 56.3k] ------------------ 2061| 198|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2062| 198| { free(((*yyvaluep).sval)); } 2063| 198|#line 2064 "bison_parser.cpp" /* yacc.c:1257 */ 2064| 198| break; 2065| | 2066| 1| case 215: /* opt_import_export_options */ ------------------ | Branch (2066:5): [True: 1, False: 56.5k] ------------------ 2067| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2068| 1| { delete (((*yyvaluep).import_export_option_t)); } 2069| 1|#line 2070 "bison_parser.cpp" /* yacc.c:1257 */ 2070| 1| break; 2071| | 2072| 56| case 216: /* import_export_options */ ------------------ | Branch (2072:5): [True: 56, False: 56.4k] ------------------ 2073| 56|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2074| 56| { delete (((*yyvaluep).import_export_option_t)); } 2075| 56|#line 2076 "bison_parser.cpp" /* yacc.c:1257 */ 2076| 56| break; 2077| | 2078| 0| case 217: /* csv_option */ ------------------ | Branch (2078:5): [True: 0, False: 56.5k] ------------------ 2079| 0|#line 203 "bison_parser.y" /* yacc.c:1257 */ 2080| 0| { 2081| 0| free(((*yyvaluep).csv_option_t)->second); 2082| 0| delete (((*yyvaluep).csv_option_t)); 2083| 0|} 2084| 0|#line 2085 "bison_parser.cpp" /* yacc.c:1257 */ 2085| 0| break; 2086| | 2087| 0| case 218: /* export_statement */ ------------------ | Branch (2087:5): [True: 0, False: 56.5k] ------------------ 2088| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2089| 0| { delete (((*yyvaluep).export_stmt)); } 2090| 0|#line 2091 "bison_parser.cpp" /* yacc.c:1257 */ 2091| 0| break; 2092| | 2093| 0| case 219: /* show_statement */ ------------------ | Branch (2093:5): [True: 0, False: 56.5k] ------------------ 2094| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2095| 0| { delete (((*yyvaluep).show_stmt)); } 2096| 0|#line 2097 "bison_parser.cpp" /* yacc.c:1257 */ 2097| 0| break; 2098| | 2099| 0| case 220: /* create_statement */ ------------------ | Branch (2099:5): [True: 0, False: 56.5k] ------------------ 2100| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2101| 0| { delete (((*yyvaluep).create_stmt)); } 2102| 0|#line 2103 "bison_parser.cpp" /* yacc.c:1257 */ 2103| 0| break; 2104| | 2105| 624| case 221: /* opt_not_exists */ ------------------ | Branch (2105:5): [True: 624, False: 55.9k] ------------------ 2106| 624|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2107| 624| { } 2108| 624|#line 2109 "bison_parser.cpp" /* yacc.c:1257 */ 2109| 624| break; 2110| | 2111| 548| case 222: /* table_elem_commalist */ ------------------ | Branch (2111:5): [True: 548, False: 55.9k] ------------------ 2112| 548|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2113| 548| { 2114| 548| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2114:7): [True: 548, False: 0] ------------------ 2115| 15.6k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2115:19): [True: 15.6k, False: 548] ------------------ 2116| 15.6k| delete ptr; 2117| 15.6k| } 2118| 548| } 2119| 548| delete (((*yyvaluep).table_element_vec)); 2120| 548|} 2121| 548|#line 2122 "bison_parser.cpp" /* yacc.c:1257 */ 2122| 548| break; 2123| | 2124| 0| case 223: /* table_elem */ ------------------ | Branch (2124:5): [True: 0, False: 56.5k] ------------------ 2125| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2126| 0| { delete (((*yyvaluep).table_element_t)); } 2127| 0|#line 2128 "bison_parser.cpp" /* yacc.c:1257 */ 2128| 0| break; 2129| | 2130| 0| case 224: /* column_def */ ------------------ | Branch (2130:5): [True: 0, False: 56.5k] ------------------ 2131| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2132| 0| { delete (((*yyvaluep).column_t)); } 2133| 0|#line 2134 "bison_parser.cpp" /* yacc.c:1257 */ 2134| 0| break; 2135| | 2136| 16| case 225: /* column_type */ ------------------ | Branch (2136:5): [True: 16, False: 56.5k] ------------------ 2137| 16|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2138| 16| { } 2139| 16|#line 2140 "bison_parser.cpp" /* yacc.c:1257 */ 2140| 16| break; 2141| | 2142| 0| case 226: /* opt_time_precision */ ------------------ | Branch (2142:5): [True: 0, False: 56.5k] ------------------ 2143| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2144| 0| { } 2145| 0|#line 2146 "bison_parser.cpp" /* yacc.c:1257 */ 2146| 0| break; 2147| | 2148| 0| case 227: /* opt_decimal_specification */ ------------------ | Branch (2148:5): [True: 0, False: 56.5k] ------------------ 2149| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2150| 0| { delete (((*yyvaluep).ival_pair)); } 2151| 0|#line 2152 "bison_parser.cpp" /* yacc.c:1257 */ 2152| 0| break; 2153| | 2154| 0| case 228: /* opt_column_constraints */ ------------------ | Branch (2154:5): [True: 0, False: 56.5k] ------------------ 2155| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2156| 0| { delete (((*yyvaluep).column_constraints_t)); } 2157| 0|#line 2158 "bison_parser.cpp" /* yacc.c:1257 */ 2158| 0| break; 2159| | 2160| 13| case 229: /* column_constraints */ ------------------ | Branch (2160:5): [True: 13, False: 56.5k] ------------------ 2161| 13|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2162| 13| { delete (((*yyvaluep).column_constraints_t)); } 2163| 13|#line 2164 "bison_parser.cpp" /* yacc.c:1257 */ 2164| 13| break; 2165| | 2166| 0| case 230: /* column_constraint */ ------------------ | Branch (2166:5): [True: 0, False: 56.5k] ------------------ 2167| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2168| 0| { } 2169| 0|#line 2170 "bison_parser.cpp" /* yacc.c:1257 */ 2170| 0| break; 2171| | 2172| 0| case 231: /* table_constraint */ ------------------ | Branch (2172:5): [True: 0, False: 56.5k] ------------------ 2173| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2174| 0| { delete (((*yyvaluep).table_constraint_t)); } 2175| 0|#line 2176 "bison_parser.cpp" /* yacc.c:1257 */ 2176| 0| break; 2177| | 2178| 0| case 232: /* references_spec */ ------------------ | Branch (2178:5): [True: 0, False: 56.5k] ------------------ 2179| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2180| 0| { delete (((*yyvaluep).references_spec_t)); } 2181| 0|#line 2182 "bison_parser.cpp" /* yacc.c:1257 */ 2182| 0| break; 2183| | 2184| 0| case 233: /* drop_statement */ ------------------ | Branch (2184:5): [True: 0, False: 56.5k] ------------------ 2185| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2186| 0| { delete (((*yyvaluep).drop_stmt)); } 2187| 0|#line 2188 "bison_parser.cpp" /* yacc.c:1257 */ 2188| 0| break; 2189| | 2190| 24| case 234: /* opt_exists */ ------------------ | Branch (2190:5): [True: 24, False: 56.5k] ------------------ 2191| 24|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2192| 24| { } 2193| 24|#line 2194 "bison_parser.cpp" /* yacc.c:1257 */ 2194| 24| break; 2195| | 2196| 0| case 235: /* alter_statement */ ------------------ | Branch (2196:5): [True: 0, False: 56.5k] ------------------ 2197| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2198| 0| { delete (((*yyvaluep).alter_stmt)); } 2199| 0|#line 2200 "bison_parser.cpp" /* yacc.c:1257 */ 2200| 0| break; 2201| | 2202| 0| case 236: /* alter_action */ ------------------ | Branch (2202:5): [True: 0, False: 56.5k] ------------------ 2203| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2204| 0| { delete (((*yyvaluep).alter_action_t)); } 2205| 0|#line 2206 "bison_parser.cpp" /* yacc.c:1257 */ 2206| 0| break; 2207| | 2208| 0| case 237: /* drop_action */ ------------------ | Branch (2208:5): [True: 0, False: 56.5k] ------------------ 2209| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2210| 0| { delete (((*yyvaluep).drop_action_t)); } 2211| 0|#line 2212 "bison_parser.cpp" /* yacc.c:1257 */ 2212| 0| break; 2213| | 2214| 0| case 238: /* delete_statement */ ------------------ | Branch (2214:5): [True: 0, False: 56.5k] ------------------ 2215| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2216| 0| { delete (((*yyvaluep).delete_stmt)); } 2217| 0|#line 2218 "bison_parser.cpp" /* yacc.c:1257 */ 2218| 0| break; 2219| | 2220| 0| case 239: /* truncate_statement */ ------------------ | Branch (2220:5): [True: 0, False: 56.5k] ------------------ 2221| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2222| 0| { delete (((*yyvaluep).delete_stmt)); } 2223| 0|#line 2224 "bison_parser.cpp" /* yacc.c:1257 */ 2224| 0| break; 2225| | 2226| 0| case 240: /* insert_statement */ ------------------ | Branch (2226:5): [True: 0, False: 56.5k] ------------------ 2227| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2228| 0| { delete (((*yyvaluep).insert_stmt)); } 2229| 0|#line 2230 "bison_parser.cpp" /* yacc.c:1257 */ 2230| 0| break; 2231| | 2232| 36| case 241: /* opt_column_list */ ------------------ | Branch (2232:5): [True: 36, False: 56.5k] ------------------ 2233| 36|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2234| 36| { 2235| 36| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2235:7): [True: 16, False: 20] ------------------ 2236| 374| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2236:19): [True: 374, False: 16] ------------------ 2237| 374| free(ptr); 2238| 374| } 2239| 16| } 2240| 36| delete (((*yyvaluep).str_vec)); 2241| 36|} 2242| 36|#line 2243 "bison_parser.cpp" /* yacc.c:1257 */ 2243| 36| break; 2244| | 2245| 0| case 242: /* update_statement */ ------------------ | Branch (2245:5): [True: 0, False: 56.5k] ------------------ 2246| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2247| 0| { delete (((*yyvaluep).update_stmt)); } 2248| 0|#line 2249 "bison_parser.cpp" /* yacc.c:1257 */ 2249| 0| break; 2250| | 2251| 13| case 243: /* update_clause_commalist */ ------------------ | Branch (2251:5): [True: 13, False: 56.5k] ------------------ 2252| 13|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2253| 13| { 2254| 13| if (((*yyvaluep).update_vec)) { ------------------ | Branch (2254:7): [True: 13, False: 0] ------------------ 2255| 379| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2255:19): [True: 379, False: 13] ------------------ 2256| 379| delete ptr; 2257| 379| } 2258| 13| } 2259| 13| delete (((*yyvaluep).update_vec)); 2260| 13|} 2261| 13|#line 2262 "bison_parser.cpp" /* yacc.c:1257 */ 2262| 13| break; 2263| | 2264| 0| case 244: /* update_clause */ ------------------ | Branch (2264:5): [True: 0, False: 56.5k] ------------------ 2265| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2266| 0| { delete (((*yyvaluep).update_t)); } 2267| 0|#line 2268 "bison_parser.cpp" /* yacc.c:1257 */ 2268| 0| break; 2269| | 2270| 4| case 245: /* select_statement */ ------------------ | Branch (2270:5): [True: 4, False: 56.5k] ------------------ 2271| 4|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2272| 4| { delete (((*yyvaluep).select_stmt)); } 2273| 4|#line 2274 "bison_parser.cpp" /* yacc.c:1257 */ 2274| 4| break; 2275| | 2276| 97| case 246: /* select_within_set_operation */ ------------------ | Branch (2276:5): [True: 97, False: 56.4k] ------------------ 2277| 97|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2278| 97| { delete (((*yyvaluep).select_stmt)); } 2279| 97|#line 2280 "bison_parser.cpp" /* yacc.c:1257 */ 2280| 97| break; 2281| | 2282| 0| case 247: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2282:5): [True: 0, False: 56.5k] ------------------ 2283| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2284| 0| { delete (((*yyvaluep).select_stmt)); } 2285| 0|#line 2286 "bison_parser.cpp" /* yacc.c:1257 */ 2286| 0| break; 2287| | 2288| 43| case 248: /* select_with_paren */ ------------------ | Branch (2288:5): [True: 43, False: 56.5k] ------------------ 2289| 43|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2290| 43| { delete (((*yyvaluep).select_stmt)); } 2291| 43|#line 2292 "bison_parser.cpp" /* yacc.c:1257 */ 2292| 43| break; 2293| | 2294| 108| case 249: /* select_no_paren */ ------------------ | Branch (2294:5): [True: 108, False: 56.4k] ------------------ 2295| 108|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2296| 108| { delete (((*yyvaluep).select_stmt)); } 2297| 108|#line 2298 "bison_parser.cpp" /* yacc.c:1257 */ 2298| 108| break; 2299| | 2300| 1.11k| case 250: /* set_operator */ ------------------ | Branch (2300:5): [True: 1.11k, False: 55.4k] ------------------ 2301| 1.11k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2302| 1.11k| { delete (((*yyvaluep).set_operator_t)); } 2303| 1.11k|#line 2304 "bison_parser.cpp" /* yacc.c:1257 */ 2304| 1.11k| break; 2305| | 2306| 0| case 251: /* set_type */ ------------------ | Branch (2306:5): [True: 0, False: 56.5k] ------------------ 2307| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2308| 0| { delete (((*yyvaluep).set_operator_t)); } 2309| 0|#line 2310 "bison_parser.cpp" /* yacc.c:1257 */ 2310| 0| break; 2311| | 2312| 0| case 252: /* opt_all */ ------------------ | Branch (2312:5): [True: 0, False: 56.5k] ------------------ 2313| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2314| 0| { } 2315| 0|#line 2316 "bison_parser.cpp" /* yacc.c:1257 */ 2316| 0| break; 2317| | 2318| 1.71k| case 253: /* select_clause */ ------------------ | Branch (2318:5): [True: 1.71k, False: 54.8k] ------------------ 2319| 1.71k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2320| 1.71k| { delete (((*yyvaluep).select_stmt)); } 2321| 1.71k|#line 2322 "bison_parser.cpp" /* yacc.c:1257 */ 2322| 1.71k| break; 2323| | 2324| 3.43k| case 254: /* opt_distinct */ ------------------ | Branch (2324:5): [True: 3.43k, False: 53.1k] ------------------ 2325| 3.43k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2326| 3.43k| { } 2327| 3.43k|#line 2328 "bison_parser.cpp" /* yacc.c:1257 */ 2328| 3.43k| break; 2329| | 2330| 607| case 255: /* select_list */ ------------------ | Branch (2330:5): [True: 607, False: 55.9k] ------------------ 2331| 607|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2332| 607| { 2333| 607| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2333:7): [True: 607, False: 0] ------------------ 2334| 981| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2334:19): [True: 981, False: 607] ------------------ 2335| 981| delete ptr; 2336| 981| } 2337| 607| } 2338| 607| delete (((*yyvaluep).expr_vec)); 2339| 607|} 2340| 607|#line 2341 "bison_parser.cpp" /* yacc.c:1257 */ 2341| 607| break; 2342| | 2343| 181| case 256: /* opt_from_clause */ ------------------ | Branch (2343:5): [True: 181, False: 56.3k] ------------------ 2344| 181|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2345| 181| { delete (((*yyvaluep).table)); } 2346| 181|#line 2347 "bison_parser.cpp" /* yacc.c:1257 */ 2347| 181| break; 2348| | 2349| 0| case 257: /* from_clause */ ------------------ | Branch (2349:5): [True: 0, False: 56.5k] ------------------ 2350| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2351| 0| { delete (((*yyvaluep).table)); } 2352| 0|#line 2353 "bison_parser.cpp" /* yacc.c:1257 */ 2353| 0| break; 2354| | 2355| 103| case 258: /* opt_where */ ------------------ | Branch (2355:5): [True: 103, False: 56.4k] ------------------ 2356| 103|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2357| 103| { delete (((*yyvaluep).expr)); } 2358| 103|#line 2359 "bison_parser.cpp" /* yacc.c:1257 */ 2359| 103| break; 2360| | 2361| 1| case 259: /* opt_group */ ------------------ | Branch (2361:5): [True: 1, False: 56.5k] ------------------ 2362| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2363| 1| { delete (((*yyvaluep).group_t)); } 2364| 1|#line 2365 "bison_parser.cpp" /* yacc.c:1257 */ 2365| 1| break; 2366| | 2367| 0| case 260: /* opt_having */ ------------------ | Branch (2367:5): [True: 0, False: 56.5k] ------------------ 2368| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2369| 0| { delete (((*yyvaluep).expr)); } 2370| 0|#line 2371 "bison_parser.cpp" /* yacc.c:1257 */ 2371| 0| break; 2372| | 2373| 578| case 261: /* opt_order */ ------------------ | Branch (2373:5): [True: 578, False: 55.9k] ------------------ 2374| 578|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2375| 578| { 2376| 578| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2376:7): [True: 99, False: 479] ------------------ 2377| 387| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2377:19): [True: 387, False: 99] ------------------ 2378| 387| delete ptr; 2379| 387| } 2380| 99| } 2381| 578| delete (((*yyvaluep).order_vec)); 2382| 578|} 2383| 578|#line 2384 "bison_parser.cpp" /* yacc.c:1257 */ 2384| 578| break; 2385| | 2386| 148| case 262: /* order_list */ ------------------ | Branch (2386:5): [True: 148, False: 56.3k] ------------------ 2387| 148|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2388| 148| { 2389| 148| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2389:7): [True: 148, False: 0] ------------------ 2390| 1.87k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2390:19): [True: 1.87k, False: 148] ------------------ 2391| 1.87k| delete ptr; 2392| 1.87k| } 2393| 148| } 2394| 148| delete (((*yyvaluep).order_vec)); 2395| 148|} 2396| 148|#line 2397 "bison_parser.cpp" /* yacc.c:1257 */ 2397| 148| break; 2398| | 2399| 0| case 263: /* order_desc */ ------------------ | Branch (2399:5): [True: 0, False: 56.5k] ------------------ 2400| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2401| 0| { delete (((*yyvaluep).order)); } 2402| 0|#line 2403 "bison_parser.cpp" /* yacc.c:1257 */ 2403| 0| break; 2404| | 2405| 138| case 264: /* opt_order_type */ ------------------ | Branch (2405:5): [True: 138, False: 56.4k] ------------------ 2406| 138|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2407| 138| { } 2408| 138|#line 2409 "bison_parser.cpp" /* yacc.c:1257 */ 2409| 138| break; 2410| | 2411| 1| case 265: /* opt_null_ordering */ ------------------ | Branch (2411:5): [True: 1, False: 56.5k] ------------------ 2412| 1|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2413| 1| { } 2414| 1|#line 2415 "bison_parser.cpp" /* yacc.c:1257 */ 2415| 1| break; 2416| | 2417| 2.06k| case 266: /* opt_top */ ------------------ | Branch (2417:5): [True: 2.06k, False: 54.4k] ------------------ 2418| 2.06k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2419| 2.06k| { delete (((*yyvaluep).limit)); } 2420| 2.06k|#line 2421 "bison_parser.cpp" /* yacc.c:1257 */ 2421| 2.06k| break; 2422| | 2423| 43| case 267: /* opt_limit */ ------------------ | Branch (2423:5): [True: 43, False: 56.5k] ------------------ 2424| 43|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2425| 43| { delete (((*yyvaluep).limit)); } 2426| 43|#line 2427 "bison_parser.cpp" /* yacc.c:1257 */ 2427| 43| break; 2428| | 2429| 632| case 268: /* expr_list */ ------------------ | Branch (2429:5): [True: 632, False: 55.9k] ------------------ 2430| 632|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2431| 632| { 2432| 632| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2432:7): [True: 632, False: 0] ------------------ 2433| 18.3k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2433:19): [True: 18.3k, False: 632] ------------------ 2434| 18.3k| delete ptr; 2435| 18.3k| } 2436| 632| } 2437| 632| delete (((*yyvaluep).expr_vec)); 2438| 632|} 2439| 632|#line 2440 "bison_parser.cpp" /* yacc.c:1257 */ 2440| 632| break; 2441| | 2442| 45| case 269: /* opt_extended_literal_list */ ------------------ | Branch (2442:5): [True: 45, False: 56.5k] ------------------ 2443| 45|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2444| 45| { 2445| 45| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2445:7): [True: 38, False: 7] ------------------ 2446| 882| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2446:19): [True: 882, False: 38] ------------------ 2447| 882| delete ptr; 2448| 882| } 2449| 38| } 2450| 45| delete (((*yyvaluep).expr_vec)); 2451| 45|} 2452| 45|#line 2453 "bison_parser.cpp" /* yacc.c:1257 */ 2453| 45| break; 2454| | 2455| 26| case 270: /* extended_literal_list */ ------------------ | Branch (2455:5): [True: 26, False: 56.5k] ------------------ 2456| 26|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2457| 26| { 2458| 26| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2458:7): [True: 26, False: 0] ------------------ 2459| 589| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2459:19): [True: 589, False: 26] ------------------ 2460| 589| delete ptr; 2461| 589| } 2462| 26| } 2463| 26| delete (((*yyvaluep).expr_vec)); 2464| 26|} 2465| 26|#line 2466 "bison_parser.cpp" /* yacc.c:1257 */ 2466| 26| break; 2467| | 2468| 0| case 271: /* casted_extended_literal */ ------------------ | Branch (2468:5): [True: 0, False: 56.5k] ------------------ 2469| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2470| 0| { delete (((*yyvaluep).expr)); } 2471| 0|#line 2472 "bison_parser.cpp" /* yacc.c:1257 */ 2472| 0| break; 2473| | 2474| 1| case 272: /* extended_literal */ ------------------ | Branch (2474:5): [True: 1, False: 56.5k] ------------------ 2475| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2476| 1| { delete (((*yyvaluep).expr)); } 2477| 1|#line 2478 "bison_parser.cpp" /* yacc.c:1257 */ 2478| 1| break; 2479| | 2480| 0| case 273: /* expr_alias */ ------------------ | Branch (2480:5): [True: 0, False: 56.5k] ------------------ 2481| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2482| 0| { delete (((*yyvaluep).expr)); } 2483| 0|#line 2484 "bison_parser.cpp" /* yacc.c:1257 */ 2484| 0| break; 2485| | 2486| 506| case 274: /* expr */ ------------------ | Branch (2486:5): [True: 506, False: 56.0k] ------------------ 2487| 506|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2488| 506| { delete (((*yyvaluep).expr)); } 2489| 506|#line 2490 "bison_parser.cpp" /* yacc.c:1257 */ 2490| 506| break; 2491| | 2492| 1.72k| case 275: /* operand */ ------------------ | Branch (2492:5): [True: 1.72k, False: 54.8k] ------------------ 2493| 1.72k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2494| 1.72k| { delete (((*yyvaluep).expr)); } 2495| 1.72k|#line 2496 "bison_parser.cpp" /* yacc.c:1257 */ 2496| 1.72k| break; 2497| | 2498| 0| case 276: /* scalar_expr */ ------------------ | Branch (2498:5): [True: 0, False: 56.5k] ------------------ 2499| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2500| 0| { delete (((*yyvaluep).expr)); } 2501| 0|#line 2502 "bison_parser.cpp" /* yacc.c:1257 */ 2502| 0| break; 2503| | 2504| 0| case 277: /* unary_expr */ ------------------ | Branch (2504:5): [True: 0, False: 56.5k] ------------------ 2505| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2506| 0| { delete (((*yyvaluep).expr)); } 2507| 0|#line 2508 "bison_parser.cpp" /* yacc.c:1257 */ 2508| 0| break; 2509| | 2510| 0| case 278: /* binary_expr */ ------------------ | Branch (2510:5): [True: 0, False: 56.5k] ------------------ 2511| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2512| 0| { delete (((*yyvaluep).expr)); } 2513| 0|#line 2514 "bison_parser.cpp" /* yacc.c:1257 */ 2514| 0| break; 2515| | 2516| 0| case 279: /* logic_expr */ ------------------ | Branch (2516:5): [True: 0, False: 56.5k] ------------------ 2517| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2518| 0| { delete (((*yyvaluep).expr)); } 2519| 0|#line 2520 "bison_parser.cpp" /* yacc.c:1257 */ 2520| 0| break; 2521| | 2522| 0| case 280: /* in_expr */ ------------------ | Branch (2522:5): [True: 0, False: 56.5k] ------------------ 2523| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2524| 0| { delete (((*yyvaluep).expr)); } 2525| 0|#line 2526 "bison_parser.cpp" /* yacc.c:1257 */ 2526| 0| break; 2527| | 2528| 0| case 281: /* case_expr */ ------------------ | Branch (2528:5): [True: 0, False: 56.5k] ------------------ 2529| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2530| 0| { delete (((*yyvaluep).expr)); } 2531| 0|#line 2532 "bison_parser.cpp" /* yacc.c:1257 */ 2532| 0| break; 2533| | 2534| 229| case 282: /* case_list */ ------------------ | Branch (2534:5): [True: 229, False: 56.3k] ------------------ 2535| 229|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2536| 229| { delete (((*yyvaluep).expr)); } 2537| 229|#line 2538 "bison_parser.cpp" /* yacc.c:1257 */ 2538| 229| break; 2539| | 2540| 0| case 283: /* exists_expr */ ------------------ | Branch (2540:5): [True: 0, False: 56.5k] ------------------ 2541| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2542| 0| { delete (((*yyvaluep).expr)); } 2543| 0|#line 2544 "bison_parser.cpp" /* yacc.c:1257 */ 2544| 0| break; 2545| | 2546| 0| case 284: /* comp_expr */ ------------------ | Branch (2546:5): [True: 0, False: 56.5k] ------------------ 2547| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2548| 0| { delete (((*yyvaluep).expr)); } 2549| 0|#line 2550 "bison_parser.cpp" /* yacc.c:1257 */ 2550| 0| break; 2551| | 2552| 0| case 285: /* function_expr */ ------------------ | Branch (2552:5): [True: 0, False: 56.5k] ------------------ 2553| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2554| 0| { delete (((*yyvaluep).expr)); } 2555| 0|#line 2556 "bison_parser.cpp" /* yacc.c:1257 */ 2556| 0| break; 2557| | 2558| 1| case 286: /* opt_window */ ------------------ | Branch (2558:5): [True: 1, False: 56.5k] ------------------ 2559| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2560| 1| { delete (((*yyvaluep).window_description)); } 2561| 1|#line 2562 "bison_parser.cpp" /* yacc.c:1257 */ 2562| 1| break; 2563| | 2564| 216| case 287: /* opt_partition */ ------------------ | Branch (2564:5): [True: 216, False: 56.3k] ------------------ 2565| 216|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2566| 216| { 2567| 216| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2567:7): [True: 56, False: 160] ------------------ 2568| 303| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2568:19): [True: 303, False: 56] ------------------ 2569| 303| delete ptr; 2570| 303| } 2571| 56| } 2572| 216| delete (((*yyvaluep).expr_vec)); 2573| 216|} 2574| 216|#line 2575 "bison_parser.cpp" /* yacc.c:1257 */ 2575| 216| break; 2576| | 2577| 70| case 288: /* opt_frame_clause */ ------------------ | Branch (2577:5): [True: 70, False: 56.4k] ------------------ 2578| 70|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2579| 70| { delete (((*yyvaluep).frame_description)); } 2580| 70|#line 2581 "bison_parser.cpp" /* yacc.c:1257 */ 2581| 70| break; 2582| | 2583| 43| case 289: /* frame_type */ ------------------ | Branch (2583:5): [True: 43, False: 56.5k] ------------------ 2584| 43|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2585| 43| { } 2586| 43|#line 2587 "bison_parser.cpp" /* yacc.c:1257 */ 2587| 43| break; 2588| | 2589| 2| case 290: /* frame_bound */ ------------------ | Branch (2589:5): [True: 2, False: 56.5k] ------------------ 2590| 2|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2591| 2| { delete (((*yyvaluep).frame_bound)); } 2592| 2|#line 2593 "bison_parser.cpp" /* yacc.c:1257 */ 2593| 2| break; 2594| | 2595| 0| case 291: /* extract_expr */ ------------------ | Branch (2595:5): [True: 0, False: 56.5k] ------------------ 2596| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2597| 0| { delete (((*yyvaluep).expr)); } 2598| 0|#line 2599 "bison_parser.cpp" /* yacc.c:1257 */ 2599| 0| break; 2600| | 2601| 0| case 292: /* cast_expr */ ------------------ | Branch (2601:5): [True: 0, False: 56.5k] ------------------ 2602| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2603| 0| { delete (((*yyvaluep).expr)); } 2604| 0|#line 2605 "bison_parser.cpp" /* yacc.c:1257 */ 2605| 0| break; 2606| | 2607| 274| case 293: /* datetime_field */ ------------------ | Branch (2607:5): [True: 274, False: 56.2k] ------------------ 2608| 274|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2609| 274| { } 2610| 274|#line 2611 "bison_parser.cpp" /* yacc.c:1257 */ 2611| 274| break; 2612| | 2613| 0| case 294: /* datetime_field_plural */ ------------------ | Branch (2613:5): [True: 0, False: 56.5k] ------------------ 2614| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2615| 0| { } 2616| 0|#line 2617 "bison_parser.cpp" /* yacc.c:1257 */ 2617| 0| break; 2618| | 2619| 0| case 295: /* duration_field */ ------------------ | Branch (2619:5): [True: 0, False: 56.5k] ------------------ 2620| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2621| 0| { } 2622| 0|#line 2623 "bison_parser.cpp" /* yacc.c:1257 */ 2623| 0| break; 2624| | 2625| 0| case 296: /* array_expr */ ------------------ | Branch (2625:5): [True: 0, False: 56.5k] ------------------ 2626| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2627| 0| { delete (((*yyvaluep).expr)); } 2628| 0|#line 2629 "bison_parser.cpp" /* yacc.c:1257 */ 2629| 0| break; 2630| | 2631| 0| case 297: /* array_index */ ------------------ | Branch (2631:5): [True: 0, False: 56.5k] ------------------ 2632| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2633| 0| { delete (((*yyvaluep).expr)); } 2634| 0|#line 2635 "bison_parser.cpp" /* yacc.c:1257 */ 2635| 0| break; 2636| | 2637| 0| case 298: /* between_expr */ ------------------ | Branch (2637:5): [True: 0, False: 56.5k] ------------------ 2638| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2639| 0| { delete (((*yyvaluep).expr)); } 2640| 0|#line 2641 "bison_parser.cpp" /* yacc.c:1257 */ 2641| 0| break; 2642| | 2643| 0| case 299: /* column_name */ ------------------ | Branch (2643:5): [True: 0, False: 56.5k] ------------------ 2644| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2645| 0| { delete (((*yyvaluep).expr)); } 2646| 0|#line 2647 "bison_parser.cpp" /* yacc.c:1257 */ 2647| 0| break; 2648| | 2649| 0| case 300: /* literal */ ------------------ | Branch (2649:5): [True: 0, False: 56.5k] ------------------ 2650| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2651| 0| { delete (((*yyvaluep).expr)); } 2652| 0|#line 2653 "bison_parser.cpp" /* yacc.c:1257 */ 2653| 0| break; 2654| | 2655| 0| case 301: /* string_literal */ ------------------ | Branch (2655:5): [True: 0, False: 56.5k] ------------------ 2656| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2657| 0| { delete (((*yyvaluep).expr)); } 2658| 0|#line 2659 "bison_parser.cpp" /* yacc.c:1257 */ 2659| 0| break; 2660| | 2661| 0| case 302: /* bool_literal */ ------------------ | Branch (2661:5): [True: 0, False: 56.5k] ------------------ 2662| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2663| 0| { delete (((*yyvaluep).expr)); } 2664| 0|#line 2665 "bison_parser.cpp" /* yacc.c:1257 */ 2665| 0| break; 2666| | 2667| 0| case 303: /* num_literal */ ------------------ | Branch (2667:5): [True: 0, False: 56.5k] ------------------ 2668| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2669| 0| { delete (((*yyvaluep).expr)); } 2670| 0|#line 2671 "bison_parser.cpp" /* yacc.c:1257 */ 2671| 0| break; 2672| | 2673| 3| case 304: /* int_literal */ ------------------ | Branch (2673:5): [True: 3, False: 56.5k] ------------------ 2674| 3|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2675| 3| { delete (((*yyvaluep).expr)); } 2676| 3|#line 2677 "bison_parser.cpp" /* yacc.c:1257 */ 2677| 3| break; 2678| | 2679| 0| case 305: /* null_literal */ ------------------ | Branch (2679:5): [True: 0, False: 56.5k] ------------------ 2680| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2681| 0| { delete (((*yyvaluep).expr)); } 2682| 0|#line 2683 "bison_parser.cpp" /* yacc.c:1257 */ 2683| 0| break; 2684| | 2685| 0| case 306: /* date_literal */ ------------------ | Branch (2685:5): [True: 0, False: 56.5k] ------------------ 2686| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2687| 0| { delete (((*yyvaluep).expr)); } 2688| 0|#line 2689 "bison_parser.cpp" /* yacc.c:1257 */ 2689| 0| break; 2690| | 2691| 0| case 307: /* interval_literal */ ------------------ | Branch (2691:5): [True: 0, False: 56.5k] ------------------ 2692| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2693| 0| { delete (((*yyvaluep).expr)); } 2694| 0|#line 2695 "bison_parser.cpp" /* yacc.c:1257 */ 2695| 0| break; 2696| | 2697| 0| case 308: /* param_expr */ ------------------ | Branch (2697:5): [True: 0, False: 56.5k] ------------------ 2698| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2699| 0| { delete (((*yyvaluep).expr)); } 2700| 0|#line 2701 "bison_parser.cpp" /* yacc.c:1257 */ 2701| 0| break; 2702| | 2703| 0| case 309: /* table_ref */ ------------------ | Branch (2703:5): [True: 0, False: 56.5k] ------------------ 2704| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2705| 0| { delete (((*yyvaluep).table)); } 2706| 0|#line 2707 "bison_parser.cpp" /* yacc.c:1257 */ 2707| 0| break; 2708| | 2709| 2.11k| case 310: /* table_ref_atomic */ ------------------ | Branch (2709:5): [True: 2.11k, False: 54.4k] ------------------ 2710| 2.11k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2711| 2.11k| { delete (((*yyvaluep).table)); } 2712| 2.11k|#line 2713 "bison_parser.cpp" /* yacc.c:1257 */ 2713| 2.11k| break; 2714| | 2715| 0| case 311: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2715:5): [True: 0, False: 56.5k] ------------------ 2716| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2717| 0| { delete (((*yyvaluep).table)); } 2718| 0|#line 2719 "bison_parser.cpp" /* yacc.c:1257 */ 2719| 0| break; 2720| | 2721| 75| case 312: /* table_ref_commalist */ ------------------ | Branch (2721:5): [True: 75, False: 56.4k] ------------------ 2722| 75|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2723| 75| { 2724| 75| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2724:7): [True: 75, False: 0] ------------------ 2725| 1.06k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2725:19): [True: 1.06k, False: 75] ------------------ 2726| 1.06k| delete ptr; 2727| 1.06k| } 2728| 75| } 2729| 75| delete (((*yyvaluep).table_vec)); 2730| 75|} 2731| 75|#line 2732 "bison_parser.cpp" /* yacc.c:1257 */ 2732| 75| break; 2733| | 2734| 0| case 313: /* table_ref_name */ ------------------ | Branch (2734:5): [True: 0, False: 56.5k] ------------------ 2735| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2736| 0| { delete (((*yyvaluep).table)); } 2737| 0|#line 2738 "bison_parser.cpp" /* yacc.c:1257 */ 2738| 0| break; 2739| | 2740| 30| case 314: /* table_ref_name_no_alias */ ------------------ | Branch (2740:5): [True: 30, False: 56.5k] ------------------ 2741| 30|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2742| 30| { delete (((*yyvaluep).table)); } 2743| 30|#line 2744 "bison_parser.cpp" /* yacc.c:1257 */ 2744| 30| break; 2745| | 2746| 869| case 315: /* table_name */ ------------------ | Branch (2746:5): [True: 869, False: 55.6k] ------------------ 2747| 869|#line 182 "bison_parser.y" /* yacc.c:1257 */ 2748| 869| { 2749| 869| free(((*yyvaluep).table_name).name); 2750| 869| free(((*yyvaluep).table_name).schema); 2751| 869|} 2752| 869|#line 2753 "bison_parser.cpp" /* yacc.c:1257 */ 2753| 869| break; 2754| | 2755| 19| case 316: /* opt_index_name */ ------------------ | Branch (2755:5): [True: 19, False: 56.5k] ------------------ 2756| 19|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2757| 19| { free(((*yyvaluep).sval)); } 2758| 19|#line 2759 "bison_parser.cpp" /* yacc.c:1257 */ 2759| 19| break; 2760| | 2761| 0| case 317: /* table_alias */ ------------------ | Branch (2761:5): [True: 0, False: 56.5k] ------------------ 2762| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2763| 0| { delete (((*yyvaluep).alias_t)); } 2764| 0|#line 2765 "bison_parser.cpp" /* yacc.c:1257 */ 2765| 0| break; 2766| | 2767| 3| case 318: /* opt_table_alias */ ------------------ | Branch (2767:5): [True: 3, False: 56.5k] ------------------ 2768| 3|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2769| 3| { delete (((*yyvaluep).alias_t)); } 2770| 3|#line 2771 "bison_parser.cpp" /* yacc.c:1257 */ 2771| 3| break; 2772| | 2773| 0| case 319: /* alias */ ------------------ | Branch (2773:5): [True: 0, False: 56.5k] ------------------ 2774| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2775| 0| { delete (((*yyvaluep).alias_t)); } 2776| 0|#line 2777 "bison_parser.cpp" /* yacc.c:1257 */ 2777| 0| break; 2778| | 2779| 2| case 320: /* opt_alias */ ------------------ | Branch (2779:5): [True: 2, False: 56.5k] ------------------ 2780| 2|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2781| 2| { delete (((*yyvaluep).alias_t)); } 2782| 2|#line 2783 "bison_parser.cpp" /* yacc.c:1257 */ 2783| 2| break; 2784| | 2785| 0| case 321: /* opt_locking_clause */ ------------------ | Branch (2785:5): [True: 0, False: 56.5k] ------------------ 2786| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2787| 0| { delete (((*yyvaluep).locking_clause_vec)); } 2788| 0|#line 2789 "bison_parser.cpp" /* yacc.c:1257 */ 2789| 0| break; 2790| | 2791| 24| case 322: /* opt_locking_clause_list */ ------------------ | Branch (2791:5): [True: 24, False: 56.5k] ------------------ 2792| 24|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2793| 24| { delete (((*yyvaluep).locking_clause_vec)); } 2794| 24|#line 2795 "bison_parser.cpp" /* yacc.c:1257 */ 2795| 24| break; 2796| | 2797| 0| case 323: /* locking_clause */ ------------------ | Branch (2797:5): [True: 0, False: 56.5k] ------------------ 2798| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2799| 0| { delete (((*yyvaluep).locking_t)); } 2800| 0|#line 2801 "bison_parser.cpp" /* yacc.c:1257 */ 2801| 0| break; 2802| | 2803| 7| case 324: /* row_lock_mode */ ------------------ | Branch (2803:5): [True: 7, False: 56.5k] ------------------ 2804| 7|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2805| 7| { } 2806| 7|#line 2807 "bison_parser.cpp" /* yacc.c:1257 */ 2807| 7| break; 2808| | 2809| 1| case 325: /* opt_row_lock_policy */ ------------------ | Branch (2809:5): [True: 1, False: 56.5k] ------------------ 2810| 1|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2811| 1| { } 2812| 1|#line 2813 "bison_parser.cpp" /* yacc.c:1257 */ 2813| 1| break; 2814| | 2815| 2.65k| case 326: /* opt_with_clause */ ------------------ | Branch (2815:5): [True: 2.65k, False: 53.8k] ------------------ 2816| 2.65k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2817| 2.65k| { delete (((*yyvaluep).with_description_vec)); } 2818| 2.65k|#line 2819 "bison_parser.cpp" /* yacc.c:1257 */ 2819| 2.65k| break; 2820| | 2821| 0| case 327: /* with_clause */ ------------------ | Branch (2821:5): [True: 0, False: 56.5k] ------------------ 2822| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2823| 0| { delete (((*yyvaluep).with_description_vec)); } 2824| 0|#line 2825 "bison_parser.cpp" /* yacc.c:1257 */ 2825| 0| break; 2826| | 2827| 38| case 328: /* with_description_list */ ------------------ | Branch (2827:5): [True: 38, False: 56.5k] ------------------ 2828| 38|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2829| 38| { delete (((*yyvaluep).with_description_vec)); } 2830| 38|#line 2831 "bison_parser.cpp" /* yacc.c:1257 */ 2831| 38| break; 2832| | 2833| 0| case 329: /* with_description */ ------------------ | Branch (2833:5): [True: 0, False: 56.5k] ------------------ 2834| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2835| 0| { delete (((*yyvaluep).with_description_t)); } 2836| 0|#line 2837 "bison_parser.cpp" /* yacc.c:1257 */ 2837| 0| break; 2838| | 2839| 0| case 330: /* join_clause */ ------------------ | Branch (2839:5): [True: 0, False: 56.5k] ------------------ 2840| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2841| 0| { delete (((*yyvaluep).table)); } 2842| 0|#line 2843 "bison_parser.cpp" /* yacc.c:1257 */ 2843| 0| break; 2844| | 2845| 2.09k| case 331: /* opt_join_type */ ------------------ | Branch (2845:5): [True: 2.09k, False: 54.4k] ------------------ 2846| 2.09k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2847| 2.09k| { } 2848| 2.09k|#line 2849 "bison_parser.cpp" /* yacc.c:1257 */ 2849| 2.09k| break; 2850| | 2851| 0| case 332: /* join_condition */ ------------------ | Branch (2851:5): [True: 0, False: 56.5k] ------------------ 2852| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2853| 0| { delete (((*yyvaluep).expr)); } 2854| 0|#line 2855 "bison_parser.cpp" /* yacc.c:1257 */ 2855| 0| break; 2856| | 2857| 30| case 334: /* ident_commalist */ ------------------ | Branch (2857:5): [True: 30, False: 56.5k] ------------------ 2858| 30|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2859| 30| { 2860| 30| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2860:7): [True: 30, False: 0] ------------------ 2861| 10.1k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2861:19): [True: 10.1k, False: 30] ------------------ 2862| 10.1k| free(ptr); 2863| 10.1k| } 2864| 30| } 2865| 30| delete (((*yyvaluep).str_vec)); 2866| 30|} 2867| 30|#line 2868 "bison_parser.cpp" /* yacc.c:1257 */ 2868| 30| break; 2869| | 2870| | 2871| 29.5k| default: ------------------ | Branch (2871:7): [True: 29.5k, False: 26.9k] ------------------ 2872| 29.5k| break; 2873| 56.5k| } 2874| 56.5k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2875| 56.5k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3152| 3.77M|{ 3153| 3.77M| yy_state_type yy_current_state; 3154| 3.77M| char *yy_cp, *yy_bp; 3155| 3.77M| int yy_act; 3156| 3.77M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3157| | 3158| 3.77M| yylval = yylval_param; ------------------ | | 2964| 3.77M| # define yylval yyg->yylval_r ------------------ 3159| | 3160| 3.77M| yylloc = yylloc_param; ------------------ | | 2966| 3.77M| # define yylloc yyg->yylloc_r ------------------ 3161| | 3162| 3.77M| if ( !yyg->yy_init ) ------------------ | Branch (3162:7): [True: 5.50k, False: 3.77M] ------------------ 3163| 5.50k| { 3164| 5.50k| yyg->yy_init = 1; 3165| | 3166| |#ifdef YY_USER_INIT 3167| | YY_USER_INIT; 3168| |#endif 3169| | 3170| 5.50k| if ( ! yyg->yy_start ) ------------------ | Branch (3170:8): [True: 5.50k, False: 0] ------------------ 3171| 5.50k| yyg->yy_start = 1; /* first start state */ 3172| | 3173| 5.50k| if ( ! yyin ) ------------------ | | 118| 5.50k|#define yyin yyg->yyin_r ------------------ | Branch (3173:8): [True: 5.50k, False: 0] ------------------ 3174| 5.50k| yyin = stdin; ------------------ | | 118| 5.50k|#define yyin yyg->yyin_r ------------------ 3175| | 3176| 5.50k| if ( ! yyout ) ------------------ | | 119| 5.50k|#define yyout yyg->yyout_r ------------------ | Branch (3176:8): [True: 5.50k, False: 0] ------------------ 3177| 5.50k| yyout = stdout; ------------------ | | 119| 5.50k|#define yyout yyg->yyout_r ------------------ 3178| | 3179| 5.50k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 269| 5.50k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.50k, False: 0] | | ------------------ | | 270| 5.50k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.50k| : NULL) ------------------ | Branch (3179:8): [True: 0, False: 5.50k] ------------------ 3180| 0| hsql_ensure_buffer_stack (yyscanner); 3181| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3182| 0| hsql__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 118| 0|#define yyin yyg->yyin_r ------------------ hsql__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); ------------------ | | 157| 0|#define YY_BUF_SIZE 16384 ------------------ 3183| 0| } 3184| | 3185| 5.50k| hsql__load_buffer_state(yyscanner ); 3186| 5.50k| } 3187| | 3188| 3.77M| { 3189| 3.77M|#line 57 "flex_lexer.l" 3190| | 3191| | 3192| 3.77M|#line 3193 "flex_lexer.cpp" 3193| | 3194| 4.29M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3194:23): [True: 4.29M, Folded] ------------------ 3195| 4.29M| { 3196| 4.29M| yy_cp = yyg->yy_c_buf_p; 3197| | 3198| | /* Support of yytext. */ 3199| 4.29M| *yy_cp = yyg->yy_hold_char; 3200| | 3201| | /* yy_bp points to the position in yy_ch_buf of the start of 3202| | * the current run. 3203| | */ 3204| 4.29M| yy_bp = yy_cp; 3205| | 3206| 4.29M| yy_current_state = yyg->yy_start; 3207| 4.29M|yy_match: 3208| 4.29M| do 3209| 25.6M| { 3210| 25.6M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 108| 25.6M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ 3211| 25.6M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3211:9): [True: 15.2M, False: 10.4M] ------------------ 3212| 15.2M| { 3213| 15.2M| yyg->yy_last_accepting_state = yy_current_state; 3214| 15.2M| yyg->yy_last_accepting_cpos = yy_cp; 3215| 15.2M| } 3216| 46.6M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3216:12): [True: 20.9M, False: 25.6M] ------------------ 3217| 20.9M| { 3218| 20.9M| yy_current_state = (int) yy_def[yy_current_state]; 3219| 20.9M| if ( yy_current_state >= 1368 ) ------------------ | Branch (3219:10): [True: 16.4M, False: 4.51M] ------------------ 3220| 16.4M| yy_c = yy_meta[(unsigned int) yy_c]; 3221| 20.9M| } 3222| 25.6M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 3223| 25.6M| ++yy_cp; 3224| 25.6M| } 3225| 25.6M| while ( yy_current_state != 1367 ); ------------------ | Branch (3225:11): [True: 21.4M, False: 4.29M] ------------------ 3226| 4.29M| yy_cp = yyg->yy_last_accepting_cpos; 3227| 4.29M| yy_current_state = yyg->yy_last_accepting_state; 3228| | 3229| 4.29M|yy_find_action: 3230| 4.29M| yy_act = yy_accept[yy_current_state]; 3231| | 3232| 4.29M| YY_DO_BEFORE_ACTION; ------------------ | | 344| 4.29M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 333| 4.29M|#define yytext_ptr yytext_r | | ------------------ | | 345| 4.29M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 121| 4.29M|#define yyleng yyg->yyleng_r | | ------------------ | | 346| 4.29M| yyg->yy_hold_char = *yy_cp; \ | | 347| 4.29M| *yy_cp = '\0'; \ | | 348| 4.29M| yyg->yy_c_buf_p = yy_cp; ------------------ 3233| | 3234| 4.29M|do_action: /* This label is used only to access EOF actions. */ 3235| | 3236| 4.29M| switch ( yy_act ) 3237| 4.29M| { /* beginning of action switch */ 3238| 22| case 0: /* must back up */ ------------------ | Branch (3238:4): [True: 22, False: 4.29M] ------------------ 3239| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3240| 22| *yy_cp = yyg->yy_hold_char; 3241| 22| yy_cp = yyg->yy_last_accepting_cpos; 3242| 22| yy_current_state = yyg->yy_last_accepting_state; 3243| 22| goto yy_find_action; 3244| | 3245| 2.39k|case 1: ------------------ | Branch (3245:1): [True: 2.39k, False: 4.29M] ------------------ 3246| 2.39k|YY_RULE_SETUP ------------------ | | 3147| 2.39k| YY_USER_ACTION | | ------------------ | | | | 61| 2.39k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.39k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.19k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.79k, False: 2.39k] | | | | ------------------ | | | | 64| 4.79k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.79k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.79k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.79k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.79k| } else { \ | | | | 70| 4.79k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.79k| } \ | | | | 72| 4.79k| } | | ------------------ ------------------ 3247| 2.39k|#line 59 "flex_lexer.l" 3248| 2.39k|BEGIN(COMMENT); ------------------ | | 131| 2.39k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 2908| 2.39k|#define COMMENT 2 ------------------ 3249| 2.39k| YY_BREAK ------------------ | | 3143| 2.39k|#define YY_BREAK /*LINTED*/break; ------------------ 3250| 2.17k|case 2: ------------------ | Branch (3250:1): [True: 2.17k, False: 4.29M] ------------------ 3251| 2.17k|YY_RULE_SETUP ------------------ | | 3147| 2.17k| YY_USER_ACTION | | ------------------ | | | | 61| 2.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 934k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 934k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 931k, False: 2.17k] | | | | ------------------ | | | | 64| 931k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 931k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 931k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 931k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 931k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 931k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 931k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 931k| } else { \ | | | | 70| 931k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 931k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 931k| } \ | | | | 72| 931k| } | | ------------------ ------------------ 3252| 2.17k|#line 60 "flex_lexer.l" 3253| 2.17k|/* skipping comment content until a end of line is read */; 3254| 2.17k| YY_BREAK ------------------ | | 3143| 2.17k|#define YY_BREAK /*LINTED*/break; ------------------ 3255| 2.21k|case 3: ------------------ | Branch (3255:1): [True: 2.21k, False: 4.29M] ------------------ 3256| |/* rule 3 can match eol */ 3257| 2.21k|YY_RULE_SETUP ------------------ | | 3147| 2.21k| YY_USER_ACTION | | ------------------ | | | | 61| 2.21k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.21k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.21k, False: 2.21k] | | | | ------------------ | | | | 64| 2.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 2.21k, False: 0] | | | | ------------------ | | | | 67| 2.21k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.21k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.21k| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 2.21k| } | | ------------------ ------------------ 3258| 2.21k|#line 61 "flex_lexer.l" 3259| 2.21k|BEGIN(INITIAL); ------------------ | | 131| 2.21k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2906| 2.21k|#define INITIAL 0 ------------------ 3260| 2.21k| YY_BREAK ------------------ | | 3143| 2.21k|#define YY_BREAK /*LINTED*/break; ------------------ 3261| 459k|case 4: ------------------ | Branch (3261:1): [True: 459k, False: 3.83M] ------------------ 3262| |/* rule 4 can match eol */ 3263| 459k|YY_RULE_SETUP ------------------ | | 3147| 459k| YY_USER_ACTION | | ------------------ | | | | 61| 459k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 459k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 459k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 459k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 459k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 459k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 935k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 935k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 475k, False: 459k] | | | | ------------------ | | | | 64| 475k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 475k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 475k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 475k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 475k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 475k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 206k, False: 269k] | | | | ------------------ | | | | 67| 206k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 206k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 206k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 206k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 269k| } else { \ | | | | 70| 269k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 269k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 269k| } \ | | | | 72| 475k| } | | ------------------ ------------------ 3264| 459k|#line 63 "flex_lexer.l" 3265| 459k|/* skip whitespace */; 3266| 459k| YY_BREAK ------------------ | | 3143| 459k|#define YY_BREAK /*LINTED*/break; ------------------ 3267| 2|case 5: ------------------ | Branch (3267:1): [True: 2, False: 4.29M] ------------------ 3268| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 2] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3269| 2|#line 65 "flex_lexer.l" 3270| 2|TOKEN(ADD) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3271| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3272| 1|case 6: ------------------ | Branch (3272:1): [True: 1, False: 4.29M] ------------------ 3273| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5, False: 1] | | | | ------------------ | | | | 64| 5| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5| } else { \ | | | | 70| 5| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5| } \ | | | | 72| 5| } | | ------------------ ------------------ 3274| 1|#line 66 "flex_lexer.l" 3275| 1|TOKEN(AFTER) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3276| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3277| 2.49k|case 7: ------------------ | Branch (3277:1): [True: 2.49k, False: 4.29M] ------------------ 3278| 2.49k|YY_RULE_SETUP ------------------ | | 3147| 2.49k| YY_USER_ACTION | | ------------------ | | | | 61| 2.49k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.49k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.48k, False: 2.49k] | | | | ------------------ | | | | 64| 7.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7.48k| } else { \ | | | | 70| 7.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.48k| } \ | | | | 72| 7.48k| } | | ------------------ ------------------ 3279| 2.49k|#line 67 "flex_lexer.l" 3280| 2.49k|TOKEN(ALL) ------------------ | | 2887| 2.49k|#define TOKEN(name) { return SQL_##name; } ------------------ 3281| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3282| 5|case 8: ------------------ | Branch (3282:1): [True: 5, False: 4.29M] ------------------ 3283| 5|YY_RULE_SETUP ------------------ | | 3147| 5| YY_USER_ACTION | | ------------------ | | | | 61| 5| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 30| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 30|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 25, False: 5] | | | | ------------------ | | | | 64| 25| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 25| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 25| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 25| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 25| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 25|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 25] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 25| } else { \ | | | | 70| 25| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 25| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 25| } \ | | | | 72| 25| } | | ------------------ ------------------ 3284| 5|#line 68 "flex_lexer.l" 3285| 5|TOKEN(ALTER) ------------------ | | 2887| 5|#define TOKEN(name) { return SQL_##name; } ------------------ 3286| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3287| 0|case 9: ------------------ | Branch (3287:1): [True: 0, False: 4.29M] ------------------ 3288| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 3289| 0|#line 69 "flex_lexer.l" 3290| 0|TOKEN(ANALYZE) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3291| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3292| 1.57k|case 10: ------------------ | Branch (3292:1): [True: 1.57k, False: 4.29M] ------------------ 3293| 1.57k|YY_RULE_SETUP ------------------ | | 3147| 1.57k| YY_USER_ACTION | | ------------------ | | | | 61| 1.57k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.57k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.29k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.71k, False: 1.57k] | | | | ------------------ | | | | 64| 4.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.71k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.71k| } else { \ | | | | 70| 4.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.71k| } \ | | | | 72| 4.71k| } | | ------------------ ------------------ 3294| 1.57k|#line 70 "flex_lexer.l" 3295| 1.57k|TOKEN(AND) ------------------ | | 2887| 1.57k|#define TOKEN(name) { return SQL_##name; } ------------------ 3296| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3297| 960|case 11: ------------------ | Branch (3297:1): [True: 960, False: 4.29M] ------------------ 3298| 960|YY_RULE_SETUP ------------------ | | 3147| 960| YY_USER_ACTION | | ------------------ | | | | 61| 960| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 960| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.80k, False: 960] | | | | ------------------ | | | | 64| 4.80k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.80k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.80k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.80k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.80k| } else { \ | | | | 70| 4.80k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.80k| } \ | | | | 72| 4.80k| } | | ------------------ ------------------ 3299| 960|#line 71 "flex_lexer.l" 3300| 960|TOKEN(ARRAY) ------------------ | | 2887| 960|#define TOKEN(name) { return SQL_##name; } ------------------ 3301| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3302| 5.27k|case 12: ------------------ | Branch (3302:1): [True: 5.27k, False: 4.29M] ------------------ 3303| 5.27k|YY_RULE_SETUP ------------------ | | 3147| 5.27k| YY_USER_ACTION | | ------------------ | | | | 61| 5.27k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.27k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.5k, False: 5.27k] | | | | ------------------ | | | | 64| 10.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.5k| } else { \ | | | | 70| 10.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.5k| } \ | | | | 72| 10.5k| } | | ------------------ ------------------ 3304| 5.27k|#line 72 "flex_lexer.l" 3305| 5.27k|TOKEN(AS) ------------------ | | 2887| 5.27k|#define TOKEN(name) { return SQL_##name; } ------------------ 3306| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3307| 613|case 13: ------------------ | Branch (3307:1): [True: 613, False: 4.29M] ------------------ 3308| 613|YY_RULE_SETUP ------------------ | | 3147| 613| YY_USER_ACTION | | ------------------ | | | | 61| 613| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 613| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 613| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 613| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 613| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 613| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.45k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.83k, False: 613] | | | | ------------------ | | | | 64| 1.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.83k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.83k| } else { \ | | | | 70| 1.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.83k| } \ | | | | 72| 1.83k| } | | ------------------ ------------------ 3309| 613|#line 73 "flex_lexer.l" 3310| 613|TOKEN(ASC) ------------------ | | 2887| 613|#define TOKEN(name) { return SQL_##name; } ------------------ 3311| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3312| 1|case 14: ------------------ | Branch (3312:1): [True: 1, False: 4.29M] ------------------ 3313| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3314| 1|#line 74 "flex_lexer.l" 3315| 1|TOKEN(BEFORE) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3316| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3317| 4.62k|case 15: ------------------ | Branch (3317:1): [True: 4.62k, False: 4.29M] ------------------ 3318| 4.62k|YY_RULE_SETUP ------------------ | | 3147| 4.62k| YY_USER_ACTION | | ------------------ | | | | 61| 4.62k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.62k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 27.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 27.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.1k, False: 4.62k] | | | | ------------------ | | | | 64| 23.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 23.1k| } else { \ | | | | 70| 23.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.1k| } \ | | | | 72| 23.1k| } | | ------------------ ------------------ 3319| 4.62k|#line 75 "flex_lexer.l" 3320| 4.62k|TOKEN(BEGIN) ------------------ | | 2887| 4.62k|#define TOKEN(name) { return SQL_##name; } ------------------ 3321| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3322| 884|case 16: ------------------ | Branch (3322:1): [True: 884, False: 4.29M] ------------------ 3323| 884|YY_RULE_SETUP ------------------ | | 3147| 884| YY_USER_ACTION | | ------------------ | | | | 61| 884| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 884| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 884| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.07k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.18k, False: 884] | | | | ------------------ | | | | 64| 6.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.18k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.18k| } else { \ | | | | 70| 6.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.18k| } \ | | | | 72| 6.18k| } | | ------------------ ------------------ 3324| 884|#line 76 "flex_lexer.l" 3325| 884|TOKEN(BETWEEN) ------------------ | | 2887| 884|#define TOKEN(name) { return SQL_##name; } ------------------ 3326| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3327| 789|case 17: ------------------ | Branch (3327:1): [True: 789, False: 4.29M] ------------------ 3328| 789|YY_RULE_SETUP ------------------ | | 3147| 789| YY_USER_ACTION | | ------------------ | | | | 61| 789| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 789| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 789| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.73k, False: 789] | | | | ------------------ | | | | 64| 4.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.73k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.73k| } else { \ | | | | 70| 4.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.73k| } \ | | | | 72| 4.73k| } | | ------------------ ------------------ 3329| 789|#line 77 "flex_lexer.l" 3330| 789|TOKEN(BIGINT) ------------------ | | 2887| 789|#define TOKEN(name) { return SQL_##name; } ------------------ 3331| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3332| 630|case 18: ------------------ | Branch (3332:1): [True: 630, False: 4.29M] ------------------ 3333| 630|YY_RULE_SETUP ------------------ | | 3147| 630| YY_USER_ACTION | | ------------------ | | | | 61| 630| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 630| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 630| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 630| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 630| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 630| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.41k, False: 630] | | | | ------------------ | | | | 64| 4.41k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.41k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.41k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.41k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.41k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.41k| } else { \ | | | | 70| 4.41k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.41k| } \ | | | | 72| 4.41k| } | | ------------------ ------------------ 3334| 630|#line 78 "flex_lexer.l" 3335| 630|TOKEN(BOOLEAN) ------------------ | | 2887| 630|#define TOKEN(name) { return SQL_##name; } ------------------ 3336| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3337| 7.39k|case 19: ------------------ | Branch (3337:1): [True: 7.39k, False: 4.29M] ------------------ 3338| 7.39k|YY_RULE_SETUP ------------------ | | 3147| 7.39k| YY_USER_ACTION | | ------------------ | | | | 61| 7.39k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.39k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 22.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 22.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.7k, False: 7.39k] | | | | ------------------ | | | | 64| 14.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.7k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14.7k| } else { \ | | | | 70| 14.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.7k| } \ | | | | 72| 14.7k| } | | ------------------ ------------------ 3339| 7.39k|#line 79 "flex_lexer.l" 3340| 7.39k|TOKEN(BY) ------------------ | | 2887| 7.39k|#define TOKEN(name) { return SQL_##name; } ------------------ 3341| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3342| 3|case 20: ------------------ | Branch (3342:1): [True: 3, False: 4.29M] ------------------ 3343| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 3] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3344| 3|#line 80 "flex_lexer.l" 3345| 3|TOKEN(CALL) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3346| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3347| 1|case 21: ------------------ | Branch (3347:1): [True: 1, False: 4.29M] ------------------ 3348| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3349| 1|#line 81 "flex_lexer.l" 3350| 1|TOKEN(CASCADE) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3351| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3352| 2.50k|case 22: ------------------ | Branch (3352:1): [True: 2.50k, False: 4.29M] ------------------ 3353| 2.50k|YY_RULE_SETUP ------------------ | | 3147| 2.50k| YY_USER_ACTION | | ------------------ | | | | 61| 2.50k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.50k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.0k, False: 2.50k] | | | | ------------------ | | | | 64| 10.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.0k| } else { \ | | | | 70| 10.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.0k| } \ | | | | 72| 10.0k| } | | ------------------ ------------------ 3354| 2.50k|#line 82 "flex_lexer.l" 3355| 2.50k|TOKEN(CASE) ------------------ | | 2887| 2.50k|#define TOKEN(name) { return SQL_##name; } ------------------ 3356| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3357| 604|case 23: ------------------ | Branch (3357:1): [True: 604, False: 4.29M] ------------------ 3358| 604|YY_RULE_SETUP ------------------ | | 3147| 604| YY_USER_ACTION | | ------------------ | | | | 61| 604| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 604| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 604| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.41k, False: 604] | | | | ------------------ | | | | 64| 2.41k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.41k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.41k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.41k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.41k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.41k| } else { \ | | | | 70| 2.41k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.41k| } \ | | | | 72| 2.41k| } | | ------------------ ------------------ 3359| 604|#line 83 "flex_lexer.l" 3360| 604|TOKEN(CAST) ------------------ | | 2887| 604|#define TOKEN(name) { return SQL_##name; } ------------------ 3361| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3362| 500|case 24: ------------------ | Branch (3362:1): [True: 500, False: 4.29M] ------------------ 3363| 500|YY_RULE_SETUP ------------------ | | 3147| 500| YY_USER_ACTION | | ------------------ | | | | 61| 500| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 500| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.00k, False: 500] | | | | ------------------ | | | | 64| 2.00k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.00k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.00k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.00k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.00k| } else { \ | | | | 70| 2.00k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.00k| } \ | | | | 72| 2.00k| } | | ------------------ ------------------ 3364| 500|#line 84 "flex_lexer.l" 3365| 500|TOKEN(CHAR) ------------------ | | 2887| 500|#define TOKEN(name) { return SQL_##name; } ------------------ 3366| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3367| 1|case 25: ------------------ | Branch (3367:1): [True: 1, False: 4.29M] ------------------ 3368| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3369| 1|#line 85 "flex_lexer.l" 3370| 1|TOKEN(COLUMN) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3371| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3372| 1.14k|case 26: ------------------ | Branch (3372:1): [True: 1.14k, False: 4.29M] ------------------ 3373| 1.14k|YY_RULE_SETUP ------------------ | | 3147| 1.14k| YY_USER_ACTION | | ------------------ | | | | 61| 1.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.03k, False: 1.14k] | | | | ------------------ | | | | 64| 8.03k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.03k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.03k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.03k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.03k| } else { \ | | | | 70| 8.03k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.03k| } \ | | | | 72| 8.03k| } | | ------------------ ------------------ 3374| 1.14k|#line 86 "flex_lexer.l" 3375| 1.14k|TOKEN(COLUMNS) ------------------ | | 2887| 1.14k|#define TOKEN(name) { return SQL_##name; } ------------------ 3376| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3377| 2.64k|case 27: ------------------ | Branch (3377:1): [True: 2.64k, False: 4.29M] ------------------ 3378| 2.64k|YY_RULE_SETUP ------------------ | | 3147| 2.64k| YY_USER_ACTION | | ------------------ | | | | 61| 2.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.8k, False: 2.64k] | | | | ------------------ | | | | 64| 15.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.8k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.8k| } else { \ | | | | 70| 15.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.8k| } \ | | | | 72| 15.8k| } | | ------------------ ------------------ 3379| 2.64k|#line 87 "flex_lexer.l" 3380| 2.64k|TOKEN(COMMIT) ------------------ | | 2887| 2.64k|#define TOKEN(name) { return SQL_##name; } ------------------ 3381| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3382| 3|case 28: ------------------ | Branch (3382:1): [True: 3, False: 4.29M] ------------------ 3383| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 24| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 24|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21, False: 3] | | | | ------------------ | | | | 64| 21| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 21| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 21| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 21|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 21] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 21| } else { \ | | | | 70| 21| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 21| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21| } \ | | | | 72| 21| } | | ------------------ ------------------ 3384| 3|#line 88 "flex_lexer.l" 3385| 3|TOKEN(CONTROL) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3386| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3387| 14.7k|case 29: ------------------ | Branch (3387:1): [True: 14.7k, False: 4.28M] ------------------ 3388| 14.7k|YY_RULE_SETUP ------------------ | | 3147| 14.7k| YY_USER_ACTION | | ------------------ | | | | 61| 14.7k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 14.7k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 14.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 73.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 73.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 59.0k, False: 14.7k] | | | | ------------------ | | | | 64| 59.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 59.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 59.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 59.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 59.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 59.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 59.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 59.0k| } else { \ | | | | 70| 59.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 59.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 59.0k| } \ | | | | 72| 59.0k| } | | ------------------ ------------------ 3389| 14.7k|#line 89 "flex_lexer.l" 3390| 14.7k|TOKEN(COPY) ------------------ | | 2887| 14.7k|#define TOKEN(name) { return SQL_##name; } ------------------ 3391| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3392| 8.69k|case 30: ------------------ | Branch (3392:1): [True: 8.69k, False: 4.29M] ------------------ 3393| 8.69k|YY_RULE_SETUP ------------------ | | 3147| 8.69k| YY_USER_ACTION | | ------------------ | | | | 61| 8.69k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 8.69k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 60.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 60.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 52.1k, False: 8.69k] | | | | ------------------ | | | | 64| 52.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 52.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 52.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 52.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 52.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 52.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 52.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 52.1k| } else { \ | | | | 70| 52.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 52.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 52.1k| } \ | | | | 72| 52.1k| } | | ------------------ ------------------ 3394| 8.69k|#line 90 "flex_lexer.l" 3395| 8.69k|TOKEN(CREATE) ------------------ | | 2887| 8.69k|#define TOKEN(name) { return SQL_##name; } ------------------ 3396| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3397| 676|case 31: ------------------ | Branch (3397:1): [True: 676, False: 4.29M] ------------------ 3398| 676|YY_RULE_SETUP ------------------ | | 3147| 676| YY_USER_ACTION | | ------------------ | | | | 61| 676| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 676| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.38k, False: 676] | | | | ------------------ | | | | 64| 3.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.38k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.38k| } else { \ | | | | 70| 3.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.38k| } \ | | | | 72| 3.38k| } | | ------------------ ------------------ 3399| 676|#line 91 "flex_lexer.l" 3400| 676|TOKEN(CROSS) ------------------ | | 2887| 676|#define TOKEN(name) { return SQL_##name; } ------------------ 3401| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3402| 3.59k|case 32: ------------------ | Branch (3402:1): [True: 3.59k, False: 4.29M] ------------------ 3403| 3.59k|YY_RULE_SETUP ------------------ | | 3147| 3.59k| YY_USER_ACTION | | ------------------ | | | | 61| 3.59k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.59k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 17.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.3k, False: 3.59k] | | | | ------------------ | | | | 64| 14.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14.3k| } else { \ | | | | 70| 14.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.3k| } \ | | | | 72| 14.3k| } | | ------------------ ------------------ 3404| 3.59k|#line 92 "flex_lexer.l" 3405| 3.59k|TOKEN(DATE) ------------------ | | 2887| 3.59k|#define TOKEN(name) { return SQL_##name; } ------------------ 3406| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3407| 561|case 33: ------------------ | Branch (3407:1): [True: 561, False: 4.29M] ------------------ 3408| 561|YY_RULE_SETUP ------------------ | | 3147| 561| YY_USER_ACTION | | ------------------ | | | | 61| 561| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 561| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 561| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 561| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 561| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 561| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.48k, False: 561] | | | | ------------------ | | | | 64| 4.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.48k| } else { \ | | | | 70| 4.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.48k| } \ | | | | 72| 4.48k| } | | ------------------ ------------------ 3409| 561|#line 93 "flex_lexer.l" 3410| 561|TOKEN(DATETIME) ------------------ | | 2887| 561|#define TOKEN(name) { return SQL_##name; } ------------------ 3411| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3412| 1.94k|case 34: ------------------ | Branch (3412:1): [True: 1.94k, False: 4.29M] ------------------ 3413| 1.94k|YY_RULE_SETUP ------------------ | | 3147| 1.94k| YY_USER_ACTION | | ------------------ | | | | 61| 1.94k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.94k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.82k, False: 1.94k] | | | | ------------------ | | | | 64| 5.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.82k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.82k| } else { \ | | | | 70| 5.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.82k| } \ | | | | 72| 5.82k| } | | ------------------ ------------------ 3414| 1.94k|#line 94 "flex_lexer.l" 3415| 1.94k|TOKEN(DAY) ------------------ | | 2887| 1.94k|#define TOKEN(name) { return SQL_##name; } ------------------ 3416| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3417| 531|case 35: ------------------ | Branch (3417:1): [True: 531, False: 4.29M] ------------------ 3418| 531|YY_RULE_SETUP ------------------ | | 3147| 531| YY_USER_ACTION | | ------------------ | | | | 61| 531| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 531| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 531| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 531| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 531| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 531| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.12k, False: 531] | | | | ------------------ | | | | 64| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.12k| } else { \ | | | | 70| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| } \ | | | | 72| 2.12k| } | | ------------------ ------------------ 3419| 531|#line 95 "flex_lexer.l" 3420| 531|TOKEN(DAYS) ------------------ | | 2887| 531|#define TOKEN(name) { return SQL_##name; } ------------------ 3421| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3422| 876|case 36: ------------------ | Branch (3422:1): [True: 876, False: 4.29M] ------------------ 3423| 876|YY_RULE_SETUP ------------------ | | 3147| 876| YY_USER_ACTION | | ------------------ | | | | 61| 876| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 876| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 876| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 876| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 876| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 876| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.63k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.76k, False: 876] | | | | ------------------ | | | | 64| 8.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.76k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.76k| } else { \ | | | | 70| 8.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.76k| } \ | | | | 72| 8.76k| } | | ------------------ ------------------ 3424| 876|#line 96 "flex_lexer.l" 3425| 876|TOKEN(DEALLOCATE) ------------------ | | 2887| 876|#define TOKEN(name) { return SQL_##name; } ------------------ 3426| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3427| 1.13k|case 37: ------------------ | Branch (3427:1): [True: 1.13k, False: 4.29M] ------------------ 3428| 1.13k|YY_RULE_SETUP ------------------ | | 3147| 1.13k| YY_USER_ACTION | | ------------------ | | | | 61| 1.13k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.13k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.06k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.93k, False: 1.13k] | | | | ------------------ | | | | 64| 7.93k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.93k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.93k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.93k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7.93k| } else { \ | | | | 70| 7.93k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.93k| } \ | | | | 72| 7.93k| } | | ------------------ ------------------ 3429| 1.13k|#line 97 "flex_lexer.l" 3430| 1.13k|TOKEN(DECIMAL) ------------------ | | 2887| 1.13k|#define TOKEN(name) { return SQL_##name; } ------------------ 3431| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3432| 1|case 38: ------------------ | Branch (3432:1): [True: 1, False: 4.29M] ------------------ 3433| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3434| 1|#line 98 "flex_lexer.l" 3435| 1|TOKEN(DEFAULT) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3436| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3437| 1.72k|case 39: ------------------ | Branch (3437:1): [True: 1.72k, False: 4.29M] ------------------ 3438| 1.72k|YY_RULE_SETUP ------------------ | | 3147| 1.72k| YY_USER_ACTION | | ------------------ | | | | 61| 1.72k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.72k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.3k, False: 1.72k] | | | | ------------------ | | | | 64| 10.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.3k| } else { \ | | | | 70| 10.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.3k| } \ | | | | 72| 10.3k| } | | ------------------ ------------------ 3439| 1.72k|#line 99 "flex_lexer.l" 3440| 1.72k|TOKEN(DELETE) ------------------ | | 2887| 1.72k|#define TOKEN(name) { return SQL_##name; } ------------------ 3441| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3442| 3|case 40: ------------------ | Branch (3442:1): [True: 3, False: 4.29M] ------------------ 3443| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15, False: 3] | | | | ------------------ | | | | 64| 15| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15| } else { \ | | | | 70| 15| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15| } \ | | | | 72| 15| } | | ------------------ ------------------ 3444| 3|#line 100 "flex_lexer.l" 3445| 3|TOKEN(DELTA) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3446| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3447| 607|case 41: ------------------ | Branch (3447:1): [True: 607, False: 4.29M] ------------------ 3448| 607|YY_RULE_SETUP ------------------ | | 3147| 607| YY_USER_ACTION | | ------------------ | | | | 61| 607| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 607| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 607| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 607| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 607| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 607| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.42k, False: 607] | | | | ------------------ | | | | 64| 2.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.42k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.42k| } else { \ | | | | 70| 2.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.42k| } \ | | | | 72| 2.42k| } | | ------------------ ------------------ 3449| 607|#line 101 "flex_lexer.l" 3450| 607|TOKEN(DESC) ------------------ | | 2887| 607|#define TOKEN(name) { return SQL_##name; } ------------------ 3451| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3452| 4.88k|case 42: ------------------ | Branch (3452:1): [True: 4.88k, False: 4.29M] ------------------ 3453| 4.88k|YY_RULE_SETUP ------------------ | | 3147| 4.88k| YY_USER_ACTION | | ------------------ | | | | 61| 4.88k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.88k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 43.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 43.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 39.0k, False: 4.88k] | | | | ------------------ | | | | 64| 39.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 39.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 39.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 39.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 39.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 39.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 39.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 39.0k| } else { \ | | | | 70| 39.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 39.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 39.0k| } \ | | | | 72| 39.0k| } | | ------------------ ------------------ 3454| 4.88k|#line 102 "flex_lexer.l" 3455| 4.88k|TOKEN(DESCRIBE) ------------------ | | 2887| 4.88k|#define TOKEN(name) { return SQL_##name; } ------------------ 3456| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3457| 1|case 43: ------------------ | Branch (3457:1): [True: 1, False: 4.29M] ------------------ 3458| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3459| 1|#line 103 "flex_lexer.l" 3460| 1|TOKEN(DIRECT) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3461| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3462| 523|case 44: ------------------ | Branch (3462:1): [True: 523, False: 4.29M] ------------------ 3463| 523|YY_RULE_SETUP ------------------ | | 3147| 523| YY_USER_ACTION | | ------------------ | | | | 61| 523| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 523| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 523| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 523| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 523| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 523| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.70k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.18k, False: 523] | | | | ------------------ | | | | 64| 4.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.18k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.18k| } else { \ | | | | 70| 4.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.18k| } \ | | | | 72| 4.18k| } | | ------------------ ------------------ 3464| 523|#line 104 "flex_lexer.l" 3465| 523|TOKEN(DISTINCT) ------------------ | | 2887| 523|#define TOKEN(name) { return SQL_##name; } ------------------ 3466| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3467| 896|case 45: ------------------ | Branch (3467:1): [True: 896, False: 4.29M] ------------------ 3468| 896|YY_RULE_SETUP ------------------ | | 3147| 896| YY_USER_ACTION | | ------------------ | | | | 61| 896| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 896| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 896| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 896| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 896| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 896| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.27k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.37k, False: 896] | | | | ------------------ | | | | 64| 5.37k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.37k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.37k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.37k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.37k| } else { \ | | | | 70| 5.37k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.37k| } \ | | | | 72| 5.37k| } | | ------------------ ------------------ 3469| 896|#line 105 "flex_lexer.l" 3470| 896|TOKEN(DOUBLE) ------------------ | | 2887| 896|#define TOKEN(name) { return SQL_##name; } ------------------ 3471| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3472| 3.26k|case 46: ------------------ | Branch (3472:1): [True: 3.26k, False: 4.29M] ------------------ 3473| 3.26k|YY_RULE_SETUP ------------------ | | 3147| 3.26k| YY_USER_ACTION | | ------------------ | | | | 61| 3.26k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.26k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.0k, False: 3.26k] | | | | ------------------ | | | | 64| 13.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.0k| } else { \ | | | | 70| 13.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.0k| } \ | | | | 72| 13.0k| } | | ------------------ ------------------ 3474| 3.26k|#line 106 "flex_lexer.l" 3475| 3.26k|TOKEN(DROP) ------------------ | | 2887| 3.26k|#define TOKEN(name) { return SQL_##name; } ------------------ 3476| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3477| 916|case 47: ------------------ | Branch (3477:1): [True: 916, False: 4.29M] ------------------ 3478| 916|YY_RULE_SETUP ------------------ | | 3147| 916| YY_USER_ACTION | | ------------------ | | | | 61| 916| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 916| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 916| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.58k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.66k, False: 916] | | | | ------------------ | | | | 64| 3.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.66k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.66k| } else { \ | | | | 70| 3.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.66k| } \ | | | | 72| 3.66k| } | | ------------------ ------------------ 3479| 916|#line 107 "flex_lexer.l" 3480| 916|TOKEN(ELSE) ------------------ | | 2887| 916|#define TOKEN(name) { return SQL_##name; } ------------------ 3481| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3482| 1.50k|case 48: ------------------ | Branch (3482:1): [True: 1.50k, False: 4.29M] ------------------ 3483| 1.50k|YY_RULE_SETUP ------------------ | | 3147| 1.50k| YY_USER_ACTION | | ------------------ | | | | 61| 1.50k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.50k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.0k, False: 1.50k] | | | | ------------------ | | | | 64| 12.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12.0k| } else { \ | | | | 70| 12.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.0k| } \ | | | | 72| 12.0k| } | | ------------------ ------------------ 3484| 1.50k|#line 108 "flex_lexer.l" 3485| 1.50k|TOKEN(ENCODING) ------------------ | | 2887| 1.50k|#define TOKEN(name) { return SQL_##name; } ------------------ 3486| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3487| 1.77k|case 49: ------------------ | Branch (3487:1): [True: 1.77k, False: 4.29M] ------------------ 3488| 1.77k|YY_RULE_SETUP ------------------ | | 3147| 1.77k| YY_USER_ACTION | | ------------------ | | | | 61| 1.77k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.77k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.08k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.31k, False: 1.77k] | | | | ------------------ | | | | 64| 5.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.31k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.31k| } else { \ | | | | 70| 5.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.31k| } \ | | | | 72| 5.31k| } | | ------------------ ------------------ 3489| 1.77k|#line 109 "flex_lexer.l" 3490| 1.77k|TOKEN(END) ------------------ | | 2887| 1.77k|#define TOKEN(name) { return SQL_##name; } ------------------ 3491| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3492| 2|case 50: ------------------ | Branch (3492:1): [True: 2, False: 4.29M] ------------------ 3493| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 2] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3494| 2|#line 110 "flex_lexer.l" 3495| 2|TOKEN(ESCAPE) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3496| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3497| 824|case 51: ------------------ | Branch (3497:1): [True: 824, False: 4.29M] ------------------ 3498| 824|YY_RULE_SETUP ------------------ | | 3147| 824| YY_USER_ACTION | | ------------------ | | | | 61| 824| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 824| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.94k, False: 824] | | | | ------------------ | | | | 64| 4.94k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.94k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.94k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.94k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.94k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.94k| } else { \ | | | | 70| 4.94k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.94k| } \ | | | | 72| 4.94k| } | | ------------------ ------------------ 3499| 824|#line 111 "flex_lexer.l" 3500| 824|TOKEN(EXCEPT) ------------------ | | 2887| 824|#define TOKEN(name) { return SQL_##name; } ------------------ 3501| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3502| 4.09k|case 52: ------------------ | Branch (3502:1): [True: 4.09k, False: 4.29M] ------------------ 3503| 4.09k|YY_RULE_SETUP ------------------ | | 3147| 4.09k| YY_USER_ACTION | | ------------------ | | | | 61| 4.09k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.09k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 32.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 32.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 28.6k, False: 4.09k] | | | | ------------------ | | | | 64| 28.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 28.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 28.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 28.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 28.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 28.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 28.6k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 28.6k| } else { \ | | | | 70| 28.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 28.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 28.6k| } \ | | | | 72| 28.6k| } | | ------------------ ------------------ 3504| 4.09k|#line 112 "flex_lexer.l" 3505| 4.09k|TOKEN(EXECUTE) ------------------ | | 2887| 4.09k|#define TOKEN(name) { return SQL_##name; } ------------------ 3506| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3507| 1.41k|case 53: ------------------ | Branch (3507:1): [True: 1.41k, False: 4.29M] ------------------ 3508| 1.41k|YY_RULE_SETUP ------------------ | | 3147| 1.41k| YY_USER_ACTION | | ------------------ | | | | 61| 1.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.89k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.48k, False: 1.41k] | | | | ------------------ | | | | 64| 8.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.48k| } else { \ | | | | 70| 8.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.48k| } \ | | | | 72| 8.48k| } | | ------------------ ------------------ 3509| 1.41k|#line 113 "flex_lexer.l" 3510| 1.41k|TOKEN(EXISTS) ------------------ | | 2887| 1.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 3511| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3512| 1|case 54: ------------------ | Branch (3512:1): [True: 1, False: 4.29M] ------------------ 3513| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3514| 1|#line 114 "flex_lexer.l" 3515| 1|TOKEN(EXPLAIN) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3516| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3517| 824|case 55: ------------------ | Branch (3517:1): [True: 824, False: 4.29M] ------------------ 3518| 824|YY_RULE_SETUP ------------------ | | 3147| 824| YY_USER_ACTION | | ------------------ | | | | 61| 824| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 824| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 824| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.76k, False: 824] | | | | ------------------ | | | | 64| 5.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.76k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.76k| } else { \ | | | | 70| 5.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.76k| } \ | | | | 72| 5.76k| } | | ------------------ ------------------ 3519| 824|#line 115 "flex_lexer.l" 3520| 824|TOKEN(EXTRACT) ------------------ | | 2887| 824|#define TOKEN(name) { return SQL_##name; } ------------------ 3521| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3522| 676|case 56: ------------------ | Branch (3522:1): [True: 676, False: 4.29M] ------------------ 3523| 676|YY_RULE_SETUP ------------------ | | 3147| 676| YY_USER_ACTION | | ------------------ | | | | 61| 676| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 676| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 676| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.38k, False: 676] | | | | ------------------ | | | | 64| 3.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.38k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.38k| } else { \ | | | | 70| 3.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.38k| } \ | | | | 72| 3.38k| } | | ------------------ ------------------ 3524| 676|#line 116 "flex_lexer.l" 3525| 676|TOKEN(FALSE) ------------------ | | 2887| 676|#define TOKEN(name) { return SQL_##name; } ------------------ 3526| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3527| 2|case 57: ------------------ | Branch (3527:1): [True: 2, False: 4.29M] ------------------ 3528| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8, False: 2] | | | | ------------------ | | | | 64| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8| } else { \ | | | | 70| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| } \ | | | | 72| 8| } | | ------------------ ------------------ 3529| 2|#line 117 "flex_lexer.l" 3530| 2|TOKEN(FILE) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3531| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3532| 696|case 58: ------------------ | Branch (3532:1): [True: 696, False: 4.29M] ------------------ 3533| 696|YY_RULE_SETUP ------------------ | | 3147| 696| YY_USER_ACTION | | ------------------ | | | | 61| 696| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 696| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.48k, False: 696] | | | | ------------------ | | | | 64| 3.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.48k| } else { \ | | | | 70| 3.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.48k| } \ | | | | 72| 3.48k| } | | ------------------ ------------------ 3534| 696|#line 118 "flex_lexer.l" 3535| 696|TOKEN(FLOAT) ------------------ | | 2887| 696|#define TOKEN(name) { return SQL_##name; } ------------------ 3536| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3537| 2.31k|case 59: ------------------ | Branch (3537:1): [True: 2.31k, False: 4.29M] ------------------ 3538| 2.31k|YY_RULE_SETUP ------------------ | | 3147| 2.31k| YY_USER_ACTION | | ------------------ | | | | 61| 2.31k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.31k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 23.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.8k, False: 2.31k] | | | | ------------------ | | | | 64| 20.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.8k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 20.8k| } else { \ | | | | 70| 20.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.8k| } \ | | | | 72| 20.8k| } | | ------------------ ------------------ 3539| 2.31k|#line 119 "flex_lexer.l" 3540| 2.31k|TOKEN(FOLLOWING) ------------------ | | 2887| 2.31k|#define TOKEN(name) { return SQL_##name; } ------------------ 3541| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3542| 4.04k|case 60: ------------------ | Branch (3542:1): [True: 4.04k, False: 4.29M] ------------------ 3543| 4.04k|YY_RULE_SETUP ------------------ | | 3147| 4.04k| YY_USER_ACTION | | ------------------ | | | | 61| 4.04k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.04k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.1k, False: 4.04k] | | | | ------------------ | | | | 64| 12.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12.1k| } else { \ | | | | 70| 12.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.1k| } \ | | | | 72| 12.1k| } | | ------------------ ------------------ 3544| 4.04k|#line 120 "flex_lexer.l" 3545| 4.04k|TOKEN(FOR) ------------------ | | 2887| 4.04k|#define TOKEN(name) { return SQL_##name; } ------------------ 3546| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3547| 1|case 61: ------------------ | Branch (3547:1): [True: 1, False: 4.29M] ------------------ 3548| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3549| 1|#line 121 "flex_lexer.l" 3550| 1|TOKEN(FOREIGN) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3551| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3552| 1.61k|case 62: ------------------ | Branch (3552:1): [True: 1.61k, False: 4.29M] ------------------ 3553| 1.61k|YY_RULE_SETUP ------------------ | | 3147| 1.61k| YY_USER_ACTION | | ------------------ | | | | 61| 1.61k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.61k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.67k, False: 1.61k] | | | | ------------------ | | | | 64| 9.67k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.67k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.67k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.67k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9.67k| } else { \ | | | | 70| 9.67k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.67k| } \ | | | | 72| 9.67k| } | | ------------------ ------------------ 3554| 1.61k|#line 122 "flex_lexer.l" 3555| 1.61k|TOKEN(FORMAT) ------------------ | | 2887| 1.61k|#define TOKEN(name) { return SQL_##name; } ------------------ 3556| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3557| 15.1k|case 63: ------------------ | Branch (3557:1): [True: 15.1k, False: 4.28M] ------------------ 3558| 15.1k|YY_RULE_SETUP ------------------ | | 3147| 15.1k| YY_USER_ACTION | | ------------------ | | | | 61| 15.1k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 15.1k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 75.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 75.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 60.4k, False: 15.1k] | | | | ------------------ | | | | 64| 60.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 60.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 60.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 60.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 60.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 60.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 60.4k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 60.4k| } else { \ | | | | 70| 60.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 60.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 60.4k| } \ | | | | 72| 60.4k| } | | ------------------ ------------------ 3559| 15.1k|#line 123 "flex_lexer.l" 3560| 15.1k|TOKEN(FROM) ------------------ | | 2887| 15.1k|#define TOKEN(name) { return SQL_##name; } ------------------ 3561| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3562| 201|case 64: ------------------ | Branch (3562:1): [True: 201, False: 4.29M] ------------------ 3563| 201|YY_RULE_SETUP ------------------ | | 3147| 201| YY_USER_ACTION | | ------------------ | | | | 61| 201| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 201| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 201| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 201| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 201| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 201| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 804, False: 201] | | | | ------------------ | | | | 64| 804| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 804| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 804| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 804|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 804] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 804| } else { \ | | | | 70| 804| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 804| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 804| } \ | | | | 72| 804| } | | ------------------ ------------------ 3564| 201|#line 124 "flex_lexer.l" 3565| 201|TOKEN(FULL) ------------------ | | 2887| 201|#define TOKEN(name) { return SQL_##name; } ------------------ 3566| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3567| 2|case 65: ------------------ | Branch (3567:1): [True: 2, False: 4.29M] ------------------ 3568| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 2] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3569| 2|#line 125 "flex_lexer.l" 3570| 2|TOKEN(GLOBAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3571| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3572| 3.63k|case 66: ------------------ | Branch (3572:1): [True: 3.63k, False: 4.29M] ------------------ 3573| 3.63k|YY_RULE_SETUP ------------------ | | 3147| 3.63k| YY_USER_ACTION | | ------------------ | | | | 61| 3.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 21.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.1k, False: 3.63k] | | | | ------------------ | | | | 64| 18.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 18.1k| } else { \ | | | | 70| 18.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.1k| } \ | | | | 72| 18.1k| } | | ------------------ ------------------ 3574| 3.63k|#line 126 "flex_lexer.l" 3575| 3.63k|TOKEN(GROUP) ------------------ | | 2887| 3.63k|#define TOKEN(name) { return SQL_##name; } ------------------ 3576| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3577| 775|case 67: ------------------ | Branch (3577:1): [True: 775, False: 4.29M] ------------------ 3578| 775|YY_RULE_SETUP ------------------ | | 3147| 775| YY_USER_ACTION | | ------------------ | | | | 61| 775| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 775| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.42k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.65k, False: 775] | | | | ------------------ | | | | 64| 4.65k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.65k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.65k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.65k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.65k| } else { \ | | | | 70| 4.65k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.65k| } \ | | | | 72| 4.65k| } | | ------------------ ------------------ 3579| 775|#line 127 "flex_lexer.l" 3580| 775|TOKEN(GROUPS) ------------------ | | 2887| 775|#define TOKEN(name) { return SQL_##name; } ------------------ 3581| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3582| 2|case 68: ------------------ | Branch (3582:1): [True: 2, False: 4.29M] ------------------ 3583| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8, False: 2] | | | | ------------------ | | | | 64| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8| } else { \ | | | | 70| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| } \ | | | | 72| 8| } | | ------------------ ------------------ 3584| 2|#line 128 "flex_lexer.l" 3585| 2|TOKEN(HASH) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3586| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3587| 827|case 69: ------------------ | Branch (3587:1): [True: 827, False: 4.29M] ------------------ 3588| 827|YY_RULE_SETUP ------------------ | | 3147| 827| YY_USER_ACTION | | ------------------ | | | | 61| 827| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 827| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.96k, False: 827] | | | | ------------------ | | | | 64| 4.96k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.96k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.96k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.96k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.96k| } else { \ | | | | 70| 4.96k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.96k| } \ | | | | 72| 4.96k| } | | ------------------ ------------------ 3589| 827|#line 129 "flex_lexer.l" 3590| 827|TOKEN(HAVING) ------------------ | | 2887| 827|#define TOKEN(name) { return SQL_##name; } ------------------ 3591| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3592| 950|case 70: ------------------ | Branch (3592:1): [True: 950, False: 4.29M] ------------------ 3593| 950|YY_RULE_SETUP ------------------ | | 3147| 950| YY_USER_ACTION | | ------------------ | | | | 61| 950| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 950| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 950| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 950| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 950| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 950| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.75k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.80k, False: 950] | | | | ------------------ | | | | 64| 3.80k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.80k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.80k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.80k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.80k| } else { \ | | | | 70| 3.80k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.80k| } \ | | | | 72| 3.80k| } | | ------------------ ------------------ 3594| 950|#line 130 "flex_lexer.l" 3595| 950|TOKEN(HINT) ------------------ | | 2887| 950|#define TOKEN(name) { return SQL_##name; } ------------------ 3596| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3597| 868|case 71: ------------------ | Branch (3597:1): [True: 868, False: 4.29M] ------------------ 3598| 868|YY_RULE_SETUP ------------------ | | 3147| 868| YY_USER_ACTION | | ------------------ | | | | 61| 868| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 868| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.47k, False: 868] | | | | ------------------ | | | | 64| 3.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.47k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.47k| } else { \ | | | | 70| 3.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.47k| } \ | | | | 72| 3.47k| } | | ------------------ ------------------ 3599| 868|#line 131 "flex_lexer.l" 3600| 868|TOKEN(HOUR) ------------------ | | 2887| 868|#define TOKEN(name) { return SQL_##name; } ------------------ 3601| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3602| 695|case 72: ------------------ | Branch (3602:1): [True: 695, False: 4.29M] ------------------ 3603| 695|YY_RULE_SETUP ------------------ | | 3147| 695| YY_USER_ACTION | | ------------------ | | | | 61| 695| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 695| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.47k, False: 695] | | | | ------------------ | | | | 64| 3.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.47k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.47k| } else { \ | | | | 70| 3.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.47k| } \ | | | | 72| 3.47k| } | | ------------------ ------------------ 3604| 695|#line 132 "flex_lexer.l" 3605| 695|TOKEN(HOURS) ------------------ | | 2887| 695|#define TOKEN(name) { return SQL_##name; } ------------------ 3606| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3607| 530|case 73: ------------------ | Branch (3607:1): [True: 530, False: 4.29M] ------------------ 3608| 530|YY_RULE_SETUP ------------------ | | 3147| 530| YY_USER_ACTION | | ------------------ | | | | 61| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.06k, False: 530] | | | | ------------------ | | | | 64| 1.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.06k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.06k| } else { \ | | | | 70| 1.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.06k| } \ | | | | 72| 1.06k| } | | ------------------ ------------------ 3609| 530|#line 133 "flex_lexer.l" 3610| 530|TOKEN(IF) ------------------ | | 2887| 530|#define TOKEN(name) { return SQL_##name; } ------------------ 3611| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3612| 719|case 74: ------------------ | Branch (3612:1): [True: 719, False: 4.29M] ------------------ 3613| 719|YY_RULE_SETUP ------------------ | | 3147| 719| YY_USER_ACTION | | ------------------ | | | | 61| 719| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 719| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.31k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.59k, False: 719] | | | | ------------------ | | | | 64| 3.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.59k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.59k| } else { \ | | | | 70| 3.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.59k| } \ | | | | 72| 3.59k| } | | ------------------ ------------------ 3614| 719|#line 134 "flex_lexer.l" 3615| 719|TOKEN(ILIKE) ------------------ | | 2887| 719|#define TOKEN(name) { return SQL_##name; } ------------------ 3616| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3617| 118|case 75: ------------------ | Branch (3617:1): [True: 118, False: 4.29M] ------------------ 3618| 118|YY_RULE_SETUP ------------------ | | 3147| 118| YY_USER_ACTION | | ------------------ | | | | 61| 118| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 118| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 118| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 118| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 118| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 118| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 826| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 826|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 708, False: 118] | | | | ------------------ | | | | 64| 708| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 708| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 708| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 708|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 708] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 708| } else { \ | | | | 70| 708| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 708| } \ | | | | 72| 708| } | | ------------------ ------------------ 3619| 118|#line 135 "flex_lexer.l" 3620| 118|TOKEN(IMPORT) ------------------ | | 2887| 118|#define TOKEN(name) { return SQL_##name; } ------------------ 3621| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3622| 1.34k|case 76: ------------------ | Branch (3622:1): [True: 1.34k, False: 4.29M] ------------------ 3623| 1.34k|YY_RULE_SETUP ------------------ | | 3147| 1.34k| YY_USER_ACTION | | ------------------ | | | | 61| 1.34k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.34k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.68k, False: 1.34k] | | | | ------------------ | | | | 64| 2.68k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.68k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.68k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.68k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.68k| } else { \ | | | | 70| 2.68k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.68k| } \ | | | | 72| 2.68k| } | | ------------------ ------------------ 3624| 1.34k|#line 136 "flex_lexer.l" 3625| 1.34k|TOKEN(IN) ------------------ | | 2887| 1.34k|#define TOKEN(name) { return SQL_##name; } ------------------ 3626| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3627| 1.76k|case 77: ------------------ | Branch (3627:1): [True: 1.76k, False: 4.29M] ------------------ 3628| 1.76k|YY_RULE_SETUP ------------------ | | 3147| 1.76k| YY_USER_ACTION | | ------------------ | | | | 61| 1.76k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.76k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.82k, False: 1.76k] | | | | ------------------ | | | | 64| 8.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.82k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.82k| } else { \ | | | | 70| 8.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.82k| } \ | | | | 72| 8.82k| } | | ------------------ ------------------ 3629| 1.76k|#line 137 "flex_lexer.l" 3630| 1.76k|TOKEN(INDEX) ------------------ | | 2887| 1.76k|#define TOKEN(name) { return SQL_##name; } ------------------ 3631| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3632| 708|case 78: ------------------ | Branch (3632:1): [True: 708, False: 4.29M] ------------------ 3633| 708|YY_RULE_SETUP ------------------ | | 3147| 708| YY_USER_ACTION | | ------------------ | | | | 61| 708| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 708| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.54k, False: 708] | | | | ------------------ | | | | 64| 3.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.54k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.54k| } else { \ | | | | 70| 3.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.54k| } \ | | | | 72| 3.54k| } | | ------------------ ------------------ 3634| 708|#line 138 "flex_lexer.l" 3635| 708|TOKEN(INNER) ------------------ | | 2887| 708|#define TOKEN(name) { return SQL_##name; } ------------------ 3636| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3637| 3.76k|case 79: ------------------ | Branch (3637:1): [True: 3.76k, False: 4.29M] ------------------ 3638| 3.76k|YY_RULE_SETUP ------------------ | | 3147| 3.76k| YY_USER_ACTION | | ------------------ | | | | 61| 3.76k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.76k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 26.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 26.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 22.5k, False: 3.76k] | | | | ------------------ | | | | 64| 22.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 22.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 22.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 22.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 22.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 22.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 22.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 22.5k| } else { \ | | | | 70| 22.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 22.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 22.5k| } \ | | | | 72| 22.5k| } | | ------------------ ------------------ 3639| 3.76k|#line 139 "flex_lexer.l" 3640| 3.76k|TOKEN(INSERT) ------------------ | | 2887| 3.76k|#define TOKEN(name) { return SQL_##name; } ------------------ 3641| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3642| 6.97k|case 80: ------------------ | Branch (3642:1): [True: 6.97k, False: 4.29M] ------------------ 3643| 6.97k|YY_RULE_SETUP ------------------ | | 3147| 6.97k| YY_USER_ACTION | | ------------------ | | | | 61| 6.97k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.97k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 27.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 27.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.9k, False: 6.97k] | | | | ------------------ | | | | 64| 20.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.9k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 20.9k| } else { \ | | | | 70| 20.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.9k| } \ | | | | 72| 20.9k| } | | ------------------ ------------------ 3644| 6.97k|#line 140 "flex_lexer.l" 3645| 6.97k|TOKEN(INT) ------------------ | | 2887| 6.97k|#define TOKEN(name) { return SQL_##name; } ------------------ 3646| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3647| 679|case 81: ------------------ | Branch (3647:1): [True: 679, False: 4.29M] ------------------ 3648| 679|YY_RULE_SETUP ------------------ | | 3147| 679| YY_USER_ACTION | | ------------------ | | | | 61| 679| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 679| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 679| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 679| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 679| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 679| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.75k, False: 679] | | | | ------------------ | | | | 64| 4.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.75k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.75k| } else { \ | | | | 70| 4.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.75k| } \ | | | | 72| 4.75k| } | | ------------------ ------------------ 3649| 679|#line 141 "flex_lexer.l" 3650| 679|TOKEN(INTEGER) ------------------ | | 2887| 679|#define TOKEN(name) { return SQL_##name; } ------------------ 3651| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3652| 639|case 82: ------------------ | Branch (3652:1): [True: 639, False: 4.29M] ------------------ 3653| 639|YY_RULE_SETUP ------------------ | | 3147| 639| YY_USER_ACTION | | ------------------ | | | | 61| 639| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 639| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 639| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 639| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 639| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 639| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.75k, False: 639] | | | | ------------------ | | | | 64| 5.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.75k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.75k| } else { \ | | | | 70| 5.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.75k| } \ | | | | 72| 5.75k| } | | ------------------ ------------------ 3654| 639|#line 142 "flex_lexer.l" 3655| 639|TOKEN(INTERSECT) ------------------ | | 2887| 639|#define TOKEN(name) { return SQL_##name; } ------------------ 3656| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3657| 4.76k|case 83: ------------------ | Branch (3657:1): [True: 4.76k, False: 4.29M] ------------------ 3658| 4.76k|YY_RULE_SETUP ------------------ | | 3147| 4.76k| YY_USER_ACTION | | ------------------ | | | | 61| 4.76k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.76k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 42.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 42.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 38.0k, False: 4.76k] | | | | ------------------ | | | | 64| 38.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 38.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 38.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 38.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 38.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 38.0k| } else { \ | | | | 70| 38.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 38.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 38.0k| } \ | | | | 72| 38.0k| } | | ------------------ ------------------ 3659| 4.76k|#line 143 "flex_lexer.l" 3660| 4.76k|TOKEN(INTERVAL) ------------------ | | 2887| 4.76k|#define TOKEN(name) { return SQL_##name; } ------------------ 3661| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3662| 3.75k|case 84: ------------------ | Branch (3662:1): [True: 3.75k, False: 4.29M] ------------------ 3663| 3.75k|YY_RULE_SETUP ------------------ | | 3147| 3.75k| YY_USER_ACTION | | ------------------ | | | | 61| 3.75k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.75k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.0k, False: 3.75k] | | | | ------------------ | | | | 64| 15.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.0k| } else { \ | | | | 70| 15.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.0k| } \ | | | | 72| 15.0k| } | | ------------------ ------------------ 3664| 3.75k|#line 144 "flex_lexer.l" 3665| 3.75k|TOKEN(INTO) ------------------ | | 2887| 3.75k|#define TOKEN(name) { return SQL_##name; } ------------------ 3666| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3667| 621|case 85: ------------------ | Branch (3667:1): [True: 621, False: 4.29M] ------------------ 3668| 621|YY_RULE_SETUP ------------------ | | 3147| 621| YY_USER_ACTION | | ------------------ | | | | 61| 621| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 621| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 621| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 621| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 621| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 621| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.86k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.24k, False: 621] | | | | ------------------ | | | | 64| 1.24k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.24k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.24k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.24k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.24k| } else { \ | | | | 70| 1.24k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.24k| } \ | | | | 72| 1.24k| } | | ------------------ ------------------ 3669| 621|#line 145 "flex_lexer.l" 3670| 621|TOKEN(IS) ------------------ | | 2887| 621|#define TOKEN(name) { return SQL_##name; } ------------------ 3671| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3672| 769|case 86: ------------------ | Branch (3672:1): [True: 769, False: 4.29M] ------------------ 3673| 769|YY_RULE_SETUP ------------------ | | 3147| 769| YY_USER_ACTION | | ------------------ | | | | 61| 769| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 769| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 769| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 769| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 769| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 769| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.38k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.61k, False: 769] | | | | ------------------ | | | | 64| 4.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.61k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.61k| } else { \ | | | | 70| 4.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.61k| } \ | | | | 72| 4.61k| } | | ------------------ ------------------ 3674| 769|#line 146 "flex_lexer.l" 3675| 769|TOKEN(ISNULL) ------------------ | | 2887| 769|#define TOKEN(name) { return SQL_##name; } ------------------ 3676| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3677| 112k|case 87: ------------------ | Branch (3677:1): [True: 112k, False: 4.18M] ------------------ 3678| 112k|YY_RULE_SETUP ------------------ | | 3147| 112k| YY_USER_ACTION | | ------------------ | | | | 61| 112k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 112k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 561k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 561k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 449k, False: 112k] | | | | ------------------ | | | | 64| 449k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 449k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 449k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 449k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 449k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 449k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 449k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 449k| } else { \ | | | | 70| 449k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 449k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 449k| } \ | | | | 72| 449k| } | | ------------------ ------------------ 3679| 112k|#line 147 "flex_lexer.l" 3680| 112k|TOKEN(JOIN) ------------------ | | 2887| 112k|#define TOKEN(name) { return SQL_##name; } ------------------ 3681| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3682| 2.09k|case 88: ------------------ | Branch (3682:1): [True: 2.09k, False: 4.29M] ------------------ 3683| 2.09k|YY_RULE_SETUP ------------------ | | 3147| 2.09k| YY_USER_ACTION | | ------------------ | | | | 61| 2.09k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.09k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.27k, False: 2.09k] | | | | ------------------ | | | | 64| 6.27k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.27k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.27k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.27k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.27k| } else { \ | | | | 70| 6.27k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.27k| } \ | | | | 72| 6.27k| } | | ------------------ ------------------ 3684| 2.09k|#line 148 "flex_lexer.l" 3685| 2.09k|TOKEN(KEY) ------------------ | | 2887| 2.09k|#define TOKEN(name) { return SQL_##name; } ------------------ 3686| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3687| 593|case 89: ------------------ | Branch (3687:1): [True: 593, False: 4.29M] ------------------ 3688| 593|YY_RULE_SETUP ------------------ | | 3147| 593| YY_USER_ACTION | | ------------------ | | | | 61| 593| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 593| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 593| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 593| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 593| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 593| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.96k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.37k, False: 593] | | | | ------------------ | | | | 64| 2.37k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.37k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.37k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.37k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.37k| } else { \ | | | | 70| 2.37k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.37k| } \ | | | | 72| 2.37k| } | | ------------------ ------------------ 3689| 593|#line 149 "flex_lexer.l" 3690| 593|TOKEN(LEFT) ------------------ | | 2887| 593|#define TOKEN(name) { return SQL_##name; } ------------------ 3691| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3692| 556|case 90: ------------------ | Branch (3692:1): [True: 556, False: 4.29M] ------------------ 3693| 556|YY_RULE_SETUP ------------------ | | 3147| 556| YY_USER_ACTION | | ------------------ | | | | 61| 556| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 556| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 556| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 556| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 556| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 556| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.22k, False: 556] | | | | ------------------ | | | | 64| 2.22k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.22k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.22k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.22k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.22k| } else { \ | | | | 70| 2.22k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.22k| } \ | | | | 72| 2.22k| } | | ------------------ ------------------ 3694| 556|#line 150 "flex_lexer.l" 3695| 556|TOKEN(LIKE) ------------------ | | 2887| 556|#define TOKEN(name) { return SQL_##name; } ------------------ 3696| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3697| 4.76k|case 91: ------------------ | Branch (3697:1): [True: 4.76k, False: 4.29M] ------------------ 3698| 4.76k|YY_RULE_SETUP ------------------ | | 3147| 4.76k| YY_USER_ACTION | | ------------------ | | | | 61| 4.76k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.76k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 28.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 28.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.8k, False: 4.76k] | | | | ------------------ | | | | 64| 23.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.8k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 23.8k| } else { \ | | | | 70| 23.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.8k| } \ | | | | 72| 23.8k| } | | ------------------ ------------------ 3699| 4.76k|#line 151 "flex_lexer.l" 3700| 4.76k|TOKEN(LIMIT) ------------------ | | 2887| 4.76k|#define TOKEN(name) { return SQL_##name; } ------------------ 3701| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3702| 2|case 92: ------------------ | Branch (3702:1): [True: 2, False: 4.29M] ------------------ 3703| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8, False: 2] | | | | ------------------ | | | | 64| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8| } else { \ | | | | 70| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| } \ | | | | 72| 8| } | | ------------------ ------------------ 3704| 2|#line 152 "flex_lexer.l" 3705| 2|TOKEN(LOAD) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3706| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3707| 2|case 93: ------------------ | Branch (3707:1): [True: 2, False: 4.29M] ------------------ 3708| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3709| 2|#line 153 "flex_lexer.l" 3710| 2|TOKEN(LOCAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3711| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3712| 3|case 94: ------------------ | Branch (3712:1): [True: 3, False: 4.29M] ------------------ 3713| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 21| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18, False: 3] | | | | ------------------ | | | | 64| 18| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 18| } else { \ | | | | 70| 18| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18| } \ | | | | 72| 18| } | | ------------------ ------------------ 3714| 3|#line 154 "flex_lexer.l" 3715| 3|TOKEN(LOCKED) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3716| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3717| 1.04k|case 95: ------------------ | Branch (3717:1): [True: 1.04k, False: 4.29M] ------------------ 3718| 1.04k|YY_RULE_SETUP ------------------ | | 3147| 1.04k| YY_USER_ACTION | | ------------------ | | | | 61| 1.04k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.04k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.21k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.17k, False: 1.04k] | | | | ------------------ | | | | 64| 4.17k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.17k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.17k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.17k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.17k| } else { \ | | | | 70| 4.17k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.17k| } \ | | | | 72| 4.17k| } | | ------------------ ------------------ 3719| 1.04k|#line 155 "flex_lexer.l" 3720| 1.04k|TOKEN(LONG) ------------------ | | 2887| 1.04k|#define TOKEN(name) { return SQL_##name; } ------------------ 3721| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3722| 2|case 96: ------------------ | Branch (3722:1): [True: 2, False: 4.29M] ------------------ 3723| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3724| 2|#line 156 "flex_lexer.l" 3725| 2|TOKEN(MERGE) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3726| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3727| 2|case 97: ------------------ | Branch (3727:1): [True: 2, False: 4.29M] ------------------ 3728| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3729| 2|#line 157 "flex_lexer.l" 3730| 2|TOKEN(MINUS) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3731| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3732| 1.09k|case 98: ------------------ | Branch (3732:1): [True: 1.09k, False: 4.29M] ------------------ 3733| 1.09k|YY_RULE_SETUP ------------------ | | 3147| 1.09k| YY_USER_ACTION | | ------------------ | | | | 61| 1.09k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.09k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.63k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.54k, False: 1.09k] | | | | ------------------ | | | | 64| 6.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.54k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.54k| } else { \ | | | | 70| 6.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.54k| } \ | | | | 72| 6.54k| } | | ------------------ ------------------ 3734| 1.09k|#line 158 "flex_lexer.l" 3735| 1.09k|TOKEN(MINUTE) ------------------ | | 2887| 1.09k|#define TOKEN(name) { return SQL_##name; } ------------------ 3736| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3737| 952|case 99: ------------------ | Branch (3737:1): [True: 952, False: 4.29M] ------------------ 3738| 952|YY_RULE_SETUP ------------------ | | 3147| 952| YY_USER_ACTION | | ------------------ | | | | 61| 952| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 952| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 952| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 952| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 952| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 952| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.61k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.66k, False: 952] | | | | ------------------ | | | | 64| 6.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.66k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.66k| } else { \ | | | | 70| 6.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.66k| } \ | | | | 72| 6.66k| } | | ------------------ ------------------ 3739| 952|#line 159 "flex_lexer.l" 3740| 952|TOKEN(MINUTES) ------------------ | | 2887| 952|#define TOKEN(name) { return SQL_##name; } ------------------ 3741| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3742| 723|case 100: ------------------ | Branch (3742:1): [True: 723, False: 4.29M] ------------------ 3743| 723|YY_RULE_SETUP ------------------ | | 3147| 723| YY_USER_ACTION | | ------------------ | | | | 61| 723| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 723| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 723| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 723| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 723| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 723| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.33k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.61k, False: 723] | | | | ------------------ | | | | 64| 3.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.61k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.61k| } else { \ | | | | 70| 3.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.61k| } \ | | | | 72| 3.61k| } | | ------------------ ------------------ 3744| 723|#line 160 "flex_lexer.l" 3745| 723|TOKEN(MONTH) ------------------ | | 2887| 723|#define TOKEN(name) { return SQL_##name; } ------------------ 3746| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3747| 739|case 101: ------------------ | Branch (3747:1): [True: 739, False: 4.29M] ------------------ 3748| 739|YY_RULE_SETUP ------------------ | | 3147| 739| YY_USER_ACTION | | ------------------ | | | | 61| 739| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 739| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.43k, False: 739] | | | | ------------------ | | | | 64| 4.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.43k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.43k| } else { \ | | | | 70| 4.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.43k| } \ | | | | 72| 4.43k| } | | ------------------ ------------------ 3749| 739|#line 161 "flex_lexer.l" 3750| 739|TOKEN(MONTHS) ------------------ | | 2887| 739|#define TOKEN(name) { return SQL_##name; } ------------------ 3751| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3752| 815|case 102: ------------------ | Branch (3752:1): [True: 815, False: 4.29M] ------------------ 3753| 815|YY_RULE_SETUP ------------------ | | 3147| 815| YY_USER_ACTION | | ------------------ | | | | 61| 815| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 815| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 815| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.70k, False: 815] | | | | ------------------ | | | | 64| 5.70k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.70k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.70k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.70k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.70k| } else { \ | | | | 70| 5.70k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.70k| } \ | | | | 72| 5.70k| } | | ------------------ ------------------ 3754| 815|#line 162 "flex_lexer.l" 3755| 815|TOKEN(NATURAL) ------------------ | | 2887| 815|#define TOKEN(name) { return SQL_##name; } ------------------ 3756| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3757| 10|case 103: ------------------ | Branch (3757:1): [True: 10, False: 4.29M] ------------------ 3758| 10|YY_RULE_SETUP ------------------ | | 3147| 10| YY_USER_ACTION | | ------------------ | | | | 61| 10| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 10| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 30| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 30|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20, False: 10] | | | | ------------------ | | | | 64| 20| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 20| } else { \ | | | | 70| 20| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20| } \ | | | | 72| 20| } | | ------------------ ------------------ 3759| 10|#line 163 "flex_lexer.l" 3760| 10|TOKEN(NO) ------------------ | | 2887| 10|#define TOKEN(name) { return SQL_##name; } ------------------ 3761| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3762| 5.22k|case 104: ------------------ | Branch (3762:1): [True: 5.22k, False: 4.29M] ------------------ 3763| 5.22k|YY_RULE_SETUP ------------------ | | 3147| 5.22k| YY_USER_ACTION | | ------------------ | | | | 61| 5.22k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.22k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.22k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.6k, False: 5.22k] | | | | ------------------ | | | | 64| 15.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.6k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.6k| } else { \ | | | | 70| 15.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.6k| } \ | | | | 72| 15.6k| } | | ------------------ ------------------ 3764| 5.22k|#line 164 "flex_lexer.l" 3765| 5.22k|TOKEN(NOT) ------------------ | | 2887| 5.22k|#define TOKEN(name) { return SQL_##name; } ------------------ 3766| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3767| 785|case 105: ------------------ | Branch (3767:1): [True: 785, False: 4.29M] ------------------ 3768| 785|YY_RULE_SETUP ------------------ | | 3147| 785| YY_USER_ACTION | | ------------------ | | | | 61| 785| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 785| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 785| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 785| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 785| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 785| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.49k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.71k, False: 785] | | | | ------------------ | | | | 64| 4.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.71k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.71k| } else { \ | | | | 70| 4.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.71k| } \ | | | | 72| 4.71k| } | | ------------------ ------------------ 3769| 785|#line 165 "flex_lexer.l" 3770| 785|TOKEN(NOWAIT) ------------------ | | 2887| 785|#define TOKEN(name) { return SQL_##name; } ------------------ 3771| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3772| 8.46k|case 106: ------------------ | Branch (3772:1): [True: 8.46k, False: 4.29M] ------------------ 3773| 8.46k|YY_RULE_SETUP ------------------ | | 3147| 8.46k| YY_USER_ACTION | | ------------------ | | | | 61| 8.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 8.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 42.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 42.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 33.8k, False: 8.46k] | | | | ------------------ | | | | 64| 33.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 33.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 33.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 33.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 33.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 33.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 33.8k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 33.8k| } else { \ | | | | 70| 33.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 33.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 33.8k| } \ | | | | 72| 33.8k| } | | ------------------ ------------------ 3774| 8.46k|#line 166 "flex_lexer.l" 3775| 8.46k|TOKEN(NULL) ------------------ | | 2887| 8.46k|#define TOKEN(name) { return SQL_##name; } ------------------ 3776| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3777| 2|case 107: ------------------ | Branch (3777:1): [True: 2, False: 4.29M] ------------------ 3778| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16, False: 2] | | | | ------------------ | | | | 64| 16| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 16| } else { \ | | | | 70| 16| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16| } \ | | | | 72| 16| } | | ------------------ ------------------ 3779| 2|#line 167 "flex_lexer.l" 3780| 2|TOKEN(NVARCHAR) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3781| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3782| 287|case 108: ------------------ | Branch (3782:1): [True: 287, False: 4.29M] ------------------ 3783| 287|YY_RULE_SETUP ------------------ | | 3147| 287| YY_USER_ACTION | | ------------------ | | | | 61| 287| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 287| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 861| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 861|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 574, False: 287] | | | | ------------------ | | | | 64| 574| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 574| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 574| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 574|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 574] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 574| } else { \ | | | | 70| 574| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 574| } \ | | | | 72| 574| } | | ------------------ ------------------ 3784| 287|#line 168 "flex_lexer.l" 3785| 287|TOKEN(OF) ------------------ | | 2887| 287|#define TOKEN(name) { return SQL_##name; } ------------------ 3786| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3787| 3|case 109: ------------------ | Branch (3787:1): [True: 3, False: 4.29M] ------------------ 3788| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9, False: 3] | | | | ------------------ | | | | 64| 9| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9| } else { \ | | | | 70| 9| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9| } \ | | | | 72| 9| } | | ------------------ ------------------ 3789| 3|#line 169 "flex_lexer.l" 3790| 3|TOKEN(OFF) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3791| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3792| 2.84k|case 110: ------------------ | Branch (3792:1): [True: 2.84k, False: 4.29M] ------------------ 3793| 2.84k|YY_RULE_SETUP ------------------ | | 3147| 2.84k| YY_USER_ACTION | | ------------------ | | | | 61| 2.84k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.84k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 17.0k, False: 2.84k] | | | | ------------------ | | | | 64| 17.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 17.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 17.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 17.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 17.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 17.0k| } else { \ | | | | 70| 17.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.0k| } \ | | | | 72| 17.0k| } | | ------------------ ------------------ 3794| 2.84k|#line 170 "flex_lexer.l" 3795| 2.84k|TOKEN(OFFSET) ------------------ | | 2887| 2.84k|#define TOKEN(name) { return SQL_##name; } ------------------ 3796| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3797| 110k|case 111: ------------------ | Branch (3797:1): [True: 110k, False: 4.18M] ------------------ 3798| 110k|YY_RULE_SETUP ------------------ | | 3147| 110k| YY_USER_ACTION | | ------------------ | | | | 61| 110k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 110k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 330k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 330k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 220k, False: 110k] | | | | ------------------ | | | | 64| 220k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 220k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 220k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 220k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 220k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 220k| } else { \ | | | | 70| 220k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 220k| } \ | | | | 72| 220k| } | | ------------------ ------------------ 3799| 110k|#line 171 "flex_lexer.l" 3800| 110k|TOKEN(ON) ------------------ | | 2887| 110k|#define TOKEN(name) { return SQL_##name; } ------------------ 3801| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3802| 665|case 112: ------------------ | Branch (3802:1): [True: 665, False: 4.29M] ------------------ 3803| 665|YY_RULE_SETUP ------------------ | | 3147| 665| YY_USER_ACTION | | ------------------ | | | | 61| 665| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 665| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 665| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 665| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 665| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 665| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.33k, False: 665] | | | | ------------------ | | | | 64| 1.33k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.33k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.33k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.33k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.33k| } else { \ | | | | 70| 1.33k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.33k| } \ | | | | 72| 1.33k| } | | ------------------ ------------------ 3804| 665|#line 172 "flex_lexer.l" 3805| 665|TOKEN(OR) ------------------ | | 2887| 665|#define TOKEN(name) { return SQL_##name; } ------------------ 3806| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3807| 3.02k|case 113: ------------------ | Branch (3807:1): [True: 3.02k, False: 4.29M] ------------------ 3808| 3.02k|YY_RULE_SETUP ------------------ | | 3147| 3.02k| YY_USER_ACTION | | ------------------ | | | | 61| 3.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.1k, False: 3.02k] | | | | ------------------ | | | | 64| 15.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.1k| } else { \ | | | | 70| 15.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.1k| } \ | | | | 72| 15.1k| } | | ------------------ ------------------ 3809| 3.02k|#line 173 "flex_lexer.l" 3810| 3.02k|TOKEN(ORDER) ------------------ | | 2887| 3.02k|#define TOKEN(name) { return SQL_##name; } ------------------ 3811| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3812| 1.08k|case 114: ------------------ | Branch (3812:1): [True: 1.08k, False: 4.29M] ------------------ 3813| 1.08k|YY_RULE_SETUP ------------------ | | 3147| 1.08k| YY_USER_ACTION | | ------------------ | | | | 61| 1.08k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.08k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.43k, False: 1.08k] | | | | ------------------ | | | | 64| 5.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.43k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.43k| } else { \ | | | | 70| 5.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.43k| } \ | | | | 72| 5.43k| } | | ------------------ ------------------ 3814| 1.08k|#line 174 "flex_lexer.l" 3815| 1.08k|TOKEN(OUTER) ------------------ | | 2887| 1.08k|#define TOKEN(name) { return SQL_##name; } ------------------ 3816| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3817| 6.14k|case 115: ------------------ | Branch (3817:1): [True: 6.14k, False: 4.29M] ------------------ 3818| 6.14k|YY_RULE_SETUP ------------------ | | 3147| 6.14k| YY_USER_ACTION | | ------------------ | | | | 61| 6.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 30.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 30.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 24.5k, False: 6.14k] | | | | ------------------ | | | | 64| 24.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 24.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 24.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 24.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 24.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 24.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 24.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 24.5k| } else { \ | | | | 70| 24.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 24.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 24.5k| } \ | | | | 72| 24.5k| } | | ------------------ ------------------ 3819| 6.14k|#line 175 "flex_lexer.l" 3820| 6.14k|TOKEN(OVER) ------------------ | | 2887| 6.14k|#define TOKEN(name) { return SQL_##name; } ------------------ 3821| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3822| 0|case 116: ------------------ | Branch (3822:1): [True: 0, False: 4.29M] ------------------ 3823| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 3824| 0|#line 176 "flex_lexer.l" 3825| 0|TOKEN(PARAMETERS) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3826| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3827| 780|case 117: ------------------ | Branch (3827:1): [True: 780, False: 4.29M] ------------------ 3828| 780|YY_RULE_SETUP ------------------ | | 3147| 780| YY_USER_ACTION | | ------------------ | | | | 61| 780| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 780| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 780| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 780| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 780| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 780| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.02k, False: 780] | | | | ------------------ | | | | 64| 7.02k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.02k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.02k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.02k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7.02k| } else { \ | | | | 70| 7.02k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.02k| } \ | | | | 72| 7.02k| } | | ------------------ ------------------ 3829| 780|#line 177 "flex_lexer.l" 3830| 780|TOKEN(PARTITION) ------------------ | | 2887| 780|#define TOKEN(name) { return SQL_##name; } ------------------ 3831| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3832| 1|case 118: ------------------ | Branch (3832:1): [True: 1, False: 4.29M] ------------------ 3833| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4, False: 1] | | | | ------------------ | | | | 64| 4| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4| } else { \ | | | | 70| 4| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4| } \ | | | | 72| 4| } | | ------------------ ------------------ 3834| 1|#line 178 "flex_lexer.l" 3835| 1|TOKEN(PLAN) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3836| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3837| 1.46k|case 119: ------------------ | Branch (3837:1): [True: 1.46k, False: 4.29M] ------------------ 3838| 1.46k|YY_RULE_SETUP ------------------ | | 3147| 1.46k| YY_USER_ACTION | | ------------------ | | | | 61| 1.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.1k, False: 1.46k] | | | | ------------------ | | | | 64| 13.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.1k| } else { \ | | | | 70| 13.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.1k| } \ | | | | 72| 13.1k| } | | ------------------ ------------------ 3839| 1.46k|#line 179 "flex_lexer.l" 3840| 1.46k|TOKEN(PRECEDING) ------------------ | | 2887| 1.46k|#define TOKEN(name) { return SQL_##name; } ------------------ 3841| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3842| 2.32k|case 120: ------------------ | Branch (3842:1): [True: 2.32k, False: 4.29M] ------------------ 3843| 2.32k|YY_RULE_SETUP ------------------ | | 3147| 2.32k| YY_USER_ACTION | | ------------------ | | | | 61| 2.32k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.32k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.2k, False: 2.32k] | | | | ------------------ | | | | 64| 16.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.2k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 16.2k| } else { \ | | | | 70| 16.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.2k| } \ | | | | 72| 16.2k| } | | ------------------ ------------------ 3844| 2.32k|#line 180 "flex_lexer.l" 3845| 2.32k|TOKEN(PREPARE) ------------------ | | 2887| 2.32k|#define TOKEN(name) { return SQL_##name; } ------------------ 3846| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3847| 1.88k|case 121: ------------------ | Branch (3847:1): [True: 1.88k, False: 4.29M] ------------------ 3848| 1.88k|YY_RULE_SETUP ------------------ | | 3147| 1.88k| YY_USER_ACTION | | ------------------ | | | | 61| 1.88k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.88k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.1k, False: 1.88k] | | | | ------------------ | | | | 64| 13.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.1k| } else { \ | | | | 70| 13.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.1k| } \ | | | | 72| 13.1k| } | | ------------------ ------------------ 3849| 1.88k|#line 181 "flex_lexer.l" 3850| 1.88k|TOKEN(PRIMARY) ------------------ | | 2887| 1.88k|#define TOKEN(name) { return SQL_##name; } ------------------ 3851| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3852| 1.31k|case 122: ------------------ | Branch (3852:1): [True: 1.31k, False: 4.29M] ------------------ 3853| 1.31k|YY_RULE_SETUP ------------------ | | 3147| 1.31k| YY_USER_ACTION | | ------------------ | | | | 61| 1.31k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.31k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.90k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.59k, False: 1.31k] | | | | ------------------ | | | | 64| 6.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.59k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.59k| } else { \ | | | | 70| 6.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.59k| } \ | | | | 72| 6.59k| } | | ------------------ ------------------ 3854| 1.31k|#line 182 "flex_lexer.l" 3855| 1.31k|TOKEN(RANGE) ------------------ | | 2887| 1.31k|#define TOKEN(name) { return SQL_##name; } ------------------ 3856| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3857| 578|case 123: ------------------ | Branch (3857:1): [True: 578, False: 4.29M] ------------------ 3858| 578|YY_RULE_SETUP ------------------ | | 3147| 578| YY_USER_ACTION | | ------------------ | | | | 61| 578| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 578| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 578| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.89k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.31k, False: 578] | | | | ------------------ | | | | 64| 2.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.31k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.31k| } else { \ | | | | 70| 2.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.31k| } \ | | | | 72| 2.31k| } | | ------------------ ------------------ 3859| 578|#line 183 "flex_lexer.l" 3860| 578|TOKEN(REAL) ------------------ | | 2887| 578|#define TOKEN(name) { return SQL_##name; } ------------------ 3861| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3862| 0|case 124: ------------------ | Branch (3862:1): [True: 0, False: 4.29M] ------------------ 3863| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 3864| 0|#line 184 "flex_lexer.l" 3865| 0|TOKEN(REFERENCES) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3866| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3867| 1|case 125: ------------------ | Branch (3867:1): [True: 1, False: 4.29M] ------------------ 3868| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3869| 1|#line 185 "flex_lexer.l" 3870| 1|TOKEN(RENAME) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3871| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3872| 2|case 126: ------------------ | Branch (3872:1): [True: 2, False: 4.29M] ------------------ 3873| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16, False: 2] | | | | ------------------ | | | | 64| 16| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 16| } else { \ | | | | 70| 16| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16| } \ | | | | 72| 16| } | | ------------------ ------------------ 3874| 2|#line 186 "flex_lexer.l" 3875| 2|TOKEN(RESTRICT) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3876| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3877| 543|case 127: ------------------ | Branch (3877:1): [True: 543, False: 4.29M] ------------------ 3878| 543|YY_RULE_SETUP ------------------ | | 3147| 543| YY_USER_ACTION | | ------------------ | | | | 61| 543| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 543| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 543| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 543| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 543| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 543| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.25k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.71k, False: 543] | | | | ------------------ | | | | 64| 2.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.71k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.71k| } else { \ | | | | 70| 2.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.71k| } \ | | | | 72| 2.71k| } | | ------------------ ------------------ 3879| 543|#line 187 "flex_lexer.l" 3880| 543|TOKEN(RIGHT) ------------------ | | 2887| 543|#define TOKEN(name) { return SQL_##name; } ------------------ 3881| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3882| 2.27k|case 128: ------------------ | Branch (3882:1): [True: 2.27k, False: 4.29M] ------------------ 3883| 2.27k|YY_RULE_SETUP ------------------ | | 3147| 2.27k| YY_USER_ACTION | | ------------------ | | | | 61| 2.27k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.27k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.1k, False: 2.27k] | | | | ------------------ | | | | 64| 18.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 18.1k| } else { \ | | | | 70| 18.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.1k| } \ | | | | 72| 18.1k| } | | ------------------ ------------------ 3884| 2.27k|#line 188 "flex_lexer.l" 3885| 2.27k|TOKEN(ROLLBACK) ------------------ | | 2887| 2.27k|#define TOKEN(name) { return SQL_##name; } ------------------ 3886| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3887| 1.54k|case 129: ------------------ | Branch (3887:1): [True: 1.54k, False: 4.29M] ------------------ 3888| 1.54k|YY_RULE_SETUP ------------------ | | 3147| 1.54k| YY_USER_ACTION | | ------------------ | | | | 61| 1.54k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.54k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.70k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.16k, False: 1.54k] | | | | ------------------ | | | | 64| 6.16k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.16k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.16k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.16k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.16k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.16k| } else { \ | | | | 70| 6.16k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.16k| } \ | | | | 72| 6.16k| } | | ------------------ ------------------ 3889| 1.54k|#line 189 "flex_lexer.l" 3890| 1.54k|TOKEN(ROWS) ------------------ | | 2887| 1.54k|#define TOKEN(name) { return SQL_##name; } ------------------ 3891| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3892| 1|case 130: ------------------ | Branch (3892:1): [True: 1, False: 4.29M] ------------------ 3893| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3894| 1|#line 190 "flex_lexer.l" 3895| 1|TOKEN(SCHEMA) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3896| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3897| 1|case 131: ------------------ | Branch (3897:1): [True: 1, False: 4.29M] ------------------ 3898| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3899| 1|#line 191 "flex_lexer.l" 3900| 1|TOKEN(SCHEMAS) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3901| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3902| 767|case 132: ------------------ | Branch (3902:1): [True: 767, False: 4.29M] ------------------ 3903| 767|YY_RULE_SETUP ------------------ | | 3147| 767| YY_USER_ACTION | | ------------------ | | | | 61| 767| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 767| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 767| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 767| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 767| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 767| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.60k, False: 767] | | | | ------------------ | | | | 64| 4.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.60k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.60k| } else { \ | | | | 70| 4.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.60k| } \ | | | | 72| 4.60k| } | | ------------------ ------------------ 3904| 767|#line 192 "flex_lexer.l" 3905| 767|TOKEN(SECOND) ------------------ | | 2887| 767|#define TOKEN(name) { return SQL_##name; } ------------------ 3906| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3907| 850|case 133: ------------------ | Branch (3907:1): [True: 850, False: 4.29M] ------------------ 3908| 850|YY_RULE_SETUP ------------------ | | 3147| 850| YY_USER_ACTION | | ------------------ | | | | 61| 850| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 850| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 850| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 850| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 850| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 850| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.95k, False: 850] | | | | ------------------ | | | | 64| 5.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.95k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.95k| } else { \ | | | | 70| 5.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.95k| } \ | | | | 72| 5.95k| } | | ------------------ ------------------ 3909| 850|#line 193 "flex_lexer.l" 3910| 850|TOKEN(SECONDS) ------------------ | | 2887| 850|#define TOKEN(name) { return SQL_##name; } ------------------ 3911| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3912| 42.9k|case 134: ------------------ | Branch (3912:1): [True: 42.9k, False: 4.25M] ------------------ 3913| 42.9k|YY_RULE_SETUP ------------------ | | 3147| 42.9k| YY_USER_ACTION | | ------------------ | | | | 61| 42.9k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 42.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 42.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 42.9k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 42.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 42.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 300k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 300k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 257k, False: 42.9k] | | | | ------------------ | | | | 64| 257k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 257k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 257k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 257k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 257k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 257k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 257k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 257k| } else { \ | | | | 70| 257k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 257k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 257k| } \ | | | | 72| 257k| } | | ------------------ ------------------ 3914| 42.9k|#line 194 "flex_lexer.l" 3915| 42.9k|TOKEN(SELECT) ------------------ | | 2887| 42.9k|#define TOKEN(name) { return SQL_##name; } ------------------ 3916| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3917| 1.94k|case 135: ------------------ | Branch (3917:1): [True: 1.94k, False: 4.29M] ------------------ 3918| 1.94k|YY_RULE_SETUP ------------------ | | 3147| 1.94k| YY_USER_ACTION | | ------------------ | | | | 61| 1.94k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.94k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.79k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.84k, False: 1.94k] | | | | ------------------ | | | | 64| 5.84k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.84k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.84k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.84k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.84k| } else { \ | | | | 70| 5.84k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.84k| } \ | | | | 72| 5.84k| } | | ------------------ ------------------ 3919| 1.94k|#line 195 "flex_lexer.l" 3920| 1.94k|TOKEN(SET) ------------------ | | 2887| 1.94k|#define TOKEN(name) { return SQL_##name; } ------------------ 3921| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3922| 3.16k|case 136: ------------------ | Branch (3922:1): [True: 3.16k, False: 4.29M] ------------------ 3923| 3.16k|YY_RULE_SETUP ------------------ | | 3147| 3.16k| YY_USER_ACTION | | ------------------ | | | | 61| 3.16k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.16k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.8k, False: 3.16k] | | | | ------------------ | | | | 64| 15.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.8k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.8k| } else { \ | | | | 70| 15.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.8k| } \ | | | | 72| 15.8k| } | | ------------------ ------------------ 3924| 3.16k|#line 196 "flex_lexer.l" 3925| 3.16k|TOKEN(SHARE) ------------------ | | 2887| 3.16k|#define TOKEN(name) { return SQL_##name; } ------------------ 3926| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3927| 2.74k|case 137: ------------------ | Branch (3927:1): [True: 2.74k, False: 4.29M] ------------------ 3928| 2.74k|YY_RULE_SETUP ------------------ | | 3147| 2.74k| YY_USER_ACTION | | ------------------ | | | | 61| 2.74k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.74k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.9k, False: 2.74k] | | | | ------------------ | | | | 64| 10.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.9k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.9k| } else { \ | | | | 70| 10.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.9k| } \ | | | | 72| 10.9k| } | | ------------------ ------------------ 3929| 2.74k|#line 197 "flex_lexer.l" 3930| 2.74k|TOKEN(SHOW) ------------------ | | 2887| 2.74k|#define TOKEN(name) { return SQL_##name; } ------------------ 3931| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3932| 1|case 138: ------------------ | Branch (3932:1): [True: 1, False: 4.29M] ------------------ 3933| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4, False: 1] | | | | ------------------ | | | | 64| 4| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4| } else { \ | | | | 70| 4| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4| } \ | | | | 72| 4| } | | ------------------ ------------------ 3934| 1|#line 198 "flex_lexer.l" 3935| 1|TOKEN(SKIP) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3936| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3937| 538|case 139: ------------------ | Branch (3937:1): [True: 538, False: 4.29M] ------------------ 3938| 538|YY_RULE_SETUP ------------------ | | 3147| 538| YY_USER_ACTION | | ------------------ | | | | 61| 538| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 538| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 538| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 538| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 538| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 538| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.30k, False: 538] | | | | ------------------ | | | | 64| 4.30k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.30k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.30k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.30k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.30k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.30k| } else { \ | | | | 70| 4.30k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.30k| } \ | | | | 72| 4.30k| } | | ------------------ ------------------ 3939| 538|#line 199 "flex_lexer.l" 3940| 538|TOKEN(SMALLINT) ------------------ | | 2887| 538|#define TOKEN(name) { return SQL_##name; } ------------------ 3941| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3942| 2|case 140: ------------------ | Branch (3942:1): [True: 2, False: 4.29M] ------------------ 3943| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 2] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3944| 2|#line 200 "flex_lexer.l" 3945| 2|TOKEN(SORTED) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3946| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3947| 2|case 141: ------------------ | Branch (3947:1): [True: 2, False: 4.29M] ------------------ 3948| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14, False: 2] | | | | ------------------ | | | | 64| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14| } else { \ | | | | 70| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| } \ | | | | 72| 14| } | | ------------------ ------------------ 3949| 2|#line 201 "flex_lexer.l" 3950| 2|TOKEN(SPATIAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3951| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3952| 6.30k|case 142: ------------------ | Branch (3952:1): [True: 6.30k, False: 4.29M] ------------------ 3953| 6.30k|YY_RULE_SETUP ------------------ | | 3147| 6.30k| YY_USER_ACTION | | ------------------ | | | | 61| 6.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 37.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 37.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 31.5k, False: 6.30k] | | | | ------------------ | | | | 64| 31.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 31.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 31.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 31.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 31.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 31.5k| } else { \ | | | | 70| 31.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 31.5k| } \ | | | | 72| 31.5k| } | | ------------------ ------------------ 3954| 6.30k|#line 202 "flex_lexer.l" 3955| 6.30k|TOKEN(TABLE) ------------------ | | 2887| 6.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 3956| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3957| 1.59k|case 143: ------------------ | Branch (3957:1): [True: 1.59k, False: 4.29M] ------------------ 3958| 1.59k|YY_RULE_SETUP ------------------ | | 3147| 1.59k| YY_USER_ACTION | | ------------------ | | | | 61| 1.59k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.59k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.57k, False: 1.59k] | | | | ------------------ | | | | 64| 9.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.57k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9.57k| } else { \ | | | | 70| 9.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.57k| } \ | | | | 72| 9.57k| } | | ------------------ ------------------ 3959| 1.59k|#line 203 "flex_lexer.l" 3960| 1.59k|TOKEN(TABLES) ------------------ | | 2887| 1.59k|#define TOKEN(name) { return SQL_##name; } ------------------ 3961| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3962| 1|case 144: ------------------ | Branch (3962:1): [True: 1, False: 4.29M] ------------------ 3963| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9, False: 1] | | | | ------------------ | | | | 64| 9| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9| } else { \ | | | | 70| 9| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9| } \ | | | | 72| 9| } | | ------------------ ------------------ 3964| 1|#line 204 "flex_lexer.l" 3965| 1|TOKEN(TEMPORARY) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3966| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3967| 410|case 145: ------------------ | Branch (3967:1): [True: 410, False: 4.29M] ------------------ 3968| 410|YY_RULE_SETUP ------------------ | | 3147| 410| YY_USER_ACTION | | ------------------ | | | | 61| 410| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 410| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 410| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 410| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 410| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 410| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.64k, False: 410] | | | | ------------------ | | | | 64| 1.64k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.64k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.64k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.64k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.64k| } else { \ | | | | 70| 1.64k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.64k| } \ | | | | 72| 1.64k| } | | ------------------ ------------------ 3969| 410|#line 205 "flex_lexer.l" 3970| 410|TOKEN(TEXT) ------------------ | | 2887| 410|#define TOKEN(name) { return SQL_##name; } ------------------ 3971| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3972| 3.39k|case 146: ------------------ | Branch (3972:1): [True: 3.39k, False: 4.29M] ------------------ 3973| 3.39k|YY_RULE_SETUP ------------------ | | 3147| 3.39k| YY_USER_ACTION | | ------------------ | | | | 61| 3.39k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.39k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.5k, False: 3.39k] | | | | ------------------ | | | | 64| 13.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.5k| } else { \ | | | | 70| 13.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.5k| } \ | | | | 72| 13.5k| } | | ------------------ ------------------ 3974| 3.39k|#line 206 "flex_lexer.l" 3975| 3.39k|TOKEN(THEN) ------------------ | | 2887| 3.39k|#define TOKEN(name) { return SQL_##name; } ------------------ 3976| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3977| 976|case 147: ------------------ | Branch (3977:1): [True: 976, False: 4.29M] ------------------ 3978| 976|YY_RULE_SETUP ------------------ | | 3147| 976| YY_USER_ACTION | | ------------------ | | | | 61| 976| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 976| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.88k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.90k, False: 976] | | | | ------------------ | | | | 64| 3.90k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.90k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.90k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.90k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.90k| } else { \ | | | | 70| 3.90k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.90k| } \ | | | | 72| 3.90k| } | | ------------------ ------------------ 3979| 976|#line 207 "flex_lexer.l" 3980| 976|TOKEN(TIME) ------------------ | | 2887| 976|#define TOKEN(name) { return SQL_##name; } ------------------ 3981| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3982| 637|case 148: ------------------ | Branch (3982:1): [True: 637, False: 4.29M] ------------------ 3983| 637|YY_RULE_SETUP ------------------ | | 3147| 637| YY_USER_ACTION | | ------------------ | | | | 61| 637| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 637| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 637| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 637| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 637| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 637| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.37k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.73k, False: 637] | | | | ------------------ | | | | 64| 5.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.73k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.73k| } else { \ | | | | 70| 5.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.73k| } \ | | | | 72| 5.73k| } | | ------------------ ------------------ 3984| 637|#line 208 "flex_lexer.l" 3985| 637|TOKEN(TIMESTAMP) ------------------ | | 2887| 637|#define TOKEN(name) { return SQL_##name; } ------------------ 3986| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3987| 7.15k|case 149: ------------------ | Branch (3987:1): [True: 7.15k, False: 4.29M] ------------------ 3988| 7.15k|YY_RULE_SETUP ------------------ | | 3147| 7.15k| YY_USER_ACTION | | ------------------ | | | | 61| 7.15k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.15k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 21.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.3k, False: 7.15k] | | | | ------------------ | | | | 64| 14.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14.3k| } else { \ | | | | 70| 14.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.3k| } \ | | | | 72| 14.3k| } | | ------------------ ------------------ 3989| 7.15k|#line 209 "flex_lexer.l" 3990| 7.15k|TOKEN(TO) ------------------ | | 2887| 7.15k|#define TOKEN(name) { return SQL_##name; } ------------------ 3991| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3992| 3.63k|case 150: ------------------ | Branch (3992:1): [True: 3.63k, False: 4.29M] ------------------ 3993| 3.63k|YY_RULE_SETUP ------------------ | | 3147| 3.63k| YY_USER_ACTION | | ------------------ | | | | 61| 3.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.9k, False: 3.63k] | | | | ------------------ | | | | 64| 10.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.9k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.9k| } else { \ | | | | 70| 10.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.9k| } \ | | | | 72| 10.9k| } | | ------------------ ------------------ 3994| 3.63k|#line 210 "flex_lexer.l" 3995| 3.63k|TOKEN(TOP) ------------------ | | 2887| 3.63k|#define TOKEN(name) { return SQL_##name; } ------------------ 3996| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3997| 0|case 151: ------------------ | Branch (3997:1): [True: 0, False: 4.29M] ------------------ 3998| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 3999| 0|#line 211 "flex_lexer.l" 4000| 0|TOKEN(TRANSACTION) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4001| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4002| 651|case 152: ------------------ | Branch (4002:1): [True: 651, False: 4.29M] ------------------ 4003| 651|YY_RULE_SETUP ------------------ | | 3147| 651| YY_USER_ACTION | | ------------------ | | | | 61| 651| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 651| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 651| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 651| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 651| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 651| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.25k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.60k, False: 651] | | | | ------------------ | | | | 64| 2.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.60k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.60k| } else { \ | | | | 70| 2.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.60k| } \ | | | | 72| 2.60k| } | | ------------------ ------------------ 4004| 651|#line 212 "flex_lexer.l" 4005| 651|TOKEN(TRUE) ------------------ | | 2887| 651|#define TOKEN(name) { return SQL_##name; } ------------------ 4006| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4007| 360|case 153: ------------------ | Branch (4007:1): [True: 360, False: 4.29M] ------------------ 4008| 360|YY_RULE_SETUP ------------------ | | 3147| 360| YY_USER_ACTION | | ------------------ | | | | 61| 360| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 360| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 360| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 360| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 360| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 360| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.88k, False: 360] | | | | ------------------ | | | | 64| 2.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.88k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.88k| } else { \ | | | | 70| 2.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.88k| } \ | | | | 72| 2.88k| } | | ------------------ ------------------ 4009| 360|#line 213 "flex_lexer.l" 4010| 360|TOKEN(TRUNCATE) ------------------ | | 2887| 360|#define TOKEN(name) { return SQL_##name; } ------------------ 4011| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4012| 960|case 154: ------------------ | Branch (4012:1): [True: 960, False: 4.29M] ------------------ 4013| 960|YY_RULE_SETUP ------------------ | | 3147| 960| YY_USER_ACTION | | ------------------ | | | | 61| 960| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 960| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 960| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.64k, False: 960] | | | | ------------------ | | | | 64| 8.64k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.64k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.64k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.64k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.64k| } else { \ | | | | 70| 8.64k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.64k| } \ | | | | 72| 8.64k| } | | ------------------ ------------------ 4014| 960|#line 214 "flex_lexer.l" 4015| 960|TOKEN(UNBOUNDED) ------------------ | | 2887| 960|#define TOKEN(name) { return SQL_##name; } ------------------ 4016| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4017| 4.33k|case 155: ------------------ | Branch (4017:1): [True: 4.33k, False: 4.29M] ------------------ 4018| 4.33k|YY_RULE_SETUP ------------------ | | 3147| 4.33k| YY_USER_ACTION | | ------------------ | | | | 61| 4.33k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.33k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 26.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 26.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21.6k, False: 4.33k] | | | | ------------------ | | | | 64| 21.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 21.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 21.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 21.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 21.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 21.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 21.6k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 21.6k| } else { \ | | | | 70| 21.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 21.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21.6k| } \ | | | | 72| 21.6k| } | | ------------------ ------------------ 4019| 4.33k|#line 215 "flex_lexer.l" 4020| 4.33k|TOKEN(UNION) ------------------ | | 2887| 4.33k|#define TOKEN(name) { return SQL_##name; } ------------------ 4021| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4022| 3.55k|case 156: ------------------ | Branch (4022:1): [True: 3.55k, False: 4.29M] ------------------ 4023| 3.55k|YY_RULE_SETUP ------------------ | | 3147| 3.55k| YY_USER_ACTION | | ------------------ | | | | 61| 3.55k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.55k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 24.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 24.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21.3k, False: 3.55k] | | | | ------------------ | | | | 64| 21.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 21.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 21.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 21.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 21.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 21.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 21.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 21.3k| } else { \ | | | | 70| 21.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 21.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21.3k| } \ | | | | 72| 21.3k| } | | ------------------ ------------------ 4024| 3.55k|#line 216 "flex_lexer.l" 4025| 3.55k|TOKEN(UNIQUE) ------------------ | | 2887| 3.55k|#define TOKEN(name) { return SQL_##name; } ------------------ 4026| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4027| 1|case 157: ------------------ | Branch (4027:1): [True: 1, False: 4.29M] ------------------ 4028| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 4029| 1|#line 217 "flex_lexer.l" 4030| 1|TOKEN(UNLOAD) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 4031| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4032| 2.79k|case 158: ------------------ | Branch (4032:1): [True: 2.79k, False: 4.29M] ------------------ 4033| 2.79k|YY_RULE_SETUP ------------------ | | 3147| 2.79k| YY_USER_ACTION | | ------------------ | | | | 61| 2.79k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.79k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.7k, False: 2.79k] | | | | ------------------ | | | | 64| 16.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.7k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 16.7k| } else { \ | | | | 70| 16.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.7k| } \ | | | | 72| 16.7k| } | | ------------------ ------------------ 4034| 2.79k|#line 218 "flex_lexer.l" 4035| 2.79k|TOKEN(UPDATE) ------------------ | | 2887| 2.79k|#define TOKEN(name) { return SQL_##name; } ------------------ 4036| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4037| 733|case 159: ------------------ | Branch (4037:1): [True: 733, False: 4.29M] ------------------ 4038| 733|YY_RULE_SETUP ------------------ | | 3147| 733| YY_USER_ACTION | | ------------------ | | | | 61| 733| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 733| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.66k, False: 733] | | | | ------------------ | | | | 64| 3.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.66k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.66k| } else { \ | | | | 70| 3.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.66k| } \ | | | | 72| 3.66k| } | | ------------------ ------------------ 4039| 733|#line 219 "flex_lexer.l" 4040| 733|TOKEN(USING) ------------------ | | 2887| 733|#define TOKEN(name) { return SQL_##name; } ------------------ 4041| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4042| 601|case 160: ------------------ | Branch (4042:1): [True: 601, False: 4.29M] ------------------ 4043| 601|YY_RULE_SETUP ------------------ | | 3147| 601| YY_USER_ACTION | | ------------------ | | | | 61| 601| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 601| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.60k, False: 601] | | | | ------------------ | | | | 64| 3.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.60k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.60k| } else { \ | | | | 70| 3.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.60k| } \ | | | | 72| 3.60k| } | | ------------------ ------------------ 4044| 601|#line 220 "flex_lexer.l" 4045| 601|TOKEN(VALUES) ------------------ | | 2887| 601|#define TOKEN(name) { return SQL_##name; } ------------------ 4046| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4047| 742|case 161: ------------------ | Branch (4047:1): [True: 742, False: 4.29M] ------------------ 4048| 742|YY_RULE_SETUP ------------------ | | 3147| 742| YY_USER_ACTION | | ------------------ | | | | 61| 742| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 742| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 742| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 742| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 742| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 742| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.19k, False: 742] | | | | ------------------ | | | | 64| 5.19k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.19k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.19k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.19k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.19k| } else { \ | | | | 70| 5.19k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.19k| } \ | | | | 72| 5.19k| } | | ------------------ ------------------ 4049| 742|#line 221 "flex_lexer.l" 4050| 742|TOKEN(VARCHAR) ------------------ | | 2887| 742|#define TOKEN(name) { return SQL_##name; } ------------------ 4051| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4052| 3.87k|case 162: ------------------ | Branch (4052:1): [True: 3.87k, False: 4.29M] ------------------ 4053| 3.87k|YY_RULE_SETUP ------------------ | | 3147| 3.87k| YY_USER_ACTION | | ------------------ | | | | 61| 3.87k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.87k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.4k, False: 3.87k] | | | | ------------------ | | | | 64| 15.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.4k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.4k| } else { \ | | | | 70| 15.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.4k| } \ | | | | 72| 15.4k| } | | ------------------ ------------------ 4054| 3.87k|#line 222 "flex_lexer.l" 4055| 3.87k|TOKEN(VIEW) ------------------ | | 2887| 3.87k|#define TOKEN(name) { return SQL_##name; } ------------------ 4056| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4057| 2|case 163: ------------------ | Branch (4057:1): [True: 2, False: 4.29M] ------------------ 4058| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14, False: 2] | | | | ------------------ | | | | 64| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14| } else { \ | | | | 70| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| } \ | | | | 72| 14| } | | ------------------ ------------------ 4059| 2|#line 223 "flex_lexer.l" 4060| 2|TOKEN(VIRTUAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4061| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4062| 3.43k|case 164: ------------------ | Branch (4062:1): [True: 3.43k, False: 4.29M] ------------------ 4063| 3.43k|YY_RULE_SETUP ------------------ | | 3147| 3.43k| YY_USER_ACTION | | ------------------ | | | | 61| 3.43k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.43k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 17.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.7k, False: 3.43k] | | | | ------------------ | | | | 64| 13.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.7k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.7k| } else { \ | | | | 70| 13.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.7k| } \ | | | | 72| 13.7k| } | | ------------------ ------------------ 4064| 3.43k|#line 224 "flex_lexer.l" 4065| 3.43k|TOKEN(WHEN) ------------------ | | 2887| 3.43k|#define TOKEN(name) { return SQL_##name; } ------------------ 4066| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4067| 1.93k|case 165: ------------------ | Branch (4067:1): [True: 1.93k, False: 4.29M] ------------------ 4068| 1.93k|YY_RULE_SETUP ------------------ | | 3147| 1.93k| YY_USER_ACTION | | ------------------ | | | | 61| 1.93k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.93k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.69k, False: 1.93k] | | | | ------------------ | | | | 64| 9.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.69k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9.69k| } else { \ | | | | 70| 9.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.69k| } \ | | | | 72| 9.69k| } | | ------------------ ------------------ 4069| 1.93k|#line 225 "flex_lexer.l" 4070| 1.93k|TOKEN(WHERE) ------------------ | | 2887| 1.93k|#define TOKEN(name) { return SQL_##name; } ------------------ 4071| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4072| 2.07k|case 166: ------------------ | Branch (4072:1): [True: 2.07k, False: 4.29M] ------------------ 4073| 2.07k|YY_RULE_SETUP ------------------ | | 3147| 2.07k| YY_USER_ACTION | | ------------------ | | | | 61| 2.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.30k, False: 2.07k] | | | | ------------------ | | | | 64| 8.30k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.30k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.30k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.30k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.30k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.30k| } else { \ | | | | 70| 8.30k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.30k| } \ | | | | 72| 8.30k| } | | ------------------ ------------------ 4074| 2.07k|#line 226 "flex_lexer.l" 4075| 2.07k|TOKEN(WITH) ------------------ | | 2887| 2.07k|#define TOKEN(name) { return SQL_##name; } ------------------ 4076| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4077| 520|case 167: ------------------ | Branch (4077:1): [True: 520, False: 4.29M] ------------------ 4078| 520|YY_RULE_SETUP ------------------ | | 3147| 520| YY_USER_ACTION | | ------------------ | | | | 61| 520| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 520| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 520| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 520| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 520| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 520| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.08k, False: 520] | | | | ------------------ | | | | 64| 2.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.08k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.08k| } else { \ | | | | 70| 2.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.08k| } \ | | | | 72| 2.08k| } | | ------------------ ------------------ 4079| 520|#line 227 "flex_lexer.l" 4080| 520|TOKEN(YEAR) ------------------ | | 2887| 520|#define TOKEN(name) { return SQL_##name; } ------------------ 4081| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4082| 673|case 168: ------------------ | Branch (4082:1): [True: 673, False: 4.29M] ------------------ 4083| 673|YY_RULE_SETUP ------------------ | | 3147| 673| YY_USER_ACTION | | ------------------ | | | | 61| 673| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 673| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 673| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 673| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 673| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 673| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.36k, False: 673] | | | | ------------------ | | | | 64| 3.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.36k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.36k| } else { \ | | | | 70| 3.36k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.36k| } \ | | | | 72| 3.36k| } | | ------------------ ------------------ 4084| 673|#line 228 "flex_lexer.l" 4085| 673|TOKEN(YEARS) ------------------ | | 2887| 673|#define TOKEN(name) { return SQL_##name; } ------------------ 4086| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4087| 0|case 169: ------------------ | Branch (4087:1): [True: 0, False: 4.29M] ------------------ 4088| |/* rule 169 can match eol */ 4089| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 4090| 0|#line 230 "flex_lexer.l" 4091| 0|TOKEN(CURRENT_ROW) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4092| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4093| 0|case 170: ------------------ | Branch (4093:1): [True: 0, False: 4.29M] ------------------ 4094| |/* rule 170 can match eol */ 4095| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 4096| 0|#line 231 "flex_lexer.l" 4097| 0|TOKEN(CHARACTER_VARYING) ------------------ | | 2887| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4098| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4099| |/* Allow =/== see https://sqlite.org/lang_expr.html#collateop */ 4100| 547|case 171: ------------------ | Branch (4100:1): [True: 547, False: 4.29M] ------------------ 4101| 547|YY_RULE_SETUP ------------------ | | 3147| 547| YY_USER_ACTION | | ------------------ | | | | 61| 547| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 547| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 547| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 547| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 547| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 547| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.64k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.09k, False: 547] | | | | ------------------ | | | | 64| 1.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.09k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.09k| } else { \ | | | | 70| 1.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.09k| } \ | | | | 72| 1.09k| } | | ------------------ ------------------ 4102| 547|#line 234 "flex_lexer.l" 4103| 547|TOKEN(EQUALS) ------------------ | | 2887| 547|#define TOKEN(name) { return SQL_##name; } ------------------ 4104| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4105| 1.10k|case 172: ------------------ | Branch (4105:1): [True: 1.10k, False: 4.29M] ------------------ 4106| 1.10k|YY_RULE_SETUP ------------------ | | 3147| 1.10k| YY_USER_ACTION | | ------------------ | | | | 61| 1.10k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.10k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.31k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.21k, False: 1.10k] | | | | ------------------ | | | | 64| 2.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.21k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.21k| } else { \ | | | | 70| 2.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.21k| } \ | | | | 72| 2.21k| } | | ------------------ ------------------ 4107| 1.10k|#line 235 "flex_lexer.l" 4108| 1.10k|TOKEN(NOTEQUALS) ------------------ | | 2887| 1.10k|#define TOKEN(name) { return SQL_##name; } ------------------ 4109| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4110| 491|case 173: ------------------ | Branch (4110:1): [True: 491, False: 4.29M] ------------------ 4111| 491|YY_RULE_SETUP ------------------ | | 3147| 491| YY_USER_ACTION | | ------------------ | | | | 61| 491| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 491| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 491| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 491| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 491| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 491| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.47k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 982, False: 491] | | | | ------------------ | | | | 64| 982| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 982| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 982| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 982| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 982| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 982|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 982] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 982| } else { \ | | | | 70| 982| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 982| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 982| } \ | | | | 72| 982| } | | ------------------ ------------------ 4112| 491|#line 236 "flex_lexer.l" 4113| 491|TOKEN(NOTEQUALS) ------------------ | | 2887| 491|#define TOKEN(name) { return SQL_##name; } ------------------ 4114| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4115| 526|case 174: ------------------ | Branch (4115:1): [True: 526, False: 4.29M] ------------------ 4116| 526|YY_RULE_SETUP ------------------ | | 3147| 526| YY_USER_ACTION | | ------------------ | | | | 61| 526| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 526| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.57k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.05k, False: 526] | | | | ------------------ | | | | 64| 1.05k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.05k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.05k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.05k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.05k| } else { \ | | | | 70| 1.05k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.05k| } \ | | | | 72| 1.05k| } | | ------------------ ------------------ 4117| 526|#line 237 "flex_lexer.l" 4118| 526|TOKEN(LESSEQ) ------------------ | | 2887| 526|#define TOKEN(name) { return SQL_##name; } ------------------ 4119| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4120| 740|case 175: ------------------ | Branch (4120:1): [True: 740, False: 4.29M] ------------------ 4121| 740|YY_RULE_SETUP ------------------ | | 3147| 740| YY_USER_ACTION | | ------------------ | | | | 61| 740| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 740| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.48k, False: 740] | | | | ------------------ | | | | 64| 1.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.48k| } else { \ | | | | 70| 1.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.48k| } \ | | | | 72| 1.48k| } | | ------------------ ------------------ 4122| 740|#line 238 "flex_lexer.l" 4123| 740|TOKEN(GREATEREQ) ------------------ | | 2887| 740|#define TOKEN(name) { return SQL_##name; } ------------------ 4124| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4125| 2.53k|case 176: ------------------ | Branch (4125:1): [True: 2.53k, False: 4.29M] ------------------ 4126| 2.53k|YY_RULE_SETUP ------------------ | | 3147| 2.53k| YY_USER_ACTION | | ------------------ | | | | 61| 2.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.61k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.07k, False: 2.53k] | | | | ------------------ | | | | 64| 5.07k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.07k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.07k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.07k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.07k| } else { \ | | | | 70| 5.07k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.07k| } \ | | | | 72| 5.07k| } | | ------------------ ------------------ 4127| 2.53k|#line 239 "flex_lexer.l" 4128| 2.53k|TOKEN(CONCAT) ------------------ | | 2887| 2.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 4129| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4130| 2.70M|case 177: ------------------ | Branch (4130:1): [True: 2.70M, False: 1.59M] ------------------ 4131| 2.70M|YY_RULE_SETUP ------------------ | | 3147| 2.70M| YY_USER_ACTION | | ------------------ | | | | 61| 2.70M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.70M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.40M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.40M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.70M, False: 2.70M] | | | | ------------------ | | | | 64| 2.70M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.70M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.70M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.70M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.70M] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.70M| } else { \ | | | | 70| 2.70M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.70M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.70M| } \ | | | | 72| 2.70M| } | | ------------------ ------------------ 4132| 2.70M|#line 241 "flex_lexer.l" 4133| 2.70M|{ return yytext[0]; } ------------------ | | 122| 2.70M|#define yytext yyg->yytext_r ------------------ 4134| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4135| 235|case 178: ------------------ | Branch (4135:1): [True: 235, False: 4.29M] ------------------ 4136| 235|#line 244 "flex_lexer.l" 4137| 1.15k|case 179: ------------------ | Branch (4137:1): [True: 923, False: 4.29M] ------------------ 4138| 1.15k|YY_RULE_SETUP ------------------ | | 3147| 1.15k| YY_USER_ACTION | | ------------------ | | | | 61| 1.15k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.15k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.01k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.85k, False: 1.15k] | | | | ------------------ | | | | 64| 6.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.85k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.85k| } else { \ | | | | 70| 6.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.85k| } \ | | | | 72| 6.85k| } | | ------------------ ------------------ 4139| 1.15k|#line 244 "flex_lexer.l" 4140| 1.15k|{ 4141| 1.15k| yylval->fval = atof(yytext); ------------------ | | 2964| 1.15k| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 122| 1.15k|#define yytext yyg->yytext_r ------------------ 4142| 1.15k| return SQL_FLOATVAL; 4143| 235|} 4144| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4145| |/* 4146| | * Regularly, negative literals are treated as . This does not work for LLONG_MIN, as it has no 4147| | * positive equivalent. We thus match for LLONG_MIN specifically. This is not an issue for floats, where 4148| | * numeric_limits::lowest() == -numeric_limits::max(); 4149| | */ 4150| 526|case 180: ------------------ | Branch (4150:1): [True: 526, False: 4.29M] ------------------ 4151| 526|YY_RULE_SETUP ------------------ | | 3147| 526| YY_USER_ACTION | | ------------------ | | | | 61| 526| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 526| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 526| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.5k, False: 526] | | | | ------------------ | | | | 64| 10.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.5k| } else { \ | | | | 70| 10.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.5k| } \ | | | | 72| 10.5k| } | | ------------------ ------------------ 4152| 526|#line 254 "flex_lexer.l" 4153| 526|{ 4154| 526| yylval->ival = LLONG_MIN; ------------------ | | 2964| 526| # define yylval yyg->yylval_r ------------------ 4155| 526| return SQL_INTVAL; 4156| 235|} 4157| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4158| 25.5k|case 181: ------------------ | Branch (4158:1): [True: 25.5k, False: 4.27M] ------------------ 4159| 25.5k|YY_RULE_SETUP ------------------ | | 3147| 25.5k| YY_USER_ACTION | | ------------------ | | | | 61| 25.5k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 25.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 25.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 25.5k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 25.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 25.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 61.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 61.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 35.9k, False: 25.5k] | | | | ------------------ | | | | 64| 35.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 35.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 35.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 35.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 35.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 35.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 35.9k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 35.9k| } else { \ | | | | 70| 35.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 35.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 35.9k| } \ | | | | 72| 35.9k| } | | ------------------ ------------------ 4160| 25.5k|#line 259 "flex_lexer.l" 4161| 25.5k|{ 4162| 25.5k| errno = 0; 4163| 25.5k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 2964| 25.5k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 122| 25.5k|#define yytext yyg->yytext_r ------------------ 4164| 25.5k| if (errno) { ------------------ | Branch (4164:7): [True: 6, False: 25.5k] ------------------ 4165| 6| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4166| 0| return 0; 4167| 6| } 4168| 25.5k| return SQL_INTVAL; 4169| 25.5k|} 4170| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4171| 1.54k|case 182: ------------------ | Branch (4171:1): [True: 1.54k, False: 4.29M] ------------------ 4172| 1.54k|YY_RULE_SETUP ------------------ | | 3147| 1.54k| YY_USER_ACTION | | ------------------ | | | | 61| 1.54k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.54k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.99k, False: 1.54k] | | | | ------------------ | | | | 64| 5.99k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.99k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.99k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.99k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.99k| } else { \ | | | | 70| 5.99k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.99k| } \ | | | | 72| 5.99k| } | | ------------------ ------------------ 4173| 1.54k|#line 269 "flex_lexer.l" 4174| 1.54k|{ 4175| | // Crop the leading and trailing quote char 4176| 1.54k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 2964| 1.54k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.54k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.54k|#define yytext yyg->yytext_r ------------------ 4177| 1.54k| return SQL_IDENTIFIER; 4178| 25.5k|} 4179| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4180| 478k|case 183: ------------------ | Branch (4180:1): [True: 478k, False: 3.82M] ------------------ 4181| 478k|YY_RULE_SETUP ------------------ | | 3147| 478k| YY_USER_ACTION | | ------------------ | | | | 61| 478k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 478k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 478k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 478k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 478k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 478k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.71M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.71M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.24M, False: 478k] | | | | ------------------ | | | | 64| 5.24M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.24M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.24M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.24M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.24M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.24M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.24M] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.24M| } else { \ | | | | 70| 5.24M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.24M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.24M| } \ | | | | 72| 5.24M| } | | ------------------ ------------------ 4182| 478k|#line 275 "flex_lexer.l" 4183| 478k|{ 4184| 478k| yylval->sval = strdup(yytext); ------------------ | | 2964| 478k| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 122| 478k|#define yytext yyg->yytext_r ------------------ 4185| 478k| return SQL_IDENTIFIER; 4186| 25.5k|} 4187| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4188| 28.4k|case 184: ------------------ | Branch (4188:1): [True: 28.4k, False: 4.27M] ------------------ 4189| 28.4k|YY_RULE_SETUP ------------------ | | 3147| 28.4k| YY_USER_ACTION | | ------------------ | | | | 61| 28.4k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 28.4k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 56.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 56.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 28.4k, False: 28.4k] | | | | ------------------ | | | | 64| 28.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 28.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 28.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 28.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 28.4k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 28.4k| } else { \ | | | | 70| 28.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 28.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 28.4k| } \ | | | | 72| 28.4k| } | | ------------------ ------------------ 4190| 28.4k|#line 280 "flex_lexer.l" 4191| 28.4k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 131| 28.4k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 2907| 28.4k|#define singlequotedstring 1 ------------------ 4192| 28.4k| YY_BREAK ------------------ | | 3143| 28.4k|#define YY_BREAK /*LINTED*/break; ------------------ 4193| 1.64k|case 185: ------------------ | Branch (4193:1): [True: 1.64k, False: 4.29M] ------------------ 4194| 1.64k|YY_RULE_SETUP ------------------ | | 3147| 1.64k| YY_USER_ACTION | | ------------------ | | | | 61| 1.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.28k, False: 1.64k] | | | | ------------------ | | | | 64| 3.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.28k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.28k| } else { \ | | | | 70| 3.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.28k| } \ | | | | 72| 3.28k| } | | ------------------ ------------------ 4195| 1.64k|#line 281 "flex_lexer.l" 4196| 1.64k|{ strbuf << '\''; } 4197| 1.64k| YY_BREAK ------------------ | | 3143| 1.64k|#define YY_BREAK /*LINTED*/break; ------------------ 4198| 17.0k|case 186: ------------------ | Branch (4198:1): [True: 17.0k, False: 4.28M] ------------------ 4199| |/* rule 186 can match eol */ 4200| 17.0k|YY_RULE_SETUP ------------------ | | 3147| 17.0k| YY_USER_ACTION | | ------------------ | | | | 61| 17.0k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 17.0k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 17.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.58M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.58M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.57M, False: 17.0k] | | | | ------------------ | | | | 64| 3.57M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.57M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.57M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.57M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.57M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.57M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 7.09k, False: 3.56M] | | | | ------------------ | | | | 67| 7.09k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 7.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.09k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 7.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.56M| } else { \ | | | | 70| 3.56M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.56M| } \ | | | | 72| 3.57M| } | | ------------------ ------------------ 4201| 17.0k|#line 282 "flex_lexer.l" 4202| 17.0k|{ strbuf << yytext; } ------------------ | | 122| 17.0k|#define yytext yyg->yytext_r ------------------ 4203| 17.0k| YY_BREAK ------------------ | | 3143| 17.0k|#define YY_BREAK /*LINTED*/break; ------------------ 4204| 28.3k|case 187: ------------------ | Branch (4204:1): [True: 28.3k, False: 4.27M] ------------------ 4205| 28.3k|YY_RULE_SETUP ------------------ | | 3147| 28.3k| YY_USER_ACTION | | ------------------ | | | | 61| 28.3k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 28.3k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 56.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 56.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 28.3k, False: 28.3k] | | | | ------------------ | | | | 64| 28.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 28.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 28.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 28.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 28.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 28.3k| } else { \ | | | | 70| 28.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 28.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 28.3k| } \ | | | | 72| 28.3k| } | | ------------------ ------------------ 4206| 28.3k|#line 283 "flex_lexer.l" 4207| 28.3k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 131| 28.3k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 2964| 28.3k| # define yylval yyg->yylval_r ------------------ 4208| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4209| 113|case YY_STATE_EOF(singlequotedstring): ------------------ | | 141| 113|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 113|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4209:1): [True: 113, False: 4.29M] ------------------ 4210| 113|#line 284 "flex_lexer.l" 4211| 113|{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } 4212| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4213| 165|case 188: ------------------ | Branch (4213:1): [True: 165, False: 4.29M] ------------------ 4214| 165|YY_RULE_SETUP ------------------ | | 3147| 165| YY_USER_ACTION | | ------------------ | | | | 61| 165| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 165| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 330| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 330|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 165, False: 165] | | | | ------------------ | | | | 64| 165| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 165| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 165| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 165|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 165] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 165| } else { \ | | | | 70| 165| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 165| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 165| } \ | | | | 72| 165| } | | ------------------ ------------------ 4215| 165|#line 286 "flex_lexer.l" 4216| 165|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 122| 165|#define yytext yyg->yytext_r ------------------ 4217| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4218| 0|case 189: ------------------ | Branch (4218:1): [True: 0, False: 4.29M] ------------------ 4219| 0|YY_RULE_SETUP ------------------ | | 3147| 0| YY_USER_ACTION | | ------------------ | | | | 61| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 0, False: 0] | | | | ------------------ | | | | 64| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 0] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 0| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 0| } | | ------------------ ------------------ 4220| 0|#line 288 "flex_lexer.l" 4221| 0|ECHO; ------------------ | | 3062| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 122| 0|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 121| 0|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 119| 0|#define yyout yyg->yyout_r | | ------------------ | | | Branch (3062:23): [True: 0, False: 0] | | | Branch (3062:80): [Folded, False: 0] | | ------------------ ------------------ 4222| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4223| 0|#line 4224 "flex_lexer.cpp" 4224| 2.93k|case YY_STATE_EOF(INITIAL): ------------------ | | 141| 2.93k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.93k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4224:1): [True: 2.93k, False: 4.29M] ------------------ 4225| 2.99k|case YY_STATE_EOF(COMMENT): ------------------ | | 141| 2.99k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.99k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4225:1): [True: 58, False: 4.29M] ------------------ 4226| 2.99k| yyterminate(); ------------------ | | 3106| 2.99k|#define yyterminate() return YY_NULL | | ------------------ | | | | 101| 2.99k|#define YY_NULL 0 | | ------------------ ------------------ 4227| | 4228| 7.83k| case YY_END_OF_BUFFER: ------------------ | | 351| 7.83k|#define YY_END_OF_BUFFER 190 ------------------ | Branch (4228:2): [True: 7.83k, False: 4.29M] ------------------ 4229| 7.83k| { 4230| | /* Amount of text matched not including the EOB char. */ 4231| 7.83k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 333| 7.83k|#define yytext_ptr yytext_r ------------------ 4232| | 4233| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4234| 7.83k| *yy_cp = yyg->yy_hold_char; 4235| 7.83k| YY_RESTORE_YY_MORE_OFFSET 4236| | 4237| 7.83k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 276| 7.83k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 246| 7.83k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4237:8): [True: 4.72k, False: 3.11k] ------------------ 4238| 4.72k| { 4239| | /* We're scanning a new file or input source. It's 4240| | * possible that this happened because the user 4241| | * just pointed yyin at a new source and called 4242| | * hsql_lex(). If so, then we have to assure 4243| | * consistency between YY_CURRENT_BUFFER and our 4244| | * globals. Here is the right place to do so, because 4245| | * this is the first action (other than possibly a 4246| | * back-up) that will match for the new input source. 4247| | */ 4248| 4.72k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 4.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4249| 4.72k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 276| 4.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 118| 4.72k|#define yyin yyg->yyin_r ------------------ 4250| 4.72k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 276| 4.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 247| 4.72k|#define YY_BUFFER_NORMAL 1 ------------------ 4251| 4.72k| } 4252| | 4253| | /* Note that here we test for yy_c_buf_p "<=" to the position 4254| | * of the first EOB in the buffer, since yy_c_buf_p will 4255| | * already have been incremented past the NUL character 4256| | * (since all states make transitions on EOB to the 4257| | * end-of-buffer state). Contrast this with the test 4258| | * in input(). 4259| | */ 4260| 7.83k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 276| 7.83k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4260:8): [True: 0, False: 7.83k] ------------------ 4261| 0| { /* This was really a NUL. */ 4262| 0| yy_state_type yy_next_state; 4263| | 4264| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ 4265| | 4266| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4267| | 4268| | /* Okay, we're now positioned to make the NUL 4269| | * transition. We couldn't have 4270| | * yy_get_previous_state() go ahead and do it 4271| | * for us because it doesn't know how to deal 4272| | * with the possibility of jamming (and we don't 4273| | * want to build jamming into it because then it 4274| | * will run more slowly). 4275| | */ 4276| | 4277| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 4278| | 4279| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 0|#define YY_MORE_ADJ 0 ------------------ 4280| | 4281| 0| if ( yy_next_state ) ------------------ | Branch (4281:9): [True: 0, False: 0] ------------------ 4282| 0| { 4283| | /* Consume the NUL. */ 4284| 0| yy_cp = ++yyg->yy_c_buf_p; 4285| 0| yy_current_state = yy_next_state; 4286| 0| goto yy_match; 4287| 0| } 4288| | 4289| 0| else 4290| 0| { 4291| 0| yy_cp = yyg->yy_last_accepting_cpos; 4292| 0| yy_current_state = yyg->yy_last_accepting_state; 4293| 0| goto yy_find_action; 4294| 0| } 4295| 0| } 4296| | 4297| 7.83k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4297:17): [True: 7.83k, False: 0] ------------------ 4298| 7.83k| { 4299| 3.10k| case EOB_ACT_END_OF_FILE: ------------------ | | 176| 3.10k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4299:4): [True: 3.10k, False: 4.73k] ------------------ 4300| 3.10k| { 4301| 3.10k| yyg->yy_did_buffer_switch_on_eof = 0; 4302| | 4303| 3.10k| if ( hsql_wrap(yyscanner ) ) ------------------ | | 326| 3.10k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | ------------------ | | | Branch (326:30): [True: 3.10k, Folded] | | ------------------ ------------------ 4304| 3.10k| { 4305| | /* Note: because we've taken care in 4306| | * yy_get_next_buffer() to have set up 4307| | * yytext, we can now set up 4308| | * yy_c_buf_p so that if some total 4309| | * hoser (like flex itself) wants to 4310| | * call the scanner after we return the 4311| | * YY_NULL, it'll still work - another 4312| | * YY_NULL will get returned. 4313| | */ 4314| 3.10k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 3.10k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 3.10k|#define YY_MORE_ADJ 0 ------------------ 4315| | 4316| 3.10k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 141| 3.10k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.10k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ 4317| 3.10k| goto do_action; 4318| 3.10k| } 4319| | 4320| 0| else 4321| 0| { 4322| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (4322:11): [True: 0, False: 0] ------------------ 4323| 0| YY_NEW_FILE; ------------------ | | 144| 0|#define YY_NEW_FILE hsql_restart(yyin ,yyscanner ) | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 4324| 0| } 4325| 0| break; 4326| 3.10k| } 4327| | 4328| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 175| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4328:4): [True: 0, False: 7.83k] ------------------ 4329| 0| yyg->yy_c_buf_p = 4330| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ 4331| | 4332| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4333| | 4334| 0| yy_cp = yyg->yy_c_buf_p; 4335| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 0|#define YY_MORE_ADJ 0 ------------------ 4336| 0| goto yy_match; 4337| | 4338| 4.73k| case EOB_ACT_LAST_MATCH: ------------------ | | 177| 4.73k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4338:4): [True: 4.73k, False: 3.10k] ------------------ 4339| 4.73k| yyg->yy_c_buf_p = 4340| 4.73k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 276| 4.73k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4341| | 4342| 4.73k| yy_current_state = yy_get_previous_state( yyscanner ); 4343| | 4344| 4.73k| yy_cp = yyg->yy_c_buf_p; 4345| 4.73k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 4.73k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 4.73k|#define YY_MORE_ADJ 0 ------------------ 4346| 4.73k| goto yy_find_action; 4347| 7.83k| } 4348| 0| break; 4349| 7.83k| } 4350| | 4351| 0| default: ------------------ | Branch (4351:2): [True: 0, False: 4.29M] ------------------ 4352| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4353| 4.29M| "fatal flex scanner internal error--no action found" ); 4354| 4.29M| } /* end of action switch */ 4355| 4.29M| } /* end of scanning one token */ 4356| 3.77M| } /* end of user's declarations */ 4357| 3.77M|} /* end of hsql_lex */ _Z22hsql__switch_to_bufferP15yy_buffer_statePv: 4662| 5.50k|{ 4663| 5.50k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4664| | 4665| | /* TODO. We should be able to replace this entire function body 4666| | * with 4667| | * hsql_pop_buffer_state(); 4668| | * hsql_push_buffer_state(new_buffer); 4669| | */ 4670| 5.50k| hsql_ensure_buffer_stack (yyscanner); 4671| 5.50k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 269| 5.50k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.50k, False: 0] | | ------------------ | | 270| 5.50k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.50k| : NULL) ------------------ | Branch (4671:7): [True: 0, False: 5.50k] ------------------ 4672| 0| return; 4673| | 4674| 5.50k| if ( YY_CURRENT_BUFFER ) ------------------ | | 269| 5.50k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 5.50k] | | | Branch (269:29): [True: 5.50k, False: 0] | | ------------------ | | 270| 5.50k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.50k| : NULL) ------------------ 4675| 0| { 4676| | /* Flush out information for old buffer. */ 4677| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 4678| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4679| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4680| 0| } 4681| | 4682| 5.50k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 276| 5.50k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4683| 5.50k| hsql__load_buffer_state(yyscanner ); 4684| | 4685| | /* We don't actually know whether we did this switch during 4686| | * EOF (hsql_wrap()) processing, but the only time this flag 4687| | * is looked at is after hsql_wrap() is called, so it's safe 4688| | * to go ahead and always set it. 4689| | */ 4690| 5.50k| yyg->yy_did_buffer_switch_on_eof = 1; 4691| 5.50k|} _Z19hsql__delete_bufferP15yy_buffer_statePv: 4737| 5.50k|{ 4738| 5.50k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4739| | 4740| 5.50k| if ( ! b ) ------------------ | Branch (4740:7): [True: 0, False: 5.50k] ------------------ 4741| 0| return; 4742| | 4743| 5.50k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 269| 5.50k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.50k, False: 0] | | ------------------ | | 270| 5.50k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.50k| : NULL) ------------------ | Branch (4743:7): [True: 5.50k, False: 0] ------------------ 4744| 5.50k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 276| 5.50k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4745| | 4746| 5.50k| if ( b->yy_is_our_buffer ) ------------------ | Branch (4746:7): [True: 5.50k, False: 0] ------------------ 4747| 5.50k| hsql_free((void *) b->yy_ch_buf ,yyscanner ); 4748| | 4749| 5.50k| hsql_free((void *) b ,yyscanner ); 4750| 5.50k|} _Z17hsql__scan_bufferPcmPv: 4917| 5.50k|{ 4918| 5.50k| YY_BUFFER_STATE b; 4919| | 4920| 5.50k| if ( size < 2 || ------------------ | Branch (4920:7): [True: 0, False: 5.50k] ------------------ 4921| 5.50k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 146| 11.0k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4921:7): [True: 0, False: 5.50k] ------------------ 4922| 5.50k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 146| 5.50k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4922:7): [True: 0, False: 5.50k] ------------------ 4923| | /* They forgot to leave room for the EOB's. */ 4924| 0| return NULL; 4925| | 4926| 5.50k| b = (YY_BUFFER_STATE) hsql_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 4927| 5.50k| if ( ! b ) ------------------ | Branch (4927:7): [True: 0, False: 5.50k] ------------------ 4928| 0| YY_FATAL_ERROR( "out of dynamic memory in hsql__scan_buffer()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4929| | 4930| 5.50k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 4931| 5.50k| b->yy_buf_pos = b->yy_ch_buf = base; 4932| 5.50k| b->yy_is_our_buffer = 0; 4933| 5.50k| b->yy_input_file = NULL; 4934| 5.50k| b->yy_n_chars = b->yy_buf_size; 4935| 5.50k| b->yy_is_interactive = 0; 4936| 5.50k| b->yy_at_bol = 1; 4937| 5.50k| b->yy_fill_buffer = 0; 4938| 5.50k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 246| 5.50k|#define YY_BUFFER_NEW 0 ------------------ 4939| | 4940| 5.50k| hsql__switch_to_buffer(b ,yyscanner ); 4941| | 4942| 5.50k| return b; 4943| 5.50k|} _Z17hsql__scan_stringPKcPv: 4954| 5.50k|{ 4955| | 4956| 5.50k| return hsql__scan_bytes(yystr,(int) strlen(yystr) ,yyscanner); 4957| 5.50k|} _Z16hsql__scan_bytesPKciPv: 4967| 5.50k|{ 4968| 5.50k| YY_BUFFER_STATE b; 4969| 5.50k| char *buf; 4970| 5.50k| yy_size_t n; 4971| 5.50k| int i; 4972| | 4973| | /* Get memory for full buffer, including space for trailing EOB's. */ 4974| 5.50k| n = (yy_size_t) (_yybytes_len + 2); 4975| 5.50k| buf = (char *) hsql_alloc(n ,yyscanner ); 4976| 5.50k| if ( ! buf ) ------------------ | Branch (4976:7): [True: 0, False: 5.50k] ------------------ 4977| 0| YY_FATAL_ERROR( "out of dynamic memory in hsql__scan_bytes()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4978| | 4979| 24.6M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (4979:15): [True: 24.6M, False: 5.50k] ------------------ 4980| 24.6M| buf[i] = yybytes[i]; 4981| | 4982| 5.50k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 5.50k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4983| | 4984| 5.50k| b = hsql__scan_buffer(buf,n ,yyscanner); 4985| 5.50k| if ( ! b ) ------------------ | Branch (4985:7): [True: 0, False: 5.50k] ------------------ 4986| 0| YY_FATAL_ERROR( "bad buffer in hsql__scan_bytes()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4987| | 4988| | /* It's okay to grow etc. this buffer, and we should throw it 4989| | * away when we're done. 4990| | */ 4991| 5.50k| b->yy_is_our_buffer = 1; 4992| | 4993| 5.50k| return b; 4994| 5.50k|} _Z13hsql_lex_initPPv: 5204| 5.50k|{ 5205| 5.50k| if (ptr_yy_globals == NULL){ ------------------ | Branch (5205:9): [True: 0, False: 5.50k] ------------------ 5206| 0| errno = EINVAL; 5207| 0| return 1; 5208| 0| } 5209| | 5210| 5.50k| *ptr_yy_globals = (yyscan_t) hsql_alloc ( sizeof( struct yyguts_t ), NULL ); 5211| | 5212| 5.50k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (5212:9): [True: 0, False: 5.50k] ------------------ 5213| 0| errno = ENOMEM; 5214| 0| return 1; 5215| 0| } 5216| | 5217| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 5218| 5.50k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 5219| | 5220| 5.50k| return yy_init_globals ( *ptr_yy_globals ); 5221| 5.50k|} _Z16hsql_lex_destroyPv: 5294| 5.50k|{ 5295| 5.50k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5296| | 5297| | /* Pop the buffer stack, destroying each element. */ 5298| 5.50k| while(YY_CURRENT_BUFFER){ ------------------ | | 269| 5.50k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 5.50k] | | | Branch (269:29): [True: 5.50k, False: 0] | | ------------------ | | 270| 5.50k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.50k| : NULL) ------------------ 5299| 0| hsql__delete_buffer(YY_CURRENT_BUFFER ,yyscanner ); ------------------ | | 269| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 0, False: 0] | | ------------------ | | 270| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 0| : NULL) ------------------ 5300| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 5301| 0| hsql_pop_buffer_state(yyscanner); 5302| 0| } 5303| | 5304| | /* Destroy the stack itself. */ 5305| 5.50k| hsql_free(yyg->yy_buffer_stack ,yyscanner); 5306| 5.50k| yyg->yy_buffer_stack = NULL; 5307| | 5308| | /* Destroy the start condition stack. */ 5309| 5.50k| hsql_free(yyg->yy_start_stack ,yyscanner ); 5310| 5.50k| yyg->yy_start_stack = NULL; 5311| | 5312| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 5313| | * hsql_lex() is called, initialization will occur. */ 5314| 5.50k| yy_init_globals( yyscanner); 5315| | 5316| | /* Destroy the main struct (reentrant only). */ 5317| 5.50k| hsql_free ( yyscanner , yyscanner ); 5318| | yyscanner = NULL; 5319| 5.50k| return 0; 5320| 5.50k|} _Z10hsql_allocmPv: 5350| 22.0k|{ 5351| 22.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5352| 22.0k| (void)yyg; 5353| 22.0k| return malloc(size); 5354| 22.0k|} _Z9hsql_freePvS_: 5372| 27.5k|{ 5373| 27.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5374| 27.5k| (void)yyg; 5375| 27.5k| free( (char *) ptr ); /* see hsql_realloc() for (char *) cast */ 5376| 27.5k|} flex_lexer.cpp:_ZL18yy_get_next_bufferPv: 4367| 7.83k|{ 4368| 7.83k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4369| 7.83k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 276| 7.83k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4370| 7.83k| char *source = yyg->yytext_ptr; ------------------ | | 333| 7.83k|#define yytext_ptr yytext_r ------------------ 4371| 7.83k| yy_size_t number_to_move, i; 4372| 7.83k| int ret_val; 4373| | 4374| 7.83k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 276| 7.83k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4374:7): [True: 0, False: 7.83k] ------------------ 4375| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4376| 7.83k| "fatal flex scanner internal error--end of buffer missed" ); 4377| | 4378| 7.83k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 276| 7.83k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4378:7): [True: 7.83k, False: 0] ------------------ 4379| 7.83k| { /* Don't try to fill the buffer, so this is an EOF. */ 4380| 7.83k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 333| 7.83k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 2868| 7.83k|#define YY_MORE_ADJ 0 ------------------ | Branch (4380:8): [True: 3.10k, False: 4.73k] ------------------ 4381| 3.10k| { 4382| | /* We matched a single character, the EOB, so 4383| | * treat this as a final EOF. 4384| | */ 4385| 3.10k| return EOB_ACT_END_OF_FILE; ------------------ | | 176| 3.10k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4386| 3.10k| } 4387| | 4388| 4.73k| else 4389| 4.73k| { 4390| | /* We matched some text prior to the EOB, first 4391| | * process it. 4392| | */ 4393| 4.73k| return EOB_ACT_LAST_MATCH; ------------------ | | 177| 4.73k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4394| 4.73k| } 4395| 7.83k| } 4396| | 4397| | /* Try to read more data. */ 4398| | 4399| | /* First move last chars to start of buffer. */ 4400| 0| number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ 4401| | 4402| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (4402:15): [True: 0, False: 0] ------------------ 4403| 0| *(dest++) = *(source++); 4404| | 4405| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 258| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (4405:7): [True: 0, False: 0] ------------------ 4406| | /* don't do the read, it's not guaranteed to return an EOF, 4407| | * just force an EOF 4408| | */ 4409| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4410| | 4411| 0| else 4412| 0| { 4413| 0| int num_to_read = 4414| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4415| | 4416| 0| while ( num_to_read <= 0 ) ------------------ | Branch (4416:11): [True: 0, False: 0] ------------------ 4417| 0| { /* Not enough room in the buffer - grow it. */ 4418| | 4419| | /* just a shorter name for the current buffer */ 4420| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4421| | 4422| 0| int yy_c_buf_p_offset = 4423| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 4424| | 4425| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (4425:9): [True: 0, False: 0] ------------------ 4426| 0| { 4427| 0| int new_size = b->yy_buf_size * 2; 4428| | 4429| 0| if ( new_size <= 0 ) ------------------ | Branch (4429:10): [True: 0, False: 0] ------------------ 4430| 0| b->yy_buf_size += b->yy_buf_size / 8; 4431| 0| else 4432| 0| b->yy_buf_size *= 2; 4433| | 4434| 0| b->yy_ch_buf = (char *) 4435| | /* Include room in for 2 EOB chars. */ 4436| 0| hsql_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2) ,yyscanner ); 4437| 0| } 4438| 0| else 4439| | /* Can't grow it, we don't own it. */ 4440| 0| b->yy_ch_buf = NULL; 4441| | 4442| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (4442:9): [True: 0, False: 0] ------------------ 4443| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4444| 0| "fatal error - scanner input buffer overflow" ); 4445| | 4446| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 4447| | 4448| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4449| 0| number_to_move - 1; 4450| | 4451| 0| } 4452| | 4453| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 3053| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (4453:8): [True: 0, False: 0] ------------------ 4454| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 3053| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 4455| | 4456| | /* Read in more data. */ 4457| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 3070| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (3070:7): [True: 0, False: 0] | | ------------------ | | 3071| 0| { \ | | 3072| 0| int c = '*'; \ | | 3073| 0| int n; \ | | 3074| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (3074:16): [True: 0, False: 0] | | ------------------ | | 3075| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3075:9): [True: 0, False: 0] | | | Branch (3075:38): [True: 0, False: 0] | | ------------------ | | 3076| 0| buf[n] = (char) c; \ | | 3077| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (3077:8): [True: 0, False: 0] | | ------------------ | | 3078| 0| buf[n++] = (char) c; \ | | 3079| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3079:8): [True: 0, False: 0] | | | Branch (3079:20): [True: 0, False: 0] | | ------------------ | | 3080| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3081| 0| result = n; \ | | 3082| 0| } \ | | 3083| 0| else \ | | 3084| 0| { \ | | 3085| 0| errno=0; \ | | 3086| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3086:11): [True: 0, False: 0] | | | Branch (3086:78): [True: 0, False: 0] | | ------------------ | | 3087| 0| { \ | | 3088| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (3088:8): [True: 0, False: 0] | | ------------------ | | 3089| 0| { \ | | 3090| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3091| 0| break; \ | | 3092| 0| } \ | | 3093| 0| errno=0; \ | | 3094| 0| clearerr(yyin); \ | | ------------------ | | | | 118| 0|#define yyin yyg->yyin_r | | ------------------ | | 3095| 0| } \ | | 3096| 0| }\ ------------------ 4458| 0| yyg->yy_n_chars, num_to_read ); 4459| | 4460| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4461| 0| } 4462| | 4463| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (4463:7): [True: 0, False: 0] ------------------ 4464| 0| { 4465| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 2868| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (4465:8): [True: 0, False: 0] ------------------ 4466| 0| { 4467| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 176| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 4468| 0| hsql_restart(yyin ,yyscanner); ------------------ | | 118| 0|#define yyin yyg->yyin_r ------------------ 4469| 0| } 4470| | 4471| 0| else 4472| 0| { 4473| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 177| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 4474| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4475| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 258| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 4476| 0| } 4477| 0| } 4478| | 4479| 0| else 4480| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 175| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 4481| | 4482| 0| if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4482:6): [True: 0, False: 0] ------------------ 4483| | /* Extend the array by 50%, plus the number we really need. */ 4484| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 4485| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) hsql_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ,yyscanner ); ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) hsql_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ,yyscanner ); ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4486| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4486:8): [True: 0, False: 0] ------------------ 4487| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4488| 0| } 4489| | 4490| 0| yyg->yy_n_chars += number_to_move; 4491| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4492| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4493| | 4494| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 333| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 276| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4495| | 4496| 0| return ret_val; 4497| 0|} flex_lexer.cpp:_ZL21yy_get_previous_statePv: 4502| 4.73k|{ 4503| 4.73k| yy_state_type yy_current_state; 4504| 4.73k| char *yy_cp; 4505| 4.73k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4506| | 4507| 4.73k| yy_current_state = yyg->yy_start; 4508| | 4509| 8.36M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 333| 4.73k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 2868| 4.73k|#define YY_MORE_ADJ 0 ------------------ | Branch (4509:47): [True: 8.35M, False: 4.73k] ------------------ 4510| 8.35M| { 4511| 8.35M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 108| 8.35M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ | Branch (4511:19): [True: 8.35M, False: 0] ------------------ 4512| 8.35M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4512:8): [True: 3.04M, False: 5.31M] ------------------ 4513| 3.04M| { 4514| 3.04M| yyg->yy_last_accepting_state = yy_current_state; 4515| 3.04M| yyg->yy_last_accepting_cpos = yy_cp; 4516| 3.04M| } 4517| 16.9M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4517:11): [True: 8.56M, False: 8.35M] ------------------ 4518| 8.56M| { 4519| 8.56M| yy_current_state = (int) yy_def[yy_current_state]; 4520| 8.56M| if ( yy_current_state >= 1368 ) ------------------ | Branch (4520:9): [True: 8.34M, False: 218k] ------------------ 4521| 8.34M| yy_c = yy_meta[(unsigned int) yy_c]; 4522| 8.56M| } 4523| 8.35M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 4524| 8.35M| } 4525| | 4526| 4.73k| return yy_current_state; 4527| 4.73k|} flex_lexer.cpp:_ZL23hsql__load_buffer_statePv: 4694| 11.0k|{ 4695| 11.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4696| 11.0k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 11.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4697| 11.0k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 333| 11.0k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 276| 11.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4698| 11.0k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 118| 11.0k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 276| 11.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4699| 11.0k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 4700| 11.0k|} flex_lexer.cpp:_ZL24hsql_ensure_buffer_stackPv: 4867| 5.50k|{ 4868| 5.50k| int num_to_alloc; 4869| 5.50k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4870| | 4871| 5.50k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (4871:6): [True: 5.50k, False: 0] ------------------ 4872| | 4873| | /* First allocation is just for 2 elements, since we don't know if this 4874| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 4875| | * immediate realloc on the next call. 4876| | */ 4877| 5.50k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 4878| 5.50k| yyg->yy_buffer_stack = (struct yy_buffer_state**)hsql_alloc 4879| 5.50k| (num_to_alloc * sizeof(struct yy_buffer_state*) 4880| 5.50k| , yyscanner); 4881| 5.50k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4881:8): [True: 0, False: 5.50k] ------------------ 4882| 0| YY_FATAL_ERROR( "out of dynamic memory in hsql_ensure_buffer_stack()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4883| | 4884| 5.50k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 4885| | 4886| 5.50k| yyg->yy_buffer_stack_max = num_to_alloc; 4887| 5.50k| yyg->yy_buffer_stack_top = 0; 4888| 5.50k| return; 4889| 5.50k| } 4890| | 4891| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (4891:6): [True: 0, False: 0] ------------------ 4892| | 4893| | /* Increase the buffer to prepare for a possible push. */ 4894| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 4895| | 4896| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 4897| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)hsql_realloc 4898| 0| (yyg->yy_buffer_stack, 4899| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 4900| 0| , yyscanner); 4901| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4901:8): [True: 0, False: 0] ------------------ 4902| 0| YY_FATAL_ERROR( "out of dynamic memory in hsql_ensure_buffer_stack()" ); ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4903| | 4904| | /* zero only the new slots.*/ 4905| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 4906| 0| yyg->yy_buffer_stack_max = num_to_alloc; 4907| 0| } 4908| 0|} flex_lexer.cpp:_ZL15yy_init_globalsPv: 5260| 11.0k|{ 5261| 11.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5262| | /* Initialization is the same as for the non-reentrant scanner. 5263| | * This function is called from hsql_lex_destroy(), so don't allocate here. 5264| | */ 5265| | 5266| 11.0k| yyg->yy_buffer_stack = NULL; 5267| 11.0k| yyg->yy_buffer_stack_top = 0; 5268| 11.0k| yyg->yy_buffer_stack_max = 0; 5269| 11.0k| yyg->yy_c_buf_p = NULL; 5270| 11.0k| yyg->yy_init = 0; 5271| 11.0k| yyg->yy_start = 0; 5272| | 5273| 11.0k| yyg->yy_start_stack_ptr = 0; 5274| 11.0k| yyg->yy_start_stack_depth = 0; 5275| 11.0k| yyg->yy_start_stack = NULL; 5276| | 5277| |/* Defined in main.c */ 5278| |#ifdef YY_STDINIT 5279| | yyin = stdin; 5280| | yyout = stdout; 5281| |#else 5282| 11.0k| yyin = NULL; ------------------ | | 118| 11.0k|#define yyin yyg->yyin_r ------------------ 5283| 11.0k| yyout = NULL; ------------------ | | 119| 11.0k|#define yyout yyg->yyout_r ------------------ 5284| 11.0k|#endif 5285| | 5286| | /* For future reference: Set errno on error, since we are called by 5287| | * hsql_lex_init() 5288| | */ 5289| 11.0k| return 0; 5290| 11.0k|} _ZN4hsql15TableConstraintC2ENS_14ConstraintTypeEPNSt3__16vectorIPcNS2_9allocatorIS4_EEEE: 29| 1.77k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 31| 1.77k|TableConstraint::~TableConstraint() { 32| 2.04k| for (auto* column : *columnNames) { ------------------ | Branch (32:21): [True: 2.04k, False: 1.77k] ------------------ 33| 2.04k| free(column); 34| 2.04k| } 35| 1.77k| delete columnNames; 36| 1.77k|} _ZN4hsql17ColumnConstraintsC2Ev: 59| 20.6k| : constraints{new std::unordered_set()}, references{new std::vector} {} _ZN4hsql16ColumnDefinitionC2EPcNS_10ColumnTypeEPNSt3__113unordered_setINS_14ConstraintTypeENS3_4hashIS5_EENS3_8equal_toIS5_EENS3_9allocatorIS5_EEEEPNS3_6vectorIPNS_23ReferencesSpecificationENSA_ISG_EEEE: 64| 20.6k| : column_constraints(column_constraints), name(name), type(type), nullable(true), references(references) {} _ZN4hsql16ColumnDefinitionD2Ev: 66| 20.6k|ColumnDefinition::~ColumnDefinition() { 67| 20.6k| free(name); 68| 20.6k| delete column_constraints; 69| 20.6k| if (references) { ------------------ | Branch (69:7): [True: 20.6k, False: 0] ------------------ 70| 20.6k| for (auto* ref : *references) { ------------------ | Branch (70:20): [True: 0, False: 20.6k] ------------------ 71| 0| delete ref; 72| 0| } 73| 20.6k| } 74| 20.6k| delete references; 75| 20.6k|} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 77| 20.6k|bool ColumnDefinition::trySetNullableExplicit() { 78| 20.6k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (78:7): [True: 1.78k, False: 18.8k] | Branch (78:7): [True: 2.47k, False: 18.1k] | Branch (78:61): [True: 684, False: 18.1k] ------------------ 79| 2.47k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (79:9): [True: 1.51k, False: 959] ------------------ 80| 1.51k| return false; 81| 1.51k| } 82| 959| nullable = false; 83| 959| } 84| | 85| 19.0k| return true; 86| 20.6k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 90| 8.05k| : SQLStatement(kStmtCreate), 91| 8.05k| type(type), 92| 8.05k| ifNotExists(false), 93| 8.05k| filePath(nullptr), 94| 8.05k| schema(nullptr), 95| 8.05k| tableName(nullptr), 96| 8.05k| indexName(nullptr), 97| 8.05k| indexColumns(nullptr), 98| 8.05k| columns(nullptr), 99| 8.05k| tableConstraints(nullptr), 100| 8.05k| viewColumns(nullptr), 101| 8.05k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 103| 8.05k|CreateStatement::~CreateStatement() { 104| 8.05k| free(filePath); 105| 8.05k| free(schema); 106| 8.05k| free(tableName); 107| 8.05k| free(indexName); 108| 8.05k| delete select; 109| | 110| 8.05k| if (columns) { ------------------ | Branch (110:7): [True: 4.56k, False: 3.48k] ------------------ 111| 5.26k| for (auto* def : *columns) { ------------------ | Branch (111:20): [True: 5.26k, False: 4.56k] ------------------ 112| 5.26k| delete def; 113| 5.26k| } 114| 4.56k| delete columns; 115| 4.56k| } 116| | 117| 8.05k| if (tableConstraints) { ------------------ | Branch (117:7): [True: 4.56k, False: 3.48k] ------------------ 118| 4.56k| for (auto* def : *tableConstraints) { ------------------ | Branch (118:20): [True: 1.50k, False: 4.56k] ------------------ 119| 1.50k| delete def; 120| 1.50k| } 121| 4.56k| delete tableConstraints; 122| 4.56k| } 123| | 124| 8.05k| if (indexColumns) { ------------------ | Branch (124:7): [True: 1.16k, False: 6.88k] ------------------ 125| 9.59k| for (char* column : *indexColumns) { ------------------ | Branch (125:23): [True: 9.59k, False: 1.16k] ------------------ 126| 9.59k| free(column); 127| 9.59k| } 128| 1.16k| delete indexColumns; 129| 1.16k| } 130| | 131| 8.05k| if (viewColumns) { ------------------ | Branch (131:7): [True: 980, False: 7.07k] ------------------ 132| 1.17k| for (char* column : *viewColumns) { ------------------ | Branch (132:23): [True: 1.17k, False: 980] ------------------ 133| 1.17k| free(column); 134| 1.17k| } 135| 980| delete viewColumns; 136| 980| } 137| 8.05k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 139| 4.56k|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 140| 4.56k| columns = new std::vector(); 141| 4.56k| tableConstraints = new std::vector(); 142| | 143| 6.76k| for (auto tableElem : *tableElements) { ------------------ | Branch (143:23): [True: 6.76k, False: 4.56k] ------------------ 144| 6.76k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (144:15): [True: 5.26k, False: 1.50k] ------------------ 145| 5.26k| columns->emplace_back(colDef); 146| 5.26k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (146:22): [True: 1.50k, False: 0] ------------------ 147| 1.50k| tableConstraints->emplace_back(tableConstraint); 148| 1.50k| } 149| 6.76k| } 150| 4.56k|} _ZN4hsql12TableElementD2Ev: 18| 22.3k| virtual ~TableElement() = default; _ZN4hsql10FrameBoundC2ElNS_14FrameBoundTypeEb: 12| 11.7k| : offset{offset}, type{type}, unbounded{unbounded} {} _ZN4hsql16FrameDescriptionC2ENS_9FrameTypeEPNS_10FrameBoundES3_: 15| 5.88k| : type{type}, start{start}, end{end} {} _ZN4hsql16FrameDescriptionD2Ev: 17| 5.88k|FrameDescription::~FrameDescription() { 18| 5.88k| delete start; 19| 5.88k| delete end; 20| 5.88k|} _ZN4hsql17WindowDescriptionC2EPNSt3__16vectorIPNS_4ExprENS1_9allocatorIS4_EEEEPNS2_IPNS_16OrderDescriptionENS5_ISA_EEEEPNS_16FrameDescriptionE: 24| 5.81k| : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {} _ZN4hsql17WindowDescriptionD2Ev: 26| 5.81k|WindowDescription::~WindowDescription() { 27| 5.81k| if (partitionList) { ------------------ | Branch (27:7): [True: 615, False: 5.20k] ------------------ 28| 1.09k| for (Expr* e : *partitionList) { ------------------ | Branch (28:18): [True: 1.09k, False: 615] ------------------ 29| 1.09k| delete e; 30| 1.09k| } 31| 615| delete partitionList; 32| 615| } 33| | 34| 5.81k| if (orderList) { ------------------ | Branch (34:7): [True: 983, False: 4.83k] ------------------ 35| 2.04k| for (OrderDescription* orderDescription : *orderList) { ------------------ | Branch (35:45): [True: 2.04k, False: 983] ------------------ 36| 2.04k| delete orderDescription; 37| 2.04k| } 38| 983| delete orderList; 39| 983| } 40| | 41| 5.81k| delete frameDescription; 42| 5.81k|} _ZN4hsql4ExprC2ENS_8ExprTypeE: 45| 2.42M| : type(type), 46| 2.42M| expr(nullptr), 47| 2.42M| expr2(nullptr), 48| 2.42M| exprList(nullptr), 49| 2.42M| select(nullptr), 50| 2.42M| name(nullptr), 51| 2.42M| table(nullptr), 52| 2.42M| schema(nullptr), 53| 2.42M| alias(nullptr), 54| 2.42M| fval(0), 55| 2.42M| ival(0), 56| 2.42M| ival2(0), 57| 2.42M| datetimeField(kDatetimeNone), 58| 2.42M| columnType(DataType::UNKNOWN, 0), 59| 2.42M| isBoolLiteral(false), 60| 2.42M| opType(kOpNone), 61| 2.42M| distinct(false), 62| 2.42M| windowDescription(nullptr) {} _ZN4hsql4ExprD2Ev: 64| 2.42M|Expr::~Expr() { 65| 2.42M| delete expr; 66| 2.42M| delete expr2; 67| 2.42M| delete select; 68| 2.42M| delete windowDescription; 69| | 70| 2.42M| free(name); 71| 2.42M| free(table); 72| 2.42M| free(schema); 73| 2.42M| free(alias); 74| | 75| 2.42M| if (exprList) { ------------------ | Branch (75:7): [True: 12.1k, False: 2.41M] ------------------ 76| 12.1k| for (Expr* e : *exprList) { ------------------ | Branch (76:18): [True: 11.1k, False: 12.1k] ------------------ 77| 11.1k| delete e; 78| 11.1k| } 79| 12.1k| delete exprList; 80| 12.1k| } 81| 2.42M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 83| 3.16k|Expr* Expr::make(ExprType type) { 84| 3.16k| Expr* e = new Expr(type); 85| 3.16k| return e; 86| 3.16k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 88| 12.1k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 89| 12.1k| Expr* e = new Expr(kExprOperator); 90| 12.1k| e->opType = op; 91| 12.1k| e->expr = expr; 92| 12.1k| e->expr2 = nullptr; 93| 12.1k| return e; 94| 12.1k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 96| 1.04M|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 97| 1.04M| Expr* e = new Expr(kExprOperator); 98| 1.04M| e->opType = op; 99| 1.04M| e->expr = expr1; 100| 1.04M| e->expr2 = expr2; 101| 1.04M| return e; 102| 1.04M|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 104| 487|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 105| 487| Expr* e = new Expr(kExprOperator); 106| 487| e->expr = expr; 107| 487| e->opType = kOpBetween; 108| 487| e->exprList = new std::vector(); 109| 487| e->exprList->push_back(left); 110| 487| e->exprList->push_back(right); 111| 487| return e; 112| 487|} _ZN4hsql4Expr12makeCaseListEPS0_: 114| 1.99k|Expr* Expr::makeCaseList(Expr* caseListElement) { 115| 1.99k| Expr* e = new Expr(kExprOperator); 116| | // Case list expressions are temporary and will be integrated into the case 117| | // expressions exprList - thus assign operator type kOpNone 118| 1.99k| e->opType = kOpNone; 119| 1.99k| e->exprList = new std::vector(); 120| 1.99k| e->exprList->push_back(caseListElement); 121| 1.99k| return e; 122| 1.99k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 124| 3.35k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 125| 3.35k| Expr* e = new Expr(kExprOperator); 126| 3.35k| e->opType = kOpCaseListElement; 127| 3.35k| e->expr = when; 128| 3.35k| e->expr2 = then; 129| 3.35k| return e; 130| 3.35k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 132| 1.36k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 133| 1.36k| caseList->exprList->push_back(caseListElement); 134| 1.36k| return caseList; 135| 1.36k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 137| 1.76k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 138| 1.76k| Expr* e = new Expr(kExprOperator); 139| 1.76k| e->opType = kOpCase; 140| 1.76k| e->expr = expr; 141| 1.76k| e->expr2 = elseExpr; 142| 1.76k| e->exprList = caseList->exprList; 143| 1.76k| caseList->exprList = nullptr; 144| 1.76k| delete caseList; 145| 1.76k| return e; 146| 1.76k|} _ZN4hsql4Expr11makeLiteralEl: 148| 11.6k|Expr* Expr::makeLiteral(int64_t val) { 149| 11.6k| Expr* e = new Expr(kExprLiteralInt); 150| 11.6k| e->ival = val; 151| 11.6k| return e; 152| 11.6k|} _ZN4hsql4Expr11makeLiteralEd: 154| 1.13k|Expr* Expr::makeLiteral(double value) { 155| 1.13k| Expr* e = new Expr(kExprLiteralFloat); 156| 1.13k| e->fval = value; 157| 1.13k| return e; 158| 1.13k|} _ZN4hsql4Expr11makeLiteralEPc: 160| 3.78k|Expr* Expr::makeLiteral(char* string) { 161| 3.78k| Expr* e = new Expr(kExprLiteralString); 162| 3.78k| e->name = string; 163| 3.78k| return e; 164| 3.78k|} _ZN4hsql4Expr11makeLiteralEb: 166| 1.32k|Expr* Expr::makeLiteral(bool val) { 167| 1.32k| Expr* e = new Expr(kExprLiteralInt); 168| 1.32k| e->ival = (int)val; 169| 1.32k| e->isBoolLiteral = true; 170| 1.32k| return e; 171| 1.32k|} _ZN4hsql4Expr15makeNullLiteralEv: 173| 2.30k|Expr* Expr::makeNullLiteral() { 174| 2.30k| Expr* e = new Expr(kExprLiteralNull); 175| 2.30k| return e; 176| 2.30k|} _ZN4hsql4Expr15makeDateLiteralEPc: 178| 201|Expr* Expr::makeDateLiteral(char* string) { 179| 201| Expr* e = new Expr(kExprLiteralDate); 180| 201| e->name = string; 181| 201| return e; 182| 201|} _ZN4hsql4Expr19makeIntervalLiteralElNS_13DatetimeFieldE: 184| 13.5k|Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) { 185| 13.5k| Expr* e = new Expr(kExprLiteralInterval); 186| 13.5k| e->ival = duration; 187| 13.5k| e->datetimeField = unit; 188| 13.5k| return e; 189| 13.5k|} _ZN4hsql4Expr13makeColumnRefEPc: 191| 114k|Expr* Expr::makeColumnRef(char* name) { 192| 114k| Expr* e = new Expr(kExprColumnRef); 193| 114k| e->name = name; 194| 114k| return e; 195| 114k|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 197| 976|Expr* Expr::makeColumnRef(char* table, char* name) { 198| 976| Expr* e = new Expr(kExprColumnRef); 199| 976| e->name = name; 200| 976| e->table = table; 201| 976| return e; 202| 976|} _ZN4hsql4Expr8makeStarEv: 204| 968k|Expr* Expr::makeStar(void) { 205| 968k| Expr* e = new Expr(kExprStar); 206| 968k| return e; 207| 968k|} _ZN4hsql4Expr8makeStarEPc: 209| 840|Expr* Expr::makeStar(char* table) { 210| 840| Expr* e = new Expr(kExprStar); 211| 840| e->table = table; 212| 840| return e; 213| 840|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 215| 7.83k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct, WindowDescription* window) { 216| 7.83k| Expr* e = new Expr(kExprFunctionRef); 217| 7.83k| e->name = func_name; 218| 7.83k| e->exprList = exprList; 219| 7.83k| e->distinct = distinct; 220| 7.83k| e->windowDescription = window; 221| 7.83k| return e; 222| 7.83k|} _ZN4hsql4Expr15makeFunctionRefEPcS1_PNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 224| 407|Expr* Expr::makeFunctionRef(char* func_name, char* schema, std::vector* exprList, bool distinct, WindowDescription* window) { 225| 407| Expr* e = new Expr(kExprFunctionRef); 226| 407| e->name = func_name; 227| 407| e->schema = schema; 228| 407| e->exprList = exprList; 229| 407| e->distinct = distinct; 230| 407| e->windowDescription = window; 231| 407| return e; 232| 407|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 234| 514|Expr* Expr::makeArray(std::vector* exprList) { 235| 514| Expr* e = new Expr(kExprArray); 236| 514| e->exprList = exprList; 237| 514| return e; 238| 514|} _ZN4hsql4Expr14makeArrayIndexEPS0_l: 240| 194|Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) { 241| 194| Expr* e = new Expr(kExprArrayIndex); 242| 194| e->expr = expr; 243| 194| e->ival = index; 244| 194| return e; 245| 194|} _ZN4hsql4Expr13makeParameterEi: 247| 229k|Expr* Expr::makeParameter(int id) { 248| 229k| Expr* e = new Expr(kExprParameter); 249| 229k| e->ival = id; 250| 229k| return e; 251| 229k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 253| 350|Expr* Expr::makeSelect(SelectStatement* select) { 254| 350| Expr* e = new Expr(kExprSelect); 255| 350| e->select = select; 256| 350| return e; 257| 350|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 259| 753|Expr* Expr::makeExists(SelectStatement* select) { 260| 753| Expr* e = new Expr(kExprOperator); 261| 753| e->opType = kOpExists; 262| 753| e->select = select; 263| 753| return e; 264| 753|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 266| 563|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 267| 563| Expr* e = new Expr(kExprOperator); 268| 563| e->opType = kOpIn; 269| 563| e->expr = expr; 270| 563| e->exprList = exprList; 271| | 272| 563| return e; 273| 563|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 275| 526|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 276| 526| Expr* e = new Expr(kExprOperator); 277| 526| e->opType = kOpIn; 278| 526| e->expr = expr; 279| 526| e->select = select; 280| | 281| 526| return e; 282| 526|} _ZN4hsql4Expr11makeExtractENS_13DatetimeFieldEPS0_: 284| 529|Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { 285| 529| Expr* e = new Expr(kExprExtract); 286| 529| e->datetimeField = datetimeField; 287| 529| e->expr = expr; 288| 529| return e; 289| 529|} _ZN4hsql4Expr8makeCastEPS0_NS_10ColumnTypeE: 291| 389|Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { 292| 389| Expr* e = new Expr(kExprCast); 293| 389| e->columnType = columnType; 294| 389| e->expr = expr; 295| 389| return e; 296| 389|} _ZN4hsql6substrEPKcii: 316| 1.54k|char* substr(const char* source, int from, int to) { 317| 1.54k| int len = to - from; 318| 1.54k| char* copy = (char*)malloc(len + 1); 319| 1.54k| ; 320| 1.54k| strncpy(copy, source + from, len); 321| 1.54k| copy[len] = '\0'; 322| 1.54k| return copy; 323| 1.54k|} _ZN4hsql16PrepareStatementC2Ev: 6| 1.45k|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 1.45k|PrepareStatement::~PrepareStatement() { 9| 1.45k| free(name); 10| 1.45k| free(query); 11| 1.45k|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 97.8k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 97.4k|SQLStatement::~SQLStatement() { 10| 97.4k| if (hints) { ------------------ | Branch (10:7): [True: 896, False: 96.5k] ------------------ 11| 2.33k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 2.33k, False: 896] ------------------ 12| 2.33k| delete hint; 13| 2.33k| } 14| 896| } 15| 97.4k| delete hints; 16| 97.4k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 11| 2.44M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 77| 2.05k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 79| 2.05k|DeleteStatement::~DeleteStatement() { 80| 2.05k| free(schema); 81| 2.05k| free(tableName); 82| 2.05k| delete expr; 83| 2.05k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 87| 4.07k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 89| 4.07k|DropStatement::~DropStatement() { 90| 4.07k| free(schema); 91| 4.07k| free(name); 92| 4.07k| free(indexName); 93| 4.07k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 117| 9.54k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 119| 9.54k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 122| 4.01k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 124| 4.01k|ExecuteStatement::~ExecuteStatement() { 125| 4.01k| free(name); 126| | 127| 4.01k| if (parameters) { ------------------ | Branch (127:7): [True: 264, False: 3.74k] ------------------ 128| 760| for (Expr* param : *parameters) { ------------------ | Branch (128:22): [True: 760, False: 264] ------------------ 129| 760| delete param; 130| 760| } 131| 264| delete parameters; 132| 264| } 133| 4.01k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 137| 6.95k| : SQLStatement(kStmtExport), 138| 6.95k| type(type), 139| 6.95k| filePath(nullptr), 140| 6.95k| schema(nullptr), 141| 6.95k| tableName(nullptr), 142| 6.95k| select(nullptr), 143| 6.95k| encoding(nullptr), 144| 6.95k| csv_options(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 146| 6.95k|ExportStatement::~ExportStatement() { 147| 6.95k| free(filePath); 148| 6.95k| free(schema); 149| 6.95k| free(tableName); 150| 6.95k| delete select; 151| 6.95k| free(encoding); 152| 6.95k| delete csv_options; 153| 6.95k|} _ZN4hsql10CsvOptionsC2Ev: 155| 1.62k|CsvOptions::CsvOptions() : delimiter(nullptr), null(nullptr), quote(nullptr) {} _ZN4hsql10CsvOptionsD2Ev: 156| 1.62k|CsvOptions::~CsvOptions() { 157| 1.62k| free(delimiter); 158| 1.62k| free(null); 159| 1.62k| free(quote); 160| 1.62k|} _ZN4hsql10CsvOptions17accept_csv_optionEPNSt3__14pairINS_13CsvOptionTypeEPcEE: 162| 1.84k|bool CsvOptions::accept_csv_option(std::pair* option) { 163| 1.84k| switch (option->first) { ------------------ | Branch (163:11): [True: 1.84k, False: 0] ------------------ 164| 334| case CsvOptionType::Delimiter: ------------------ | Branch (164:5): [True: 334, False: 1.50k] ------------------ 165| 334| if (delimiter != nullptr) { ------------------ | Branch (165:11): [True: 1, False: 333] ------------------ 166| 1| return false; 167| 1| } 168| 333| delimiter = option->second; 169| 333| break; 170| 1.00k| case CsvOptionType::Null: ------------------ | Branch (170:5): [True: 1.00k, False: 836] ------------------ 171| 1.00k| if (null != nullptr) { ------------------ | Branch (171:11): [True: 4, False: 1.00k] ------------------ 172| 4| return false; 173| 4| } 174| 1.00k| null = option->second; 175| 1.00k| break; 176| 502| case CsvOptionType::Quote: ------------------ | Branch (176:5): [True: 502, False: 1.33k] ------------------ 177| 502| if (quote != nullptr) { ------------------ | Branch (177:11): [True: 8, False: 494] ------------------ 178| 8| return false; 179| 8| } 180| 494| quote = option->second; 181| 494| break; 182| 1.84k| } 183| | 184| 1.82k| return true; 185| 1.84k|} _ZN4hsql19ImportExportOptionsC2Ev: 187| 14.6k|ImportExportOptions::ImportExportOptions() : format(kImportAuto), encoding(nullptr), csv_options(nullptr) {} _ZN4hsql19ImportExportOptionsD2Ev: 189| 14.6k|ImportExportOptions::~ImportExportOptions() { 190| 14.6k| free(encoding); 191| 14.6k| delete csv_options; 192| 14.6k|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 196| 7.57k| : SQLStatement(kStmtImport), 197| 7.57k| type(type), 198| 7.57k| filePath(nullptr), 199| 7.57k| schema(nullptr), 200| 7.57k| tableName(nullptr), 201| 7.57k| whereClause(nullptr), 202| 7.57k| encoding(nullptr), 203| 7.57k| csv_options(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 205| 7.57k|ImportStatement::~ImportStatement() { 206| 7.57k| free(filePath); 207| 7.57k| free(schema); 208| 7.57k| free(tableName); 209| 7.57k| delete whereClause; 210| 7.57k| free(encoding); 211| 7.57k| delete csv_options; 212| 7.57k|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 216| 3.70k| : SQLStatement(kStmtInsert), 217| 3.70k| type(type), 218| 3.70k| schema(nullptr), 219| 3.70k| tableName(nullptr), 220| 3.70k| columns(nullptr), 221| 3.70k| values(nullptr), 222| 3.70k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 224| 3.70k|InsertStatement::~InsertStatement() { 225| 3.70k| free(schema); 226| 3.70k| free(tableName); 227| 3.70k| delete select; 228| | 229| 3.70k| if (columns) { ------------------ | Branch (229:7): [True: 83, False: 3.62k] ------------------ 230| 277| for (char* column : *columns) { ------------------ | Branch (230:23): [True: 277, False: 83] ------------------ 231| 277| free(column); 232| 277| } 233| 83| delete columns; 234| 83| } 235| | 236| 3.70k| if (values) { ------------------ | Branch (236:7): [True: 584, False: 3.12k] ------------------ 237| 1.00k| for (Expr* expr : *values) { ------------------ | Branch (237:21): [True: 1.00k, False: 584] ------------------ 238| 1.00k| delete expr; 239| 1.00k| } 240| 584| delete values; 241| 584| } 242| 3.70k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 245| 7.58k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 247| 7.58k|ShowStatement::~ShowStatement() { 248| 7.58k| free(schema); 249| 7.58k| free(name); 250| 7.58k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprENS_12NullOrderingE: 256| 9.62k| : type(type), expr(expr), null_ordering(null_ordering) {} _ZN4hsql16OrderDescriptionD2Ev: 258| 9.62k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 261| 10.0k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 263| 10.0k|LimitDescription::~LimitDescription() { 264| 10.0k| delete limit; 265| 10.0k| delete offset; 266| 10.0k|} _ZN4hsql18GroupByDescriptionC2Ev: 269| 3.52k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 271| 3.52k|GroupByDescription::~GroupByDescription() { 272| 3.52k| delete having; 273| | 274| 3.52k| if (columns) { ------------------ | Branch (274:7): [True: 3.52k, False: 0] ------------------ 275| 5.96k| for (Expr* expr : *columns) { ------------------ | Branch (275:21): [True: 5.96k, False: 3.52k] ------------------ 276| 5.96k| delete expr; 277| 5.96k| } 278| 3.52k| delete columns; 279| 3.52k| } 280| 3.52k|} _ZN4hsql15WithDescriptionD2Ev: 282| 1.71k|WithDescription::~WithDescription() { 283| 1.71k| free(alias); 284| 1.71k| delete select; 285| 1.71k|} _ZN4hsql15SelectStatementC2Ev: 289| 40.8k| : SQLStatement(kStmtSelect), 290| 40.8k| fromTable(nullptr), 291| 40.8k| selectDistinct(false), 292| 40.8k| selectList(nullptr), 293| 40.8k| whereClause(nullptr), 294| 40.8k| groupBy(nullptr), 295| 40.8k| setOperations(nullptr), 296| 40.8k| order(nullptr), 297| 40.8k| withDescriptions(nullptr), 298| 40.8k| limit(nullptr), 299| 40.8k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 301| 40.5k|SelectStatement::~SelectStatement() { 302| 40.5k| delete fromTable; 303| 40.5k| delete whereClause; 304| 40.5k| delete groupBy; 305| 40.5k| delete limit; 306| | 307| | // Delete each element in the select list. 308| 40.5k| if (selectList) { ------------------ | Branch (308:7): [True: 40.5k, False: 0] ------------------ 309| 134k| for (Expr* expr : *selectList) { ------------------ | Branch (309:21): [True: 134k, False: 40.5k] ------------------ 310| 134k| delete expr; 311| 134k| } 312| 40.5k| delete selectList; 313| 40.5k| } 314| | 315| 40.5k| if (order) { ------------------ | Branch (315:7): [True: 699, False: 39.8k] ------------------ 316| 2.56k| for (OrderDescription* desc : *order) { ------------------ | Branch (316:33): [True: 2.56k, False: 699] ------------------ 317| 2.56k| delete desc; 318| 2.56k| } 319| 699| delete order; 320| 699| } 321| | 322| 40.5k| if (withDescriptions) { ------------------ | Branch (322:7): [True: 951, False: 39.6k] ------------------ 323| 1.71k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (323:32): [True: 1.71k, False: 951] ------------------ 324| 1.71k| delete desc; 325| 1.71k| } 326| 951| delete withDescriptions; 327| 951| } 328| | 329| 40.5k| if (setOperations) { ------------------ | Branch (329:7): [True: 4.36k, False: 36.2k] ------------------ 330| 4.66k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (330:37): [True: 4.66k, False: 4.36k] ------------------ 331| 4.66k| delete setOperation; 332| 4.66k| } 333| 4.36k| delete setOperations; 334| 4.36k| } 335| | 336| 40.5k| if (lockings) { ------------------ | Branch (336:7): [True: 439, False: 40.1k] ------------------ 337| 3.12k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (337:39): [True: 3.12k, False: 439] ------------------ 338| 3.12k| if (lockingClause->tables) { ------------------ | Branch (338:11): [True: 202, False: 2.92k] ------------------ 339| 396| for (char* dtable : *lockingClause->tables) { ------------------ | Branch (339:27): [True: 396, False: 202] ------------------ 340| 396| free(dtable); 341| 396| } 342| 202| delete lockingClause->tables; 343| 202| } 344| 3.12k| delete lockingClause; 345| 3.12k| } 346| 439| delete lockings; 347| 439| } 348| 40.5k|} _ZN4hsql15UpdateStatementC2Ev: 351| 1.91k|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 353| 1.91k|UpdateStatement::~UpdateStatement() { 354| 1.91k| delete table; 355| 1.91k| delete where; 356| | 357| 1.91k| if (updates) { ------------------ | Branch (357:7): [True: 1.91k, False: 0] ------------------ 358| 3.07k| for (UpdateClause* update : *updates) { ------------------ | Branch (358:31): [True: 3.07k, False: 1.91k] ------------------ 359| 3.07k| free(update->column); 360| 3.07k| delete update->value; 361| 3.07k| delete update; 362| 3.07k| } 363| 1.91k| delete updates; 364| 1.91k| } 365| 1.91k|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 368| 22.0k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 370| 22.0k|Alias::~Alias() { 371| 22.0k| free(name); 372| 22.0k| if (columns) { ------------------ | Branch (372:7): [True: 185, False: 21.8k] ------------------ 373| 839| for (char* column : *columns) { ------------------ | Branch (373:23): [True: 839, False: 185] ------------------ 374| 839| free(column); 375| 839| } 376| 185| delete columns; 377| 185| } 378| 22.0k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 382| 338k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 384| 338k|TableRef::~TableRef() { 385| 338k| free(schema); 386| 338k| free(name); 387| | 388| 338k| delete select; 389| 338k| delete join; 390| 338k| delete alias; 391| | 392| 338k| if (list) { ------------------ | Branch (392:7): [True: 1.60k, False: 337k] ------------------ 393| 109k| for (TableRef* table : *list) { ------------------ | Branch (393:26): [True: 109k, False: 1.60k] ------------------ 394| 109k| delete table; 395| 109k| } 396| 1.60k| delete list; 397| 1.60k| } 398| 338k|} _ZN4hsql14JoinDefinitionC2Ev: 411| 110k| : left(nullptr), right(nullptr), condition(nullptr), namedColumns(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 413| 110k|JoinDefinition::~JoinDefinition() { 414| 110k| delete left; 415| 110k| delete right; 416| 110k| delete condition; 417| | 418| 110k| if (namedColumns) { ------------------ | Branch (418:7): [True: 718, False: 109k] ------------------ 419| 912| for (auto* column : *namedColumns) { ------------------ | Branch (419:23): [True: 912, False: 718] ------------------ 420| 912| free(column); 421| 912| } 422| 718| delete namedColumns; 423| 718| } 424| 110k|} _ZN4hsql12SetOperationC2Ev: 426| 5.77k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 428| 5.77k|SetOperation::~SetOperation() { 429| 5.77k| delete nestedSelectStatement; 430| 5.77k| delete resultLimit; 431| | 432| 5.77k| if (resultOrder) { ------------------ | Branch (432:7): [True: 862, False: 4.91k] ------------------ 433| 2.75k| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (433:33): [True: 2.75k, False: 862] ------------------ 434| 2.75k| delete desc; 435| 2.75k| } 436| 862| delete resultOrder; 437| 862| } 438| 5.77k|}