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| 5.24k|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 11.1k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.66k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.66k| errorMsg_ = errorMsg; 46| 5.66k| errorLine_ = errorLine; 47| 5.66k| errorColumn_ = errorColumn; 48| 5.66k|} _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| 111k|void SQLParserResult::addParameter(Expr* parameter) { 76| 111k| parameters_.push_back(parameter); 77| 111k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 111k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 614M| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 97| 5.66k| int yyerror(YYLTYPE * llocp, SQLParserResult * result, yyscan_t scanner, const char* msg) { 98| 5.66k| result->setIsValid(false); 99| 5.66k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 100| 5.66k| return 0; 101| 5.66k| } _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| 13.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| 13.0M| yyssp++; 2997| | 2998| 13.0M| yysetstate: 2999| 13.0M| *yyssp = yystate; 3000| | 3001| 13.0M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3001:7): [True: 19, False: 13.0M] ------------------ 3002| 19| { 3003| | /* Get the current used size of the three stacks, in elements. */ 3004| 19| YYSIZE_T yysize = yyssp - yyss + 1; ------------------ | | 496| 19|# 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| 19|# ifndef YYSTACK_RELOCATE 3031| 19| 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| 13.0M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3068| | 3069| 13.0M| if (yystate == YYFINAL) ------------------ | | 706| 13.0M|#define YYFINAL 69 ------------------ | Branch (3069:7): [True: 1.41k, False: 13.0M] ------------------ 3070| 1.41k| YYACCEPT; ------------------ | | 1456| 1.41k|#define YYACCEPT goto yyacceptlab ------------------ 3071| | 3072| 13.0M| goto yybackup; 3073| | 3074| |/*-----------. 3075| || yybackup. | 3076| |`-----------*/ 3077| 13.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| 13.0M| yyn = yypact[yystate]; 3084| 13.0M| if (yypact_value_is_default (yyn)) ------------------ | | 923| 13.0M| (!!((Yystate) == (-529))) | | ------------------ | | | Branch (923:3): [True: 6.63M, False: 6.44M] | | ------------------ ------------------ 3085| 6.63M| 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.44M| if (yychar == YYEMPTY) ------------------ | | 1453| 6.44M|#define YYEMPTY (-2) ------------------ | Branch (3090:7): [True: 3.49M, False: 2.95M] ------------------ 3091| 3.49M| { 3092| 3.49M| YYDPRINTF ((stderr, "Reading a token: ")); 3093| 3.49M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 66| 3.49M|#define yylex hsql_lex ------------------ 3094| 3.49M| } 3095| | 3096| 6.44M| if (yychar <= YYEOF) ------------------ | | 1454| 6.44M|#define YYEOF 0 ------------------ | Branch (3096:7): [True: 23.4k, False: 6.42M] ------------------ 3097| 23.4k| { 3098| 23.4k| yychar = yytoken = YYEOF; ------------------ | | 1454| 23.4k|#define YYEOF 0 ------------------ 3099| 23.4k| YYDPRINTF ((stderr, "Now at end of input.\n")); 3100| 23.4k| } 3101| 6.42M| else 3102| 6.42M| { 3103| 6.42M| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 6.42M| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 6.42M|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 6.42M, False: 0] | | ------------------ ------------------ 3104| 6.42M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3105| 6.42M| } 3106| | 3107| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3108| | detect an error, take that action. */ 3109| 6.44M| yyn += yytoken; 3110| 6.44M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 708| 6.44M|#define YYLAST 856 ------------------ | Branch (3110:7): [True: 4.54k, False: 6.44M] | Branch (3110:18): [True: 5.61k, False: 6.43M] | Branch (3110:34): [True: 2.72M, False: 3.70M] ------------------ 3111| 2.73M| goto yydefault; 3112| 3.70M| yyn = yytable[yyn]; 3113| 3.70M| if (yyn <= 0) ------------------ | Branch (3113:7): [True: 221k, False: 3.48M] ------------------ 3114| 221k| { 3115| 221k| if (yytable_value_is_error (yyn)) ------------------ | | 928| 221k| (!!((Yytable_value) == (-355))) | | ------------------ | | | Branch (928:3): [True: 15, False: 221k] | | ------------------ ------------------ 3116| 15| goto yyerrlab; 3117| 221k| yyn = -yyn; 3118| 221k| goto yyreduce; 3119| 221k| } 3120| | 3121| | /* Count tokens shifted since error; after three, turn off error 3122| | status. */ 3123| 3.48M| if (yyerrstatus) ------------------ | Branch (3123:7): [True: 0, False: 3.48M] ------------------ 3124| 0| yyerrstatus--; 3125| | 3126| | /* Shift the lookahead token. */ 3127| 3.48M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3128| | 3129| | /* Discard the shifted token. */ 3130| 3.48M| yychar = YYEMPTY; ------------------ | | 1453| 3.48M|#define YYEMPTY (-2) ------------------ 3131| | 3132| 3.48M| yystate = yyn; 3133| 3.48M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3134| 3.48M| *++yyvsp = yylval; 3135| 3.48M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3136| 3.48M| *++yylsp = yylloc; 3137| 3.48M| goto yynewstate; 3138| | 3139| | 3140| |/*-----------------------------------------------------------. 3141| || yydefault -- do the default action for the current state. | 3142| |`-----------------------------------------------------------*/ 3143| 9.36M|yydefault: 3144| 9.36M| yyn = yydefact[yystate]; 3145| 9.36M| if (yyn == 0) ------------------ | Branch (3145:7): [True: 3.40k, False: 9.36M] ------------------ 3146| 3.40k| goto yyerrlab; 3147| 9.36M| goto yyreduce; 3148| | 3149| | 3150| |/*-----------------------------. 3151| || yyreduce -- Do a reduction. | 3152| |`-----------------------------*/ 3153| 9.58M|yyreduce: 3154| | /* yyn is the number of a rule to reduce with. */ 3155| 9.58M| 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| 9.58M| yyval = yyvsp[1-yylen]; 3166| | 3167| | /* Default location. */ 3168| 9.58M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1491| 9.58M| do \ | | 1492| 9.58M| if (N) \ | | ------------------ | | | Branch (1492:11): [True: 8.55M, False: 1.02M] | | ------------------ | | 1493| 9.58M| { \ | | 1494| 8.55M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1509| 8.55M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1495| 8.55M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1509| 8.55M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1496| 8.55M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1509| 8.55M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1497| 8.55M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1509| 8.55M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1498| 8.55M| } \ | | 1499| 9.58M| else \ | | 1500| 9.58M| { \ | | 1501| 1.02M| (Current).first_line = (Current).last_line = \ | | 1502| 1.02M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1509| 1.02M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1503| 1.02M| (Current).first_column = (Current).last_column = \ | | 1504| 1.02M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1509| 1.02M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1505| 1.02M| } \ | | 1506| 9.58M| while (0) | | ------------------ | | | Branch (1506:12): [Folded, False: 9.58M] | | ------------------ ------------------ 3169| 9.58M| YY_REDUCE_PRINT (yyn); 3170| 9.58M| switch (yyn) 3171| 9.58M| { 3172| 1.67k| case 2: ------------------ | Branch (3172:9): [True: 1.67k, False: 9.58M] ------------------ 3173| 1.67k|#line 343 "bison_parser.y" /* yacc.c:1646 */ 3174| 1.67k| { 3175| 44.4k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3175:27): [True: 44.4k, False: 1.67k] ------------------ 3176| | // Transfers ownership of the statement. 3177| 44.4k| result->addStatement(stmt); 3178| 44.4k| } 3179| | 3180| 1.67k| unsigned param_id = 0; 3181| 111k| for (void* param : yyloc.param_list) { ------------------ | Branch (3181:20): [True: 111k, False: 1.67k] ------------------ 3182| 111k| if (param) { ------------------ | Branch (3182:9): [True: 111k, False: 0] ------------------ 3183| 111k| Expr* expr = (Expr*)param; 3184| 111k| expr->ival = param_id; 3185| 111k| result->addParameter(expr); 3186| 111k| ++param_id; 3187| 111k| } 3188| 111k| } 3189| 1.67k| delete (yyvsp[-1].stmt_vec); 3190| 1.67k| } 3191| 1.67k|#line 3192 "bison_parser.cpp" /* yacc.c:1646 */ 3192| 1.67k| break; 3193| | 3194| 2.23k| case 3: ------------------ | Branch (3194:3): [True: 2.23k, False: 9.58M] ------------------ 3195| 2.23k|#line 362 "bison_parser.y" /* yacc.c:1646 */ 3196| 2.23k| { 3197| 2.23k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3198| 2.23k| yylloc.string_length = 0; 3199| 2.23k| (yyval.stmt_vec) = new std::vector(); 3200| 2.23k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3201| 2.23k|} 3202| 2.23k|#line 3203 "bison_parser.cpp" /* yacc.c:1646 */ 3203| 2.23k| break; 3204| | 3205| 86.5k| case 4: ------------------ | Branch (3205:3): [True: 86.5k, False: 9.49M] ------------------ 3206| 86.5k|#line 368 "bison_parser.y" /* yacc.c:1646 */ 3207| 86.5k| { 3208| 86.5k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3209| 86.5k| yylloc.string_length = 0; 3210| 86.5k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3211| 86.5k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3212| 86.5k|} 3213| 86.5k|#line 3214 "bison_parser.cpp" /* yacc.c:1646 */ 3214| 86.5k| break; 3215| | 3216| 2.00k| case 5: ------------------ | Branch (3216:3): [True: 2.00k, False: 9.58M] ------------------ 3217| 2.00k|#line 375 "bison_parser.y" /* yacc.c:1646 */ 3218| 2.00k| { 3219| 2.00k| (yyval.statement) = (yyvsp[-1].prep_stmt); 3220| 2.00k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3221| 2.00k|} 3222| 2.00k|#line 3223 "bison_parser.cpp" /* yacc.c:1646 */ 3223| 2.00k| break; 3224| | 3225| 64.2k| case 6: ------------------ | Branch (3225:3): [True: 64.2k, False: 9.52M] ------------------ 3226| 64.2k|#line 379 "bison_parser.y" /* yacc.c:1646 */ 3227| 64.2k| { 3228| 64.2k| (yyval.statement) = (yyvsp[-1].statement); 3229| 64.2k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3230| 64.2k|} 3231| 64.2k|#line 3232 "bison_parser.cpp" /* yacc.c:1646 */ 3232| 64.2k| break; 3233| | 3234| 7.67k| case 7: ------------------ | Branch (3234:3): [True: 7.67k, False: 9.57M] ------------------ 3235| 7.67k|#line 383 "bison_parser.y" /* yacc.c:1646 */ 3236| 7.67k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3237| 7.67k|#line 3238 "bison_parser.cpp" /* yacc.c:1646 */ 3238| 7.67k| break; 3239| | 3240| 7.71k| case 8: ------------------ | Branch (3240:3): [True: 7.71k, False: 9.57M] ------------------ 3241| 7.71k|#line 384 "bison_parser.y" /* yacc.c:1646 */ 3242| 7.71k| { (yyval.statement) = (yyvsp[0].import_stmt); } 3243| 7.71k|#line 3244 "bison_parser.cpp" /* yacc.c:1646 */ 3244| 7.71k| break; 3245| | 3246| 7.15k| case 9: ------------------ | Branch (3246:3): [True: 7.15k, False: 9.57M] ------------------ 3247| 7.15k|#line 385 "bison_parser.y" /* yacc.c:1646 */ 3248| 7.15k| { (yyval.statement) = (yyvsp[0].export_stmt); } 3249| 7.15k|#line 3250 "bison_parser.cpp" /* yacc.c:1646 */ 3250| 7.15k| break; 3251| | 3252| 25.6k| case 10: ------------------ | Branch (3252:3): [True: 25.6k, False: 9.56M] ------------------ 3253| 25.6k|#line 387 "bison_parser.y" /* yacc.c:1646 */ 3254| 25.6k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3255| 25.6k|#line 3256 "bison_parser.cpp" /* yacc.c:1646 */ 3256| 25.6k| break; 3257| | 3258| 8.91k| case 11: ------------------ | Branch (3258:3): [True: 8.91k, False: 9.57M] ------------------ 3259| 8.91k|#line 388 "bison_parser.y" /* yacc.c:1646 */ 3260| 8.91k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3261| 8.91k|#line 3262 "bison_parser.cpp" /* yacc.c:1646 */ 3262| 8.91k| break; 3263| | 3264| 3.81k| case 12: ------------------ | Branch (3264:3): [True: 3.81k, False: 9.58M] ------------------ 3265| 3.81k|#line 389 "bison_parser.y" /* yacc.c:1646 */ 3266| 3.81k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3267| 3.81k|#line 3268 "bison_parser.cpp" /* yacc.c:1646 */ 3268| 3.81k| break; 3269| | 3270| 1.86k| case 13: ------------------ | Branch (3270:3): [True: 1.86k, False: 9.58M] ------------------ 3271| 1.86k|#line 390 "bison_parser.y" /* yacc.c:1646 */ 3272| 1.86k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3273| 1.86k|#line 3274 "bison_parser.cpp" /* yacc.c:1646 */ 3274| 1.86k| break; 3275| | 3276| 379| case 14: ------------------ | Branch (3276:3): [True: 379, False: 9.58M] ------------------ 3277| 379|#line 391 "bison_parser.y" /* yacc.c:1646 */ 3278| 379| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3279| 379|#line 3280 "bison_parser.cpp" /* yacc.c:1646 */ 3280| 379| break; 3281| | 3282| 2.82k| case 15: ------------------ | Branch (3282:3): [True: 2.82k, False: 9.58M] ------------------ 3283| 2.82k|#line 392 "bison_parser.y" /* yacc.c:1646 */ 3284| 2.82k| { (yyval.statement) = (yyvsp[0].update_stmt); } 3285| 2.82k|#line 3286 "bison_parser.cpp" /* yacc.c:1646 */ 3286| 2.82k| break; 3287| | 3288| 4.38k| case 16: ------------------ | Branch (3288:3): [True: 4.38k, False: 9.58M] ------------------ 3289| 4.38k|#line 393 "bison_parser.y" /* yacc.c:1646 */ 3290| 4.38k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3291| 4.38k|#line 3292 "bison_parser.cpp" /* yacc.c:1646 */ 3292| 4.38k| break; 3293| | 3294| 0| case 17: ------------------ | Branch (3294:3): [True: 0, False: 9.58M] ------------------ 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.82k| case 18: ------------------ | Branch (3300:3): [True: 4.82k, False: 9.58M] ------------------ 3301| 4.82k|#line 395 "bison_parser.y" /* yacc.c:1646 */ 3302| 4.82k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3303| 4.82k|#line 3304 "bison_parser.cpp" /* yacc.c:1646 */ 3304| 4.82k| break; 3305| | 3306| 11.6k| case 19: ------------------ | Branch (3306:3): [True: 11.6k, False: 9.57M] ------------------ 3307| 11.6k|#line 396 "bison_parser.y" /* yacc.c:1646 */ 3308| 11.6k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3309| 11.6k|#line 3310 "bison_parser.cpp" /* yacc.c:1646 */ 3310| 11.6k| break; 3311| | 3312| 939| case 20: ------------------ | Branch (3312:3): [True: 939, False: 9.58M] ------------------ 3313| 939|#line 402 "bison_parser.y" /* yacc.c:1646 */ 3314| 939| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3315| 939|#line 3316 "bison_parser.cpp" /* yacc.c:1646 */ 3316| 939| break; 3317| | 3318| 65.2k| case 21: ------------------ | Branch (3318:3): [True: 65.2k, False: 9.52M] ------------------ 3319| 65.2k|#line 403 "bison_parser.y" /* yacc.c:1646 */ 3320| 65.2k| { (yyval.expr_vec) = nullptr; } 3321| 65.2k|#line 3322 "bison_parser.cpp" /* yacc.c:1646 */ 3322| 65.2k| break; 3323| | 3324| 976| case 22: ------------------ | Branch (3324:3): [True: 976, False: 9.58M] ------------------ 3325| 976|#line 405 "bison_parser.y" /* yacc.c:1646 */ 3326| 976| { 3327| 976| (yyval.expr_vec) = new std::vector(); 3328| 976| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3329| 976|} 3330| 976|#line 3331 "bison_parser.cpp" /* yacc.c:1646 */ 3331| 976| break; 3332| | 3333| 2.27k| case 23: ------------------ | Branch (3333:3): [True: 2.27k, False: 9.58M] ------------------ 3334| 2.27k|#line 409 "bison_parser.y" /* yacc.c:1646 */ 3335| 2.27k| { 3336| 2.27k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3337| 2.27k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3338| 2.27k|} 3339| 2.27k|#line 3340 "bison_parser.cpp" /* yacc.c:1646 */ 3340| 2.27k| break; 3341| | 3342| 2.92k| case 24: ------------------ | Branch (3342:3): [True: 2.92k, False: 9.58M] ------------------ 3343| 2.92k|#line 414 "bison_parser.y" /* yacc.c:1646 */ 3344| 2.92k| { 3345| 2.92k| (yyval.expr) = Expr::make(kExprHint); 3346| 2.92k| (yyval.expr)->name = (yyvsp[0].sval); 3347| 2.92k|} 3348| 2.92k|#line 3349 "bison_parser.cpp" /* yacc.c:1646 */ 3349| 2.92k| break; 3350| | 3351| 320| case 25: ------------------ | Branch (3351:3): [True: 320, False: 9.58M] ------------------ 3352| 320|#line 418 "bison_parser.y" /* yacc.c:1646 */ 3353| 320| { 3354| 320| (yyval.expr) = Expr::make(kExprHint); 3355| 320| (yyval.expr)->name = (yyvsp[-3].sval); 3356| 320| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3357| 320|} 3358| 320|#line 3359 "bison_parser.cpp" /* yacc.c:1646 */ 3359| 320| break; 3360| | 3361| 6.64k| case 26: ------------------ | Branch (3361:3): [True: 6.64k, False: 9.57M] ------------------ 3362| 6.64k|#line 428 "bison_parser.y" /* yacc.c:1646 */ 3363| 6.64k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3364| 6.64k|#line 3365 "bison_parser.cpp" /* yacc.c:1646 */ 3365| 6.64k| break; 3366| | 3367| 2.89k| case 27: ------------------ | Branch (3367:3): [True: 2.89k, False: 9.58M] ------------------ 3368| 2.89k|#line 429 "bison_parser.y" /* yacc.c:1646 */ 3369| 2.89k| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3370| 2.89k|#line 3371 "bison_parser.cpp" /* yacc.c:1646 */ 3371| 2.89k| break; 3372| | 3373| 2.08k| case 28: ------------------ | Branch (3373:3): [True: 2.08k, False: 9.58M] ------------------ 3374| 2.08k|#line 430 "bison_parser.y" /* yacc.c:1646 */ 3375| 2.08k| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3376| 2.08k|#line 3377 "bison_parser.cpp" /* yacc.c:1646 */ 3377| 2.08k| break; 3378| | 3379| 2.00k| case 31: ------------------ | Branch (3379:3): [True: 2.00k, False: 9.58M] ------------------ 3380| 2.00k|#line 438 "bison_parser.y" /* yacc.c:1646 */ 3381| 2.00k| { 3382| 2.00k| (yyval.prep_stmt) = new PrepareStatement(); 3383| 2.00k| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3384| 2.00k| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3385| 2.00k|} 3386| 2.00k|#line 3387 "bison_parser.cpp" /* yacc.c:1646 */ 3387| 2.00k| break; 3388| | 3389| 4.31k| case 33: ------------------ | Branch (3389:3): [True: 4.31k, False: 9.58M] ------------------ 3390| 4.31k|#line 446 "bison_parser.y" /* yacc.c:1646 */ 3391| 4.31k| { 3392| 4.31k| (yyval.exec_stmt) = new ExecuteStatement(); 3393| 4.31k| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3394| 4.31k|} 3395| 4.31k|#line 3396 "bison_parser.cpp" /* yacc.c:1646 */ 3396| 4.31k| break; 3397| | 3398| 507| case 34: ------------------ | Branch (3398:3): [True: 507, False: 9.58M] ------------------ 3399| 507|#line 450 "bison_parser.y" /* yacc.c:1646 */ 3400| 507| { 3401| 507| (yyval.exec_stmt) = new ExecuteStatement(); 3402| 507| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3403| 507| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3404| 507|} 3405| 507|#line 3406 "bison_parser.cpp" /* yacc.c:1646 */ 3406| 507| break; 3407| | 3408| 0| case 35: ------------------ | Branch (3408:3): [True: 0, False: 9.58M] ------------------ 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.71k| case 36: ------------------ | Branch (3419:3): [True: 7.71k, False: 9.57M] ------------------ 3420| 7.71k|#line 468 "bison_parser.y" /* yacc.c:1646 */ 3421| 7.71k| { 3422| 7.71k| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_export_option_t)->format); 3423| 7.71k| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3424| 7.71k| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3425| 7.71k| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3426| 7.71k| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3427| 7.71k| if ((yyvsp[-1].import_export_option_t)->encoding) { ------------------ | Branch (3427:7): [True: 194, False: 7.52k] ------------------ 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.71k| if ((yyvsp[-1].import_export_option_t)->csv_options) { ------------------ | Branch (3431:7): [True: 194, False: 7.52k] ------------------ 3432| 194| (yyval.import_stmt)->csv_options = (yyvsp[-1].import_export_option_t)->csv_options; 3433| 194| (yyvsp[-1].import_export_option_t)->csv_options = nullptr; 3434| 194| } 3435| 7.71k| delete (yyvsp[-1].import_export_option_t); 3436| 7.71k|} 3437| 7.71k|#line 3438 "bison_parser.cpp" /* yacc.c:1646 */ 3438| 7.71k| break; 3439| | 3440| 1.68k| case 37: ------------------ | Branch (3440:3): [True: 1.68k, False: 9.58M] ------------------ 3441| 1.68k|#line 485 "bison_parser.y" /* yacc.c:1646 */ 3442| 1.68k| { 3443| 1.68k| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3443:7): [True: 753, False: 929] ------------------ 3444| 753| (yyval.import_type_t) = kImportCSV; 3445| 929| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3445:14): [True: 195, False: 734] ------------------ 3446| 195| (yyval.import_type_t) = kImportTbl; 3447| 734| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3447:14): [True: 67, False: 667] | Branch (3447:60): [True: 560, False: 107] ------------------ 3448| 627| (yyval.import_type_t) = kImportBinary; 3449| 627| } else { 3450| 107| free((yyvsp[0].sval)); 3451| 107| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 67| 107|#define yyerror hsql_error ------------------ 3452| 107| YYERROR; ------------------ | | 1458| 107|#define YYERROR goto yyerrorlab ------------------ 3453| 107| } 3454| 1.57k| free((yyvsp[0].sval)); 3455| 1.57k|} 3456| 0|#line 3457 "bison_parser.cpp" /* yacc.c:1646 */ 3457| 0| break; 3458| | 3459| 15.0k| case 38: ------------------ | Branch (3459:3): [True: 15.0k, False: 9.57M] ------------------ 3460| 15.0k|#line 500 "bison_parser.y" /* yacc.c:1646 */ 3461| 15.0k| { (yyval.sval) = (yyvsp[0].sval); } 3462| 15.0k|#line 3463 "bison_parser.cpp" /* yacc.c:1646 */ 3463| 15.0k| break; 3464| | 3465| 195| case 39: ------------------ | Branch (3465:3): [True: 195, False: 9.58M] ------------------ 3466| 195|#line 502 "bison_parser.y" /* yacc.c:1646 */ 3467| 195| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3468| 195|#line 3469 "bison_parser.cpp" /* yacc.c:1646 */ 3469| 195| break; 3470| | 3471| 3.26k| case 40: ------------------ | Branch (3471:3): [True: 3.26k, False: 9.58M] ------------------ 3472| 3.26k|#line 503 "bison_parser.y" /* yacc.c:1646 */ 3473| 3.26k| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3474| 3.26k|#line 3475 "bison_parser.cpp" /* yacc.c:1646 */ 3475| 3.26k| break; 3476| | 3477| 11.4k| case 41: ------------------ | Branch (3477:3): [True: 11.4k, False: 9.57M] ------------------ 3478| 11.4k|#line 504 "bison_parser.y" /* yacc.c:1646 */ 3479| 11.4k| { (yyval.import_export_option_t) = new ImportExportOptions{}; } 3480| 11.4k|#line 3481 "bison_parser.cpp" /* yacc.c:1646 */ 3481| 11.4k| break; 3482| | 3483| 531| case 42: ------------------ | Branch (3483:3): [True: 531, False: 9.58M] ------------------ 3484| 531|#line 506 "bison_parser.y" /* yacc.c:1646 */ 3485| 531| { 3486| 531| if ((yyvsp[-3].import_export_option_t)->format != kImportAuto) { ------------------ | Branch (3486:7): [True: 6, False: 525] ------------------ 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| 525| 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: 459, False: 66] | Branch (3491:58): [True: 1, False: 458] | Branch (3491:100): [True: 1, False: 0] ------------------ 3492| 1| delete (yyvsp[-3].import_export_option_t); 3493| 1| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) are only allowed for CSV files."); ------------------ | | 67| 1|#define yyerror hsql_error ------------------ 3494| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 3495| 1| } 3496| 524| (yyvsp[-3].import_export_option_t)->format = (yyvsp[0].import_type_t); 3497| 524| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3498| 524|} 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: 9.58M] ------------------ 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| 456| case 44: ------------------ | Branch (3511:3): [True: 456, False: 9.58M] ------------------ 3512| 456|#line 524 "bison_parser.y" /* yacc.c:1646 */ 3513| 456| { 3514| 456| if ((yyvsp[-3].import_export_option_t)->encoding) { ------------------ | Branch (3514:7): [True: 1, False: 455] ------------------ 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| 455| (yyvsp[-3].import_export_option_t)->encoding = (yyvsp[0].sval); 3521| 455| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3522| 455|} 3523| 0|#line 3524 "bison_parser.cpp" /* yacc.c:1646 */ 3524| 0| break; 3525| | 3526| 1.02k| case 45: ------------------ | Branch (3526:3): [True: 1.02k, False: 9.58M] ------------------ 3527| 1.02k|#line 534 "bison_parser.y" /* yacc.c:1646 */ 3528| 1.02k| { 3529| 1.02k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3530| 1.02k| (yyval.import_export_option_t)->encoding = (yyvsp[0].sval); 3531| 1.02k|} 3532| 1.02k|#line 3533 "bison_parser.cpp" /* yacc.c:1646 */ 3533| 1.02k| break; 3534| | 3535| 487| case 46: ------------------ | Branch (3535:3): [True: 487, False: 9.58M] ------------------ 3536| 487|#line 538 "bison_parser.y" /* yacc.c:1646 */ 3537| 487| { 3538| 487| if ((yyvsp[-2].import_export_option_t)->format != kImportAuto && (yyvsp[-2].import_export_option_t)->format != kImportCSV) { ------------------ | Branch (3538:7): [True: 218, False: 269] | Branch (3538:68): [True: 1, False: 217] ------------------ 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| 486| if ((yyvsp[-2].import_export_option_t)->csv_options == nullptr) { ------------------ | Branch (3546:7): [True: 210, False: 276] ------------------ 3547| 210| (yyvsp[-2].import_export_option_t)->csv_options = new CsvOptions{}; 3548| 210| } 3549| | 3550| 486| if (!(yyvsp[-2].import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t))) { ------------------ | Branch (3550:7): [True: 12, False: 474] ------------------ 3551| 12| free((yyvsp[0].csv_option_t)->second); 3552| 12| delete (yyvsp[0].csv_option_t); 3553| 12| delete (yyvsp[-2].import_export_option_t); 3554| 12| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) cannot be provided more than once."); ------------------ | | 67| 12|#define yyerror hsql_error ------------------ 3555| 12| YYERROR; ------------------ | | 1458| 12|#define YYERROR goto yyerrorlab ------------------ 3556| 12| } 3557| | 3558| 474| delete (yyvsp[0].csv_option_t); 3559| 474| (yyval.import_export_option_t) = (yyvsp[-2].import_export_option_t); 3560| 474|} 3561| 0|#line 3562 "bison_parser.cpp" /* yacc.c:1646 */ 3562| 0| break; 3563| | 3564| 1.46k| case 47: ------------------ | Branch (3564:3): [True: 1.46k, False: 9.58M] ------------------ 3565| 1.46k|#line 562 "bison_parser.y" /* yacc.c:1646 */ 3566| 1.46k| { 3567| 1.46k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3568| 1.46k| (yyval.import_export_option_t)->csv_options = new CsvOptions{}; 3569| 1.46k| (yyval.import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t)); 3570| | 3571| 1.46k| delete (yyvsp[0].csv_option_t); 3572| 1.46k|} 3573| 1.46k|#line 3574 "bison_parser.cpp" /* yacc.c:1646 */ 3574| 1.46k| break; 3575| | 3576| 906| case 48: ------------------ | Branch (3576:3): [True: 906, False: 9.58M] ------------------ 3577| 906|#line 570 "bison_parser.y" /* yacc.c:1646 */ 3578| 906| { 3579| 906| if (strcasecmp((yyvsp[-1].sval), "DELIMITER") == 0) { ------------------ | Branch (3579:7): [True: 206, False: 700] ------------------ 3580| 206| (yyval.csv_option_t) = new std::pair(CsvOptionType::Delimiter, (yyvsp[0].sval)); 3581| 700| } else if (strcasecmp((yyvsp[-1].sval), "QUOTE") == 0) { ------------------ | Branch (3581:14): [True: 582, False: 118] ------------------ 3582| 582| (yyval.csv_option_t) = new std::pair(CsvOptionType::Quote, (yyvsp[0].sval)); 3583| 582| } else { 3584| 118| free((yyvsp[-1].sval)); 3585| 118| free((yyvsp[0].sval)); 3586| 118| yyerror(&yyloc, result, scanner, "Unknown CSV option."); ------------------ | | 67| 118|#define yyerror hsql_error ------------------ 3587| 118| YYERROR; ------------------ | | 1458| 118|#define YYERROR goto yyerrorlab ------------------ 3588| 118| } 3589| 788| free((yyvsp[-1].sval)); 3590| 788|} 3591| 0|#line 3592 "bison_parser.cpp" /* yacc.c:1646 */ 3592| 0| break; 3593| | 3594| 1.16k| case 49: ------------------ | Branch (3594:3): [True: 1.16k, False: 9.58M] ------------------ 3595| 1.16k|#line 583 "bison_parser.y" /* yacc.c:1646 */ 3596| 1.16k| { (yyval.csv_option_t) = new std::pair(CsvOptionType::Null, (yyvsp[0].sval)); } 3597| 1.16k|#line 3598 "bison_parser.cpp" /* yacc.c:1646 */ 3598| 1.16k| break; 3599| | 3600| 6.59k| case 50: ------------------ | Branch (3600:3): [True: 6.59k, False: 9.57M] ------------------ 3601| 6.59k|#line 590 "bison_parser.y" /* yacc.c:1646 */ 3602| 6.59k| { 3603| 6.59k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3604| 6.59k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3605| 6.59k| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3606| 6.59k| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3607| 6.59k| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3607:7): [True: 1.07k, False: 5.51k] ------------------ 3608| 1.07k| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3609| 1.07k| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3610| 1.07k| } 3611| 6.59k| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3611:7): [True: 1.22k, False: 5.37k] ------------------ 3612| 1.22k| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3613| 1.22k| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3614| 1.22k| } 3615| 6.59k| delete (yyvsp[0].import_export_option_t); 3616| 6.59k|} 3617| 6.59k|#line 3618 "bison_parser.cpp" /* yacc.c:1646 */ 3618| 6.59k| break; 3619| | 3620| 559| case 51: ------------------ | Branch (3620:3): [True: 559, False: 9.58M] ------------------ 3621| 559|#line 605 "bison_parser.y" /* yacc.c:1646 */ 3622| 559| { 3623| 559| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3624| 559| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3625| 559| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3626| 559| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3626:7): [True: 194, False: 365] ------------------ 3627| 194| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3628| 194| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3629| 194| } 3630| 559| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3630:7): [True: 212, False: 347] ------------------ 3631| 212| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3632| 212| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3633| 212| } 3634| 559| delete (yyvsp[0].import_export_option_t); 3635| 559|} 3636| 559|#line 3637 "bison_parser.cpp" /* yacc.c:1646 */ 3637| 559| break; 3638| | 3639| 1.62k| case 52: ------------------ | Branch (3639:3): [True: 1.62k, False: 9.58M] ------------------ 3640| 1.62k|#line 625 "bison_parser.y" /* yacc.c:1646 */ 3641| 1.62k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3642| 1.62k|#line 3643 "bison_parser.cpp" /* yacc.c:1646 */ 3643| 1.62k| break; 3644| | 3645| 1.17k| case 53: ------------------ | Branch (3645:3): [True: 1.17k, False: 9.58M] ------------------ 3646| 1.17k|#line 626 "bison_parser.y" /* yacc.c:1646 */ 3647| 1.17k| { 3648| 1.17k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3649| 1.17k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3650| 1.17k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3651| 1.17k|} 3652| 1.17k|#line 3653 "bison_parser.cpp" /* yacc.c:1646 */ 3653| 1.17k| break; 3654| | 3655| 4.88k| case 54: ------------------ | Branch (3655:3): [True: 4.88k, False: 9.58M] ------------------ 3656| 4.88k|#line 631 "bison_parser.y" /* yacc.c:1646 */ 3657| 4.88k| { 3658| 4.88k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3659| 4.88k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3660| 4.88k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3661| 4.88k|} 3662| 4.88k|#line 3663 "bison_parser.cpp" /* yacc.c:1646 */ 3663| 4.88k| break; 3664| | 3665| 0| case 55: ------------------ | Branch (3665:3): [True: 0, False: 9.58M] ------------------ 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| 5.24k| case 56: ------------------ | Branch (3683:3): [True: 5.24k, False: 9.58M] ------------------ 3684| 5.24k|#line 655 "bison_parser.y" /* yacc.c:1646 */ 3685| 5.24k| { 3686| 5.24k| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3687| 5.24k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3688| 5.24k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3689| 5.24k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3690| 5.24k| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3691| 5.24k| delete (yyvsp[-1].table_element_vec); 3692| 5.24k| if (result->errorMsg()) { ------------------ | Branch (3692:7): [True: 2, False: 5.24k] ------------------ 3693| 2| delete (yyval.create_stmt); 3694| 2| YYERROR; ------------------ | | 1458| 2|#define YYERROR goto yyerrorlab ------------------ 3695| 2| } 3696| 5.24k|} 3697| 5.24k|#line 3698 "bison_parser.cpp" /* yacc.c:1646 */ 3698| 5.24k| break; 3699| | 3700| 5.24k| case 57: ------------------ | Branch (3700:3): [True: 195, False: 9.58M] ------------------ 3701| 195|#line 667 "bison_parser.y" /* yacc.c:1646 */ 3702| 195| { 3703| 195| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3704| 195| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3705| 195| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3706| 195| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3707| 195| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3708| 195|} 3709| 195|#line 3710 "bison_parser.cpp" /* yacc.c:1646 */ 3710| 195| break; 3711| | 3712| 1.29k| case 58: ------------------ | Branch (3712:3): [True: 1.29k, False: 9.58M] ------------------ 3713| 1.29k|#line 674 "bison_parser.y" /* yacc.c:1646 */ 3714| 1.29k| { 3715| 1.29k| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3716| 1.29k| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3717| 1.29k| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3718| 1.29k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3719| 1.29k| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3720| 1.29k|} 3721| 1.29k|#line 3722 "bison_parser.cpp" /* yacc.c:1646 */ 3722| 1.29k| break; 3723| | 3724| 2.18k| case 59: ------------------ | Branch (3724:3): [True: 2.18k, False: 9.58M] ------------------ 3725| 2.18k|#line 681 "bison_parser.y" /* yacc.c:1646 */ 3726| 2.18k| { 3727| 2.18k| (yyval.create_stmt) = new CreateStatement(kCreateView); 3728| 2.18k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3729| 2.18k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3730| 2.18k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3731| 2.18k| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3732| 2.18k| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3733| 2.18k|} 3734| 2.18k|#line 3735 "bison_parser.cpp" /* yacc.c:1646 */ 3735| 2.18k| break; 3736| | 3737| 66| case 60: ------------------ | Branch (3737:3): [True: 66, False: 9.58M] ------------------ 3738| 66|#line 690 "bison_parser.y" /* yacc.c:1646 */ 3739| 66| { (yyval.bval) = true; } 3740| 66|#line 3741 "bison_parser.cpp" /* yacc.c:1646 */ 3741| 66| break; 3742| | 3743| 9.47k| case 61: ------------------ | Branch (3743:3): [True: 9.47k, False: 9.57M] ------------------ 3744| 9.47k|#line 691 "bison_parser.y" /* yacc.c:1646 */ 3745| 9.47k| { (yyval.bval) = false; } 3746| 9.47k|#line 3747 "bison_parser.cpp" /* yacc.c:1646 */ 3747| 9.47k| break; 3748| | 3749| 5.79k| case 62: ------------------ | Branch (3749:3): [True: 5.79k, False: 9.58M] ------------------ 3750| 5.79k|#line 693 "bison_parser.y" /* yacc.c:1646 */ 3751| 5.79k| { 3752| 5.79k| (yyval.table_element_vec) = new std::vector(); 3753| 5.79k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3754| 5.79k|} 3755| 5.79k|#line 3756 "bison_parser.cpp" /* yacc.c:1646 */ 3756| 5.79k| break; 3757| | 3758| 17.1k| case 63: ------------------ | Branch (3758:3): [True: 17.1k, False: 9.56M] ------------------ 3759| 17.1k|#line 697 "bison_parser.y" /* yacc.c:1646 */ 3760| 17.1k| { 3761| 17.1k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3762| 17.1k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3763| 17.1k|} 3764| 17.1k|#line 3765 "bison_parser.cpp" /* yacc.c:1646 */ 3765| 17.1k| break; 3766| | 3767| 21.2k| case 64: ------------------ | Branch (3767:3): [True: 21.2k, False: 9.56M] ------------------ 3768| 21.2k|#line 702 "bison_parser.y" /* yacc.c:1646 */ 3769| 21.2k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3770| 21.2k|#line 3771 "bison_parser.cpp" /* yacc.c:1646 */ 3771| 21.2k| break; 3772| | 3773| 1.67k| case 65: ------------------ | Branch (3773:3): [True: 1.67k, False: 9.58M] ------------------ 3774| 1.67k|#line 703 "bison_parser.y" /* yacc.c:1646 */ 3775| 1.67k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3776| 1.67k|#line 3777 "bison_parser.cpp" /* yacc.c:1646 */ 3777| 1.67k| break; 3778| | 3779| 21.2k| case 66: ------------------ | Branch (3779:3): [True: 21.2k, False: 9.56M] ------------------ 3780| 21.2k|#line 705 "bison_parser.y" /* yacc.c:1646 */ 3781| 21.2k| { 3782| 21.2k| (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| 21.2k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3783:7): [True: 1.58k, False: 19.6k] ------------------ 3784| 1.58k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 67| 1.58k|#define yyerror hsql_error ------------------ 3785| 1.58k| } 3786| 21.2k| delete (yyvsp[0].column_constraints_t); 3787| 21.2k|} 3788| 21.2k|#line 3789 "bison_parser.cpp" /* yacc.c:1646 */ 3789| 21.2k| break; 3790| | 3791| 776| case 67: ------------------ | Branch (3791:3): [True: 776, False: 9.58M] ------------------ 3792| 776|#line 713 "bison_parser.y" /* yacc.c:1646 */ 3793| 776| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3794| 776|#line 3795 "bison_parser.cpp" /* yacc.c:1646 */ 3795| 776| break; 3796| | 3797| 623| case 68: ------------------ | Branch (3797:3): [True: 623, False: 9.58M] ------------------ 3798| 623|#line 714 "bison_parser.y" /* yacc.c:1646 */ 3799| 623| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3800| 623|#line 3801 "bison_parser.cpp" /* yacc.c:1646 */ 3801| 623| break; 3802| | 3803| 515| case 69: ------------------ | Branch (3803:3): [True: 515, False: 9.58M] ------------------ 3804| 515|#line 715 "bison_parser.y" /* yacc.c:1646 */ 3805| 515| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3806| 515|#line 3807 "bison_parser.cpp" /* yacc.c:1646 */ 3807| 515| break; 3808| | 3809| 0| case 70: ------------------ | Branch (3809:3): [True: 0, False: 9.58M] ------------------ 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.36k| case 71: ------------------ | Branch (3815:3): [True: 3.36k, False: 9.58M] ------------------ 3816| 3.36k|#line 717 "bison_parser.y" /* yacc.c:1646 */ 3817| 3.36k| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3818| 3.36k|#line 3819 "bison_parser.cpp" /* yacc.c:1646 */ 3819| 3.36k| break; 3820| | 3821| 425| case 72: ------------------ | Branch (3821:3): [True: 425, False: 9.58M] ------------------ 3822| 425|#line 718 "bison_parser.y" /* yacc.c:1646 */ 3823| 425| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3824| 425|#line 3825 "bison_parser.cpp" /* yacc.c:1646 */ 3825| 425| break; 3826| | 3827| 1.12k| case 73: ------------------ | Branch (3827:3): [True: 1.12k, False: 9.58M] ------------------ 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| 729| case 74: ------------------ | Branch (3836:3): [True: 729, False: 9.58M] ------------------ 3837| 729|#line 723 "bison_parser.y" /* yacc.c:1646 */ 3838| 729| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3839| 729|#line 3840 "bison_parser.cpp" /* yacc.c:1646 */ 3840| 729| break; 3841| | 3842| 691| case 75: ------------------ | Branch (3842:3): [True: 691, False: 9.58M] ------------------ 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| 7.82k| case 76: ------------------ | Branch (3848:3): [True: 7.82k, False: 9.57M] ------------------ 3849| 7.82k|#line 725 "bison_parser.y" /* yacc.c:1646 */ 3850| 7.82k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3851| 7.82k|#line 3852 "bison_parser.cpp" /* yacc.c:1646 */ 3852| 7.82k| break; 3853| | 3854| 669| case 77: ------------------ | Branch (3854:3): [True: 669, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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: 9.58M] ------------------ 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| 550| case 80: ------------------ | Branch (3872:3): [True: 550, False: 9.58M] ------------------ 3873| 550|#line 729 "bison_parser.y" /* yacc.c:1646 */ 3874| 550| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3875| 550|#line 3876 "bison_parser.cpp" /* yacc.c:1646 */ 3876| 550| break; 3877| | 3878| 402| case 81: ------------------ | Branch (3878:3): [True: 402, False: 9.58M] ------------------ 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| 954| case 82: ------------------ | Branch (3884:3): [True: 954, False: 9.58M] ------------------ 3885| 954|#line 731 "bison_parser.y" /* yacc.c:1646 */ 3886| 954| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3887| 954|#line 3888 "bison_parser.cpp" /* yacc.c:1646 */ 3888| 954| break; 3889| | 3890| 631| case 83: ------------------ | Branch (3890:3): [True: 631, False: 9.58M] ------------------ 3891| 631|#line 732 "bison_parser.y" /* yacc.c:1646 */ 3892| 631| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3893| 631|#line 3894 "bison_parser.cpp" /* yacc.c:1646 */ 3894| 631| break; 3895| | 3896| 756| case 84: ------------------ | Branch (3896:3): [True: 756, False: 9.58M] ------------------ 3897| 756|#line 733 "bison_parser.y" /* yacc.c:1646 */ 3898| 756| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3899| 756|#line 3900 "bison_parser.cpp" /* yacc.c:1646 */ 3900| 756| break; 3901| | 3902| 280| case 85: ------------------ | Branch (3902:3): [True: 280, False: 9.58M] ------------------ 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| 674| case 86: ------------------ | Branch (3908:3): [True: 674, False: 9.58M] ------------------ 3909| 674|#line 736 "bison_parser.y" /* yacc.c:1646 */ 3910| 674| { (yyval.ival) = 0; } 3911| 674|#line 3912 "bison_parser.cpp" /* yacc.c:1646 */ 3912| 674| break; 3913| | 3914| 266| case 87: ------------------ | Branch (3914:3): [True: 266, False: 9.58M] ------------------ 3915| 266|#line 738 "bison_parser.y" /* yacc.c:1646 */ 3916| 266| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3917| 266|#line 3918 "bison_parser.cpp" /* yacc.c:1646 */ 3918| 266| break; 3919| | 3920| 194| case 88: ------------------ | Branch (3920:3): [True: 194, False: 9.58M] ------------------ 3921| 194|#line 739 "bison_parser.y" /* yacc.c:1646 */ 3922| 194| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3923| 194|#line 3924 "bison_parser.cpp" /* yacc.c:1646 */ 3924| 194| break; 3925| | 3926| 660| case 89: ------------------ | Branch (3926:3): [True: 660, False: 9.58M] ------------------ 3927| 660|#line 740 "bison_parser.y" /* yacc.c:1646 */ 3928| 660| { (yyval.ival_pair) = new std::pair{0, 0}; } 3929| 660|#line 3930 "bison_parser.cpp" /* yacc.c:1646 */ 3930| 660| break; 3931| | 3932| 3.01k| case 90: ------------------ | Branch (3932:3): [True: 3.01k, False: 9.58M] ------------------ 3933| 3.01k|#line 742 "bison_parser.y" /* yacc.c:1646 */ 3934| 3.01k| { (yyval.column_constraints_t) = (yyvsp[0].column_constraints_t); } 3935| 3.01k|#line 3936 "bison_parser.cpp" /* yacc.c:1646 */ 3936| 3.01k| break; 3937| | 3938| 18.2k| case 91: ------------------ | Branch (3938:3): [True: 18.2k, False: 9.56M] ------------------ 3939| 18.2k|#line 743 "bison_parser.y" /* yacc.c:1646 */ 3940| 18.2k| { (yyval.column_constraints_t) = new ColumnConstraints(); } 3941| 18.2k|#line 3942 "bison_parser.cpp" /* yacc.c:1646 */ 3942| 18.2k| break; 3943| | 3944| 3.02k| case 92: ------------------ | Branch (3944:3): [True: 3.02k, False: 9.58M] ------------------ 3945| 3.02k|#line 745 "bison_parser.y" /* yacc.c:1646 */ 3946| 3.02k| { 3947| 3.02k| (yyval.column_constraints_t) = new ColumnConstraints(); 3948| 3.02k| (yyval.column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3949| 3.02k|} 3950| 3.02k|#line 3951 "bison_parser.cpp" /* yacc.c:1646 */ 3951| 3.02k| break; 3952| | 3953| 5.64k| case 93: ------------------ | Branch (3953:3): [True: 5.64k, False: 9.58M] ------------------ 3954| 5.64k|#line 749 "bison_parser.y" /* yacc.c:1646 */ 3955| 5.64k| { 3956| 5.64k| (yyvsp[-1].column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3957| 5.64k| (yyval.column_constraints_t) = (yyvsp[-1].column_constraints_t); 3958| 5.64k|} 3959| 5.64k|#line 3960 "bison_parser.cpp" /* yacc.c:1646 */ 3960| 5.64k| break; 3961| | 3962| 0| case 94: ------------------ | Branch (3962:3): [True: 0, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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.85k| case 96: ------------------ | Branch (3984:3): [True: 1.85k, False: 9.58M] ------------------ 3985| 1.85k|#line 766 "bison_parser.y" /* yacc.c:1646 */ 3986| 1.85k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3987| 1.85k|#line 3988 "bison_parser.cpp" /* yacc.c:1646 */ 3988| 1.85k| break; 3989| | 3990| 1.97k| case 97: ------------------ | Branch (3990:3): [True: 1.97k, False: 9.58M] ------------------ 3991| 1.97k|#line 767 "bison_parser.y" /* yacc.c:1646 */ 3992| 1.97k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3993| 1.97k|#line 3994 "bison_parser.cpp" /* yacc.c:1646 */ 3994| 1.97k| break; 3995| | 3996| 2.81k| case 98: ------------------ | Branch (3996:3): [True: 2.81k, False: 9.58M] ------------------ 3997| 2.81k|#line 768 "bison_parser.y" /* yacc.c:1646 */ 3998| 2.81k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3999| 2.81k|#line 4000 "bison_parser.cpp" /* yacc.c:1646 */ 4000| 2.81k| break; 4001| | 4002| 2.03k| case 99: ------------------ | Branch (4002:3): [True: 2.03k, False: 9.58M] ------------------ 4003| 2.03k|#line 769 "bison_parser.y" /* yacc.c:1646 */ 4004| 2.03k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 4005| 2.03k|#line 4006 "bison_parser.cpp" /* yacc.c:1646 */ 4006| 2.03k| break; 4007| | 4008| 194| case 100: ------------------ | Branch (4008:3): [True: 194, False: 9.58M] ------------------ 4009| 194|#line 771 "bison_parser.y" /* yacc.c:1646 */ 4010| 194| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 4011| 194|#line 4012 "bison_parser.cpp" /* yacc.c:1646 */ 4012| 194| break; 4013| | 4014| 1.48k| case 101: ------------------ | Branch (4014:3): [True: 1.48k, False: 9.58M] ------------------ 4015| 1.48k|#line 772 "bison_parser.y" /* yacc.c:1646 */ 4016| 1.48k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 4017| 1.48k|#line 4018 "bison_parser.cpp" /* yacc.c:1646 */ 4018| 1.48k| break; 4019| | 4020| 0| case 102: ------------------ | Branch (4020:3): [True: 0, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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.09k| case 104: ------------------ | Branch (4032:3): [True: 1.09k, False: 9.58M] ------------------ 4033| 1.09k|#line 783 "bison_parser.y" /* yacc.c:1646 */ 4034| 1.09k| { 4035| 1.09k| (yyval.drop_stmt) = new DropStatement(kDropTable); 4036| 1.09k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4037| 1.09k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4038| 1.09k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4039| 1.09k|} 4040| 1.09k|#line 4041 "bison_parser.cpp" /* yacc.c:1646 */ 4041| 1.09k| break; 4042| | 4043| 1.84k| case 105: ------------------ | Branch (4043:3): [True: 1.84k, False: 9.58M] ------------------ 4044| 1.84k|#line 789 "bison_parser.y" /* yacc.c:1646 */ 4045| 1.84k| { 4046| 1.84k| (yyval.drop_stmt) = new DropStatement(kDropView); 4047| 1.84k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4048| 1.84k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4049| 1.84k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4050| 1.84k|} 4051| 1.84k|#line 4052 "bison_parser.cpp" /* yacc.c:1646 */ 4052| 1.84k| break; 4053| | 4054| 879| case 106: ------------------ | Branch (4054:3): [True: 879, False: 9.58M] ------------------ 4055| 879|#line 795 "bison_parser.y" /* yacc.c:1646 */ 4056| 879| { 4057| 879| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 4058| 879| (yyval.drop_stmt)->ifExists = false; 4059| 879| (yyval.drop_stmt)->name = (yyvsp[0].sval); 4060| 879|} 4061| 879|#line 4062 "bison_parser.cpp" /* yacc.c:1646 */ 4062| 879| break; 4063| | 4064| 564| case 107: ------------------ | Branch (4064:3): [True: 564, False: 9.58M] ------------------ 4065| 564|#line 801 "bison_parser.y" /* yacc.c:1646 */ 4066| 564| { 4067| 564| (yyval.drop_stmt) = new DropStatement(kDropIndex); 4068| 564| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4069| 564| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 4070| 564|} 4071| 564|#line 4072 "bison_parser.cpp" /* yacc.c:1646 */ 4072| 564| break; 4073| | 4074| 507| case 108: ------------------ | Branch (4074:3): [True: 507, False: 9.58M] ------------------ 4075| 507|#line 807 "bison_parser.y" /* yacc.c:1646 */ 4076| 507| { (yyval.bval) = true; } 4077| 507|#line 4078 "bison_parser.cpp" /* yacc.c:1646 */ 4078| 507| break; 4079| | 4080| 3.02k| case 109: ------------------ | Branch (4080:3): [True: 3.02k, False: 9.58M] ------------------ 4081| 3.02k|#line 808 "bison_parser.y" /* yacc.c:1646 */ 4082| 3.02k| { (yyval.bval) = false; } 4083| 3.02k|#line 4084 "bison_parser.cpp" /* yacc.c:1646 */ 4084| 3.02k| break; 4085| | 4086| 0| case 110: ------------------ | Branch (4086:3): [True: 0, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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: 9.58M] ------------------ 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.86k| case 113: ------------------ | Branch (4111:3): [True: 1.86k, False: 9.58M] ------------------ 4112| 1.86k|#line 833 "bison_parser.y" /* yacc.c:1646 */ 4113| 1.86k| { 4114| 1.86k| (yyval.delete_stmt) = new DeleteStatement(); 4115| 1.86k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 4116| 1.86k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 4117| 1.86k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 4118| 1.86k|} 4119| 1.86k|#line 4120 "bison_parser.cpp" /* yacc.c:1646 */ 4120| 1.86k| break; 4121| | 4122| 379| case 114: ------------------ | Branch (4122:3): [True: 379, False: 9.58M] ------------------ 4123| 379|#line 840 "bison_parser.y" /* yacc.c:1646 */ 4124| 379| { 4125| 379| (yyval.delete_stmt) = new DeleteStatement(); 4126| 379| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 4127| 379| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 4128| 379|} 4129| 379|#line 4130 "bison_parser.cpp" /* yacc.c:1646 */ 4130| 379| break; 4131| | 4132| 557| case 115: ------------------ | Branch (4132:3): [True: 557, False: 9.58M] ------------------ 4133| 557|#line 851 "bison_parser.y" /* yacc.c:1646 */ 4134| 557| { 4135| 557| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 4136| 557| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 4137| 557| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 4138| 557| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 4139| 557| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 4140| 557|} 4141| 557|#line 4142 "bison_parser.cpp" /* yacc.c:1646 */ 4142| 557| break; 4143| | 4144| 3.25k| case 116: ------------------ | Branch (4144:3): [True: 3.25k, False: 9.58M] ------------------ 4145| 3.25k|#line 858 "bison_parser.y" /* yacc.c:1646 */ 4146| 3.25k| { 4147| 3.25k| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 4148| 3.25k| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 4149| 3.25k| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 4150| 3.25k| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 4151| 3.25k| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 4152| 3.25k|} 4153| 3.25k|#line 4154 "bison_parser.cpp" /* yacc.c:1646 */ 4154| 3.25k| break; 4155| | 4156| 1.01k| case 117: ------------------ | Branch (4156:3): [True: 1.01k, False: 9.58M] ------------------ 4157| 1.01k|#line 866 "bison_parser.y" /* yacc.c:1646 */ 4158| 1.01k| { (yyval.str_vec) = (yyvsp[-1].str_vec); } 4159| 1.01k|#line 4160 "bison_parser.cpp" /* yacc.c:1646 */ 4160| 1.01k| break; 4161| | 4162| 5.01k| case 118: ------------------ | Branch (4162:3): [True: 5.01k, False: 9.58M] ------------------ 4163| 5.01k|#line 867 "bison_parser.y" /* yacc.c:1646 */ 4164| 5.01k| { (yyval.str_vec) = nullptr; } 4165| 5.01k|#line 4166 "bison_parser.cpp" /* yacc.c:1646 */ 4166| 5.01k| break; 4167| | 4168| 2.82k| case 119: ------------------ | Branch (4168:3): [True: 2.82k, False: 9.58M] ------------------ 4169| 2.82k|#line 874 "bison_parser.y" /* yacc.c:1646 */ 4170| 2.82k| { 4171| 2.82k| (yyval.update_stmt) = new UpdateStatement(); 4172| 2.82k| (yyval.update_stmt)->table = (yyvsp[-3].table); 4173| 2.82k| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4174| 2.82k| (yyval.update_stmt)->where = (yyvsp[0].expr); 4175| 2.82k|} 4176| 2.82k|#line 4177 "bison_parser.cpp" /* yacc.c:1646 */ 4177| 2.82k| break; 4178| | 4179| 2.83k| case 120: ------------------ | Branch (4179:3): [True: 2.83k, False: 9.58M] ------------------ 4180| 2.83k|#line 881 "bison_parser.y" /* yacc.c:1646 */ 4181| 2.83k| { 4182| 2.83k| (yyval.update_vec) = new std::vector(); 4183| 2.83k| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4184| 2.83k|} 4185| 2.83k|#line 4186 "bison_parser.cpp" /* yacc.c:1646 */ 4186| 2.83k| break; 4187| | 4188| 1.65k| case 121: ------------------ | Branch (4188:3): [True: 1.65k, False: 9.58M] ------------------ 4189| 1.65k|#line 885 "bison_parser.y" /* yacc.c:1646 */ 4190| 1.65k| { 4191| 1.65k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4192| 1.65k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4193| 1.65k|} 4194| 1.65k|#line 4195 "bison_parser.cpp" /* yacc.c:1646 */ 4195| 1.65k| break; 4196| | 4197| 4.48k| case 122: ------------------ | Branch (4197:3): [True: 4.48k, False: 9.58M] ------------------ 4198| 4.48k|#line 890 "bison_parser.y" /* yacc.c:1646 */ 4199| 4.48k| { 4200| 4.48k| (yyval.update_t) = new UpdateClause(); 4201| 4.48k| (yyval.update_t)->column = (yyvsp[-2].sval); 4202| 4.48k| (yyval.update_t)->value = (yyvsp[0].expr); 4203| 4.48k|} 4204| 4.48k|#line 4205 "bison_parser.cpp" /* yacc.c:1646 */ 4205| 4.48k| break; 4206| | 4207| 656| case 123: ------------------ | Branch (4207:3): [True: 656, False: 9.58M] ------------------ 4208| 656|#line 900 "bison_parser.y" /* yacc.c:1646 */ 4209| 656| { 4210| 656| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4211| 656| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4212| 656|} 4213| 656|#line 4214 "bison_parser.cpp" /* yacc.c:1646 */ 4214| 656| break; 4215| | 4216| 26.0k| case 124: ------------------ | Branch (4216:3): [True: 26.0k, False: 9.55M] ------------------ 4217| 26.0k|#line 904 "bison_parser.y" /* yacc.c:1646 */ 4218| 26.0k| { 4219| 26.0k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4220| 26.0k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4221| 26.0k|} 4222| 26.0k|#line 4223 "bison_parser.cpp" /* yacc.c:1646 */ 4223| 26.0k| break; 4224| | 4225| 2.00k| case 125: ------------------ | Branch (4225:3): [True: 2.00k, False: 9.58M] ------------------ 4226| 2.00k|#line 908 "bison_parser.y" /* yacc.c:1646 */ 4227| 2.00k| { 4228| 2.00k| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4229| 2.00k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4229:7): [True: 1.71k, False: 294] ------------------ 4230| 1.71k| (yyval.select_stmt)->setOperations = new std::vector(); 4231| 1.71k| } 4232| 2.00k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4233| 2.00k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4234| 2.00k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4235| 2.00k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4236| 2.00k| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4237| 2.00k|} 4238| 2.00k|#line 4239 "bison_parser.cpp" /* yacc.c:1646 */ 4239| 2.00k| break; 4240| | 4241| 3.72k| case 128: ------------------ | Branch (4241:3): [True: 3.72k, False: 9.58M] ------------------ 4242| 3.72k|#line 922 "bison_parser.y" /* yacc.c:1646 */ 4243| 3.72k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4244| 3.72k|#line 4245 "bison_parser.cpp" /* yacc.c:1646 */ 4245| 3.72k| break; 4246| | 4247| 1.35k| case 129: ------------------ | Branch (4247:3): [True: 1.35k, False: 9.58M] ------------------ 4248| 1.35k|#line 923 "bison_parser.y" /* yacc.c:1646 */ 4249| 1.35k| { 4250| 1.35k| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4251| 1.35k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4251:7): [True: 1.35k, False: 0] ------------------ 4252| 1.35k| (yyval.select_stmt)->setOperations = new std::vector(); 4253| 1.35k| } 4254| 1.35k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4255| 1.35k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4256| 1.35k|} 4257| 1.35k|#line 4258 "bison_parser.cpp" /* yacc.c:1646 */ 4258| 1.35k| break; 4259| | 4260| 5.37k| case 130: ------------------ | Branch (4260:3): [True: 5.37k, False: 9.58M] ------------------ 4261| 5.37k|#line 932 "bison_parser.y" /* yacc.c:1646 */ 4262| 5.37k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4263| 5.37k|#line 4264 "bison_parser.cpp" /* yacc.c:1646 */ 4264| 5.37k| break; 4265| | 4266| 200| case 131: ------------------ | Branch (4266:3): [True: 200, False: 9.58M] ------------------ 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| 34.9k| case 132: ------------------ | Branch (4272:3): [True: 34.9k, False: 9.55M] ------------------ 4273| 34.9k|#line 935 "bison_parser.y" /* yacc.c:1646 */ 4274| 34.9k| { 4275| 34.9k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4276| 34.9k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4277| | 4278| | // Limit could have been set by TOP. 4279| 34.9k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4279:7): [True: 4.91k, False: 30.0k] ------------------ 4280| 4.91k| delete (yyval.select_stmt)->limit; 4281| 4.91k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4282| 4.91k| } 4283| | 4284| 34.9k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4284:7): [True: 425, False: 34.5k] ------------------ 4285| 425| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4286| 425| } 4287| 34.9k|} 4288| 34.9k|#line 4289 "bison_parser.cpp" /* yacc.c:1646 */ 4289| 34.9k| break; 4290| | 4291| 1.67k| case 133: ------------------ | Branch (4291:3): [True: 1.67k, False: 9.58M] ------------------ 4292| 1.67k|#line 949 "bison_parser.y" /* yacc.c:1646 */ 4293| 1.67k| { 4294| 1.67k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4295| 1.67k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4295:7): [True: 1.67k, False: 0] ------------------ 4296| 1.67k| (yyval.select_stmt)->setOperations = new std::vector(); 4297| 1.67k| } 4298| 1.67k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4299| 1.67k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4300| 1.67k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4301| 1.67k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4302| 1.67k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4303| 1.67k|} 4304| 1.67k|#line 4305 "bison_parser.cpp" /* yacc.c:1646 */ 4305| 1.67k| break; 4306| | 4307| 6.18k| case 134: ------------------ | Branch (4307:3): [True: 6.18k, False: 9.57M] ------------------ 4308| 6.18k|#line 961 "bison_parser.y" /* yacc.c:1646 */ 4309| 6.18k| { 4310| 6.18k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4311| 6.18k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4312| 6.18k|} 4313| 6.18k|#line 4314 "bison_parser.cpp" /* yacc.c:1646 */ 4314| 6.18k| break; 4315| | 4316| 4.57k| case 135: ------------------ | Branch (4316:3): [True: 4.57k, False: 9.58M] ------------------ 4317| 4.57k|#line 966 "bison_parser.y" /* yacc.c:1646 */ 4318| 4.57k| { 4319| 4.57k| (yyval.set_operator_t) = new SetOperation(); 4320| 4.57k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4321| 4.57k|} 4322| 4.57k|#line 4323 "bison_parser.cpp" /* yacc.c:1646 */ 4323| 4.57k| break; 4324| | 4325| 634| case 136: ------------------ | Branch (4325:3): [True: 634, False: 9.58M] ------------------ 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| 974| case 137: ------------------ | Branch (4334:3): [True: 974, False: 9.58M] ------------------ 4335| 974|#line 974 "bison_parser.y" /* yacc.c:1646 */ 4336| 974| { 4337| 974| (yyval.set_operator_t) = new SetOperation(); 4338| 974| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4339| 974|} 4340| 974|#line 4341 "bison_parser.cpp" /* yacc.c:1646 */ 4341| 974| break; 4342| | 4343| 397| case 138: ------------------ | Branch (4343:3): [True: 397, False: 9.58M] ------------------ 4344| 397|#line 979 "bison_parser.y" /* yacc.c:1646 */ 4345| 397| { (yyval.bval) = true; } 4346| 397|#line 4347 "bison_parser.cpp" /* yacc.c:1646 */ 4347| 397| break; 4348| | 4349| 5.78k| case 139: ------------------ | Branch (4349:3): [True: 5.78k, False: 9.58M] ------------------ 4350| 5.78k|#line 980 "bison_parser.y" /* yacc.c:1646 */ 4351| 5.78k| { (yyval.bval) = false; } 4352| 5.78k|#line 4353 "bison_parser.cpp" /* yacc.c:1646 */ 4353| 5.78k| break; 4354| | 4355| 43.4k| case 140: ------------------ | Branch (4355:3): [True: 43.4k, False: 9.54M] ------------------ 4356| 43.4k|#line 982 "bison_parser.y" /* yacc.c:1646 */ 4357| 43.4k| { 4358| 43.4k| (yyval.select_stmt) = new SelectStatement(); 4359| 43.4k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4360| 43.4k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4361| 43.4k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4362| 43.4k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4363| 43.4k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4364| 43.4k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4365| 43.4k|} 4366| 43.4k|#line 4367 "bison_parser.cpp" /* yacc.c:1646 */ 4367| 43.4k| break; 4368| | 4369| 551| case 141: ------------------ | Branch (4369:3): [True: 551, False: 9.58M] ------------------ 4370| 551|#line 992 "bison_parser.y" /* yacc.c:1646 */ 4371| 551| { (yyval.bval) = true; } 4372| 551|#line 4373 "bison_parser.cpp" /* yacc.c:1646 */ 4373| 551| break; 4374| | 4375| 49.8k| case 142: ------------------ | Branch (4375:3): [True: 49.8k, False: 9.53M] ------------------ 4376| 49.8k|#line 993 "bison_parser.y" /* yacc.c:1646 */ 4377| 49.8k| { (yyval.bval) = false; } 4378| 49.8k|#line 4379 "bison_parser.cpp" /* yacc.c:1646 */ 4379| 49.8k| break; 4380| | 4381| 3.85k| case 144: ------------------ | Branch (4381:3): [True: 3.85k, False: 9.58M] ------------------ 4382| 3.85k|#line 997 "bison_parser.y" /* yacc.c:1646 */ 4383| 3.85k| { (yyval.table) = (yyvsp[0].table); } 4384| 3.85k|#line 4385 "bison_parser.cpp" /* yacc.c:1646 */ 4385| 3.85k| break; 4386| | 4387| 39.7k| case 145: ------------------ | Branch (4387:3): [True: 39.7k, False: 9.54M] ------------------ 4388| 39.7k|#line 998 "bison_parser.y" /* yacc.c:1646 */ 4389| 39.7k| { (yyval.table) = nullptr; } 4390| 39.7k|#line 4391 "bison_parser.cpp" /* yacc.c:1646 */ 4391| 39.7k| break; 4392| | 4393| 3.85k| case 146: ------------------ | Branch (4393:3): [True: 3.85k, False: 9.58M] ------------------ 4394| 3.85k|#line 1000 "bison_parser.y" /* yacc.c:1646 */ 4395| 3.85k| { (yyval.table) = (yyvsp[0].table); } 4396| 3.85k|#line 4397 "bison_parser.cpp" /* yacc.c:1646 */ 4397| 3.85k| break; 4398| | 4399| 1.92k| case 147: ------------------ | Branch (4399:3): [True: 1.92k, False: 9.58M] ------------------ 4400| 1.92k|#line 1002 "bison_parser.y" /* yacc.c:1646 */ 4401| 1.92k| { (yyval.expr) = (yyvsp[0].expr); } 4402| 1.92k|#line 4403 "bison_parser.cpp" /* yacc.c:1646 */ 4403| 1.92k| break; 4404| | 4405| 54.0k| case 148: ------------------ | Branch (4405:3): [True: 54.0k, False: 9.53M] ------------------ 4406| 54.0k|#line 1003 "bison_parser.y" /* yacc.c:1646 */ 4407| 54.0k| { (yyval.expr) = nullptr; } 4408| 54.0k|#line 4409 "bison_parser.cpp" /* yacc.c:1646 */ 4409| 54.0k| break; 4410| | 4411| 3.73k| case 149: ------------------ | Branch (4411:3): [True: 3.73k, False: 9.58M] ------------------ 4412| 3.73k|#line 1005 "bison_parser.y" /* yacc.c:1646 */ 4413| 3.73k| { 4414| 3.73k| (yyval.group_t) = new GroupByDescription(); 4415| 3.73k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4416| 3.73k| (yyval.group_t)->having = (yyvsp[0].expr); 4417| 3.73k|} 4418| 3.73k|#line 4419 "bison_parser.cpp" /* yacc.c:1646 */ 4419| 3.73k| break; 4420| | 4421| 39.7k| case 150: ------------------ | Branch (4421:3): [True: 39.7k, False: 9.54M] ------------------ 4422| 39.7k|#line 1010 "bison_parser.y" /* yacc.c:1646 */ 4423| 39.7k| { (yyval.group_t) = nullptr; } 4424| 39.7k|#line 4425 "bison_parser.cpp" /* yacc.c:1646 */ 4425| 39.7k| break; 4426| | 4427| 872| case 151: ------------------ | Branch (4427:3): [True: 872, False: 9.58M] ------------------ 4428| 872|#line 1012 "bison_parser.y" /* yacc.c:1646 */ 4429| 872| { (yyval.expr) = (yyvsp[0].expr); } 4430| 872|#line 4431 "bison_parser.cpp" /* yacc.c:1646 */ 4431| 872| break; 4432| | 4433| 2.86k| case 152: ------------------ | Branch (4433:3): [True: 2.86k, False: 9.58M] ------------------ 4434| 2.86k|#line 1013 "bison_parser.y" /* yacc.c:1646 */ 4435| 2.86k| { (yyval.expr) = nullptr; } 4436| 2.86k|#line 4437 "bison_parser.cpp" /* yacc.c:1646 */ 4437| 2.86k| break; 4438| | 4439| 2.61k| case 153: ------------------ | Branch (4439:3): [True: 2.61k, False: 9.58M] ------------------ 4440| 2.61k|#line 1015 "bison_parser.y" /* yacc.c:1646 */ 4441| 2.61k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4442| 2.61k|#line 4443 "bison_parser.cpp" /* yacc.c:1646 */ 4443| 2.61k| break; 4444| | 4445| 42.3k| case 154: ------------------ | Branch (4445:3): [True: 42.3k, False: 9.54M] ------------------ 4446| 42.3k|#line 1016 "bison_parser.y" /* yacc.c:1646 */ 4447| 42.3k| { (yyval.order_vec) = nullptr; } 4448| 42.3k|#line 4449 "bison_parser.cpp" /* yacc.c:1646 */ 4449| 42.3k| break; 4450| | 4451| 2.74k| case 155: ------------------ | Branch (4451:3): [True: 2.74k, False: 9.58M] ------------------ 4452| 2.74k|#line 1018 "bison_parser.y" /* yacc.c:1646 */ 4453| 2.74k| { 4454| 2.74k| (yyval.order_vec) = new std::vector(); 4455| 2.74k| (yyval.order_vec)->push_back((yyvsp[0].order)); 4456| 2.74k|} 4457| 2.74k|#line 4458 "bison_parser.cpp" /* yacc.c:1646 */ 4458| 2.74k| break; 4459| | 4460| 5.78k| case 156: ------------------ | Branch (4460:3): [True: 5.78k, False: 9.58M] ------------------ 4461| 5.78k|#line 1022 "bison_parser.y" /* yacc.c:1646 */ 4462| 5.78k| { 4463| 5.78k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4464| 5.78k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4465| 5.78k|} 4466| 5.78k|#line 4467 "bison_parser.cpp" /* yacc.c:1646 */ 4467| 5.78k| break; 4468| | 4469| 8.52k| case 157: ------------------ | Branch (4469:3): [True: 8.52k, False: 9.57M] ------------------ 4470| 8.52k|#line 1027 "bison_parser.y" /* yacc.c:1646 */ 4471| 8.52k| { (yyval.order) = new OrderDescription((yyvsp[-1].order_type), (yyvsp[-2].expr), (yyvsp[0].null_ordering_t)); } 4472| 8.52k|#line 4473 "bison_parser.cpp" /* yacc.c:1646 */ 4473| 8.52k| break; 4474| | 4475| 606| case 158: ------------------ | Branch (4475:3): [True: 606, False: 9.58M] ------------------ 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| 527| case 159: ------------------ | Branch (4481:3): [True: 527, False: 9.58M] ------------------ 4482| 527|#line 1030 "bison_parser.y" /* yacc.c:1646 */ 4483| 527| { (yyval.order_type) = kOrderDesc; } 4484| 527|#line 4485 "bison_parser.cpp" /* yacc.c:1646 */ 4485| 527| break; 4486| | 4487| 7.53k| case 160: ------------------ | Branch (4487:3): [True: 7.53k, False: 9.57M] ------------------ 4488| 7.53k|#line 1031 "bison_parser.y" /* yacc.c:1646 */ 4489| 7.53k| { (yyval.order_type) = kOrderAsc; } 4490| 7.53k|#line 4491 "bison_parser.cpp" /* yacc.c:1646 */ 4491| 7.53k| break; 4492| | 4493| 8.13k| case 161: ------------------ | Branch (4493:3): [True: 8.13k, False: 9.57M] ------------------ 4494| 8.13k|#line 1033 "bison_parser.y" /* yacc.c:1646 */ 4495| 8.13k| { (yyval.null_ordering_t) = NullOrdering::Undefined; } 4496| 8.13k|#line 4497 "bison_parser.cpp" /* yacc.c:1646 */ 4497| 8.13k| break; 4498| | 4499| 518| case 162: ------------------ | Branch (4499:3): [True: 518, False: 9.58M] ------------------ 4500| 518|#line 1034 "bison_parser.y" /* yacc.c:1646 */ 4501| 518| { 4502| 518| auto null_ordering = NullOrdering::Undefined; 4503| 518| if (strcasecmp((yyvsp[-1].sval), "nulls") == 0) { ------------------ | Branch (4503:7): [True: 464, False: 54] ------------------ 4504| 464| if (strcasecmp((yyvsp[0].sval), "first") == 0) { ------------------ | Branch (4504:9): [True: 194, False: 270] ------------------ 4505| 194| null_ordering = NullOrdering::First; 4506| 270| } else if (strcasecmp((yyvsp[0].sval), "last") == 0) { ------------------ | Branch (4506:16): [True: 196, False: 74] ------------------ 4507| 196| null_ordering = NullOrdering::Last; 4508| 196| } 4509| 464| } 4510| 518| free((yyvsp[-1].sval)); 4511| 518| free((yyvsp[0].sval)); 4512| | 4513| 518| if (null_ordering == NullOrdering::Undefined) { ------------------ | Branch (4513:7): [True: 128, False: 390] ------------------ 4514| 128| yyerror(&yyloc, result, scanner, "Expected NULLS FIRST or NULLS LAST ordering."); ------------------ | | 67| 128|#define yyerror hsql_error ------------------ 4515| 128| YYERROR; ------------------ | | 1458| 128|#define YYERROR goto yyerrorlab ------------------ 4516| 128| } 4517| | 4518| 390| (yyval.null_ordering_t) = null_ordering; 4519| 390|} 4520| 0|#line 4521 "bison_parser.cpp" /* yacc.c:1646 */ 4521| 0| break; 4522| | 4523| 3.71k| case 163: ------------------ | Branch (4523:3): [True: 3.71k, False: 9.58M] ------------------ 4524| 3.71k|#line 1056 "bison_parser.y" /* yacc.c:1646 */ 4525| 3.71k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4526| 3.71k|#line 4527 "bison_parser.cpp" /* yacc.c:1646 */ 4527| 3.71k| break; 4528| | 4529| 41.8k| case 164: ------------------ | Branch (4529:3): [True: 41.8k, False: 9.54M] ------------------ 4530| 41.8k|#line 1057 "bison_parser.y" /* yacc.c:1646 */ 4531| 41.8k| { (yyval.limit) = nullptr; } 4532| 41.8k|#line 4533 "bison_parser.cpp" /* yacc.c:1646 */ 4533| 41.8k| break; 4534| | 4535| 1.91k| case 165: ------------------ | Branch (4535:3): [True: 1.91k, False: 9.58M] ------------------ 4536| 1.91k|#line 1059 "bison_parser.y" /* yacc.c:1646 */ 4537| 1.91k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4538| 1.91k|#line 4539 "bison_parser.cpp" /* yacc.c:1646 */ 4539| 1.91k| break; 4540| | 4541| 1.90k| case 166: ------------------ | Branch (4541:3): [True: 1.90k, False: 9.58M] ------------------ 4542| 1.90k|#line 1060 "bison_parser.y" /* yacc.c:1646 */ 4543| 1.90k| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4544| 1.90k|#line 4545 "bison_parser.cpp" /* yacc.c:1646 */ 4545| 1.90k| break; 4546| | 4547| 520| case 167: ------------------ | Branch (4547:3): [True: 520, False: 9.58M] ------------------ 4548| 520|#line 1061 "bison_parser.y" /* yacc.c:1646 */ 4549| 520| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4550| 520|#line 4551 "bison_parser.cpp" /* yacc.c:1646 */ 4551| 520| break; 4552| | 4553| 1.80k| case 168: ------------------ | Branch (4553:3): [True: 1.80k, False: 9.58M] ------------------ 4554| 1.80k|#line 1062 "bison_parser.y" /* yacc.c:1646 */ 4555| 1.80k| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4556| 1.80k|#line 4557 "bison_parser.cpp" /* yacc.c:1646 */ 4557| 1.80k| break; 4558| | 4559| 302| case 169: ------------------ | Branch (4559:3): [True: 302, False: 9.58M] ------------------ 4560| 302|#line 1063 "bison_parser.y" /* yacc.c:1646 */ 4561| 302| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4562| 302|#line 4563 "bison_parser.cpp" /* yacc.c:1646 */ 4563| 302| break; 4564| | 4565| 32.2k| case 170: ------------------ | Branch (4565:3): [True: 32.2k, False: 9.55M] ------------------ 4566| 32.2k|#line 1064 "bison_parser.y" /* yacc.c:1646 */ 4567| 32.2k| { (yyval.limit) = nullptr; } 4568| 32.2k|#line 4569 "bison_parser.cpp" /* yacc.c:1646 */ 4569| 32.2k| break; 4570| | 4571| 53.7k| case 171: ------------------ | Branch (4571:3): [True: 53.7k, False: 9.53M] ------------------ 4572| 53.7k|#line 1069 "bison_parser.y" /* yacc.c:1646 */ 4573| 53.7k| { 4574| 53.7k| (yyval.expr_vec) = new std::vector(); 4575| 53.7k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4576| 53.7k|} 4577| 53.7k|#line 4578 "bison_parser.cpp" /* yacc.c:1646 */ 4578| 53.7k| break; 4579| | 4580| 127k| case 172: ------------------ | Branch (4580:3): [True: 127k, False: 9.45M] ------------------ 4581| 127k|#line 1073 "bison_parser.y" /* yacc.c:1646 */ 4582| 127k| { 4583| 127k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4584| 127k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4585| 127k|} 4586| 127k|#line 4587 "bison_parser.cpp" /* yacc.c:1646 */ 4587| 127k| break; 4588| | 4589| 303| case 173: ------------------ | Branch (4589:3): [True: 303, False: 9.58M] ------------------ 4590| 303|#line 1079 "bison_parser.y" /* yacc.c:1646 */ 4591| 303| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4592| 303|#line 4593 "bison_parser.cpp" /* yacc.c:1646 */ 4593| 303| break; 4594| | 4595| 253| case 174: ------------------ | Branch (4595:3): [True: 253, False: 9.58M] ------------------ 4596| 253|#line 1080 "bison_parser.y" /* yacc.c:1646 */ 4597| 253| { (yyval.expr_vec) = nullptr; } 4598| 253|#line 4599 "bison_parser.cpp" /* yacc.c:1646 */ 4599| 253| break; 4600| | 4601| 1.20k| case 175: ------------------ | Branch (4601:3): [True: 1.20k, False: 9.58M] ------------------ 4602| 1.20k|#line 1082 "bison_parser.y" /* yacc.c:1646 */ 4603| 1.20k| { 4604| 1.20k| (yyval.expr_vec) = new std::vector(); 4605| 1.20k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4606| 1.20k|} 4607| 1.20k|#line 4608 "bison_parser.cpp" /* yacc.c:1646 */ 4608| 1.20k| break; 4609| | 4610| 2.50k| case 176: ------------------ | Branch (4610:3): [True: 2.50k, False: 9.58M] ------------------ 4611| 2.50k|#line 1086 "bison_parser.y" /* yacc.c:1646 */ 4612| 2.50k| { 4613| 2.50k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4614| 2.50k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4615| 2.50k|} 4616| 2.50k|#line 4617 "bison_parser.cpp" /* yacc.c:1646 */ 4617| 2.50k| break; 4618| | 4619| 194| case 178: ------------------ | Branch (4619:3): [True: 194, False: 9.58M] ------------------ 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| 2.98k| case 179: ------------------ | Branch (4627:3): [True: 2.98k, False: 9.58M] ------------------ 4628| 2.98k|#line 1095 "bison_parser.y" /* yacc.c:1646 */ 4629| 2.98k| { 4630| 2.98k| if ((yyvsp[0].expr)->type == ExprType::kExprParameter) { ------------------ | Branch (4630:7): [True: 1, False: 2.98k] ------------------ 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| 2.98k| (yyval.expr) = (yyvsp[0].expr); 4636| 2.98k|} 4637| 0|#line 4638 "bison_parser.cpp" /* yacc.c:1646 */ 4638| 0| break; 4639| | 4640| 522| case 180: ------------------ | Branch (4640:3): [True: 522, False: 9.58M] ------------------ 4641| 522|#line 1103 "bison_parser.y" /* yacc.c:1646 */ 4642| 522| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4643| 522|#line 4644 "bison_parser.cpp" /* yacc.c:1646 */ 4644| 522| break; 4645| | 4646| 199| case 181: ------------------ | Branch (4646:3): [True: 199, False: 9.58M] ------------------ 4647| 199|#line 1104 "bison_parser.y" /* yacc.c:1646 */ 4648| 199| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4649| 199|#line 4650 "bison_parser.cpp" /* yacc.c:1646 */ 4650| 199| break; 4651| | 4652| 181k| case 182: ------------------ | Branch (4652:3): [True: 181k, False: 9.40M] ------------------ 4653| 181k|#line 1106 "bison_parser.y" /* yacc.c:1646 */ 4654| 181k| { 4655| 181k| (yyval.expr) = (yyvsp[-1].expr); 4656| 181k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4656:7): [True: 13.2k, False: 168k] ------------------ 4657| 13.2k| (yyval.expr)->alias = (yyvsp[0].alias_t)->name; 4658| 13.2k| (yyvsp[0].alias_t)->name = nullptr; 4659| 13.2k| delete (yyvsp[0].alias_t); 4660| 13.2k| } 4661| 181k|} 4662| 181k|#line 4663 "bison_parser.cpp" /* yacc.c:1646 */ 4663| 181k| break; 4664| | 4665| 940| case 188: ------------------ | Branch (4665:3): [True: 940, False: 9.58M] ------------------ 4666| 940|#line 1117 "bison_parser.y" /* yacc.c:1646 */ 4667| 940| { (yyval.expr) = (yyvsp[-1].expr); } 4668| 940|#line 4669 "bison_parser.cpp" /* yacc.c:1646 */ 4669| 940| break; 4670| | 4671| 704| case 198: ------------------ | Branch (4671:3): [True: 704, False: 9.58M] ------------------ 4672| 704|#line 1119 "bison_parser.y" /* yacc.c:1646 */ 4673| 704| { 4674| 704| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4675| 704|} 4676| 704|#line 4677 "bison_parser.cpp" /* yacc.c:1646 */ 4677| 704| break; 4678| | 4679| 6.97k| case 201: ------------------ | Branch (4679:3): [True: 6.97k, False: 9.57M] ------------------ 4680| 6.97k|#line 1125 "bison_parser.y" /* yacc.c:1646 */ 4681| 6.97k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4682| 6.97k|#line 4683 "bison_parser.cpp" /* yacc.c:1646 */ 4683| 6.97k| break; 4684| | 4685| 2.10k| case 202: ------------------ | Branch (4685:3): [True: 2.10k, False: 9.58M] ------------------ 4686| 2.10k|#line 1126 "bison_parser.y" /* yacc.c:1646 */ 4687| 2.10k| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4688| 2.10k|#line 4689 "bison_parser.cpp" /* yacc.c:1646 */ 4689| 2.10k| break; 4690| | 4691| 765| case 203: ------------------ | Branch (4691:3): [True: 765, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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: 9.58M] ------------------ 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.3k| case 207: ------------------ | Branch (4709:3): [True: 19.3k, False: 9.56M] ------------------ 4710| 19.3k|#line 1131 "bison_parser.y" /* yacc.c:1646 */ 4711| 19.3k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4712| 19.3k|#line 4713 "bison_parser.cpp" /* yacc.c:1646 */ 4713| 19.3k| break; 4714| | 4715| 5.64k| case 208: ------------------ | Branch (4715:3): [True: 5.64k, False: 9.58M] ------------------ 4716| 5.64k|#line 1132 "bison_parser.y" /* yacc.c:1646 */ 4717| 5.64k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4718| 5.64k|#line 4719 "bison_parser.cpp" /* yacc.c:1646 */ 4719| 5.64k| break; 4720| | 4721| 159k| case 209: ------------------ | Branch (4721:3): [True: 159k, False: 9.42M] ------------------ 4722| 159k|#line 1133 "bison_parser.y" /* yacc.c:1646 */ 4723| 159k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4724| 159k|#line 4725 "bison_parser.cpp" /* yacc.c:1646 */ 4725| 159k| break; 4726| | 4727| 649k| case 210: ------------------ | Branch (4727:3): [True: 649k, False: 8.93M] ------------------ 4728| 649k|#line 1134 "bison_parser.y" /* yacc.c:1646 */ 4729| 649k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4730| 649k|#line 4731 "bison_parser.cpp" /* yacc.c:1646 */ 4731| 649k| break; 4732| | 4733| 8.69k| case 211: ------------------ | Branch (4733:3): [True: 8.69k, False: 9.57M] ------------------ 4734| 8.69k|#line 1135 "bison_parser.y" /* yacc.c:1646 */ 4735| 8.69k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4736| 8.69k|#line 4737 "bison_parser.cpp" /* yacc.c:1646 */ 4737| 8.69k| break; 4738| | 4739| 4.24k| case 212: ------------------ | Branch (4739:3): [True: 4.24k, False: 9.58M] ------------------ 4740| 4.24k|#line 1136 "bison_parser.y" /* yacc.c:1646 */ 4741| 4.24k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4742| 4.24k|#line 4743 "bison_parser.cpp" /* yacc.c:1646 */ 4743| 4.24k| break; 4744| | 4745| 369| case 213: ------------------ | Branch (4745:3): [True: 369, False: 9.58M] ------------------ 4746| 369|#line 1137 "bison_parser.y" /* yacc.c:1646 */ 4747| 369| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4748| 369|#line 4749 "bison_parser.cpp" /* yacc.c:1646 */ 4749| 369| break; 4750| | 4751| 320| case 214: ------------------ | Branch (4751:3): [True: 320, False: 9.58M] ------------------ 4752| 320|#line 1138 "bison_parser.y" /* yacc.c:1646 */ 4753| 320| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4754| 320|#line 4755 "bison_parser.cpp" /* yacc.c:1646 */ 4755| 320| break; 4756| | 4757| 693| case 215: ------------------ | Branch (4757:3): [True: 693, False: 9.58M] ------------------ 4758| 693|#line 1139 "bison_parser.y" /* yacc.c:1646 */ 4759| 693| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4760| 693|#line 4761 "bison_parser.cpp" /* yacc.c:1646 */ 4761| 693| break; 4762| | 4763| 3.49k| case 216: ------------------ | Branch (4763:3): [True: 3.49k, False: 9.58M] ------------------ 4764| 3.49k|#line 1140 "bison_parser.y" /* yacc.c:1646 */ 4765| 3.49k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4766| 3.49k|#line 4767 "bison_parser.cpp" /* yacc.c:1646 */ 4767| 3.49k| break; 4768| | 4769| 852| case 217: ------------------ | Branch (4769:3): [True: 852, False: 9.58M] ------------------ 4770| 852|#line 1142 "bison_parser.y" /* yacc.c:1646 */ 4771| 852| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4772| 852|#line 4773 "bison_parser.cpp" /* yacc.c:1646 */ 4773| 852| break; 4774| | 4775| 567| case 218: ------------------ | Branch (4775:3): [True: 567, False: 9.58M] ------------------ 4776| 567|#line 1143 "bison_parser.y" /* yacc.c:1646 */ 4777| 567| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } 4778| 567|#line 4779 "bison_parser.cpp" /* yacc.c:1646 */ 4779| 567| break; 4780| | 4781| 368| case 219: ------------------ | Branch (4781:3): [True: 368, False: 9.58M] ------------------ 4782| 368|#line 1145 "bison_parser.y" /* yacc.c:1646 */ 4783| 368| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4784| 368|#line 4785 "bison_parser.cpp" /* yacc.c:1646 */ 4785| 368| break; 4786| | 4787| 200| case 220: ------------------ | Branch (4787:3): [True: 200, False: 9.58M] ------------------ 4788| 200|#line 1146 "bison_parser.y" /* yacc.c:1646 */ 4789| 200| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4790| 200|#line 4791 "bison_parser.cpp" /* yacc.c:1646 */ 4791| 200| break; 4792| | 4793| 266| case 221: ------------------ | Branch (4793:3): [True: 266, False: 9.58M] ------------------ 4794| 266|#line 1147 "bison_parser.y" /* yacc.c:1646 */ 4795| 266| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4796| 266|#line 4797 "bison_parser.cpp" /* yacc.c:1646 */ 4797| 266| break; 4798| | 4799| 198| case 222: ------------------ | Branch (4799:3): [True: 198, False: 9.58M] ------------------ 4800| 198|#line 1148 "bison_parser.y" /* yacc.c:1646 */ 4801| 198| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4802| 198|#line 4803 "bison_parser.cpp" /* yacc.c:1646 */ 4803| 198| break; 4804| | 4805| 305| case 223: ------------------ | Branch (4805:3): [True: 305, False: 9.58M] ------------------ 4806| 305|#line 1152 "bison_parser.y" /* yacc.c:1646 */ 4807| 305| { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } 4808| 305|#line 4809 "bison_parser.cpp" /* yacc.c:1646 */ 4809| 305| break; 4810| | 4811| 205| case 224: ------------------ | Branch (4811:3): [True: 205, False: 9.58M] ------------------ 4812| 205|#line 1153 "bison_parser.y" /* yacc.c:1646 */ 4813| 205| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4814| 205|#line 4815 "bison_parser.cpp" /* yacc.c:1646 */ 4815| 205| break; 4816| | 4817| 714| case 225: ------------------ | Branch (4817:3): [True: 714, False: 9.58M] ------------------ 4818| 714|#line 1154 "bison_parser.y" /* yacc.c:1646 */ 4819| 714| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4820| 714|#line 4821 "bison_parser.cpp" /* yacc.c:1646 */ 4821| 714| break; 4822| | 4823| 481| case 226: ------------------ | Branch (4823:3): [True: 481, False: 9.58M] ------------------ 4824| 481|#line 1155 "bison_parser.y" /* yacc.c:1646 */ 4825| 481| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4826| 481|#line 4827 "bison_parser.cpp" /* yacc.c:1646 */ 4827| 481| break; 4828| | 4829| 1.93k| case 227: ------------------ | Branch (4829:3): [True: 1.93k, False: 9.58M] ------------------ 4830| 1.93k|#line 1157 "bison_parser.y" /* yacc.c:1646 */ 4831| 1.93k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4832| 1.93k|#line 4833 "bison_parser.cpp" /* yacc.c:1646 */ 4833| 1.93k| break; 4834| | 4835| 1.39k| case 228: ------------------ | Branch (4835:3): [True: 1.39k, False: 9.58M] ------------------ 4836| 1.39k|#line 1158 "bison_parser.y" /* yacc.c:1646 */ 4837| 1.39k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4838| 1.39k|#line 4839 "bison_parser.cpp" /* yacc.c:1646 */ 4839| 1.39k| break; 4840| | 4841| 456| case 229: ------------------ | Branch (4841:3): [True: 456, False: 9.58M] ------------------ 4842| 456|#line 1160 "bison_parser.y" /* yacc.c:1646 */ 4843| 456| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4844| 456|#line 4845 "bison_parser.cpp" /* yacc.c:1646 */ 4845| 456| break; 4846| | 4847| 209| case 230: ------------------ | Branch (4847:3): [True: 209, False: 9.58M] ------------------ 4848| 209|#line 1161 "bison_parser.y" /* yacc.c:1646 */ 4849| 209| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4850| 209|#line 4851 "bison_parser.cpp" /* yacc.c:1646 */ 4851| 209| break; 4852| | 4853| 2.78k| case 231: ------------------ | Branch (4853:3): [True: 2.78k, False: 9.58M] ------------------ 4854| 2.78k|#line 1163 "bison_parser.y" /* yacc.c:1646 */ 4855| 2.78k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4856| 2.78k|#line 4857 "bison_parser.cpp" /* yacc.c:1646 */ 4857| 2.78k| break; 4858| | 4859| 459| case 232: ------------------ | Branch (4859:3): [True: 459, False: 9.58M] ------------------ 4860| 459|#line 1164 "bison_parser.y" /* yacc.c:1646 */ 4861| 459| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4862| 459|#line 4863 "bison_parser.cpp" /* yacc.c:1646 */ 4863| 459| break; 4864| | 4865| 1.31k| case 233: ------------------ | Branch (4865:3): [True: 1.31k, False: 9.58M] ------------------ 4866| 1.31k|#line 1165 "bison_parser.y" /* yacc.c:1646 */ 4867| 1.31k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4868| 1.31k|#line 4869 "bison_parser.cpp" /* yacc.c:1646 */ 4869| 1.31k| break; 4870| | 4871| 2.37k| case 234: ------------------ | Branch (4871:3): [True: 2.37k, False: 9.58M] ------------------ 4872| 2.37k|#line 1166 "bison_parser.y" /* yacc.c:1646 */ 4873| 2.37k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4874| 2.37k|#line 4875 "bison_parser.cpp" /* yacc.c:1646 */ 4875| 2.37k| break; 4876| | 4877| 4.06k| case 235: ------------------ | Branch (4877:3): [True: 4.06k, False: 9.58M] ------------------ 4878| 4.06k|#line 1167 "bison_parser.y" /* yacc.c:1646 */ 4879| 4.06k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4880| 4.06k|#line 4881 "bison_parser.cpp" /* yacc.c:1646 */ 4881| 4.06k| break; 4882| | 4883| 1.18k| case 236: ------------------ | Branch (4883:3): [True: 1.18k, False: 9.58M] ------------------ 4884| 1.18k|#line 1168 "bison_parser.y" /* yacc.c:1646 */ 4885| 1.18k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4886| 1.18k|#line 4887 "bison_parser.cpp" /* yacc.c:1646 */ 4887| 1.18k| break; 4888| | 4889| 684| case 237: ------------------ | Branch (4889:3): [True: 684, False: 9.58M] ------------------ 4890| 684|#line 1169 "bison_parser.y" /* yacc.c:1646 */ 4891| 684| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4892| 684|#line 4893 "bison_parser.cpp" /* yacc.c:1646 */ 4893| 684| break; 4894| | 4895| 4.74k| case 238: ------------------ | Branch (4895:3): [True: 4.74k, False: 9.58M] ------------------ 4896| 4.74k|#line 1173 "bison_parser.y" /* yacc.c:1646 */ 4897| 4.74k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4898| 4.74k|#line 4899 "bison_parser.cpp" /* yacc.c:1646 */ 4899| 4.74k| break; 4900| | 4901| 3.26k| case 239: ------------------ | Branch (4901:3): [True: 3.26k, False: 9.58M] ------------------ 4902| 3.26k|#line 1174 "bison_parser.y" /* yacc.c:1646 */ 4903| 3.26k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4904| 3.26k|#line 4905 "bison_parser.cpp" /* yacc.c:1646 */ 4905| 3.26k| break; 4906| | 4907| 204| case 240: ------------------ | Branch (4907:3): [True: 204, False: 9.58M] ------------------ 4908| 204|#line 1175 "bison_parser.y" /* yacc.c:1646 */ 4909| 204| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), (yyvsp[-5].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4910| 204|#line 4911 "bison_parser.cpp" /* yacc.c:1646 */ 4911| 204| break; 4912| | 4913| 202| case 241: ------------------ | Branch (4913:3): [True: 202, False: 9.58M] ------------------ 4914| 202|#line 1176 "bison_parser.y" /* yacc.c:1646 */ 4915| 202| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-7].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4916| 202|#line 4917 "bison_parser.cpp" /* yacc.c:1646 */ 4917| 202| break; 4918| | 4919| 5.78k| case 242: ------------------ | Branch (4919:3): [True: 5.78k, False: 9.58M] ------------------ 4920| 5.78k|#line 1180 "bison_parser.y" /* yacc.c:1646 */ 4921| 5.78k| { (yyval.window_description) = new WindowDescription((yyvsp[-3].expr_vec), (yyvsp[-2].order_vec), (yyvsp[-1].frame_description)); } 4922| 5.78k|#line 4923 "bison_parser.cpp" /* yacc.c:1646 */ 4923| 5.78k| break; 4924| | 4925| 2.63k| case 243: ------------------ | Branch (4925:3): [True: 2.63k, False: 9.58M] ------------------ 4926| 2.63k|#line 1181 "bison_parser.y" /* yacc.c:1646 */ 4927| 2.63k| { (yyval.window_description) = nullptr; } 4928| 2.63k|#line 4929 "bison_parser.cpp" /* yacc.c:1646 */ 4929| 2.63k| break; 4930| | 4931| 710| case 244: ------------------ | Branch (4931:3): [True: 710, False: 9.58M] ------------------ 4932| 710|#line 1183 "bison_parser.y" /* yacc.c:1646 */ 4933| 710| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4934| 710|#line 4935 "bison_parser.cpp" /* yacc.c:1646 */ 4935| 710| break; 4936| | 4937| 5.27k| case 245: ------------------ | Branch (4937:3): [True: 5.27k, False: 9.58M] ------------------ 4938| 5.27k|#line 1184 "bison_parser.y" /* yacc.c:1646 */ 4939| 5.27k| { (yyval.expr_vec) = nullptr; } 4940| 5.27k|#line 4941 "bison_parser.cpp" /* yacc.c:1646 */ 4941| 5.27k| break; 4942| | 4943| 3.45k| case 246: ------------------ | Branch (4943:3): [True: 3.45k, False: 9.58M] ------------------ 4944| 3.45k|#line 1189 "bison_parser.y" /* yacc.c:1646 */ 4945| 3.45k| { (yyval.frame_description) = new FrameDescription{(yyvsp[-1].frame_type), (yyvsp[0].frame_bound), new FrameBound{0, kCurrentRow, false}}; } 4946| 3.45k|#line 4947 "bison_parser.cpp" /* yacc.c:1646 */ 4947| 3.45k| break; 4948| | 4949| 194| case 247: ------------------ | Branch (4949:3): [True: 194, False: 9.58M] ------------------ 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.20k| case 248: ------------------ | Branch (4955:3): [True: 2.20k, False: 9.58M] ------------------ 4956| 2.20k|#line 1191 "bison_parser.y" /* yacc.c:1646 */ 4957| 2.20k| { 4958| 2.20k| (yyval.frame_description) = new FrameDescription{kRange, new FrameBound{0, kPreceding, true}, new FrameBound{0, kCurrentRow, false}}; 4959| 2.20k|} 4960| 2.20k|#line 4961 "bison_parser.cpp" /* yacc.c:1646 */ 4961| 2.20k| break; 4962| | 4963| 1.44k| case 249: ------------------ | Branch (4963:3): [True: 1.44k, False: 9.58M] ------------------ 4964| 1.44k|#line 1195 "bison_parser.y" /* yacc.c:1646 */ 4965| 1.44k| { (yyval.frame_type) = kRange; } 4966| 1.44k|#line 4967 "bison_parser.cpp" /* yacc.c:1646 */ 4967| 1.44k| break; 4968| | 4969| 1.52k| case 250: ------------------ | Branch (4969:3): [True: 1.52k, False: 9.58M] ------------------ 4970| 1.52k|#line 1196 "bison_parser.y" /* yacc.c:1646 */ 4971| 1.52k| { (yyval.frame_type) = kRows; } 4972| 1.52k|#line 4973 "bison_parser.cpp" /* yacc.c:1646 */ 4973| 1.52k| break; 4974| | 4975| 723| case 251: ------------------ | Branch (4975:3): [True: 723, False: 9.58M] ------------------ 4976| 723|#line 1197 "bison_parser.y" /* yacc.c:1646 */ 4977| 723| { (yyval.frame_type) = kGroups; } 4978| 723|#line 4979 "bison_parser.cpp" /* yacc.c:1646 */ 4979| 723| break; 4980| | 4981| 632| case 252: ------------------ | Branch (4981:3): [True: 632, False: 9.58M] ------------------ 4982| 632|#line 1199 "bison_parser.y" /* yacc.c:1646 */ 4983| 632| { (yyval.frame_bound) = new FrameBound{0, kPreceding, true}; } 4984| 632|#line 4985 "bison_parser.cpp" /* yacc.c:1646 */ 4985| 632| break; 4986| | 4987| 893| case 253: ------------------ | Branch (4987:3): [True: 893, False: 9.58M] ------------------ 4988| 893|#line 1200 "bison_parser.y" /* yacc.c:1646 */ 4989| 893| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kPreceding, false}; } 4990| 893|#line 4991 "bison_parser.cpp" /* yacc.c:1646 */ 4991| 893| break; 4992| | 4993| 388| case 254: ------------------ | Branch (4993:3): [True: 388, False: 9.58M] ------------------ 4994| 388|#line 1201 "bison_parser.y" /* yacc.c:1646 */ 4995| 388| { (yyval.frame_bound) = new FrameBound{0, kFollowing, true}; } 4996| 388|#line 4997 "bison_parser.cpp" /* yacc.c:1646 */ 4997| 388| break; 4998| | 4999| 1.93k| case 255: ------------------ | Branch (4999:3): [True: 1.93k, False: 9.58M] ------------------ 5000| 1.93k|#line 1202 "bison_parser.y" /* yacc.c:1646 */ 5001| 1.93k| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kFollowing, false}; } 5002| 1.93k|#line 5003 "bison_parser.cpp" /* yacc.c:1646 */ 5003| 1.93k| break; 5004| | 5005| 0| case 256: ------------------ | Branch (5005:3): [True: 0, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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: 9.58M] ------------------ 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: 9.58M] ------------------ 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| 963| case 260: ------------------ | Branch (5029:3): [True: 963, False: 9.58M] ------------------ 5030| 963|#line 1210 "bison_parser.y" /* yacc.c:1646 */ 5031| 963| { (yyval.datetime_field) = kDatetimeMinute; } 5032| 963|#line 5033 "bison_parser.cpp" /* yacc.c:1646 */ 5033| 963| break; 5034| | 5035| 979| case 261: ------------------ | Branch (5035:3): [True: 979, False: 9.58M] ------------------ 5036| 979|#line 1211 "bison_parser.y" /* yacc.c:1646 */ 5037| 979| { (yyval.datetime_field) = kDatetimeHour; } 5038| 979|#line 5039 "bison_parser.cpp" /* yacc.c:1646 */ 5039| 979| break; 5040| | 5041| 1.90k| case 262: ------------------ | Branch (5041:3): [True: 1.90k, False: 9.58M] ------------------ 5042| 1.90k|#line 1212 "bison_parser.y" /* yacc.c:1646 */ 5043| 1.90k| { (yyval.datetime_field) = kDatetimeDay; } 5044| 1.90k|#line 5045 "bison_parser.cpp" /* yacc.c:1646 */ 5045| 1.90k| break; 5046| | 5047| 716| case 263: ------------------ | Branch (5047:3): [True: 716, False: 9.58M] ------------------ 5048| 716|#line 1213 "bison_parser.y" /* yacc.c:1646 */ 5049| 716| { (yyval.datetime_field) = kDatetimeMonth; } 5050| 716|#line 5051 "bison_parser.cpp" /* yacc.c:1646 */ 5051| 716| break; 5052| | 5053| 512| case 264: ------------------ | Branch (5053:3): [True: 512, False: 9.58M] ------------------ 5054| 512|#line 1214 "bison_parser.y" /* yacc.c:1646 */ 5055| 512| { (yyval.datetime_field) = kDatetimeYear; } 5056| 512|#line 5057 "bison_parser.cpp" /* yacc.c:1646 */ 5057| 512| break; 5058| | 5059| 851| case 265: ------------------ | Branch (5059:3): [True: 851, False: 9.58M] ------------------ 5060| 851|#line 1216 "bison_parser.y" /* yacc.c:1646 */ 5061| 851| { (yyval.datetime_field) = kDatetimeSecond; } 5062| 851|#line 5063 "bison_parser.cpp" /* yacc.c:1646 */ 5063| 851| break; 5064| | 5065| 1.05k| case 266: ------------------ | Branch (5065:3): [True: 1.05k, False: 9.58M] ------------------ 5066| 1.05k|#line 1217 "bison_parser.y" /* yacc.c:1646 */ 5067| 1.05k| { (yyval.datetime_field) = kDatetimeMinute; } 5068| 1.05k|#line 5069 "bison_parser.cpp" /* yacc.c:1646 */ 5069| 1.05k| break; 5070| | 5071| 635| case 267: ------------------ | Branch (5071:3): [True: 635, False: 9.58M] ------------------ 5072| 635|#line 1218 "bison_parser.y" /* yacc.c:1646 */ 5073| 635| { (yyval.datetime_field) = kDatetimeHour; } 5074| 635|#line 5075 "bison_parser.cpp" /* yacc.c:1646 */ 5075| 635| break; 5076| | 5077| 520| case 268: ------------------ | Branch (5077:3): [True: 520, False: 9.58M] ------------------ 5078| 520|#line 1219 "bison_parser.y" /* yacc.c:1646 */ 5079| 520| { (yyval.datetime_field) = kDatetimeDay; } 5080| 520|#line 5081 "bison_parser.cpp" /* yacc.c:1646 */ 5081| 520| break; 5082| | 5083| 359| case 269: ------------------ | Branch (5083:3): [True: 359, False: 9.58M] ------------------ 5084| 359|#line 1220 "bison_parser.y" /* yacc.c:1646 */ 5085| 359| { (yyval.datetime_field) = kDatetimeMonth; } 5086| 359|#line 5087 "bison_parser.cpp" /* yacc.c:1646 */ 5087| 359| break; 5088| | 5089| 463| case 270: ------------------ | Branch (5089:3): [True: 463, False: 9.58M] ------------------ 5090| 463|#line 1221 "bison_parser.y" /* yacc.c:1646 */ 5091| 463| { (yyval.datetime_field) = kDatetimeYear; } 5092| 463|#line 5093 "bison_parser.cpp" /* yacc.c:1646 */ 5093| 463| break; 5094| | 5095| 518| case 273: ------------------ | Branch (5095:3): [True: 518, False: 9.58M] ------------------ 5096| 518|#line 1225 "bison_parser.y" /* yacc.c:1646 */ 5097| 518| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 5098| 518|#line 5099 "bison_parser.cpp" /* yacc.c:1646 */ 5099| 518| break; 5100| | 5101| 202| case 274: ------------------ | Branch (5101:3): [True: 202, False: 9.58M] ------------------ 5102| 202|#line 1227 "bison_parser.y" /* yacc.c:1646 */ 5103| 202| { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } 5104| 202|#line 5105 "bison_parser.cpp" /* yacc.c:1646 */ 5105| 202| break; 5106| | 5107| 359| case 275: ------------------ | Branch (5107:3): [True: 359, False: 9.58M] ------------------ 5108| 359|#line 1229 "bison_parser.y" /* yacc.c:1646 */ 5109| 359| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 5110| 359|#line 5111 "bison_parser.cpp" /* yacc.c:1646 */ 5111| 359| break; 5112| | 5113| 134k| case 276: ------------------ | Branch (5113:3): [True: 134k, False: 9.45M] ------------------ 5114| 134k|#line 1231 "bison_parser.y" /* yacc.c:1646 */ 5115| 134k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 5116| 134k|#line 5117 "bison_parser.cpp" /* yacc.c:1646 */ 5117| 134k| break; 5118| | 5119| 966| case 277: ------------------ | Branch (5119:3): [True: 966, False: 9.58M] ------------------ 5120| 966|#line 1232 "bison_parser.y" /* yacc.c:1646 */ 5121| 966| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 5122| 966|#line 5123 "bison_parser.cpp" /* yacc.c:1646 */ 5123| 966| break; 5124| | 5125| 785k| case 278: ------------------ | Branch (5125:3): [True: 785k, False: 8.80M] ------------------ 5126| 785k|#line 1233 "bison_parser.y" /* yacc.c:1646 */ 5127| 785k| { (yyval.expr) = Expr::makeStar(); } 5128| 785k|#line 5129 "bison_parser.cpp" /* yacc.c:1646 */ 5129| 785k| break; 5130| | 5131| 705| case 279: ------------------ | Branch (5131:3): [True: 705, False: 9.58M] ------------------ 5132| 705|#line 1234 "bison_parser.y" /* yacc.c:1646 */ 5133| 705| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 5134| 705|#line 5135 "bison_parser.cpp" /* yacc.c:1646 */ 5135| 705| break; 5136| | 5137| 5.24k| case 287: ------------------ | Branch (5137:3): [True: 5.24k, False: 9.58M] ------------------ 5138| 5.24k|#line 1238 "bison_parser.y" /* yacc.c:1646 */ 5139| 5.24k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 5140| 5.24k|#line 5141 "bison_parser.cpp" /* yacc.c:1646 */ 5141| 5.24k| break; 5142| | 5143| 643| case 288: ------------------ | Branch (5143:3): [True: 643, False: 9.58M] ------------------ 5144| 643|#line 1240 "bison_parser.y" /* yacc.c:1646 */ 5145| 643| { (yyval.expr) = Expr::makeLiteral(true); } 5146| 643|#line 5147 "bison_parser.cpp" /* yacc.c:1646 */ 5147| 643| break; 5148| | 5149| 664| case 289: ------------------ | Branch (5149:3): [True: 664, False: 9.58M] ------------------ 5150| 664|#line 1241 "bison_parser.y" /* yacc.c:1646 */ 5151| 664| { (yyval.expr) = Expr::makeLiteral(false); } 5152| 664|#line 5153 "bison_parser.cpp" /* yacc.c:1646 */ 5153| 664| break; 5154| | 5155| 2.08k| case 290: ------------------ | Branch (5155:3): [True: 2.08k, False: 9.58M] ------------------ 5156| 2.08k|#line 1243 "bison_parser.y" /* yacc.c:1646 */ 5157| 2.08k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 5158| 2.08k|#line 5159 "bison_parser.cpp" /* yacc.c:1646 */ 5159| 2.08k| break; 5160| | 5161| 12.0k| case 292: ------------------ | Branch (5161:3): [True: 12.0k, False: 9.57M] ------------------ 5162| 12.0k|#line 1246 "bison_parser.y" /* yacc.c:1646 */ 5163| 12.0k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 5164| 12.0k|#line 5165 "bison_parser.cpp" /* yacc.c:1646 */ 5165| 12.0k| break; 5166| | 5167| 2.32k| case 293: ------------------ | Branch (5167:3): [True: 2.32k, False: 9.58M] ------------------ 5168| 2.32k|#line 1248 "bison_parser.y" /* yacc.c:1646 */ 5169| 2.32k| { (yyval.expr) = Expr::makeNullLiteral(); } 5170| 2.32k|#line 5171 "bison_parser.cpp" /* yacc.c:1646 */ 5171| 2.32k| break; 5172| | 5173| 287| case 294: ------------------ | Branch (5173:3): [True: 287, False: 9.58M] ------------------ 5174| 287|#line 1250 "bison_parser.y" /* yacc.c:1646 */ 5175| 287| { 5176| 287| 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| 287| 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: 3, False: 284] | Branch (5178:92): [True: 8, False: 276] ------------------ 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| 276| (yyval.expr) = Expr::makeDateLiteral((yyvsp[0].sval)); 5184| 276|} 5185| 0|#line 5186 "bison_parser.cpp" /* yacc.c:1646 */ 5186| 0| break; 5187| | 5188| 8.56k| case 295: ------------------ | Branch (5188:3): [True: 8.56k, False: 9.57M] ------------------ 5189| 8.56k|#line 1261 "bison_parser.y" /* yacc.c:1646 */ 5190| 8.56k| { (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].ival), (yyvsp[0].datetime_field)); } 5191| 8.56k|#line 5192 "bison_parser.cpp" /* yacc.c:1646 */ 5192| 8.56k| break; 5193| | 5194| 346| case 296: ------------------ | Branch (5194:3): [True: 346, False: 9.58M] ------------------ 5195| 346|#line 1262 "bison_parser.y" /* yacc.c:1646 */ 5196| 346| { 5197| 346| 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| 346| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (5199:7): [True: 2, False: 344] | Branch (5199:74): [True: 7, False: 337] ------------------ 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| 337| free((yyvsp[-1].sval)); 5205| 337| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 5206| 337|} 5207| 0|#line 5208 "bison_parser.cpp" /* yacc.c:1646 */ 5208| 0| break; 5209| | 5210| 4.28k| case 297: ------------------ | Branch (5210:3): [True: 4.28k, False: 9.58M] ------------------ 5211| 4.28k|#line 1273 "bison_parser.y" /* yacc.c:1646 */ 5212| 4.28k| { 5213| 4.28k| int duration{0}, chars_parsed{0}; 5214| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 5215| 4.28k| 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.28k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5217:7): [True: 7, False: 4.27k] | Branch (5217:90): [True: 5, False: 4.26k] ------------------ 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.26k| free((yyvsp[0].sval)); 5223| | 5224| 4.26k| DatetimeField unit; 5225| 4.26k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (5225:7): [True: 398, False: 3.87k] | Branch (5225:49): [True: 571, False: 3.30k] ------------------ 5226| 969| unit = kDatetimeSecond; 5227| 3.30k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (5227:14): [True: 205, False: 3.09k] | Branch (5227:56): [True: 194, False: 2.90k] ------------------ 5228| 399| unit = kDatetimeMinute; 5229| 2.90k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (5229:14): [True: 194, False: 2.70k] | Branch (5229:54): [True: 1.09k, False: 1.61k] ------------------ 5230| 1.28k| unit = kDatetimeHour; 5231| 1.61k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (5231:14): [True: 254, False: 1.36k] | Branch (5231:53): [True: 202, False: 1.16k] ------------------ 5232| 456| unit = kDatetimeDay; 5233| 1.16k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (5233:14): [True: 194, False: 966] | Branch (5233:55): [True: 198, False: 768] ------------------ 5234| 392| unit = kDatetimeMonth; 5235| 768| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (5235:14): [True: 230, False: 538] | Branch (5235:54): [True: 302, False: 236] ------------------ 5236| 532| unit = kDatetimeYear; 5237| 532| } else { 5238| 236| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 67| 236|#define yyerror hsql_error ------------------ 5239| 236| YYERROR; ------------------ | | 1458| 236|#define YYERROR goto yyerrorlab ------------------ 5240| 236| } 5241| 4.03k| (yyval.expr) = Expr::makeIntervalLiteral(duration, unit); 5242| 4.03k|} 5243| 0|#line 5244 "bison_parser.cpp" /* yacc.c:1646 */ 5244| 0| break; 5245| | 5246| 227k| case 298: ------------------ | Branch (5246:3): [True: 227k, False: 9.35M] ------------------ 5247| 227k|#line 1305 "bison_parser.y" /* yacc.c:1646 */ 5248| 227k| { 5249| 227k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 5250| 227k| (yyval.expr)->ival2 = yyloc.param_list.size(); 5251| 227k| yyloc.param_list.push_back((yyval.expr)); 5252| 227k|} 5253| 227k|#line 5254 "bison_parser.cpp" /* yacc.c:1646 */ 5254| 227k| break; 5255| | 5256| 1.98k| case 300: ------------------ | Branch (5256:3): [True: 1.98k, False: 9.58M] ------------------ 5257| 1.98k|#line 1314 "bison_parser.y" /* yacc.c:1646 */ 5258| 1.98k| { 5259| 1.98k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5260| 1.98k| auto tbl = new TableRef(kTableCrossProduct); 5261| 1.98k| tbl->list = (yyvsp[-2].table_vec); 5262| 1.98k| (yyval.table) = tbl; 5263| 1.98k|} 5264| 1.98k|#line 5265 "bison_parser.cpp" /* yacc.c:1646 */ 5265| 1.98k| break; 5266| | 5267| 683| case 304: ------------------ | Branch (5267:3): [True: 683, False: 9.58M] ------------------ 5268| 683|#line 1323 "bison_parser.y" /* yacc.c:1646 */ 5269| 683| { 5270| 683| auto tbl = new TableRef(kTableSelect); 5271| 683| tbl->select = (yyvsp[-2].select_stmt); 5272| 683| tbl->alias = (yyvsp[0].alias_t); 5273| 683| (yyval.table) = tbl; 5274| 683|} 5275| 683|#line 5276 "bison_parser.cpp" /* yacc.c:1646 */ 5276| 683| break; 5277| | 5278| 2.06k| case 305: ------------------ | Branch (5278:3): [True: 2.06k, False: 9.58M] ------------------ 5279| 2.06k|#line 1330 "bison_parser.y" /* yacc.c:1646 */ 5280| 2.06k| { 5281| 2.06k| (yyval.table_vec) = new std::vector(); 5282| 2.06k| (yyval.table_vec)->push_back((yyvsp[0].table)); 5283| 2.06k|} 5284| 2.06k|#line 5285 "bison_parser.cpp" /* yacc.c:1646 */ 5285| 2.06k| break; 5286| | 5287| 110k| case 306: ------------------ | Branch (5287:3): [True: 110k, False: 9.47M] ------------------ 5288| 110k|#line 1334 "bison_parser.y" /* yacc.c:1646 */ 5289| 110k| { 5290| 110k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5291| 110k| (yyval.table_vec) = (yyvsp[-2].table_vec); 5292| 110k|} 5293| 110k|#line 5294 "bison_parser.cpp" /* yacc.c:1646 */ 5294| 110k| break; 5295| | 5296| 229k| case 307: ------------------ | Branch (5296:3): [True: 229k, False: 9.35M] ------------------ 5297| 229k|#line 1339 "bison_parser.y" /* yacc.c:1646 */ 5298| 229k| { 5299| 229k| auto tbl = new TableRef(kTableName); 5300| 229k| tbl->schema = (yyvsp[-1].table_name).schema; 5301| 229k| tbl->name = (yyvsp[-1].table_name).name; 5302| 229k| tbl->alias = (yyvsp[0].alias_t); 5303| 229k| (yyval.table) = tbl; 5304| 229k|} 5305| 229k|#line 5306 "bison_parser.cpp" /* yacc.c:1646 */ 5306| 229k| break; 5307| | 5308| 2.85k| case 308: ------------------ | Branch (5308:3): [True: 2.85k, False: 9.58M] ------------------ 5309| 2.85k|#line 1347 "bison_parser.y" /* yacc.c:1646 */ 5310| 2.85k| { 5311| 2.85k| (yyval.table) = new TableRef(kTableName); 5312| 2.85k| (yyval.table)->schema = (yyvsp[0].table_name).schema; 5313| 2.85k| (yyval.table)->name = (yyvsp[0].table_name).name; 5314| 2.85k|} 5315| 2.85k|#line 5316 "bison_parser.cpp" /* yacc.c:1646 */ 5316| 2.85k| break; 5317| | 5318| 271k| case 309: ------------------ | Branch (5318:3): [True: 271k, False: 9.31M] ------------------ 5319| 271k|#line 1353 "bison_parser.y" /* yacc.c:1646 */ 5320| 271k| { 5321| 271k| (yyval.table_name).schema = nullptr; 5322| 271k| (yyval.table_name).name = (yyvsp[0].sval); 5323| 271k|} 5324| 271k|#line 5325 "bison_parser.cpp" /* yacc.c:1646 */ 5325| 271k| break; 5326| | 5327| 194| case 310: ------------------ | Branch (5327:3): [True: 194, False: 9.58M] ------------------ 5328| 194|#line 1357 "bison_parser.y" /* yacc.c:1646 */ 5329| 194| { 5330| 194| (yyval.table_name).schema = (yyvsp[-2].sval); 5331| 194| (yyval.table_name).name = (yyvsp[0].sval); 5332| 194|} 5333| 194|#line 5334 "bison_parser.cpp" /* yacc.c:1646 */ 5334| 194| break; 5335| | 5336| 236| case 311: ------------------ | Branch (5336:3): [True: 236, False: 9.58M] ------------------ 5337| 236|#line 1362 "bison_parser.y" /* yacc.c:1646 */ 5338| 236| { (yyval.sval) = (yyvsp[0].sval); } 5339| 236|#line 5340 "bison_parser.cpp" /* yacc.c:1646 */ 5340| 236| break; 5341| | 5342| 1.07k| case 312: ------------------ | Branch (5342:3): [True: 1.07k, False: 9.58M] ------------------ 5343| 1.07k|#line 1363 "bison_parser.y" /* yacc.c:1646 */ 5344| 1.07k| { (yyval.sval) = nullptr; } 5345| 1.07k|#line 5346 "bison_parser.cpp" /* yacc.c:1646 */ 5346| 1.07k| break; 5347| | 5348| 314| case 314: ------------------ | Branch (5348:3): [True: 314, False: 9.58M] ------------------ 5349| 314|#line 1365 "bison_parser.y" /* yacc.c:1646 */ 5350| 314| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5351| 314|#line 5352 "bison_parser.cpp" /* yacc.c:1646 */ 5352| 314| break; 5353| | 5354| 218k| case 316: ------------------ | Branch (5354:3): [True: 218k, False: 9.36M] ------------------ 5355| 218k|#line 1367 "bison_parser.y" /* yacc.c:1646 */ 5356| 218k| { (yyval.alias_t) = nullptr; } 5357| 218k|#line 5358 "bison_parser.cpp" /* yacc.c:1646 */ 5358| 218k| break; 5359| | 5360| 342| case 317: ------------------ | Branch (5360:3): [True: 342, False: 9.58M] ------------------ 5361| 342|#line 1369 "bison_parser.y" /* yacc.c:1646 */ 5362| 342| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5363| 342|#line 5364 "bison_parser.cpp" /* yacc.c:1646 */ 5364| 342| break; 5365| | 5366| 24.2k| case 318: ------------------ | Branch (5366:3): [True: 24.2k, False: 9.56M] ------------------ 5367| 24.2k|#line 1370 "bison_parser.y" /* yacc.c:1646 */ 5368| 24.2k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5369| 24.2k|#line 5370 "bison_parser.cpp" /* yacc.c:1646 */ 5370| 24.2k| break; 5371| | 5372| 168k| case 320: ------------------ | Branch (5372:3): [True: 168k, False: 9.41M] ------------------ 5373| 168k|#line 1372 "bison_parser.y" /* yacc.c:1646 */ 5374| 168k| { (yyval.alias_t) = nullptr; } 5375| 168k|#line 5376 "bison_parser.cpp" /* yacc.c:1646 */ 5376| 168k| break; 5377| | 5378| 425| case 321: ------------------ | Branch (5378:3): [True: 425, False: 9.58M] ------------------ 5379| 425|#line 1378 "bison_parser.y" /* yacc.c:1646 */ 5380| 425| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5381| 425|#line 5382 "bison_parser.cpp" /* yacc.c:1646 */ 5382| 425| break; 5383| | 5384| 36.1k| case 322: ------------------ | Branch (5384:3): [True: 36.1k, False: 9.54M] ------------------ 5385| 36.1k|#line 1379 "bison_parser.y" /* yacc.c:1646 */ 5386| 36.1k| { (yyval.locking_clause_vec) = nullptr; } 5387| 36.1k|#line 5388 "bison_parser.cpp" /* yacc.c:1646 */ 5388| 36.1k| break; 5389| | 5390| 451| case 323: ------------------ | Branch (5390:3): [True: 451, False: 9.58M] ------------------ 5391| 451|#line 1381 "bison_parser.y" /* yacc.c:1646 */ 5392| 451| { 5393| 451| (yyval.locking_clause_vec) = new std::vector(); 5394| 451| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5395| 451|} 5396| 451|#line 5397 "bison_parser.cpp" /* yacc.c:1646 */ 5397| 451| break; 5398| | 5399| 3.66k| case 324: ------------------ | Branch (5399:3): [True: 3.66k, False: 9.58M] ------------------ 5400| 3.66k|#line 1385 "bison_parser.y" /* yacc.c:1646 */ 5401| 3.66k| { 5402| 3.66k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5403| 3.66k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5404| 3.66k|} 5405| 3.66k|#line 5406 "bison_parser.cpp" /* yacc.c:1646 */ 5406| 3.66k| break; 5407| | 5408| 3.84k| case 325: ------------------ | Branch (5408:3): [True: 3.84k, False: 9.58M] ------------------ 5409| 3.84k|#line 1390 "bison_parser.y" /* yacc.c:1646 */ 5410| 3.84k| { 5411| 3.84k| (yyval.locking_t) = new LockingClause(); 5412| 3.84k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5413| 3.84k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5414| 3.84k| (yyval.locking_t)->tables = nullptr; 5415| 3.84k|} 5416| 3.84k|#line 5417 "bison_parser.cpp" /* yacc.c:1646 */ 5417| 3.84k| break; 5418| | 5419| 274| case 326: ------------------ | Branch (5419:3): [True: 274, False: 9.58M] ------------------ 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| 757| case 327: ------------------ | Branch (5430:3): [True: 757, False: 9.58M] ------------------ 5431| 757|#line 1403 "bison_parser.y" /* yacc.c:1646 */ 5432| 757| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5433| 757|#line 5434 "bison_parser.cpp" /* yacc.c:1646 */ 5434| 757| break; 5435| | 5436| 0| case 328: ------------------ | Branch (5436:3): [True: 0, False: 9.58M] ------------------ 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| 3.15k| case 329: ------------------ | Branch (5442:3): [True: 3.15k, False: 9.58M] ------------------ 5443| 3.15k|#line 1405 "bison_parser.y" /* yacc.c:1646 */ 5444| 3.15k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5445| 3.15k|#line 5446 "bison_parser.cpp" /* yacc.c:1646 */ 5446| 3.15k| break; 5447| | 5448| 216| case 330: ------------------ | Branch (5448:3): [True: 216, False: 9.58M] ------------------ 5449| 216|#line 1406 "bison_parser.y" /* yacc.c:1646 */ 5450| 216| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5451| 216|#line 5452 "bison_parser.cpp" /* yacc.c:1646 */ 5452| 216| break; 5453| | 5454| 0| case 331: ------------------ | Branch (5454:3): [True: 0, False: 9.58M] ------------------ 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| 782| case 332: ------------------ | Branch (5460:3): [True: 782, False: 9.58M] ------------------ 5461| 782|#line 1409 "bison_parser.y" /* yacc.c:1646 */ 5462| 782| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5463| 782|#line 5464 "bison_parser.cpp" /* yacc.c:1646 */ 5464| 782| break; 5465| | 5466| 3.33k| case 333: ------------------ | Branch (5466:3): [True: 3.33k, False: 9.58M] ------------------ 5467| 3.33k|#line 1410 "bison_parser.y" /* yacc.c:1646 */ 5468| 3.33k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5469| 3.33k|#line 5470 "bison_parser.cpp" /* yacc.c:1646 */ 5470| 3.33k| break; 5471| | 5472| 30.2k| case 335: ------------------ | Branch (5472:3): [True: 30.2k, False: 9.55M] ------------------ 5473| 30.2k|#line 1416 "bison_parser.y" /* yacc.c:1646 */ 5474| 30.2k| { (yyval.with_description_vec) = nullptr; } 5475| 30.2k|#line 5476 "bison_parser.cpp" /* yacc.c:1646 */ 5476| 30.2k| break; 5477| | 5478| 1.15k| case 336: ------------------ | Branch (5478:3): [True: 1.15k, False: 9.58M] ------------------ 5479| 1.15k|#line 1418 "bison_parser.y" /* yacc.c:1646 */ 5480| 1.15k| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5481| 1.15k|#line 5482 "bison_parser.cpp" /* yacc.c:1646 */ 5482| 1.15k| break; 5483| | 5484| 1.19k| case 337: ------------------ | Branch (5484:3): [True: 1.19k, False: 9.58M] ------------------ 5485| 1.19k|#line 1420 "bison_parser.y" /* yacc.c:1646 */ 5486| 1.19k| { 5487| 1.19k| (yyval.with_description_vec) = new std::vector(); 5488| 1.19k| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5489| 1.19k|} 5490| 1.19k|#line 5491 "bison_parser.cpp" /* yacc.c:1646 */ 5491| 1.19k| break; 5492| | 5493| 887| case 338: ------------------ | Branch (5493:3): [True: 887, False: 9.58M] ------------------ 5494| 887|#line 1424 "bison_parser.y" /* yacc.c:1646 */ 5495| 887| { 5496| 887| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5497| 887| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5498| 887|} 5499| 887|#line 5500 "bison_parser.cpp" /* yacc.c:1646 */ 5500| 887| break; 5501| | 5502| 2.08k| case 339: ------------------ | Branch (5502:3): [True: 2.08k, False: 9.58M] ------------------ 5503| 2.08k|#line 1429 "bison_parser.y" /* yacc.c:1646 */ 5504| 2.08k| { 5505| 2.08k| (yyval.with_description_t) = new WithDescription(); 5506| 2.08k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5507| 2.08k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5508| 2.08k|} 5509| 2.08k|#line 5510 "bison_parser.cpp" /* yacc.c:1646 */ 5510| 2.08k| break; 5511| | 5512| 792| case 340: ------------------ | Branch (5512:3): [True: 792, False: 9.58M] ------------------ 5513| 792|#line 1439 "bison_parser.y" /* yacc.c:1646 */ 5514| 792| { 5515| 792| (yyval.table) = new TableRef(kTableJoin); 5516| 792| (yyval.table)->join = new JoinDefinition(); 5517| 792| (yyval.table)->join->type = kJoinNatural; 5518| 792| (yyval.table)->join->left = (yyvsp[-3].table); 5519| 792| (yyval.table)->join->right = (yyvsp[0].table); 5520| 792|} 5521| 792|#line 5522 "bison_parser.cpp" /* yacc.c:1646 */ 5522| 792| break; 5523| | 5524| 110k| case 341: ------------------ | Branch (5524:3): [True: 110k, False: 9.47M] ------------------ 5525| 110k|#line 1446 "bison_parser.y" /* yacc.c:1646 */ 5526| 110k| { 5527| 110k| (yyval.table) = new TableRef(kTableJoin); 5528| 110k| (yyval.table)->join = new JoinDefinition(); 5529| 110k| (yyval.table)->join->type = (JoinType)(yyvsp[-4].join_type); 5530| 110k| (yyval.table)->join->left = (yyvsp[-5].table); 5531| 110k| (yyval.table)->join->right = (yyvsp[-2].table); 5532| 110k| (yyval.table)->join->condition = (yyvsp[0].expr); 5533| 110k|} 5534| 110k|#line 5535 "bison_parser.cpp" /* yacc.c:1646 */ 5535| 110k| break; 5536| | 5537| 716| case 342: ------------------ | Branch (5537:3): [True: 716, False: 9.58M] ------------------ 5538| 716|#line 1454 "bison_parser.y" /* yacc.c:1646 */ 5539| 716| { 5540| 716| (yyval.table) = new TableRef(kTableJoin); 5541| 716| (yyval.table)->join = new JoinDefinition(); 5542| 716| (yyval.table)->join->type = (yyvsp[-6].join_type); 5543| 716| (yyval.table)->join->left = (yyvsp[-7].table); 5544| 716| (yyval.table)->join->right = (yyvsp[-4].table); 5545| 716| (yyval.table)->join->namedColumns = (yyvsp[-1].str_vec); 5546| 716|} 5547| 716|#line 5548 "bison_parser.cpp" /* yacc.c:1646 */ 5548| 716| break; 5549| | 5550| 700| case 343: ------------------ | Branch (5550:3): [True: 700, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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| 514| case 345: ------------------ | Branch (5562:3): [True: 514, False: 9.58M] ------------------ 5563| 514|#line 1465 "bison_parser.y" /* yacc.c:1646 */ 5564| 514| { (yyval.join_type) = kJoinLeft; } 5565| 514|#line 5566 "bison_parser.cpp" /* yacc.c:1646 */ 5566| 514| break; 5567| | 5568| 74| case 346: ------------------ | Branch (5568:3): [True: 74, False: 9.58M] ------------------ 5569| 74|#line 1466 "bison_parser.y" /* yacc.c:1646 */ 5570| 74| { (yyval.join_type) = kJoinRight; } 5571| 74|#line 5572 "bison_parser.cpp" /* yacc.c:1646 */ 5572| 74| break; 5573| | 5574| 468| case 347: ------------------ | Branch (5574:3): [True: 468, False: 9.58M] ------------------ 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: 9.58M] ------------------ 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| 937| case 349: ------------------ | Branch (5586:3): [True: 937, False: 9.58M] ------------------ 5587| 937|#line 1469 "bison_parser.y" /* yacc.c:1646 */ 5588| 937| { (yyval.join_type) = kJoinFull; } 5589| 937|#line 5590 "bison_parser.cpp" /* yacc.c:1646 */ 5590| 937| break; 5591| | 5592| 78| case 350: ------------------ | Branch (5592:3): [True: 78, False: 9.58M] ------------------ 5593| 78|#line 1470 "bison_parser.y" /* yacc.c:1646 */ 5594| 78| { (yyval.join_type) = kJoinFull; } 5595| 78|#line 5596 "bison_parser.cpp" /* yacc.c:1646 */ 5596| 78| break; 5597| | 5598| 671| case 351: ------------------ | Branch (5598:3): [True: 671, False: 9.58M] ------------------ 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| 109k| case 352: ------------------ | Branch (5604:3): [True: 109k, False: 9.47M] ------------------ 5605| 109k|#line 1472 "bison_parser.y" /* yacc.c:1646 */ 5606| 109k| { (yyval.join_type) = kJoinInner; } 5607| 109k|#line 5608 "bison_parser.cpp" /* yacc.c:1646 */ 5608| 109k| break; 5609| | 5610| 5.31k| case 356: ------------------ | Branch (5610:3): [True: 5.31k, False: 9.58M] ------------------ 5611| 5.31k|#line 1483 "bison_parser.y" /* yacc.c:1646 */ 5612| 5.31k| { 5613| 5.31k| (yyval.str_vec) = new std::vector(); 5614| 5.31k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5615| 5.31k|} 5616| 5.31k|#line 5617 "bison_parser.cpp" /* yacc.c:1646 */ 5617| 5.31k| break; 5618| | 5619| 19.1k| case 357: ------------------ | Branch (5619:3): [True: 19.1k, False: 9.56M] ------------------ 5620| 19.1k|#line 1487 "bison_parser.y" /* yacc.c:1646 */ 5621| 19.1k| { 5622| 19.1k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5623| 19.1k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5624| 19.1k|} 5625| 19.1k|#line 5626 "bison_parser.cpp" /* yacc.c:1646 */ 5626| 19.1k| break; 5627| | 5628| | 5629| 0|#line 5630 "bison_parser.cpp" /* yacc.c:1646 */ 5630| 4.64M| default: break; ------------------ | Branch (5630:7): [True: 4.64M, False: 4.93M] ------------------ 5631| 9.58M| } 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| 9.58M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5644| | 5645| 9.58M| YYPOPSTACK (yylen); ------------------ | | 2956| 9.58M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5646| 9.58M| yylen = 0; 5647| 9.58M| YY_STACK_PRINT (yyss, yyssp); 5648| | 5649| 9.58M| *++yyvsp = yyval; 5650| 9.58M| *++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| 9.58M| yyn = yyr1[yyn]; 5657| | 5658| 9.58M| yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ------------------ | | 711| 9.58M|#define YYNTOKENS 199 ------------------ 5659| 9.58M| if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ------------------ | | 708| 14.3M|#define YYLAST 856 ------------------ | Branch (5659:7): [True: 4.79M, False: 4.78M] | Branch (5659:23): [True: 4.75M, False: 36.9k] | Branch (5659:44): [True: 2.44M, False: 2.31M] ------------------ 5660| 2.44M| yystate = yytable[yystate]; 5661| 7.14M| else 5662| 7.14M| yystate = yydefgoto[yyn - YYNTOKENS]; ------------------ | | 711| 7.14M|#define YYNTOKENS 199 ------------------ 5663| | 5664| 9.58M| goto yynewstate; 5665| | 5666| | 5667| |/*--------------------------------------. 5668| || yyerrlab -- here on detecting error. | 5669| |`--------------------------------------*/ 5670| 3.42k|yyerrlab: 5671| | /* Make sure we have latest lookahead translation. See comments at 5672| | user semantic actions for why this is necessary. */ 5673| 3.42k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 3.42k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 725| 6.84k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.42k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.42k, False: 0] | | ------------------ ------------------ | Branch (5673:13): [True: 0, False: 3.42k] ------------------ 5674| | 5675| | /* If not already recovering from an error, report this error. */ 5676| 3.42k| if (!yyerrstatus) ------------------ | Branch (5676:7): [True: 3.42k, False: 0] ------------------ 5677| 3.42k| { 5678| 3.42k| ++yynerrs; ------------------ | | 69| 3.42k|#define yynerrs hsql_nerrs ------------------ 5679| |#if ! YYERROR_VERBOSE 5680| | yyerror (&yylloc, result, scanner, YY_("syntax error")); 5681| |#else 5682| 3.42k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5683| 3.42k| yyssp, yytoken) 5684| 3.42k| { 5685| 3.42k| char const *yymsgp = YY_("syntax error"); ------------------ | | 517| 3.42k|# define YY_(Msgid) Msgid ------------------ 5686| 3.42k| int yysyntax_error_status; 5687| 3.42k| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 5682| 3.42k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 5683| 3.42k| yyssp, yytoken) ------------------ 5688| 3.42k| if (yysyntax_error_status == 0) ------------------ | Branch (5688:13): [True: 3.42k, False: 0] ------------------ 5689| 3.42k| 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.42k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 67| 3.42k|#define yyerror hsql_error ------------------ 5708| 3.42k| if (yysyntax_error_status == 2) ------------------ | Branch (5708:13): [True: 0, False: 3.42k] ------------------ 5709| 0| goto yyexhaustedlab; 5710| 3.42k| } 5711| 3.42k|# undef YYSYNTAX_ERROR 5712| 3.42k|#endif 5713| 3.42k| } 5714| | 5715| 3.42k| yyerror_range[1] = yylloc; 5716| | 5717| 3.42k| if (yyerrstatus == 3) ------------------ | Branch (5717:7): [True: 0, False: 3.42k] ------------------ 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.42k| goto yyerrlab1; 5739| | 5740| | 5741| |/*---------------------------------------------------. 5742| || yyerrorlab -- error raised explicitly by YYERROR. | 5743| |`---------------------------------------------------*/ 5744| 3.42k|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| 645| if (/*CONSTCOND*/ 0) ------------------ | Branch (5749:21): [Folded, False: 645] ------------------ 5750| 0| goto yyerrorlab; 5751| | 5752| 645| yyerror_range[1] = yylsp[1-yylen]; 5753| | /* Do not reclaim the symbols of the rule whose action triggered 5754| | this YYERROR. */ 5755| 645| YYPOPSTACK (yylen); ------------------ | | 2956| 645|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5756| 645| yylen = 0; 5757| 645| YY_STACK_PRINT (yyss, yyssp); 5758| 645| yystate = *yyssp; 5759| 645| goto yyerrlab1; 5760| | 5761| | 5762| |/*-------------------------------------------------------------. 5763| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5764| |`-------------------------------------------------------------*/ 5765| 4.06k|yyerrlab1: 5766| 4.06k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5767| | 5768| 4.06k| for (;;) 5769| 50.2k| { 5770| 50.2k| yyn = yypact[yystate]; 5771| 50.2k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 50.2k| (!!((Yystate) == (-529))) ------------------ | Branch (5771:11): [True: 50.2k, False: 0] ------------------ 5772| 50.2k| { 5773| 50.2k| yyn += YYTERROR; ------------------ | | 1481| 50.2k|#define YYTERROR 1 ------------------ 5774| 50.2k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 708| 94.5k|#define YYLAST 856 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 1481| 44.2k|#define YYTERROR 1 ------------------ | Branch (5774:15): [True: 44.2k, False: 5.97k] | Branch (5774:27): [True: 44.2k, False: 0] | Branch (5774:44): [True: 0, False: 44.2k] ------------------ 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| 50.2k| } 5781| | 5782| | /* Pop the current state because it cannot handle the error token. */ 5783| 50.2k| if (yyssp == yyss) ------------------ | Branch (5783:11): [True: 4.06k, False: 46.1k] ------------------ 5784| 4.06k| YYABORT; ------------------ | | 1457| 4.06k|#define YYABORT goto yyabortlab ------------------ 5785| | 5786| 46.1k| yyerror_range[1] = *yylsp; 5787| 46.1k| yydestruct ("Error: popping", 5788| 46.1k| yystos[yystate], yyvsp, yylsp, result, scanner); 5789| 46.1k| YYPOPSTACK (1); ------------------ | | 2956| 46.1k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5790| 46.1k| yystate = *yyssp; 5791| 46.1k| YY_STACK_PRINT (yyss, yyssp); 5792| 46.1k| } 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.41k|yyacceptlab: 5815| 1.41k| yyresult = 0; 5816| 1.41k| goto yyreturn; 5817| | 5818| |/*-----------------------------------. 5819| || yyabortlab -- YYABORT comes here. | 5820| |`-----------------------------------*/ 5821| 4.06k|yyabortlab: 5822| 4.06k| yyresult = 1; 5823| 4.06k| goto yyreturn; 5824| | 5825| 0|#if !defined yyoverflow || YYERROR_VERBOSE 5826| |/*-------------------------------------------------. 5827| || yyexhaustedlab -- memory exhaustion comes here. | 5828| |`-------------------------------------------------*/ 5829| 19|yyexhaustedlab: 5830| 19| yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 67| 19|#define yyerror hsql_error ------------------ yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 517| 19|# define YY_(Msgid) Msgid ------------------ 5831| 19| yyresult = 2; 5832| | /* Fall through. */ 5833| 19|#endif 5834| | 5835| 5.50k|yyreturn: 5836| 5.50k| if (yychar != YYEMPTY) ------------------ | | 1453| 5.50k|#define YYEMPTY (-2) ------------------ | Branch (5836:7): [True: 3.68k, False: 1.82k] ------------------ 5837| 3.68k| { 5838| | /* Make sure we have latest lookahead translation. See comments at 5839| | user semantic actions for why this is necessary. */ 5840| 3.68k| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 3.68k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.68k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.68k, False: 0] | | ------------------ ------------------ 5841| 3.68k| yydestruct ("Cleanup: discarding lookahead", 5842| 3.68k| yytoken, &yylval, &yylloc, result, scanner); 5843| 3.68k| } 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.1k| while (yyssp != yyss) ------------------ | Branch (5848:10): [True: 6.61k, False: 5.50k] ------------------ 5849| 6.61k| { 5850| 6.61k| yydestruct ("Cleanup: popping", 5851| 6.61k| yystos[*yyssp], yyvsp, yylsp, result, scanner); 5852| 6.61k| YYPOPSTACK (1); ------------------ | | 2956| 6.61k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5853| 6.61k| } 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| 19|} bison_parser.cpp:_ZL14yysyntax_errorPmPPcPsi: 1800| 3.42k|{ 1801| 3.42k| YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 496| 3.42k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 108| 3.42k|# define YY_NULLPTR nullptr ------------------ 1802| 3.42k| YYSIZE_T yysize = yysize0; ------------------ | | 496| 3.42k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1803| 3.42k| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1804| | /* Internationalized format string. */ 1805| 3.42k| const char *yyformat = YY_NULLPTR; ------------------ | | 108| 3.42k|# define YY_NULLPTR nullptr ------------------ 1806| | /* Arguments of yyformat. */ 1807| 3.42k| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1808| | /* Number of reported tokens (one for the "unexpected", one per 1809| | "expected"). */ 1810| 3.42k| 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.42k| if (yytoken != YYEMPTY) ------------------ | | 1453| 3.42k|#define YYEMPTY (-2) ------------------ | Branch (1835:7): [True: 3.42k, False: 0] ------------------ 1836| 3.42k| { 1837| 3.42k| int yyn = yypact[*yyssp]; 1838| 3.42k| yyarg[yycount++] = yytname[yytoken]; 1839| 3.42k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 3.42k| (!!((Yystate) == (-529))) ------------------ | Branch (1839:11): [True: 3.42k, False: 0] ------------------ 1840| 3.42k| { 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.42k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1844:26): [True: 966, False: 2.45k] ------------------ 1845| | /* Stay within bounds of both yycheck and yytname. */ 1846| 3.42k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 708| 3.42k|#define YYLAST 856 ------------------ 1847| 3.42k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.42k|#define YYNTOKENS 199 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.30k|#define YYNTOKENS 199 ------------------ | Branch (1847:24): [True: 115, False: 3.30k] ------------------ 1848| 3.42k| int yyx; 1849| | 1850| 574k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1850:32): [True: 572k, False: 2.85k] ------------------ 1851| 572k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 1481| 580k|#define YYTERROR 1 ------------------ | Branch (1851:17): [True: 8.03k, False: 564k] | Branch (1851:46): [True: 8.03k, False: 0] ------------------ 1852| 8.03k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 928| 8.03k| (!!((Yytable_value) == (-355))) ------------------ | Branch (1852:20): [True: 7.96k, False: 70] ------------------ 1853| 7.96k| { 1854| 7.96k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1854:21): [True: 571, False: 7.39k] ------------------ 1855| 571| { 1856| 571| yycount = 1; 1857| 571| yysize = yysize0; 1858| 571| break; 1859| 571| } 1860| 7.39k| yyarg[yycount++] = yytname[yyx]; 1861| 7.39k| { 1862| 7.39k| YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 496| 7.39k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 108| 7.39k|# define YY_NULLPTR nullptr ------------------ 1863| 7.39k| if (! (yysize <= yysize1 ------------------ | Branch (1863:26): [True: 7.39k, False: 0] ------------------ 1864| 7.39k| && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 7.39k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 7.39k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1864:29): [True: 7.39k, False: 0] ------------------ 1865| 0| return 2; 1866| 7.39k| yysize = yysize1; 1867| 7.39k| } 1868| 7.39k| } 1869| 3.42k| } 1870| 3.42k| } 1871| | 1872| 3.42k| switch (yycount) ------------------ | Branch (1872:11): [True: 3.42k, False: 0] ------------------ 1873| 3.42k| { 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.42k] | | ------------------ | | 1876| 0| yyformat = S; \ | | 1877| 0| break ------------------ 1879| 571| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1875| 571| case N: \ | | ------------------ | | | Branch (1875:7): [True: 571, False: 2.85k] | | ------------------ | | 1876| 571| yyformat = S; \ | | 1877| 571| break ------------------ 1880| 1.03k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1875| 1.03k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.03k, False: 2.38k] | | ------------------ | | 1876| 1.03k| yyformat = S; \ | | 1877| 1.03k| break ------------------ 1881| 1.50k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1875| 1.50k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.50k, False: 1.91k] | | ------------------ | | 1876| 1.50k| yyformat = S; \ | | 1877| 1.50k| break ------------------ 1882| 175| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1875| 175| case N: \ | | ------------------ | | | Branch (1875:7): [True: 175, False: 3.24k] | | ------------------ | | 1876| 175| yyformat = S; \ | | 1877| 175| break ------------------ 1883| 3.42k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1875| 133| case N: \ | | ------------------ | | | Branch (1875:7): [True: 133, False: 3.29k] | | ------------------ | | 1876| 133| yyformat = S; \ | | 1877| 133| break ------------------ 1884| 3.42k|# undef YYCASE_ 1885| 3.42k| } 1886| | 1887| 3.42k| { 1888| 3.42k| YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 496| 3.42k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 1707| 3.42k|# define yystrlen strlen ------------------ 1889| 3.42k| if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 3.42k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 3.42k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1889:12): [True: 3.42k, False: 0] | Branch (1889:33): [True: 3.42k, False: 0] ------------------ 1890| 0| return 2; 1891| 3.42k| yysize = yysize1; 1892| 3.42k| } 1893| | 1894| 3.42k| if (*yymsg_alloc < yysize) ------------------ | Branch (1894:7): [True: 0, False: 3.42k] ------------------ 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.42k| { 1907| 3.42k| char *yyp = *yymsg; 1908| 3.42k| int yyi = 0; 1909| 140k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1909:12): [True: 137k, False: 3.42k] ------------------ 1910| 137k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1910:11): [True: 8.52k, False: 128k] | Branch (1910:26): [True: 8.52k, False: 0] | Branch (1910:48): [True: 8.52k, False: 0] ------------------ 1911| 8.52k| { 1912| 8.52k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1913| 8.52k| yyformat += 2; 1914| 8.52k| } 1915| 128k| else 1916| 128k| { 1917| 128k| yyp++; 1918| 128k| yyformat++; 1919| 128k| } 1920| 3.42k| } 1921| 3.42k| return 0; 1922| 3.42k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1751| 19.3k|{ 1752| 19.3k| if (*yystr == '"') ------------------ | Branch (1752:7): [True: 0, False: 19.3k] ------------------ 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.3k| if (! yyres) ------------------ | Branch (1782:7): [True: 10.8k, False: 8.52k] ------------------ 1783| 10.8k| return yystrlen (yystr); ------------------ | | 1707| 10.8k|# define yystrlen strlen ------------------ 1784| | 1785| 8.52k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1723| 8.52k|# define yystpcpy stpcpy ------------------ 1786| 19.3k|} bison_parser.cpp:_ZL10yydestructPKciP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 1931| 56.4k|{ 1932| 56.4k| YYUSE (yyvaluep); ------------------ | | 550| 56.4k|# define YYUSE(E) ((void) (E)) ------------------ 1933| 56.4k| YYUSE (yylocationp); ------------------ | | 550| 56.4k|# define YYUSE(E) ((void) (E)) ------------------ 1934| 56.4k| YYUSE (result); ------------------ | | 550| 56.4k|# define YYUSE(E) ((void) (E)) ------------------ 1935| 56.4k| YYUSE (scanner); ------------------ | | 550| 56.4k|# define YYUSE(E) ((void) (E)) ------------------ 1936| 56.4k| if (!yymsg) ------------------ | Branch (1936:7): [True: 0, False: 56.4k] ------------------ 1937| 0| yymsg = "Deleting"; 1938| 56.4k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1939| | 1940| 56.4k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1941| 56.4k| switch (yytype) 1942| 56.4k| { 1943| 2.62k| case 3: /* IDENTIFIER */ ------------------ | Branch (1943:11): [True: 2.62k, False: 53.8k] ------------------ 1944| 2.62k|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1945| 2.62k| { free(((*yyvaluep).sval)); } 1946| 2.62k|#line 1947 "bison_parser.cpp" /* yacc.c:1257 */ 1947| 2.62k| break; 1948| | 1949| 18| case 4: /* STRING */ ------------------ | Branch (1949:5): [True: 18, False: 56.4k] ------------------ 1950| 18|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1951| 18| { free(((*yyvaluep).sval)); } 1952| 18|#line 1953 "bison_parser.cpp" /* yacc.c:1257 */ 1953| 18| break; 1954| | 1955| 24| case 5: /* FLOATVAL */ ------------------ | Branch (1955:5): [True: 24, False: 56.4k] ------------------ 1956| 24|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1957| 24| { } 1958| 24|#line 1959 "bison_parser.cpp" /* yacc.c:1257 */ 1959| 24| break; 1960| | 1961| 48| case 6: /* INTVAL */ ------------------ | Branch (1961:5): [True: 48, False: 56.4k] ------------------ 1962| 48|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1963| 48| { } 1964| 48|#line 1965 "bison_parser.cpp" /* yacc.c:1257 */ 1965| 48| break; 1966| | 1967| 562| case 201: /* statement_list */ ------------------ | Branch (1967:5): [True: 562, False: 55.9k] ------------------ 1968| 562|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1969| 562| { 1970| 562| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (1970:7): [True: 562, False: 0] ------------------ 1971| 44.3k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (1971:19): [True: 44.3k, False: 562] ------------------ 1972| 44.3k| delete ptr; 1973| 44.3k| } 1974| 562| } 1975| 562| delete (((*yyvaluep).stmt_vec)); 1976| 562|} 1977| 562|#line 1978 "bison_parser.cpp" /* yacc.c:1257 */ 1978| 562| break; 1979| | 1980| 0| case 202: /* statement */ ------------------ | Branch (1980:5): [True: 0, False: 56.4k] ------------------ 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| 52| case 203: /* preparable_statement */ ------------------ | Branch (1986:5): [True: 52, False: 56.4k] ------------------ 1987| 52|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1988| 52| { delete (((*yyvaluep).statement)); } 1989| 52|#line 1990 "bison_parser.cpp" /* yacc.c:1257 */ 1990| 52| break; 1991| | 1992| 0| case 204: /* opt_hints */ ------------------ | Branch (1992:5): [True: 0, False: 56.4k] ------------------ 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| 37| case 205: /* hint_list */ ------------------ | Branch (2005:5): [True: 37, False: 56.4k] ------------------ 2006| 37|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2007| 37| { 2008| 37| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2008:7): [True: 37, False: 0] ------------------ 2009| 832| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2009:19): [True: 832, False: 37] ------------------ 2010| 832| delete ptr; 2011| 832| } 2012| 37| } 2013| 37| delete (((*yyvaluep).expr_vec)); 2014| 37|} 2015| 37|#line 2016 "bison_parser.cpp" /* yacc.c:1257 */ 2016| 37| break; 2017| | 2018| 0| case 206: /* hint */ ------------------ | Branch (2018:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 4| case 213: /* file_type */ ------------------ | Branch (2054:5): [True: 4, False: 56.4k] ------------------ 2055| 4|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2056| 4| { } 2057| 4|#line 2058 "bison_parser.cpp" /* yacc.c:1257 */ 2058| 4| break; 2059| | 2060| 211| case 214: /* file_path */ ------------------ | Branch (2060:5): [True: 211, False: 56.2k] ------------------ 2061| 211|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2062| 211| { free(((*yyvaluep).sval)); } 2063| 211|#line 2064 "bison_parser.cpp" /* yacc.c:1257 */ 2064| 211| break; 2065| | 2066| 1| case 215: /* opt_import_export_options */ ------------------ | Branch (2066:5): [True: 1, False: 56.4k] ------------------ 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| 58| case 216: /* import_export_options */ ------------------ | Branch (2072:5): [True: 58, False: 56.4k] ------------------ 2073| 58|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2074| 58| { delete (((*yyvaluep).import_export_option_t)); } 2075| 58|#line 2076 "bison_parser.cpp" /* yacc.c:1257 */ 2076| 58| break; 2077| | 2078| 0| case 217: /* csv_option */ ------------------ | Branch (2078:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 620| case 221: /* opt_not_exists */ ------------------ | Branch (2105:5): [True: 620, False: 55.8k] ------------------ 2106| 620|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2107| 620| { } 2108| 620|#line 2109 "bison_parser.cpp" /* yacc.c:1257 */ 2109| 620| break; 2110| | 2111| 549| case 222: /* table_elem_commalist */ ------------------ | Branch (2111:5): [True: 549, False: 55.9k] ------------------ 2112| 549|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2113| 549| { 2114| 549| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2114:7): [True: 549, False: 0] ------------------ 2115| 15.3k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2115:19): [True: 15.3k, False: 549] ------------------ 2116| 15.3k| delete ptr; 2117| 15.3k| } 2118| 549| } 2119| 549| delete (((*yyvaluep).table_element_vec)); 2120| 549|} 2121| 549|#line 2122 "bison_parser.cpp" /* yacc.c:1257 */ 2122| 549| break; 2123| | 2124| 0| case 223: /* table_elem */ ------------------ | Branch (2124:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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| 15| case 225: /* column_type */ ------------------ | Branch (2136:5): [True: 15, False: 56.4k] ------------------ 2137| 15|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2138| 15| { } 2139| 15|#line 2140 "bison_parser.cpp" /* yacc.c:1257 */ 2140| 15| break; 2141| | 2142| 0| case 226: /* opt_time_precision */ ------------------ | Branch (2142:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 12| case 229: /* column_constraints */ ------------------ | Branch (2160:5): [True: 12, False: 56.4k] ------------------ 2161| 12|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2162| 12| { delete (((*yyvaluep).column_constraints_t)); } 2163| 12|#line 2164 "bison_parser.cpp" /* yacc.c:1257 */ 2164| 12| break; 2165| | 2166| 0| case 230: /* column_constraint */ ------------------ | Branch (2166:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 25| case 234: /* opt_exists */ ------------------ | Branch (2190:5): [True: 25, False: 56.4k] ------------------ 2191| 25|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2192| 25| { } 2193| 25|#line 2194 "bison_parser.cpp" /* yacc.c:1257 */ 2194| 25| break; 2195| | 2196| 0| case 235: /* alter_statement */ ------------------ | Branch (2196:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 33| case 241: /* opt_column_list */ ------------------ | Branch (2232:5): [True: 33, False: 56.4k] ------------------ 2233| 33|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2234| 33| { 2235| 33| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2235:7): [True: 13, False: 20] ------------------ 2236| 245| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2236:19): [True: 245, False: 13] ------------------ 2237| 245| free(ptr); 2238| 245| } 2239| 13| } 2240| 33| delete (((*yyvaluep).str_vec)); 2241| 33|} 2242| 33|#line 2243 "bison_parser.cpp" /* yacc.c:1257 */ 2243| 33| break; 2244| | 2245| 0| case 242: /* update_statement */ ------------------ | Branch (2245:5): [True: 0, False: 56.4k] ------------------ 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| 12| case 243: /* update_clause_commalist */ ------------------ | Branch (2251:5): [True: 12, False: 56.4k] ------------------ 2252| 12|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2253| 12| { 2254| 12| if (((*yyvaluep).update_vec)) { ------------------ | Branch (2254:7): [True: 12, False: 0] ------------------ 2255| 231| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2255:19): [True: 231, False: 12] ------------------ 2256| 231| delete ptr; 2257| 231| } 2258| 12| } 2259| 12| delete (((*yyvaluep).update_vec)); 2260| 12|} 2261| 12|#line 2262 "bison_parser.cpp" /* yacc.c:1257 */ 2262| 12| break; 2263| | 2264| 0| case 244: /* update_clause */ ------------------ | Branch (2264:5): [True: 0, False: 56.4k] ------------------ 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| 5| case 245: /* select_statement */ ------------------ | Branch (2270:5): [True: 5, False: 56.4k] ------------------ 2271| 5|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2272| 5| { delete (((*yyvaluep).select_stmt)); } 2273| 5|#line 2274 "bison_parser.cpp" /* yacc.c:1257 */ 2274| 5| break; 2275| | 2276| 70| case 246: /* select_within_set_operation */ ------------------ | Branch (2276:5): [True: 70, False: 56.4k] ------------------ 2277| 70|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2278| 70| { delete (((*yyvaluep).select_stmt)); } 2279| 70|#line 2280 "bison_parser.cpp" /* yacc.c:1257 */ 2280| 70| break; 2281| | 2282| 0| case 247: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2282:5): [True: 0, False: 56.4k] ------------------ 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| 45| case 248: /* select_with_paren */ ------------------ | Branch (2288:5): [True: 45, False: 56.4k] ------------------ 2289| 45|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2290| 45| { delete (((*yyvaluep).select_stmt)); } 2291| 45|#line 2292 "bison_parser.cpp" /* yacc.c:1257 */ 2292| 45| break; 2293| | 2294| 98| case 249: /* select_no_paren */ ------------------ | Branch (2294:5): [True: 98, False: 56.3k] ------------------ 2295| 98|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2296| 98| { delete (((*yyvaluep).select_stmt)); } 2297| 98|#line 2298 "bison_parser.cpp" /* yacc.c:1257 */ 2298| 98| break; 2299| | 2300| 1.15k| case 250: /* set_operator */ ------------------ | Branch (2300:5): [True: 1.15k, False: 55.3k] ------------------ 2301| 1.15k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2302| 1.15k| { delete (((*yyvaluep).set_operator_t)); } 2303| 1.15k|#line 2304 "bison_parser.cpp" /* yacc.c:1257 */ 2304| 1.15k| break; 2305| | 2306| 0| case 251: /* set_type */ ------------------ | Branch (2306:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.78k| case 253: /* select_clause */ ------------------ | Branch (2318:5): [True: 1.78k, False: 54.6k] ------------------ 2319| 1.78k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2320| 1.78k| { delete (((*yyvaluep).select_stmt)); } 2321| 1.78k|#line 2322 "bison_parser.cpp" /* yacc.c:1257 */ 2322| 1.78k| break; 2323| | 2324| 3.47k| case 254: /* opt_distinct */ ------------------ | Branch (2324:5): [True: 3.47k, False: 53.0k] ------------------ 2325| 3.47k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2326| 3.47k| { } 2327| 3.47k|#line 2328 "bison_parser.cpp" /* yacc.c:1257 */ 2328| 3.47k| break; 2329| | 2330| 611| case 255: /* select_list */ ------------------ | Branch (2330:5): [True: 611, False: 55.8k] ------------------ 2331| 611|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2332| 611| { 2333| 611| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2333:7): [True: 611, False: 0] ------------------ 2334| 985| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2334:19): [True: 985, False: 611] ------------------ 2335| 985| delete ptr; 2336| 985| } 2337| 611| } 2338| 611| delete (((*yyvaluep).expr_vec)); 2339| 611|} 2340| 611|#line 2341 "bison_parser.cpp" /* yacc.c:1257 */ 2341| 611| break; 2342| | 2343| 179| case 256: /* opt_from_clause */ ------------------ | Branch (2343:5): [True: 179, False: 56.2k] ------------------ 2344| 179|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2345| 179| { delete (((*yyvaluep).table)); } 2346| 179|#line 2347 "bison_parser.cpp" /* yacc.c:1257 */ 2347| 179| break; 2348| | 2349| 0| case 257: /* from_clause */ ------------------ | Branch (2349:5): [True: 0, False: 56.4k] ------------------ 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| 100| case 258: /* opt_where */ ------------------ | Branch (2355:5): [True: 100, False: 56.3k] ------------------ 2356| 100|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2357| 100| { delete (((*yyvaluep).expr)); } 2358| 100|#line 2359 "bison_parser.cpp" /* yacc.c:1257 */ 2359| 100| break; 2360| | 2361| 1| case 259: /* opt_group */ ------------------ | Branch (2361:5): [True: 1, False: 56.4k] ------------------ 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.4k] ------------------ 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| 574| case 261: /* opt_order */ ------------------ | Branch (2373:5): [True: 574, False: 55.9k] ------------------ 2374| 574|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2375| 574| { 2376| 574| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2376:7): [True: 58, False: 516] ------------------ 2377| 325| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2377:19): [True: 325, False: 58] ------------------ 2378| 325| delete ptr; 2379| 325| } 2380| 58| } 2381| 574| delete (((*yyvaluep).order_vec)); 2382| 574|} 2383| 574|#line 2384 "bison_parser.cpp" /* yacc.c:1257 */ 2384| 574| break; 2385| | 2386| 132| case 262: /* order_list */ ------------------ | Branch (2386:5): [True: 132, False: 56.3k] ------------------ 2387| 132|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2388| 132| { 2389| 132| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2389:7): [True: 132, False: 0] ------------------ 2390| 1.81k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2390:19): [True: 1.81k, False: 132] ------------------ 2391| 1.81k| delete ptr; 2392| 1.81k| } 2393| 132| } 2394| 132| delete (((*yyvaluep).order_vec)); 2395| 132|} 2396| 132|#line 2397 "bison_parser.cpp" /* yacc.c:1257 */ 2397| 132| break; 2398| | 2399| 0| case 263: /* order_desc */ ------------------ | Branch (2399:5): [True: 0, False: 56.4k] ------------------ 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.3k] ------------------ 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.4k] ------------------ 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.04k| case 266: /* opt_top */ ------------------ | Branch (2417:5): [True: 2.04k, False: 54.4k] ------------------ 2418| 2.04k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2419| 2.04k| { delete (((*yyvaluep).limit)); } 2420| 2.04k|#line 2421 "bison_parser.cpp" /* yacc.c:1257 */ 2421| 2.04k| break; 2422| | 2423| 45| case 267: /* opt_limit */ ------------------ | Branch (2423:5): [True: 45, False: 56.4k] ------------------ 2424| 45|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2425| 45| { delete (((*yyvaluep).limit)); } 2426| 45|#line 2427 "bison_parser.cpp" /* yacc.c:1257 */ 2427| 45| break; 2428| | 2429| 646| case 268: /* expr_list */ ------------------ | Branch (2429:5): [True: 646, False: 55.8k] ------------------ 2430| 646|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2431| 646| { 2432| 646| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2432:7): [True: 646, False: 0] ------------------ 2433| 20.8k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2433:19): [True: 20.8k, False: 646] ------------------ 2434| 20.8k| delete ptr; 2435| 20.8k| } 2436| 646| } 2437| 646| delete (((*yyvaluep).expr_vec)); 2438| 646|} 2439| 646|#line 2440 "bison_parser.cpp" /* yacc.c:1257 */ 2440| 646| break; 2441| | 2442| 49| case 269: /* opt_extended_literal_list */ ------------------ | Branch (2442:5): [True: 49, False: 56.4k] ------------------ 2443| 49|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2444| 49| { 2445| 49| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2445:7): [True: 42, False: 7] ------------------ 2446| 855| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2446:19): [True: 855, False: 42] ------------------ 2447| 855| delete ptr; 2448| 855| } 2449| 42| } 2450| 49| delete (((*yyvaluep).expr_vec)); 2451| 49|} 2452| 49|#line 2453 "bison_parser.cpp" /* yacc.c:1257 */ 2453| 49| break; 2454| | 2455| 21| case 270: /* extended_literal_list */ ------------------ | Branch (2455:5): [True: 21, False: 56.4k] ------------------ 2456| 21|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2457| 21| { 2458| 21| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2458:7): [True: 21, False: 0] ------------------ 2459| 566| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2459:19): [True: 566, False: 21] ------------------ 2460| 566| delete ptr; 2461| 566| } 2462| 21| } 2463| 21| delete (((*yyvaluep).expr_vec)); 2464| 21|} 2465| 21|#line 2466 "bison_parser.cpp" /* yacc.c:1257 */ 2466| 21| break; 2467| | 2468| 0| case 271: /* casted_extended_literal */ ------------------ | Branch (2468:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 503| case 274: /* expr */ ------------------ | Branch (2486:5): [True: 503, False: 55.9k] ------------------ 2487| 503|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2488| 503| { delete (((*yyvaluep).expr)); } 2489| 503|#line 2490 "bison_parser.cpp" /* yacc.c:1257 */ 2490| 503| break; 2491| | 2492| 1.59k| case 275: /* operand */ ------------------ | Branch (2492:5): [True: 1.59k, False: 54.8k] ------------------ 2493| 1.59k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2494| 1.59k| { delete (((*yyvaluep).expr)); } 2495| 1.59k|#line 2496 "bison_parser.cpp" /* yacc.c:1257 */ 2496| 1.59k| break; 2497| | 2498| 0| case 276: /* scalar_expr */ ------------------ | Branch (2498:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 226| case 282: /* case_list */ ------------------ | Branch (2534:5): [True: 226, False: 56.2k] ------------------ 2535| 226|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2536| 226| { delete (((*yyvaluep).expr)); } 2537| 226|#line 2538 "bison_parser.cpp" /* yacc.c:1257 */ 2538| 226| break; 2539| | 2540| 0| case 283: /* exists_expr */ ------------------ | Branch (2540:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 204| case 287: /* opt_partition */ ------------------ | Branch (2564:5): [True: 204, False: 56.2k] ------------------ 2565| 204|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2566| 204| { 2567| 204| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2567:7): [True: 56, False: 148] ------------------ 2568| 303| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2568:19): [True: 303, False: 56] ------------------ 2569| 303| delete ptr; 2570| 303| } 2571| 56| } 2572| 204| delete (((*yyvaluep).expr_vec)); 2573| 204|} 2574| 204|#line 2575 "bison_parser.cpp" /* yacc.c:1257 */ 2575| 204| break; 2576| | 2577| 67| case 288: /* opt_frame_clause */ ------------------ | Branch (2577:5): [True: 67, False: 56.4k] ------------------ 2578| 67|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2579| 67| { delete (((*yyvaluep).frame_description)); } 2580| 67|#line 2581 "bison_parser.cpp" /* yacc.c:1257 */ 2581| 67| break; 2582| | 2583| 45| case 289: /* frame_type */ ------------------ | Branch (2583:5): [True: 45, False: 56.4k] ------------------ 2584| 45|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2585| 45| { } 2586| 45|#line 2587 "bison_parser.cpp" /* yacc.c:1257 */ 2587| 45| break; 2588| | 2589| 2| case 290: /* frame_bound */ ------------------ | Branch (2589:5): [True: 2, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 2| case 304: /* int_literal */ ------------------ | Branch (2673:5): [True: 2, False: 56.4k] ------------------ 2674| 2|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2675| 2| { delete (((*yyvaluep).expr)); } 2676| 2|#line 2677 "bison_parser.cpp" /* yacc.c:1257 */ 2677| 2| break; 2678| | 2679| 0| case 305: /* null_literal */ ------------------ | Branch (2679:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.14k| case 310: /* table_ref_atomic */ ------------------ | Branch (2709:5): [True: 2.14k, False: 54.3k] ------------------ 2710| 2.14k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2711| 2.14k| { delete (((*yyvaluep).table)); } 2712| 2.14k|#line 2713 "bison_parser.cpp" /* yacc.c:1257 */ 2713| 2.14k| break; 2714| | 2715| 0| case 311: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2715:5): [True: 0, False: 56.4k] ------------------ 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| 76| case 312: /* table_ref_commalist */ ------------------ | Branch (2721:5): [True: 76, False: 56.4k] ------------------ 2722| 76|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2723| 76| { 2724| 76| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2724:7): [True: 76, False: 0] ------------------ 2725| 1.06k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2725:19): [True: 1.06k, False: 76] ------------------ 2726| 1.06k| delete ptr; 2727| 1.06k| } 2728| 76| } 2729| 76| delete (((*yyvaluep).table_vec)); 2730| 76|} 2731| 76|#line 2732 "bison_parser.cpp" /* yacc.c:1257 */ 2732| 76| break; 2733| | 2734| 0| case 313: /* table_ref_name */ ------------------ | Branch (2734:5): [True: 0, False: 56.4k] ------------------ 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| 29| case 314: /* table_ref_name_no_alias */ ------------------ | Branch (2740:5): [True: 29, False: 56.4k] ------------------ 2741| 29|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2742| 29| { delete (((*yyvaluep).table)); } 2743| 29|#line 2744 "bison_parser.cpp" /* yacc.c:1257 */ 2744| 29| break; 2745| | 2746| 873| case 315: /* table_name */ ------------------ | Branch (2746:5): [True: 873, False: 55.6k] ------------------ 2747| 873|#line 182 "bison_parser.y" /* yacc.c:1257 */ 2748| 873| { 2749| 873| free(((*yyvaluep).table_name).name); 2750| 873| free(((*yyvaluep).table_name).schema); 2751| 873|} 2752| 873|#line 2753 "bison_parser.cpp" /* yacc.c:1257 */ 2753| 873| break; 2754| | 2755| 20| case 316: /* opt_index_name */ ------------------ | Branch (2755:5): [True: 20, False: 56.4k] ------------------ 2756| 20|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2757| 20| { free(((*yyvaluep).sval)); } 2758| 20|#line 2759 "bison_parser.cpp" /* yacc.c:1257 */ 2759| 20| break; 2760| | 2761| 0| case 317: /* table_alias */ ------------------ | Branch (2761:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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| 26| case 322: /* opt_locking_clause_list */ ------------------ | Branch (2791:5): [True: 26, False: 56.4k] ------------------ 2792| 26|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2793| 26| { delete (((*yyvaluep).locking_clause_vec)); } 2794| 26|#line 2795 "bison_parser.cpp" /* yacc.c:1257 */ 2795| 26| break; 2796| | 2797| 0| case 323: /* locking_clause */ ------------------ | Branch (2797:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.4k] ------------------ 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.64k| case 326: /* opt_with_clause */ ------------------ | Branch (2815:5): [True: 2.64k, False: 53.8k] ------------------ 2816| 2.64k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2817| 2.64k| { delete (((*yyvaluep).with_description_vec)); } 2818| 2.64k|#line 2819 "bison_parser.cpp" /* yacc.c:1257 */ 2819| 2.64k| break; 2820| | 2821| 0| case 327: /* with_clause */ ------------------ | Branch (2821:5): [True: 0, False: 56.4k] ------------------ 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| 37| case 328: /* with_description_list */ ------------------ | Branch (2827:5): [True: 37, False: 56.4k] ------------------ 2828| 37|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2829| 37| { delete (((*yyvaluep).with_description_vec)); } 2830| 37|#line 2831 "bison_parser.cpp" /* yacc.c:1257 */ 2831| 37| break; 2832| | 2833| 0| case 329: /* with_description */ ------------------ | Branch (2833:5): [True: 0, False: 56.4k] ------------------ 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.4k] ------------------ 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.12k| case 331: /* opt_join_type */ ------------------ | Branch (2845:5): [True: 2.12k, False: 54.3k] ------------------ 2846| 2.12k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2847| 2.12k| { } 2848| 2.12k|#line 2849 "bison_parser.cpp" /* yacc.c:1257 */ 2849| 2.12k| break; 2850| | 2851| 0| case 332: /* join_condition */ ------------------ | Branch (2851:5): [True: 0, False: 56.4k] ------------------ 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| 27| case 334: /* ident_commalist */ ------------------ | Branch (2857:5): [True: 27, False: 56.4k] ------------------ 2858| 27|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2859| 27| { 2860| 27| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2860:7): [True: 27, False: 0] ------------------ 2861| 10.1k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2861:19): [True: 10.1k, False: 27] ------------------ 2862| 10.1k| free(ptr); 2863| 10.1k| } 2864| 27| } 2865| 27| delete (((*yyvaluep).str_vec)); 2866| 27|} 2867| 27|#line 2868 "bison_parser.cpp" /* yacc.c:1257 */ 2868| 27| break; 2869| | 2870| | 2871| 29.4k| default: ------------------ | Branch (2871:7): [True: 29.4k, False: 27.0k] ------------------ 2872| 29.4k| break; 2873| 56.4k| } 2874| 56.4k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2875| 56.4k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3152| 3.49M|{ 3153| 3.49M| yy_state_type yy_current_state; 3154| 3.49M| char *yy_cp, *yy_bp; 3155| 3.49M| int yy_act; 3156| 3.49M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3157| | 3158| 3.49M| yylval = yylval_param; ------------------ | | 2964| 3.49M| # define yylval yyg->yylval_r ------------------ 3159| | 3160| 3.49M| yylloc = yylloc_param; ------------------ | | 2966| 3.49M| # define yylloc yyg->yylloc_r ------------------ 3161| | 3162| 3.49M| if ( !yyg->yy_init ) ------------------ | Branch (3162:7): [True: 5.50k, False: 3.48M] ------------------ 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.49M| { 3189| 3.49M|#line 57 "flex_lexer.l" 3190| | 3191| | 3192| 3.49M|#line 3193 "flex_lexer.cpp" 3193| | 3194| 4.03M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3194:23): [True: 4.03M, Folded] ------------------ 3195| 4.03M| { 3196| 4.03M| yy_cp = yyg->yy_c_buf_p; 3197| | 3198| | /* Support of yytext. */ 3199| 4.03M| *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.03M| yy_bp = yy_cp; 3205| | 3206| 4.03M| yy_current_state = yyg->yy_start; 3207| 4.03M|yy_match: 3208| 4.03M| do 3209| 22.5M| { 3210| 22.5M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 108| 22.5M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ 3211| 22.5M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3211:9): [True: 14.4M, False: 8.11M] ------------------ 3212| 14.4M| { 3213| 14.4M| yyg->yy_last_accepting_state = yy_current_state; 3214| 14.4M| yyg->yy_last_accepting_cpos = yy_cp; 3215| 14.4M| } 3216| 40.5M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3216:12): [True: 18.0M, False: 22.5M] ------------------ 3217| 18.0M| { 3218| 18.0M| yy_current_state = (int) yy_def[yy_current_state]; 3219| 18.0M| if ( yy_current_state >= 1368 ) ------------------ | Branch (3219:10): [True: 13.7M, False: 4.25M] ------------------ 3220| 13.7M| yy_c = yy_meta[(unsigned int) yy_c]; 3221| 18.0M| } 3222| 22.5M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 3223| 22.5M| ++yy_cp; 3224| 22.5M| } 3225| 22.5M| while ( yy_current_state != 1367 ); ------------------ | Branch (3225:11): [True: 18.5M, False: 4.03M] ------------------ 3226| 4.03M| yy_cp = yyg->yy_last_accepting_cpos; 3227| 4.03M| yy_current_state = yyg->yy_last_accepting_state; 3228| | 3229| 4.04M|yy_find_action: 3230| 4.04M| yy_act = yy_accept[yy_current_state]; 3231| | 3232| 4.04M| YY_DO_BEFORE_ACTION; ------------------ | | 344| 4.04M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 333| 4.04M|#define yytext_ptr yytext_r | | ------------------ | | 345| 4.04M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 121| 4.04M|#define yyleng yyg->yyleng_r | | ------------------ | | 346| 4.04M| yyg->yy_hold_char = *yy_cp; \ | | 347| 4.04M| *yy_cp = '\0'; \ | | 348| 4.04M| yyg->yy_c_buf_p = yy_cp; ------------------ 3233| | 3234| 4.04M|do_action: /* This label is used only to access EOF actions. */ 3235| | 3236| 4.04M| switch ( yy_act ) 3237| 4.04M| { /* beginning of action switch */ 3238| 21| case 0: /* must back up */ ------------------ | Branch (3238:4): [True: 21, False: 4.04M] ------------------ 3239| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3240| 21| *yy_cp = yyg->yy_hold_char; 3241| 21| yy_cp = yyg->yy_last_accepting_cpos; 3242| 21| yy_current_state = yyg->yy_last_accepting_state; 3243| 21| goto yy_find_action; 3244| | 3245| 2.54k|case 1: ------------------ | Branch (3245:1): [True: 2.54k, False: 4.04M] ------------------ 3246| 2.54k|YY_RULE_SETUP ------------------ | | 3147| 2.54k| YY_USER_ACTION | | ------------------ | | | | 61| 2.54k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.54k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.62k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.08k, False: 2.54k] | | | | ------------------ | | | | 64| 5.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.08k| } else { \ | | | | 70| 5.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.08k| } \ | | | | 72| 5.08k| } | | ------------------ ------------------ 3247| 2.54k|#line 59 "flex_lexer.l" 3248| 2.54k|BEGIN(COMMENT); ------------------ | | 131| 2.54k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 2908| 2.54k|#define COMMENT 2 ------------------ 3249| 2.54k| YY_BREAK ------------------ | | 3143| 2.54k|#define YY_BREAK /*LINTED*/break; ------------------ 3250| 2.47k|case 2: ------------------ | Branch (3250:1): [True: 2.47k, False: 4.04M] ------------------ 3251| 2.47k|YY_RULE_SETUP ------------------ | | 3147| 2.47k| YY_USER_ACTION | | ------------------ | | | | 61| 2.47k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.47k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 947k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 947k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 944k, False: 2.47k] | | | | ------------------ | | | | 64| 944k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 944k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 944k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 944k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 944k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 944k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 944k] | | | | ------------------ | | | | 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| 944k| } else { \ | | | | 70| 944k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 944k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 944k| } \ | | | | 72| 944k| } | | ------------------ ------------------ 3252| 2.47k|#line 60 "flex_lexer.l" 3253| 2.47k|/* skipping comment content until a end of line is read */; 3254| 2.47k| YY_BREAK ------------------ | | 3143| 2.47k|#define YY_BREAK /*LINTED*/break; ------------------ 3255| 2.36k|case 3: ------------------ | Branch (3255:1): [True: 2.36k, False: 4.04M] ------------------ 3256| |/* rule 3 can match eol */ 3257| 2.36k|YY_RULE_SETUP ------------------ | | 3147| 2.36k| YY_USER_ACTION | | ------------------ | | | | 61| 2.36k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.36k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.72k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.36k, False: 2.36k] | | | | ------------------ | | | | 64| 2.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 2.36k, False: 0] | | | | ------------------ | | | | 67| 2.36k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.36k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 2.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.36k| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 2.36k| } | | ------------------ ------------------ 3258| 2.36k|#line 61 "flex_lexer.l" 3259| 2.36k|BEGIN(INITIAL); ------------------ | | 131| 2.36k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2906| 2.36k|#define INITIAL 0 ------------------ 3260| 2.36k| YY_BREAK ------------------ | | 3143| 2.36k|#define YY_BREAK /*LINTED*/break; ------------------ 3261| 483k|case 4: ------------------ | Branch (3261:1): [True: 483k, False: 3.56M] ------------------ 3262| |/* rule 4 can match eol */ 3263| 483k|YY_RULE_SETUP ------------------ | | 3147| 483k| YY_USER_ACTION | | ------------------ | | | | 61| 483k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 483k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 483k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 483k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 483k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 483k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 982k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 982k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 499k, False: 483k] | | | | ------------------ | | | | 64| 499k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 499k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 499k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 499k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 499k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 499k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 216k, False: 283k] | | | | ------------------ | | | | 67| 216k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 216k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 216k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 283k| } else { \ | | | | 70| 283k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 283k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 283k| } \ | | | | 72| 499k| } | | ------------------ ------------------ 3264| 483k|#line 63 "flex_lexer.l" 3265| 483k|/* skip whitespace */; 3266| 483k| YY_BREAK ------------------ | | 3143| 483k|#define YY_BREAK /*LINTED*/break; ------------------ 3267| 2|case 5: ------------------ | Branch (3267:1): [True: 2, False: 4.04M] ------------------ 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| 2|case 6: ------------------ | Branch (3272:1): [True: 2, False: 4.04M] ------------------ 3273| 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| } | | ------------------ ------------------ 3274| 2|#line 66 "flex_lexer.l" 3275| 2|TOKEN(AFTER) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3276| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3277| 2.50k|case 7: ------------------ | Branch (3277:1): [True: 2.50k, False: 4.04M] ------------------ 3278| 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| 10.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.52k, False: 2.50k] | | | | ------------------ | | | | 64| 7.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.52k] | | | | ------------------ | | | | 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.52k| } else { \ | | | | 70| 7.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.52k| } \ | | | | 72| 7.52k| } | | ------------------ ------------------ 3279| 2.50k|#line 67 "flex_lexer.l" 3280| 2.50k|TOKEN(ALL) ------------------ | | 2887| 2.50k|#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.04M] ------------------ 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.04M] ------------------ 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.44k|case 10: ------------------ | Branch (3292:1): [True: 1.44k, False: 4.04M] ------------------ 3293| 1.44k|YY_RULE_SETUP ------------------ | | 3147| 1.44k| YY_USER_ACTION | | ------------------ | | | | 61| 1.44k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.44k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.44k| # 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.33k, False: 1.44k] | | | | ------------------ | | | | 64| 4.33k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.33k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.33k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.33k| } else { \ | | | | 70| 4.33k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.33k| } \ | | | | 72| 4.33k| } | | ------------------ ------------------ 3294| 1.44k|#line 70 "flex_lexer.l" 3295| 1.44k|TOKEN(AND) ------------------ | | 2887| 1.44k|#define TOKEN(name) { return SQL_##name; } ------------------ 3296| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3297| 945|case 11: ------------------ | Branch (3297:1): [True: 945, False: 4.04M] ------------------ 3298| 945|YY_RULE_SETUP ------------------ | | 3147| 945| YY_USER_ACTION | | ------------------ | | | | 61| 945| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 945| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 945| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 945| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 945| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 945| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.67k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.72k, False: 945] | | | | ------------------ | | | | 64| 4.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.72k] | | | | ------------------ | | | | 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.72k| } else { \ | | | | 70| 4.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.72k| } \ | | | | 72| 4.72k| } | | ------------------ ------------------ 3299| 945|#line 71 "flex_lexer.l" 3300| 945|TOKEN(ARRAY) ------------------ | | 2887| 945|#define TOKEN(name) { return SQL_##name; } ------------------ 3301| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3302| 5.57k|case 12: ------------------ | Branch (3302:1): [True: 5.57k, False: 4.03M] ------------------ 3303| 5.57k|YY_RULE_SETUP ------------------ | | 3147| 5.57k| YY_USER_ACTION | | ------------------ | | | | 61| 5.57k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.57k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.1k, False: 5.57k] | | | | ------------------ | | | | 64| 11.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.1k| } else { \ | | | | 70| 11.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.1k| } \ | | | | 72| 11.1k| } | | ------------------ ------------------ 3304| 5.57k|#line 72 "flex_lexer.l" 3305| 5.57k|TOKEN(AS) ------------------ | | 2887| 5.57k|#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.04M] ------------------ 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.04M] ------------------ 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| 6.64k|case 15: ------------------ | Branch (3317:1): [True: 6.64k, False: 4.03M] ------------------ 3318| 6.64k|YY_RULE_SETUP ------------------ | | 3147| 6.64k| YY_USER_ACTION | | ------------------ | | | | 61| 6.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 39.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 39.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 33.2k, False: 6.64k] | | | | ------------------ | | | | 64| 33.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 33.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 33.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 33.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 33.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 33.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 33.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| 33.2k| } else { \ | | | | 70| 33.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 33.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 33.2k| } \ | | | | 72| 33.2k| } | | ------------------ ------------------ 3319| 6.64k|#line 75 "flex_lexer.l" 3320| 6.64k|TOKEN(BEGIN) ------------------ | | 2887| 6.64k|#define TOKEN(name) { return SQL_##name; } ------------------ 3321| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3322| 755|case 16: ------------------ | Branch (3322:1): [True: 755, False: 4.04M] ------------------ 3323| 755|YY_RULE_SETUP ------------------ | | 3147| 755| YY_USER_ACTION | | ------------------ | | | | 61| 755| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 755| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 755| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 755| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 755| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 755| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.28k, False: 755] | | | | ------------------ | | | | 64| 5.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.28k| } else { \ | | | | 70| 5.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.28k| } \ | | | | 72| 5.28k| } | | ------------------ ------------------ 3324| 755|#line 76 "flex_lexer.l" 3325| 755|TOKEN(BETWEEN) ------------------ | | 2887| 755|#define TOKEN(name) { return SQL_##name; } ------------------ 3326| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3327| 785|case 17: ------------------ | Branch (3327:1): [True: 785, False: 4.04M] ------------------ 3328| 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| } | | ------------------ ------------------ 3329| 785|#line 77 "flex_lexer.l" 3330| 785|TOKEN(BIGINT) ------------------ | | 2887| 785|#define TOKEN(name) { return SQL_##name; } ------------------ 3331| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3332| 631|case 18: ------------------ | Branch (3332:1): [True: 631, False: 4.04M] ------------------ 3333| 631|YY_RULE_SETUP ------------------ | | 3147| 631| YY_USER_ACTION | | ------------------ | | | | 61| 631| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 631| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 631| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 631| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 631| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 631| # 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: 631] | | | | ------------------ | | | | 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| 631|#line 78 "flex_lexer.l" 3335| 631|TOKEN(BOOLEAN) ------------------ | | 2887| 631|#define TOKEN(name) { return SQL_##name; } ------------------ 3336| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3337| 7.62k|case 19: ------------------ | Branch (3337:1): [True: 7.62k, False: 4.03M] ------------------ 3338| 7.62k|YY_RULE_SETUP ------------------ | | 3147| 7.62k| YY_USER_ACTION | | ------------------ | | | | 61| 7.62k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.62k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 22.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 22.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.2k, False: 7.62k] | | | | ------------------ | | | | 64| 15.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.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| 15.2k| } else { \ | | | | 70| 15.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.2k| } \ | | | | 72| 15.2k| } | | ------------------ ------------------ 3339| 7.62k|#line 79 "flex_lexer.l" 3340| 7.62k|TOKEN(BY) ------------------ | | 2887| 7.62k|#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.04M] ------------------ 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| 2|case 21: ------------------ | Branch (3347:1): [True: 2, False: 4.04M] ------------------ 3348| 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| } | | ------------------ ------------------ 3349| 2|#line 81 "flex_lexer.l" 3350| 2|TOKEN(CASCADE) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3351| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3352| 2.44k|case 22: ------------------ | Branch (3352:1): [True: 2.44k, False: 4.04M] ------------------ 3353| 2.44k|YY_RULE_SETUP ------------------ | | 3147| 2.44k| YY_USER_ACTION | | ------------------ | | | | 61| 2.44k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.44k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.78k, False: 2.44k] | | | | ------------------ | | | | 64| 9.78k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.78k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.78k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.78k] | | | | ------------------ | | | | 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.78k| } else { \ | | | | 70| 9.78k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.78k| } \ | | | | 72| 9.78k| } | | ------------------ ------------------ 3354| 2.44k|#line 82 "flex_lexer.l" 3355| 2.44k|TOKEN(CASE) ------------------ | | 2887| 2.44k|#define TOKEN(name) { return SQL_##name; } ------------------ 3356| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3357| 610|case 23: ------------------ | Branch (3357:1): [True: 610, False: 4.04M] ------------------ 3358| 610|YY_RULE_SETUP ------------------ | | 3147| 610| YY_USER_ACTION | | ------------------ | | | | 61| 610| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 610| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 610| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.44k, False: 610] | | | | ------------------ | | | | 64| 2.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.44k] | | | | ------------------ | | | | 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.44k| } else { \ | | | | 70| 2.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.44k| } \ | | | | 72| 2.44k| } | | ------------------ ------------------ 3359| 610|#line 83 "flex_lexer.l" 3360| 610|TOKEN(CAST) ------------------ | | 2887| 610|#define TOKEN(name) { return SQL_##name; } ------------------ 3361| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3362| 532|case 24: ------------------ | Branch (3362:1): [True: 532, False: 4.04M] ------------------ 3363| 532|YY_RULE_SETUP ------------------ | | 3147| 532| YY_USER_ACTION | | ------------------ | | | | 61| 532| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 532| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.12k, False: 532] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3364| 532|#line 84 "flex_lexer.l" 3365| 532|TOKEN(CHAR) ------------------ | | 2887| 532|#define TOKEN(name) { return SQL_##name; } ------------------ 3366| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3367| 2|case 25: ------------------ | Branch (3367:1): [True: 2, False: 4.04M] ------------------ 3368| 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| } | | ------------------ ------------------ 3369| 2|#line 85 "flex_lexer.l" 3370| 2|TOKEN(COLUMN) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3371| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3372| 1.19k|case 26: ------------------ | Branch (3372:1): [True: 1.19k, False: 4.04M] ------------------ 3373| 1.19k|YY_RULE_SETUP ------------------ | | 3147| 1.19k| YY_USER_ACTION | | ------------------ | | | | 61| 1.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.33k, False: 1.19k] | | | | ------------------ | | | | 64| 8.33k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.33k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.33k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.33k| } else { \ | | | | 70| 8.33k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.33k| } \ | | | | 72| 8.33k| } | | ------------------ ------------------ 3374| 1.19k|#line 86 "flex_lexer.l" 3375| 1.19k|TOKEN(COLUMNS) ------------------ | | 2887| 1.19k|#define TOKEN(name) { return SQL_##name; } ------------------ 3376| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3377| 2.08k|case 27: ------------------ | Branch (3377:1): [True: 2.08k, False: 4.04M] ------------------ 3378| 2.08k|YY_RULE_SETUP ------------------ | | 3147| 2.08k| YY_USER_ACTION | | ------------------ | | | | 61| 2.08k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.08k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.08k| # 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: 12.5k, False: 2.08k] | | | | ------------------ | | | | 64| 12.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.5k| } else { \ | | | | 70| 12.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.5k| } \ | | | | 72| 12.5k| } | | ------------------ ------------------ 3379| 2.08k|#line 87 "flex_lexer.l" 3380| 2.08k|TOKEN(COMMIT) ------------------ | | 2887| 2.08k|#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.04M] ------------------ 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| 15.1k|case 29: ------------------ | Branch (3387:1): [True: 15.1k, False: 4.02M] ------------------ 3388| 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.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 75.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 60.5k, False: 15.1k] | | | | ------------------ | | | | 64| 60.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 60.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 60.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 60.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 60.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 60.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 60.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| 60.5k| } else { \ | | | | 70| 60.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 60.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 60.5k| } \ | | | | 72| 60.5k| } | | ------------------ ------------------ 3389| 15.1k|#line 89 "flex_lexer.l" 3390| 15.1k|TOKEN(COPY) ------------------ | | 2887| 15.1k|#define TOKEN(name) { return SQL_##name; } ------------------ 3391| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3392| 9.56k|case 30: ------------------ | Branch (3392:1): [True: 9.56k, False: 4.03M] ------------------ 3393| 9.56k|YY_RULE_SETUP ------------------ | | 3147| 9.56k| YY_USER_ACTION | | ------------------ | | | | 61| 9.56k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 9.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 9.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 9.56k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 9.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 9.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 66.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 66.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 57.3k, False: 9.56k] | | | | ------------------ | | | | 64| 57.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 57.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 57.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 57.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 57.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 57.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 57.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| 57.3k| } else { \ | | | | 70| 57.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 57.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 57.3k| } \ | | | | 72| 57.3k| } | | ------------------ ------------------ 3394| 9.56k|#line 90 "flex_lexer.l" 3395| 9.56k|TOKEN(CREATE) ------------------ | | 2887| 9.56k|#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.04M] ------------------ 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.65k|case 32: ------------------ | Branch (3402:1): [True: 3.65k, False: 4.03M] ------------------ 3403| 3.65k|YY_RULE_SETUP ------------------ | | 3147| 3.65k| YY_USER_ACTION | | ------------------ | | | | 61| 3.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.6k, False: 3.65k] | | | | ------------------ | | | | 64| 14.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.6k| } else { \ | | | | 70| 14.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.6k| } \ | | | | 72| 14.6k| } | | ------------------ ------------------ 3404| 3.65k|#line 92 "flex_lexer.l" 3405| 3.65k|TOKEN(DATE) ------------------ | | 2887| 3.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 3406| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3407| 431|case 33: ------------------ | Branch (3407:1): [True: 431, False: 4.04M] ------------------ 3408| 431|YY_RULE_SETUP ------------------ | | 3147| 431| YY_USER_ACTION | | ------------------ | | | | 61| 431| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 431| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 431| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 431| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 431| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 431| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.87k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.44k, False: 431] | | | | ------------------ | | | | 64| 3.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.44k] | | | | ------------------ | | | | 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.44k| } else { \ | | | | 70| 3.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.44k| } \ | | | | 72| 3.44k| } | | ------------------ ------------------ 3409| 431|#line 93 "flex_lexer.l" 3410| 431|TOKEN(DATETIME) ------------------ | | 2887| 431|#define TOKEN(name) { return SQL_##name; } ------------------ 3411| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3412| 1.90k|case 34: ------------------ | Branch (3412:1): [True: 1.90k, False: 4.04M] ------------------ 3413| 1.90k|YY_RULE_SETUP ------------------ | | 3147| 1.90k| YY_USER_ACTION | | ------------------ | | | | 61| 1.90k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.90k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.90k| # 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: 5.72k, False: 1.90k] | | | | ------------------ | | | | 64| 5.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.72k] | | | | ------------------ | | | | 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.72k| } else { \ | | | | 70| 5.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.72k| } \ | | | | 72| 5.72k| } | | ------------------ ------------------ 3414| 1.90k|#line 94 "flex_lexer.l" 3415| 1.90k|TOKEN(DAY) ------------------ | | 2887| 1.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 3416| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3417| 527|case 35: ------------------ | Branch (3417:1): [True: 527, False: 4.04M] ------------------ 3418| 527|YY_RULE_SETUP ------------------ | | 3147| 527| YY_USER_ACTION | | ------------------ | | | | 61| 527| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 527| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 527| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 527| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 527| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 527| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.63k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.10k, False: 527] | | | | ------------------ | | | | 64| 2.10k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.10k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.10k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.10k] | | | | ------------------ | | | | 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.10k| } else { \ | | | | 70| 2.10k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.10k| } \ | | | | 72| 2.10k| } | | ------------------ ------------------ 3419| 527|#line 95 "flex_lexer.l" 3420| 527|TOKEN(DAYS) ------------------ | | 2887| 527|#define TOKEN(name) { return SQL_##name; } ------------------ 3421| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3422| 902|case 36: ------------------ | Branch (3422:1): [True: 902, False: 4.04M] ------------------ 3423| 902|YY_RULE_SETUP ------------------ | | 3147| 902| YY_USER_ACTION | | ------------------ | | | | 61| 902| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 902| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 902| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 902| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 902| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 902| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.02k, False: 902] | | | | ------------------ | | | | 64| 9.02k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.02k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.02k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.02k| } else { \ | | | | 70| 9.02k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.02k| } \ | | | | 72| 9.02k| } | | ------------------ ------------------ 3424| 902|#line 96 "flex_lexer.l" 3425| 902|TOKEN(DEALLOCATE) ------------------ | | 2887| 902|#define TOKEN(name) { return SQL_##name; } ------------------ 3426| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3427| 1.12k|case 37: ------------------ | Branch (3427:1): [True: 1.12k, False: 4.04M] ------------------ 3428| 1.12k|YY_RULE_SETUP ------------------ | | 3147| 1.12k| YY_USER_ACTION | | ------------------ | | | | 61| 1.12k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.12k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.90k, False: 1.12k] | | | | ------------------ | | | | 64| 7.90k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.90k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.90k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.90k| } else { \ | | | | 70| 7.90k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.90k| } \ | | | | 72| 7.90k| } | | ------------------ ------------------ 3429| 1.12k|#line 97 "flex_lexer.l" 3430| 1.12k|TOKEN(DECIMAL) ------------------ | | 2887| 1.12k|#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.04M] ------------------ 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.88k|case 39: ------------------ | Branch (3437:1): [True: 1.88k, False: 4.04M] ------------------ 3438| 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| 13.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.3k, False: 1.88k] | | | | ------------------ | | | | 64| 11.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.3k| } else { \ | | | | 70| 11.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.3k| } \ | | | | 72| 11.3k| } | | ------------------ ------------------ 3439| 1.88k|#line 99 "flex_lexer.l" 3440| 1.88k|TOKEN(DELETE) ------------------ | | 2887| 1.88k|#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.04M] ------------------ 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| 533|case 41: ------------------ | Branch (3447:1): [True: 533, False: 4.04M] ------------------ 3448| 533|YY_RULE_SETUP ------------------ | | 3147| 533| YY_USER_ACTION | | ------------------ | | | | 61| 533| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 533| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 533| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 533| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 533| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 533| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.13k, False: 533] | | | | ------------------ | | | | 64| 2.13k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.13k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.13k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.13k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.13k] | | | | ------------------ | | | | 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.13k| } else { \ | | | | 70| 2.13k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.13k| } \ | | | | 72| 2.13k| } | | ------------------ ------------------ 3449| 533|#line 101 "flex_lexer.l" 3450| 533|TOKEN(DESC) ------------------ | | 2887| 533|#define TOKEN(name) { return SQL_##name; } ------------------ 3451| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3452| 4.89k|case 42: ------------------ | Branch (3452:1): [True: 4.89k, False: 4.03M] ------------------ 3453| 4.89k|YY_RULE_SETUP ------------------ | | 3147| 4.89k| YY_USER_ACTION | | ------------------ | | | | 61| 4.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 44.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 44.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 39.1k, False: 4.89k] | | | | ------------------ | | | | 64| 39.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 39.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 39.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 39.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 39.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 39.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 39.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| 39.1k| } else { \ | | | | 70| 39.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 39.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 39.1k| } \ | | | | 72| 39.1k| } | | ------------------ ------------------ 3454| 4.89k|#line 102 "flex_lexer.l" 3455| 4.89k|TOKEN(DESCRIBE) ------------------ | | 2887| 4.89k|#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.04M] ------------------ 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| 556|case 44: ------------------ | Branch (3462:1): [True: 556, False: 4.04M] ------------------ 3463| 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| 5.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.44k, False: 556] | | | | ------------------ | | | | 64| 4.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.44k] | | | | ------------------ | | | | 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.44k| } else { \ | | | | 70| 4.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.44k| } \ | | | | 72| 4.44k| } | | ------------------ ------------------ 3464| 556|#line 104 "flex_lexer.l" 3465| 556|TOKEN(DISTINCT) ------------------ | | 2887| 556|#define TOKEN(name) { return SQL_##name; } ------------------ 3466| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3467| 737|case 45: ------------------ | Branch (3467:1): [True: 737, False: 4.04M] ------------------ 3468| 737|YY_RULE_SETUP ------------------ | | 3147| 737| YY_USER_ACTION | | ------------------ | | | | 61| 737| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 737| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.15k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.42k, False: 737] | | | | ------------------ | | | | 64| 4.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.42k| } else { \ | | | | 70| 4.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.42k| } \ | | | | 72| 4.42k| } | | ------------------ ------------------ 3469| 737|#line 105 "flex_lexer.l" 3470| 737|TOKEN(DOUBLE) ------------------ | | 2887| 737|#define TOKEN(name) { return SQL_##name; } ------------------ 3471| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3472| 3.55k|case 46: ------------------ | Branch (3472:1): [True: 3.55k, False: 4.03M] ------------------ 3473| 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| 17.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.2k, False: 3.55k] | | | | ------------------ | | | | 64| 14.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.2k| } else { \ | | | | 70| 14.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.2k| } \ | | | | 72| 14.2k| } | | ------------------ ------------------ 3474| 3.55k|#line 106 "flex_lexer.l" 3475| 3.55k|TOKEN(DROP) ------------------ | | 2887| 3.55k|#define TOKEN(name) { return SQL_##name; } ------------------ 3476| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3477| 831|case 47: ------------------ | Branch (3477:1): [True: 831, False: 4.04M] ------------------ 3478| 831|YY_RULE_SETUP ------------------ | | 3147| 831| YY_USER_ACTION | | ------------------ | | | | 61| 831| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 831| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 831| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 831| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 831| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 831| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.15k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.32k, False: 831] | | | | ------------------ | | | | 64| 3.32k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.32k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.32k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.32k] | | | | ------------------ | | | | 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.32k| } else { \ | | | | 70| 3.32k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.32k| } \ | | | | 72| 3.32k| } | | ------------------ ------------------ 3479| 831|#line 107 "flex_lexer.l" 3480| 831|TOKEN(ELSE) ------------------ | | 2887| 831|#define TOKEN(name) { return SQL_##name; } ------------------ 3481| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3482| 1.49k|case 48: ------------------ | Branch (3482:1): [True: 1.49k, False: 4.04M] ------------------ 3483| 1.49k|YY_RULE_SETUP ------------------ | | 3147| 1.49k| YY_USER_ACTION | | ------------------ | | | | 61| 1.49k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.49k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.9k, False: 1.49k] | | | | ------------------ | | | | 64| 11.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.9k| } else { \ | | | | 70| 11.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.9k| } \ | | | | 72| 11.9k| } | | ------------------ ------------------ 3484| 1.49k|#line 108 "flex_lexer.l" 3485| 1.49k|TOKEN(ENCODING) ------------------ | | 2887| 1.49k|#define TOKEN(name) { return SQL_##name; } ------------------ 3486| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3487| 1.71k|case 49: ------------------ | Branch (3487:1): [True: 1.71k, False: 4.04M] ------------------ 3488| 1.71k|YY_RULE_SETUP ------------------ | | 3147| 1.71k| YY_USER_ACTION | | ------------------ | | | | 61| 1.71k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.71k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.86k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.14k, False: 1.71k] | | | | ------------------ | | | | 64| 5.14k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.14k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.14k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.14k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.14k] | | | | ------------------ | | | | 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.14k| } else { \ | | | | 70| 5.14k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.14k| } \ | | | | 72| 5.14k| } | | ------------------ ------------------ 3489| 1.71k|#line 109 "flex_lexer.l" 3490| 1.71k|TOKEN(END) ------------------ | | 2887| 1.71k|#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.04M] ------------------ 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| 983|case 51: ------------------ | Branch (3497:1): [True: 983, False: 4.04M] ------------------ 3498| 983|YY_RULE_SETUP ------------------ | | 3147| 983| YY_USER_ACTION | | ------------------ | | | | 61| 983| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 983| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 983| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 983| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 983| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 983| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.88k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.89k, False: 983] | | | | ------------------ | | | | 64| 5.89k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.89k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.89k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.89k] | | | | ------------------ | | | | 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.89k| } else { \ | | | | 70| 5.89k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.89k| } \ | | | | 72| 5.89k| } | | ------------------ ------------------ 3499| 983|#line 111 "flex_lexer.l" 3500| 983|TOKEN(EXCEPT) ------------------ | | 2887| 983|#define TOKEN(name) { return SQL_##name; } ------------------ 3501| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3502| 4.90k|case 52: ------------------ | Branch (3502:1): [True: 4.90k, False: 4.03M] ------------------ 3503| 4.90k|YY_RULE_SETUP ------------------ | | 3147| 4.90k| YY_USER_ACTION | | ------------------ | | | | 61| 4.90k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.90k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 39.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 39.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 34.3k, False: 4.90k] | | | | ------------------ | | | | 64| 34.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 34.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 34.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 34.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 34.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 34.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 34.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| 34.3k| } else { \ | | | | 70| 34.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 34.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 34.3k| } \ | | | | 72| 34.3k| } | | ------------------ ------------------ 3504| 4.90k|#line 112 "flex_lexer.l" 3505| 4.90k|TOKEN(EXECUTE) ------------------ | | 2887| 4.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 3506| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3507| 1.38k|case 53: ------------------ | Branch (3507:1): [True: 1.38k, False: 4.04M] ------------------ 3508| 1.38k|YY_RULE_SETUP ------------------ | | 3147| 1.38k| YY_USER_ACTION | | ------------------ | | | | 61| 1.38k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.38k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.28k, False: 1.38k] | | | | ------------------ | | | | 64| 8.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.28k| } else { \ | | | | 70| 8.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.28k| } \ | | | | 72| 8.28k| } | | ------------------ ------------------ 3509| 1.38k|#line 113 "flex_lexer.l" 3510| 1.38k|TOKEN(EXISTS) ------------------ | | 2887| 1.38k|#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.04M] ------------------ 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.04M] ------------------ 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| 666|case 56: ------------------ | Branch (3522:1): [True: 666, False: 4.04M] ------------------ 3523| 666|YY_RULE_SETUP ------------------ | | 3147| 666| YY_USER_ACTION | | ------------------ | | | | 61| 666| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 666| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 666| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 666| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 666| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 666| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.33k, False: 666] | | | | ------------------ | | | | 64| 3.33k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.33k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.33k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.33k| } else { \ | | | | 70| 3.33k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.33k| } \ | | | | 72| 3.33k| } | | ------------------ ------------------ 3524| 666|#line 116 "flex_lexer.l" 3525| 666|TOKEN(FALSE) ------------------ | | 2887| 666|#define TOKEN(name) { return SQL_##name; } ------------------ 3526| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3527| 3|case 57: ------------------ | Branch (3527:1): [True: 3, False: 4.04M] ------------------ 3528| 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| } | | ------------------ ------------------ 3529| 3|#line 117 "flex_lexer.l" 3530| 3|TOKEN(FILE) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3531| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3532| 695|case 58: ------------------ | Branch (3532:1): [True: 695, False: 4.04M] ------------------ 3533| 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| } | | ------------------ ------------------ 3534| 695|#line 118 "flex_lexer.l" 3535| 695|TOKEN(FLOAT) ------------------ | | 2887| 695|#define TOKEN(name) { return SQL_##name; } ------------------ 3536| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3537| 2.32k|case 59: ------------------ | Branch (3537:1): [True: 2.32k, False: 4.04M] ------------------ 3538| 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| 23.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.9k, False: 2.32k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3539| 2.32k|#line 119 "flex_lexer.l" 3540| 2.32k|TOKEN(FOLLOWING) ------------------ | | 2887| 2.32k|#define TOKEN(name) { return SQL_##name; } ------------------ 3541| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3542| 4.17k|case 60: ------------------ | Branch (3542:1): [True: 4.17k, False: 4.03M] ------------------ 3543| 4.17k|YY_RULE_SETUP ------------------ | | 3147| 4.17k| YY_USER_ACTION | | ------------------ | | | | 61| 4.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.5k, False: 4.17k] | | | | ------------------ | | | | 64| 12.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.5k| } else { \ | | | | 70| 12.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.5k| } \ | | | | 72| 12.5k| } | | ------------------ ------------------ 3544| 4.17k|#line 120 "flex_lexer.l" 3545| 4.17k|TOKEN(FOR) ------------------ | | 2887| 4.17k|#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.04M] ------------------ 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.58k|case 62: ------------------ | Branch (3552:1): [True: 1.58k, False: 4.04M] ------------------ 3553| 1.58k|YY_RULE_SETUP ------------------ | | 3147| 1.58k| YY_USER_ACTION | | ------------------ | | | | 61| 1.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.58k| # 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: 9.50k, False: 1.58k] | | | | ------------------ | | | | 64| 9.50k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.50k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.50k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.50k] | | | | ------------------ | | | | 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.50k| } else { \ | | | | 70| 9.50k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.50k| } \ | | | | 72| 9.50k| } | | ------------------ ------------------ 3554| 1.58k|#line 122 "flex_lexer.l" 3555| 1.58k|TOKEN(FORMAT) ------------------ | | 2887| 1.58k|#define TOKEN(name) { return SQL_##name; } ------------------ 3556| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3557| 16.8k|case 63: ------------------ | Branch (3557:1): [True: 16.8k, False: 4.02M] ------------------ 3558| 16.8k|YY_RULE_SETUP ------------------ | | 3147| 16.8k| YY_USER_ACTION | | ------------------ | | | | 61| 16.8k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 16.8k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 84.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 84.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 67.2k, False: 16.8k] | | | | ------------------ | | | | 64| 67.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 67.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 67.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 67.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 67.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 67.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 67.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| 67.2k| } else { \ | | | | 70| 67.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 67.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 67.2k| } \ | | | | 72| 67.2k| } | | ------------------ ------------------ 3559| 16.8k|#line 123 "flex_lexer.l" 3560| 16.8k|TOKEN(FROM) ------------------ | | 2887| 16.8k|#define TOKEN(name) { return SQL_##name; } ------------------ 3561| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3562| 193|case 64: ------------------ | Branch (3562:1): [True: 193, False: 4.04M] ------------------ 3563| 193|YY_RULE_SETUP ------------------ | | 3147| 193| YY_USER_ACTION | | ------------------ | | | | 61| 193| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 193| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 193| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 193| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 193| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 193| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 965| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 965|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 772, False: 193] | | | | ------------------ | | | | 64| 772| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 772| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 772| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 772|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 772] | | | | ------------------ | | | | 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| 772| } else { \ | | | | 70| 772| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 772| } \ | | | | 72| 772| } | | ------------------ ------------------ 3564| 193|#line 124 "flex_lexer.l" 3565| 193|TOKEN(FULL) ------------------ | | 2887| 193|#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.04M] ------------------ 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.84k|case 66: ------------------ | Branch (3572:1): [True: 3.84k, False: 4.03M] ------------------ 3573| 3.84k|YY_RULE_SETUP ------------------ | | 3147| 3.84k| YY_USER_ACTION | | ------------------ | | | | 61| 3.84k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.84k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 23.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 19.2k, False: 3.84k] | | | | ------------------ | | | | 64| 19.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 19.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 19.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 19.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 19.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 19.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 19.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| 19.2k| } else { \ | | | | 70| 19.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 19.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 19.2k| } \ | | | | 72| 19.2k| } | | ------------------ ------------------ 3574| 3.84k|#line 126 "flex_lexer.l" 3575| 3.84k|TOKEN(GROUP) ------------------ | | 2887| 3.84k|#define TOKEN(name) { return SQL_##name; } ------------------ 3576| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3577| 731|case 67: ------------------ | Branch (3577:1): [True: 731, False: 4.04M] ------------------ 3578| 731|YY_RULE_SETUP ------------------ | | 3147| 731| YY_USER_ACTION | | ------------------ | | | | 61| 731| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 731| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 731| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 731| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 731| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 731| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.11k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.38k, False: 731] | | | | ------------------ | | | | 64| 4.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.38k| } else { \ | | | | 70| 4.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.38k| } \ | | | | 72| 4.38k| } | | ------------------ ------------------ 3579| 731|#line 127 "flex_lexer.l" 3580| 731|TOKEN(GROUPS) ------------------ | | 2887| 731|#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.04M] ------------------ 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| 886|case 69: ------------------ | Branch (3587:1): [True: 886, False: 4.04M] ------------------ 3588| 886|YY_RULE_SETUP ------------------ | | 3147| 886| YY_USER_ACTION | | ------------------ | | | | 61| 886| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 886| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 886| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 886| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 886| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 886| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.31k, False: 886] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3589| 886|#line 129 "flex_lexer.l" 3590| 886|TOKEN(HAVING) ------------------ | | 2887| 886|#define TOKEN(name) { return SQL_##name; } ------------------ 3591| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3592| 992|case 70: ------------------ | Branch (3592:1): [True: 992, False: 4.04M] ------------------ 3593| 992|YY_RULE_SETUP ------------------ | | 3147| 992| YY_USER_ACTION | | ------------------ | | | | 61| 992| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 992| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.96k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.96k, False: 992] | | | | ------------------ | | | | 64| 3.96k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.96k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.96k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.96k| } else { \ | | | | 70| 3.96k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.96k| } \ | | | | 72| 3.96k| } | | ------------------ ------------------ 3594| 992|#line 130 "flex_lexer.l" 3595| 992|TOKEN(HINT) ------------------ | | 2887| 992|#define TOKEN(name) { return SQL_##name; } ------------------ 3596| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3597| 984|case 71: ------------------ | Branch (3597:1): [True: 984, False: 4.04M] ------------------ 3598| 984|YY_RULE_SETUP ------------------ | | 3147| 984| YY_USER_ACTION | | ------------------ | | | | 61| 984| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 984| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.93k, False: 984] | | | | ------------------ | | | | 64| 3.93k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.93k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.93k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.93k| } else { \ | | | | 70| 3.93k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.93k| } \ | | | | 72| 3.93k| } | | ------------------ ------------------ 3599| 984|#line 131 "flex_lexer.l" 3600| 984|TOKEN(HOUR) ------------------ | | 2887| 984|#define TOKEN(name) { return SQL_##name; } ------------------ 3601| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3602| 643|case 72: ------------------ | Branch (3602:1): [True: 643, False: 4.04M] ------------------ 3603| 643|YY_RULE_SETUP ------------------ | | 3147| 643| YY_USER_ACTION | | ------------------ | | | | 61| 643| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 643| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 643| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 643| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 643| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 643| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.21k, False: 643] | | | | ------------------ | | | | 64| 3.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.21k| } else { \ | | | | 70| 3.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.21k| } \ | | | | 72| 3.21k| } | | ------------------ ------------------ 3604| 643|#line 132 "flex_lexer.l" 3605| 643|TOKEN(HOURS) ------------------ | | 2887| 643|#define TOKEN(name) { return SQL_##name; } ------------------ 3606| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3607| 587|case 73: ------------------ | Branch (3607:1): [True: 587, False: 4.04M] ------------------ 3608| 587|YY_RULE_SETUP ------------------ | | 3147| 587| YY_USER_ACTION | | ------------------ | | | | 61| 587| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 587| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.17k, False: 587] | | | | ------------------ | | | | 64| 1.17k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.17k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.17k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.17k| } else { \ | | | | 70| 1.17k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.17k| } \ | | | | 72| 1.17k| } | | ------------------ ------------------ 3609| 587|#line 133 "flex_lexer.l" 3610| 587|TOKEN(IF) ------------------ | | 2887| 587|#define TOKEN(name) { return SQL_##name; } ------------------ 3611| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3612| 716|case 74: ------------------ | Branch (3612:1): [True: 716, False: 4.04M] ------------------ 3613| 716|YY_RULE_SETUP ------------------ | | 3147| 716| YY_USER_ACTION | | ------------------ | | | | 61| 716| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 716| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 716| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 716| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 716| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 716| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.29k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.58k, False: 716] | | | | ------------------ | | | | 64| 3.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.58k] | | | | ------------------ | | | | 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.58k| } else { \ | | | | 70| 3.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.58k| } \ | | | | 72| 3.58k| } | | ------------------ ------------------ 3614| 716|#line 134 "flex_lexer.l" 3615| 716|TOKEN(ILIKE) ------------------ | | 2887| 716|#define TOKEN(name) { return SQL_##name; } ------------------ 3616| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3617| 113|case 75: ------------------ | Branch (3617:1): [True: 113, False: 4.04M] ------------------ 3618| 113|YY_RULE_SETUP ------------------ | | 3147| 113| YY_USER_ACTION | | ------------------ | | | | 61| 113| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 113| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 791| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 791|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 678, False: 113] | | | | ------------------ | | | | 64| 678| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 678| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 678| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 678|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 678] | | | | ------------------ | | | | 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| 678| } else { \ | | | | 70| 678| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 678| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 678| } \ | | | | 72| 678| } | | ------------------ ------------------ 3619| 113|#line 135 "flex_lexer.l" 3620| 113|TOKEN(IMPORT) ------------------ | | 2887| 113|#define TOKEN(name) { return SQL_##name; } ------------------ 3621| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3622| 1.28k|case 76: ------------------ | Branch (3622:1): [True: 1.28k, False: 4.04M] ------------------ 3623| 1.28k|YY_RULE_SETUP ------------------ | | 3147| 1.28k| YY_USER_ACTION | | ------------------ | | | | 61| 1.28k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.28k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.57k, False: 1.28k] | | | | ------------------ | | | | 64| 2.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.57k| } else { \ | | | | 70| 2.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.57k| } \ | | | | 72| 2.57k| } | | ------------------ ------------------ 3624| 1.28k|#line 136 "flex_lexer.l" 3625| 1.28k|TOKEN(IN) ------------------ | | 2887| 1.28k|#define TOKEN(name) { return SQL_##name; } ------------------ 3626| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3627| 1.89k|case 77: ------------------ | Branch (3627:1): [True: 1.89k, False: 4.04M] ------------------ 3628| 1.89k|YY_RULE_SETUP ------------------ | | 3147| 1.89k| YY_USER_ACTION | | ------------------ | | | | 61| 1.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.47k, False: 1.89k] | | | | ------------------ | | | | 64| 9.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.47k| } else { \ | | | | 70| 9.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.47k| } \ | | | | 72| 9.47k| } | | ------------------ ------------------ 3629| 1.89k|#line 137 "flex_lexer.l" 3630| 1.89k|TOKEN(INDEX) ------------------ | | 2887| 1.89k|#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.04M] ------------------ 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.87k|case 79: ------------------ | Branch (3637:1): [True: 3.87k, False: 4.03M] ------------------ 3638| 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| 27.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 27.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.2k, False: 3.87k] | | | | ------------------ | | | | 64| 23.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.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| 23.2k| } else { \ | | | | 70| 23.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.2k| } \ | | | | 72| 23.2k| } | | ------------------ ------------------ 3639| 3.87k|#line 139 "flex_lexer.l" 3640| 3.87k|TOKEN(INSERT) ------------------ | | 2887| 3.87k|#define TOKEN(name) { return SQL_##name; } ------------------ 3641| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3642| 7.83k|case 80: ------------------ | Branch (3642:1): [True: 7.83k, False: 4.03M] ------------------ 3643| 7.83k|YY_RULE_SETUP ------------------ | | 3147| 7.83k| YY_USER_ACTION | | ------------------ | | | | 61| 7.83k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.83k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 31.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 31.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.4k, False: 7.83k] | | | | ------------------ | | | | 64| 23.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.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| 23.4k| } else { \ | | | | 70| 23.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.4k| } \ | | | | 72| 23.4k| } | | ------------------ ------------------ 3644| 7.83k|#line 140 "flex_lexer.l" 3645| 7.83k|TOKEN(INT) ------------------ | | 2887| 7.83k|#define TOKEN(name) { return SQL_##name; } ------------------ 3646| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3647| 680|case 81: ------------------ | Branch (3647:1): [True: 680, False: 4.04M] ------------------ 3648| 680|YY_RULE_SETUP ------------------ | | 3147| 680| YY_USER_ACTION | | ------------------ | | | | 61| 680| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 680| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.76k, False: 680] | | | | ------------------ | | | | 64| 4.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.76k| } else { \ | | | | 70| 4.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.76k| } \ | | | | 72| 4.76k| } | | ------------------ ------------------ 3649| 680|#line 141 "flex_lexer.l" 3650| 680|TOKEN(INTEGER) ------------------ | | 2887| 680|#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.04M] ------------------ 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.63k|case 83: ------------------ | Branch (3657:1): [True: 4.63k, False: 4.03M] ------------------ 3658| 4.63k|YY_RULE_SETUP ------------------ | | 3147| 4.63k| YY_USER_ACTION | | ------------------ | | | | 61| 4.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 41.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 41.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 37.0k, False: 4.63k] | | | | ------------------ | | | | 64| 37.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 37.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 37.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 37.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 37.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 37.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 37.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| 37.0k| } else { \ | | | | 70| 37.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 37.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 37.0k| } \ | | | | 72| 37.0k| } | | ------------------ ------------------ 3659| 4.63k|#line 143 "flex_lexer.l" 3660| 4.63k|TOKEN(INTERVAL) ------------------ | | 2887| 4.63k|#define TOKEN(name) { return SQL_##name; } ------------------ 3661| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3662| 3.85k|case 84: ------------------ | Branch (3662:1): [True: 3.85k, False: 4.03M] ------------------ 3663| 3.85k|YY_RULE_SETUP ------------------ | | 3147| 3.85k| YY_USER_ACTION | | ------------------ | | | | 61| 3.85k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.85k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.4k, False: 3.85k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3664| 3.85k|#line 144 "flex_lexer.l" 3665| 3.85k|TOKEN(INTO) ------------------ | | 2887| 3.85k|#define TOKEN(name) { return SQL_##name; } ------------------ 3666| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3667| 622|case 85: ------------------ | Branch (3667:1): [True: 622, False: 4.04M] ------------------ 3668| 622|YY_RULE_SETUP ------------------ | | 3147| 622| YY_USER_ACTION | | ------------------ | | | | 61| 622| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 622| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 622| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 622| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 622| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 622| # 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: 622] | | | | ------------------ | | | | 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| 622|#line 145 "flex_lexer.l" 3670| 622|TOKEN(IS) ------------------ | | 2887| 622|#define TOKEN(name) { return SQL_##name; } ------------------ 3671| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3672| 768|case 86: ------------------ | Branch (3672:1): [True: 768, False: 4.04M] ------------------ 3673| 768|YY_RULE_SETUP ------------------ | | 3147| 768| YY_USER_ACTION | | ------------------ | | | | 61| 768| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 768| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 768| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 768| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 768| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 768| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.37k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.60k, False: 768] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3674| 768|#line 146 "flex_lexer.l" 3675| 768|TOKEN(ISNULL) ------------------ | | 2887| 768|#define TOKEN(name) { return SQL_##name; } ------------------ 3676| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3677| 113k|case 87: ------------------ | Branch (3677:1): [True: 113k, False: 3.92M] ------------------ 3678| 113k|YY_RULE_SETUP ------------------ | | 3147| 113k| YY_USER_ACTION | | ------------------ | | | | 61| 113k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 113k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 569k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 569k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 455k, False: 113k] | | | | ------------------ | | | | 64| 455k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 455k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 455k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 455k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 455k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 455k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 455k] | | | | ------------------ | | | | 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| 455k| } else { \ | | | | 70| 455k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 455k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 455k| } \ | | | | 72| 455k| } | | ------------------ ------------------ 3679| 113k|#line 147 "flex_lexer.l" 3680| 113k|TOKEN(JOIN) ------------------ | | 2887| 113k|#define TOKEN(name) { return SQL_##name; } ------------------ 3681| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3682| 2.27k|case 88: ------------------ | Branch (3682:1): [True: 2.27k, False: 4.04M] ------------------ 3683| 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| 9.11k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.83k, False: 2.27k] | | | | ------------------ | | | | 64| 6.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.83k| } else { \ | | | | 70| 6.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.83k| } \ | | | | 72| 6.83k| } | | ------------------ ------------------ 3684| 2.27k|#line 148 "flex_lexer.l" 3685| 2.27k|TOKEN(KEY) ------------------ | | 2887| 2.27k|#define TOKEN(name) { return SQL_##name; } ------------------ 3686| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3687| 586|case 89: ------------------ | Branch (3687:1): [True: 586, False: 4.04M] ------------------ 3688| 586|YY_RULE_SETUP ------------------ | | 3147| 586| YY_USER_ACTION | | ------------------ | | | | 61| 586| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 586| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 586| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 586| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 586| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 586| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.34k, False: 586] | | | | ------------------ | | | | 64| 2.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.34k] | | | | ------------------ | | | | 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.34k| } else { \ | | | | 70| 2.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.34k| } \ | | | | 72| 2.34k| } | | ------------------ ------------------ 3689| 586|#line 149 "flex_lexer.l" 3690| 586|TOKEN(LEFT) ------------------ | | 2887| 586|#define TOKEN(name) { return SQL_##name; } ------------------ 3691| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3692| 718|case 90: ------------------ | Branch (3692:1): [True: 718, False: 4.04M] ------------------ 3693| 718|YY_RULE_SETUP ------------------ | | 3147| 718| YY_USER_ACTION | | ------------------ | | | | 61| 718| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 718| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 718| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 718| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 718| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 718| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.87k, False: 718] | | | | ------------------ | | | | 64| 2.87k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.87k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.87k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.87k] | | | | ------------------ | | | | 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.87k| } else { \ | | | | 70| 2.87k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.87k| } \ | | | | 72| 2.87k| } | | ------------------ ------------------ 3694| 718|#line 150 "flex_lexer.l" 3695| 718|TOKEN(LIKE) ------------------ | | 2887| 718|#define TOKEN(name) { return SQL_##name; } ------------------ 3696| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3697| 4.74k|case 91: ------------------ | Branch (3697:1): [True: 4.74k, False: 4.03M] ------------------ 3698| 4.74k|YY_RULE_SETUP ------------------ | | 3147| 4.74k| YY_USER_ACTION | | ------------------ | | | | 61| 4.74k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.74k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 28.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 28.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.7k, False: 4.74k] | | | | ------------------ | | | | 64| 23.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.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| 23.7k| } else { \ | | | | 70| 23.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.7k| } \ | | | | 72| 23.7k| } | | ------------------ ------------------ 3699| 4.74k|#line 151 "flex_lexer.l" 3700| 4.74k|TOKEN(LIMIT) ------------------ | | 2887| 4.74k|#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.04M] ------------------ 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.04M] ------------------ 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| 2|case 94: ------------------ | Branch (3712:1): [True: 2, False: 4.04M] ------------------ 3713| 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| } | | ------------------ ------------------ 3714| 2|#line 154 "flex_lexer.l" 3715| 2|TOKEN(LOCKED) ------------------ | | 2887| 2|#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.04M] ------------------ 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.04M] ------------------ 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.04M] ------------------ 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| 967|case 98: ------------------ | Branch (3732:1): [True: 967, False: 4.04M] ------------------ 3733| 967|YY_RULE_SETUP ------------------ | | 3147| 967| YY_USER_ACTION | | ------------------ | | | | 61| 967| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 967| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 967| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 967| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 967| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 967| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.80k, False: 967] | | | | ------------------ | | | | 64| 5.80k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.80k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.80k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.80k| } else { \ | | | | 70| 5.80k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.80k| } \ | | | | 72| 5.80k| } | | ------------------ ------------------ 3734| 967|#line 158 "flex_lexer.l" 3735| 967|TOKEN(MINUTE) ------------------ | | 2887| 967|#define TOKEN(name) { return SQL_##name; } ------------------ 3736| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3737| 1.05k|case 99: ------------------ | Branch (3737:1): [True: 1.05k, False: 4.04M] ------------------ 3738| 1.05k|YY_RULE_SETUP ------------------ | | 3147| 1.05k| YY_USER_ACTION | | ------------------ | | | | 61| 1.05k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.05k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.39k, False: 1.05k] | | | | ------------------ | | | | 64| 7.39k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.39k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.39k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.39k] | | | | ------------------ | | | | 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.39k| } else { \ | | | | 70| 7.39k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.39k| } \ | | | | 72| 7.39k| } | | ------------------ ------------------ 3739| 1.05k|#line 159 "flex_lexer.l" 3740| 1.05k|TOKEN(MINUTES) ------------------ | | 2887| 1.05k|#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.04M] ------------------ 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| 364|case 101: ------------------ | Branch (3747:1): [True: 364, False: 4.04M] ------------------ 3748| 364|YY_RULE_SETUP ------------------ | | 3147| 364| YY_USER_ACTION | | ------------------ | | | | 61| 364| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 364| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 364| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 364| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 364| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 364| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.18k, False: 364] | | | | ------------------ | | | | 64| 2.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.18k| } else { \ | | | | 70| 2.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.18k| } \ | | | | 72| 2.18k| } | | ------------------ ------------------ 3749| 364|#line 161 "flex_lexer.l" 3750| 364|TOKEN(MONTHS) ------------------ | | 2887| 364|#define TOKEN(name) { return SQL_##name; } ------------------ 3751| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3752| 813|case 102: ------------------ | Branch (3752:1): [True: 813, False: 4.04M] ------------------ 3753| 813|YY_RULE_SETUP ------------------ | | 3147| 813| YY_USER_ACTION | | ------------------ | | | | 61| 813| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 813| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 813| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 813| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 813| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 813| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.69k, False: 813] | | | | ------------------ | | | | 64| 5.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.69k| } else { \ | | | | 70| 5.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.69k| } \ | | | | 72| 5.69k| } | | ------------------ ------------------ 3754| 813|#line 162 "flex_lexer.l" 3755| 813|TOKEN(NATURAL) ------------------ | | 2887| 813|#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.04M] ------------------ 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.53k|case 104: ------------------ | Branch (3762:1): [True: 5.53k, False: 4.03M] ------------------ 3763| 5.53k|YY_RULE_SETUP ------------------ | | 3147| 5.53k| YY_USER_ACTION | | ------------------ | | | | 61| 5.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.53k| # 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: 16.5k, False: 5.53k] | | | | ------------------ | | | | 64| 16.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.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| 16.5k| } else { \ | | | | 70| 16.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.5k| } \ | | | | 72| 16.5k| } | | ------------------ ------------------ 3764| 5.53k|#line 164 "flex_lexer.l" 3765| 5.53k|TOKEN(NOT) ------------------ | | 2887| 5.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3766| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3767| 790|case 105: ------------------ | Branch (3767:1): [True: 790, False: 4.04M] ------------------ 3768| 790|YY_RULE_SETUP ------------------ | | 3147| 790| YY_USER_ACTION | | ------------------ | | | | 61| 790| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 790| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 790| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 790| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 790| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 790| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.53k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.74k, False: 790] | | | | ------------------ | | | | 64| 4.74k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.74k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.74k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.74k] | | | | ------------------ | | | | 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.74k| } else { \ | | | | 70| 4.74k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.74k| } \ | | | | 72| 4.74k| } | | ------------------ ------------------ 3769| 790|#line 165 "flex_lexer.l" 3770| 790|TOKEN(NOWAIT) ------------------ | | 2887| 790|#define TOKEN(name) { return SQL_##name; } ------------------ 3771| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3772| 8.94k|case 106: ------------------ | Branch (3772:1): [True: 8.94k, False: 4.03M] ------------------ 3773| 8.94k|YY_RULE_SETUP ------------------ | | 3147| 8.94k| YY_USER_ACTION | | ------------------ | | | | 61| 8.94k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 8.94k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 44.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 44.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 35.7k, False: 8.94k] | | | | ------------------ | | | | 64| 35.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 35.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 35.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 35.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 35.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 35.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 35.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| 35.7k| } else { \ | | | | 70| 35.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 35.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 35.7k| } \ | | | | 72| 35.7k| } | | ------------------ ------------------ 3774| 8.94k|#line 166 "flex_lexer.l" 3775| 8.94k|TOKEN(NULL) ------------------ | | 2887| 8.94k|#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.04M] ------------------ 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| 288|case 108: ------------------ | Branch (3782:1): [True: 288, False: 4.04M] ------------------ 3783| 288|YY_RULE_SETUP ------------------ | | 3147| 288| YY_USER_ACTION | | ------------------ | | | | 61| 288| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 288| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 288| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 288| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 288| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 288| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 864| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 864|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 576, False: 288] | | | | ------------------ | | | | 64| 576| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 576| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 576| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 576|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 576] | | | | ------------------ | | | | 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| 576| } else { \ | | | | 70| 576| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 576| } \ | | | | 72| 576| } | | ------------------ ------------------ 3784| 288|#line 168 "flex_lexer.l" 3785| 288|TOKEN(OF) ------------------ | | 2887| 288|#define TOKEN(name) { return SQL_##name; } ------------------ 3786| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3787| 2|case 109: ------------------ | Branch (3787:1): [True: 2, False: 4.04M] ------------------ 3788| 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| } | | ------------------ ------------------ 3789| 2|#line 169 "flex_lexer.l" 3790| 2|TOKEN(OFF) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3791| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3792| 2.95k|case 110: ------------------ | Branch (3792:1): [True: 2.95k, False: 4.04M] ------------------ 3793| 2.95k|YY_RULE_SETUP ------------------ | | 3147| 2.95k| YY_USER_ACTION | | ------------------ | | | | 61| 2.95k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.95k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 17.7k, False: 2.95k] | | | | ------------------ | | | | 64| 17.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 17.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 17.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 17.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 17.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 17.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 17.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| 17.7k| } else { \ | | | | 70| 17.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 17.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.7k| } \ | | | | 72| 17.7k| } | | ------------------ ------------------ 3794| 2.95k|#line 170 "flex_lexer.l" 3795| 2.95k|TOKEN(OFFSET) ------------------ | | 2887| 2.95k|#define TOKEN(name) { return SQL_##name; } ------------------ 3796| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3797| 111k|case 111: ------------------ | Branch (3797:1): [True: 111k, False: 3.93M] ------------------ 3798| 111k|YY_RULE_SETUP ------------------ | | 3147| 111k| YY_USER_ACTION | | ------------------ | | | | 61| 111k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 111k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 111k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 111k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 111k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 111k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 334k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 334k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 223k, False: 111k] | | | | ------------------ | | | | 64| 223k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 223k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 223k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 223k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 223k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 223k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 223k] | | | | ------------------ | | | | 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| 223k| } else { \ | | | | 70| 223k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 223k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 223k| } \ | | | | 72| 223k| } | | ------------------ ------------------ 3799| 111k|#line 171 "flex_lexer.l" 3800| 111k|TOKEN(ON) ------------------ | | 2887| 111k|#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.04M] ------------------ 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| 2.98k|case 113: ------------------ | Branch (3807:1): [True: 2.98k, False: 4.04M] ------------------ 3808| 2.98k|YY_RULE_SETUP ------------------ | | 3147| 2.98k| YY_USER_ACTION | | ------------------ | | | | 61| 2.98k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.98k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.98k| # 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.9k, False: 2.98k] | | | | ------------------ | | | | 64| 14.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.9k| } else { \ | | | | 70| 14.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.9k| } \ | | | | 72| 14.9k| } | | ------------------ ------------------ 3809| 2.98k|#line 173 "flex_lexer.l" 3810| 2.98k|TOKEN(ORDER) ------------------ | | 2887| 2.98k|#define TOKEN(name) { return SQL_##name; } ------------------ 3811| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3812| 1.19k|case 114: ------------------ | Branch (3812:1): [True: 1.19k, False: 4.04M] ------------------ 3813| 1.19k|YY_RULE_SETUP ------------------ | | 3147| 1.19k| YY_USER_ACTION | | ------------------ | | | | 61| 1.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.98k, False: 1.19k] | | | | ------------------ | | | | 64| 5.98k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.98k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.98k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.98k] | | | | ------------------ | | | | 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.98k| } else { \ | | | | 70| 5.98k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.98k| } \ | | | | 72| 5.98k| } | | ------------------ ------------------ 3814| 1.19k|#line 174 "flex_lexer.l" 3815| 1.19k|TOKEN(OUTER) ------------------ | | 2887| 1.19k|#define TOKEN(name) { return SQL_##name; } ------------------ 3816| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3817| 6.11k|case 115: ------------------ | Branch (3817:1): [True: 6.11k, False: 4.03M] ------------------ 3818| 6.11k|YY_RULE_SETUP ------------------ | | 3147| 6.11k| YY_USER_ACTION | | ------------------ | | | | 61| 6.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 30.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 30.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 24.4k, False: 6.11k] | | | | ------------------ | | | | 64| 24.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 24.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 24.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 24.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 24.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 24.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 24.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| 24.4k| } else { \ | | | | 70| 24.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 24.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 24.4k| } \ | | | | 72| 24.4k| } | | ------------------ ------------------ 3819| 6.11k|#line 175 "flex_lexer.l" 3820| 6.11k|TOKEN(OVER) ------------------ | | 2887| 6.11k|#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.04M] ------------------ 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| 844|case 117: ------------------ | Branch (3827:1): [True: 844, False: 4.04M] ------------------ 3828| 844|YY_RULE_SETUP ------------------ | | 3147| 844| YY_USER_ACTION | | ------------------ | | | | 61| 844| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 844| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 844| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 844| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 844| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 844| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.59k, False: 844] | | | | ------------------ | | | | 64| 7.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.59k| } else { \ | | | | 70| 7.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.59k| } \ | | | | 72| 7.59k| } | | ------------------ ------------------ 3829| 844|#line 177 "flex_lexer.l" 3830| 844|TOKEN(PARTITION) ------------------ | | 2887| 844|#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.04M] ------------------ 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.53k|case 119: ------------------ | Branch (3837:1): [True: 1.53k, False: 4.04M] ------------------ 3838| 1.53k|YY_RULE_SETUP ------------------ | | 3147| 1.53k| YY_USER_ACTION | | ------------------ | | | | 61| 1.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.7k, False: 1.53k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3839| 1.53k|#line 179 "flex_lexer.l" 3840| 1.53k|TOKEN(PRECEDING) ------------------ | | 2887| 1.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3841| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3842| 2.90k|case 120: ------------------ | Branch (3842:1): [True: 2.90k, False: 4.04M] ------------------ 3843| 2.90k|YY_RULE_SETUP ------------------ | | 3147| 2.90k| YY_USER_ACTION | | ------------------ | | | | 61| 2.90k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.90k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 23.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.3k, False: 2.90k] | | | | ------------------ | | | | 64| 20.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.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| 20.3k| } else { \ | | | | 70| 20.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.3k| } \ | | | | 72| 20.3k| } | | ------------------ ------------------ 3844| 2.90k|#line 180 "flex_lexer.l" 3845| 2.90k|TOKEN(PREPARE) ------------------ | | 2887| 2.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 3846| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3847| 2.06k|case 121: ------------------ | Branch (3847:1): [True: 2.06k, False: 4.04M] ------------------ 3848| 2.06k|YY_RULE_SETUP ------------------ | | 3147| 2.06k| YY_USER_ACTION | | ------------------ | | | | 61| 2.06k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.06k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.4k, False: 2.06k] | | | | ------------------ | | | | 64| 14.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.4k| } else { \ | | | | 70| 14.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.4k| } \ | | | | 72| 14.4k| } | | ------------------ ------------------ 3849| 2.06k|#line 181 "flex_lexer.l" 3850| 2.06k|TOKEN(PRIMARY) ------------------ | | 2887| 2.06k|#define TOKEN(name) { return SQL_##name; } ------------------ 3851| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3852| 1.45k|case 122: ------------------ | Branch (3852:1): [True: 1.45k, False: 4.04M] ------------------ 3853| 1.45k|YY_RULE_SETUP ------------------ | | 3147| 1.45k| YY_USER_ACTION | | ------------------ | | | | 61| 1.45k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.45k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.70k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.25k, False: 1.45k] | | | | ------------------ | | | | 64| 7.25k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.25k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.25k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.25k] | | | | ------------------ | | | | 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.25k| } else { \ | | | | 70| 7.25k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.25k| } \ | | | | 72| 7.25k| } | | ------------------ ------------------ 3854| 1.45k|#line 182 "flex_lexer.l" 3855| 1.45k|TOKEN(RANGE) ------------------ | | 2887| 1.45k|#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.04M] ------------------ 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.04M] ------------------ 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.04M] ------------------ 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.04M] ------------------ 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| 551|case 127: ------------------ | Branch (3877:1): [True: 551, False: 4.04M] ------------------ 3878| 551|YY_RULE_SETUP ------------------ | | 3147| 551| YY_USER_ACTION | | ------------------ | | | | 61| 551| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 551| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 551| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 551| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 551| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 551| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.30k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.30k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.75k, False: 551] | | | | ------------------ | | | | 64| 2.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.75k| } else { \ | | | | 70| 2.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.75k| } \ | | | | 72| 2.75k| } | | ------------------ ------------------ 3879| 551|#line 187 "flex_lexer.l" 3880| 551|TOKEN(RIGHT) ------------------ | | 2887| 551|#define TOKEN(name) { return SQL_##name; } ------------------ 3881| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3882| 2.89k|case 128: ------------------ | Branch (3882:1): [True: 2.89k, False: 4.04M] ------------------ 3883| 2.89k|YY_RULE_SETUP ------------------ | | 3147| 2.89k| YY_USER_ACTION | | ------------------ | | | | 61| 2.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.89k| # 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: 23.1k, False: 2.89k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3884| 2.89k|#line 188 "flex_lexer.l" 3885| 2.89k|TOKEN(ROLLBACK) ------------------ | | 2887| 2.89k|#define TOKEN(name) { return SQL_##name; } ------------------ 3886| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3887| 1.53k|case 129: ------------------ | Branch (3887:1): [True: 1.53k, False: 4.04M] ------------------ 3888| 1.53k|YY_RULE_SETUP ------------------ | | 3147| 1.53k| YY_USER_ACTION | | ------------------ | | | | 61| 1.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.12k, False: 1.53k] | | | | ------------------ | | | | 64| 6.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.12k| } else { \ | | | | 70| 6.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.12k| } \ | | | | 72| 6.12k| } | | ------------------ ------------------ 3889| 1.53k|#line 189 "flex_lexer.l" 3890| 1.53k|TOKEN(ROWS) ------------------ | | 2887| 1.53k|#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.04M] ------------------ 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.04M] ------------------ 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.04M] ------------------ 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| 856|case 133: ------------------ | Branch (3907:1): [True: 856, False: 4.04M] ------------------ 3908| 856|YY_RULE_SETUP ------------------ | | 3147| 856| YY_USER_ACTION | | ------------------ | | | | 61| 856| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 856| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.99k, False: 856] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3909| 856|#line 193 "flex_lexer.l" 3910| 856|TOKEN(SECONDS) ------------------ | | 2887| 856|#define TOKEN(name) { return SQL_##name; } ------------------ 3911| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3912| 45.5k|case 134: ------------------ | Branch (3912:1): [True: 45.5k, False: 3.99M] ------------------ 3913| 45.5k|YY_RULE_SETUP ------------------ | | 3147| 45.5k| YY_USER_ACTION | | ------------------ | | | | 61| 45.5k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 45.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 45.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 45.5k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 45.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 45.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 318k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 318k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 273k, False: 45.5k] | | | | ------------------ | | | | 64| 273k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 273k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 273k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 273k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 273k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 273k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 273k] | | | | ------------------ | | | | 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| 273k| } else { \ | | | | 70| 273k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 273k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 273k| } \ | | | | 72| 273k| } | | ------------------ ------------------ 3914| 45.5k|#line 194 "flex_lexer.l" 3915| 45.5k|TOKEN(SELECT) ------------------ | | 2887| 45.5k|#define TOKEN(name) { return SQL_##name; } ------------------ 3916| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3917| 2.85k|case 135: ------------------ | Branch (3917:1): [True: 2.85k, False: 4.04M] ------------------ 3918| 2.85k|YY_RULE_SETUP ------------------ | | 3147| 2.85k| YY_USER_ACTION | | ------------------ | | | | 61| 2.85k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.85k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.56k, False: 2.85k] | | | | ------------------ | | | | 64| 8.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.56k] | | | | ------------------ | | | | 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.56k| } else { \ | | | | 70| 8.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.56k| } \ | | | | 72| 8.56k| } | | ------------------ ------------------ 3919| 2.85k|#line 195 "flex_lexer.l" 3920| 2.85k|TOKEN(SET) ------------------ | | 2887| 2.85k|#define TOKEN(name) { return SQL_##name; } ------------------ 3921| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3922| 3.37k|case 136: ------------------ | Branch (3922:1): [True: 3.37k, False: 4.04M] ------------------ 3923| 3.37k|YY_RULE_SETUP ------------------ | | 3147| 3.37k| YY_USER_ACTION | | ------------------ | | | | 61| 3.37k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.37k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.8k, False: 3.37k] | | | | ------------------ | | | | 64| 16.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.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| 16.8k| } else { \ | | | | 70| 16.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.8k| } \ | | | | 72| 16.8k| } | | ------------------ ------------------ 3924| 3.37k|#line 196 "flex_lexer.l" 3925| 3.37k|TOKEN(SHARE) ------------------ | | 2887| 3.37k|#define TOKEN(name) { return SQL_##name; } ------------------ 3926| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3927| 2.82k|case 137: ------------------ | Branch (3927:1): [True: 2.82k, False: 4.04M] ------------------ 3928| 2.82k|YY_RULE_SETUP ------------------ | | 3147| 2.82k| YY_USER_ACTION | | ------------------ | | | | 61| 2.82k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.82k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.3k, False: 2.82k] | | | | ------------------ | | | | 64| 11.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.3k| } else { \ | | | | 70| 11.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.3k| } \ | | | | 72| 11.3k| } | | ------------------ ------------------ 3929| 2.82k|#line 197 "flex_lexer.l" 3930| 2.82k|TOKEN(SHOW) ------------------ | | 2887| 2.82k|#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.04M] ------------------ 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| 554|case 139: ------------------ | Branch (3937:1): [True: 554, False: 4.04M] ------------------ 3938| 554|YY_RULE_SETUP ------------------ | | 3147| 554| YY_USER_ACTION | | ------------------ | | | | 61| 554| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 554| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 554| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 554| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 554| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 554| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.43k, False: 554] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3939| 554|#line 199 "flex_lexer.l" 3940| 554|TOKEN(SMALLINT) ------------------ | | 2887| 554|#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.04M] ------------------ 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.04M] ------------------ 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| 7.12k|case 142: ------------------ | Branch (3952:1): [True: 7.12k, False: 4.03M] ------------------ 3953| 7.12k|YY_RULE_SETUP ------------------ | | 3147| 7.12k| YY_USER_ACTION | | ------------------ | | | | 61| 7.12k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.12k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 42.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 42.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 35.6k, False: 7.12k] | | | | ------------------ | | | | 64| 35.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 35.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 35.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 35.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 35.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 35.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 35.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| 35.6k| } else { \ | | | | 70| 35.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 35.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 35.6k| } \ | | | | 72| 35.6k| } | | ------------------ ------------------ 3954| 7.12k|#line 202 "flex_lexer.l" 3955| 7.12k|TOKEN(TABLE) ------------------ | | 2887| 7.12k|#define TOKEN(name) { return SQL_##name; } ------------------ 3956| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3957| 1.63k|case 143: ------------------ | Branch (3957:1): [True: 1.63k, False: 4.04M] ------------------ 3958| 1.63k|YY_RULE_SETUP ------------------ | | 3147| 1.63k| YY_USER_ACTION | | ------------------ | | | | 61| 1.63k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.63k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.79k, False: 1.63k] | | | | ------------------ | | | | 64| 9.79k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.79k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.79k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.79k| } else { \ | | | | 70| 9.79k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.79k| } \ | | | | 72| 9.79k| } | | ------------------ ------------------ 3959| 1.63k|#line 203 "flex_lexer.l" 3960| 1.63k|TOKEN(TABLES) ------------------ | | 2887| 1.63k|#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.04M] ------------------ 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.04M] ------------------ 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.36k|case 146: ------------------ | Branch (3972:1): [True: 3.36k, False: 4.04M] ------------------ 3973| 3.36k|YY_RULE_SETUP ------------------ | | 3147| 3.36k| YY_USER_ACTION | | ------------------ | | | | 61| 3.36k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.36k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.4k, False: 3.36k] | | | | ------------------ | | | | 64| 13.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.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| 13.4k| } else { \ | | | | 70| 13.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.4k| } \ | | | | 72| 13.4k| } | | ------------------ ------------------ 3974| 3.36k|#line 206 "flex_lexer.l" 3975| 3.36k|TOKEN(THEN) ------------------ | | 2887| 3.36k|#define TOKEN(name) { return SQL_##name; } ------------------ 3976| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3977| 963|case 147: ------------------ | Branch (3977:1): [True: 963, False: 4.04M] ------------------ 3978| 963|YY_RULE_SETUP ------------------ | | 3147| 963| YY_USER_ACTION | | ------------------ | | | | 61| 963| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 963| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 963| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 963| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 963| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 963| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.81k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.85k, False: 963] | | | | ------------------ | | | | 64| 3.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.85k| } else { \ | | | | 70| 3.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.85k| } \ | | | | 72| 3.85k| } | | ------------------ ------------------ 3979| 963|#line 207 "flex_lexer.l" 3980| 963|TOKEN(TIME) ------------------ | | 2887| 963|#define TOKEN(name) { return SQL_##name; } ------------------ 3981| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3982| 639|case 148: ------------------ | Branch (3982:1): [True: 639, False: 4.04M] ------------------ 3983| 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| } | | ------------------ ------------------ 3984| 639|#line 208 "flex_lexer.l" 3985| 639|TOKEN(TIMESTAMP) ------------------ | | 2887| 639|#define TOKEN(name) { return SQL_##name; } ------------------ 3986| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3987| 7.37k|case 149: ------------------ | Branch (3987:1): [True: 7.37k, False: 4.03M] ------------------ 3988| 7.37k|YY_RULE_SETUP ------------------ | | 3147| 7.37k| YY_USER_ACTION | | ------------------ | | | | 61| 7.37k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.37k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.37k| # 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.37k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3989| 7.37k|#line 209 "flex_lexer.l" 3990| 7.37k|TOKEN(TO) ------------------ | | 2887| 7.37k|#define TOKEN(name) { return SQL_##name; } ------------------ 3991| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3992| 3.72k|case 150: ------------------ | Branch (3992:1): [True: 3.72k, False: 4.03M] ------------------ 3993| 3.72k|YY_RULE_SETUP ------------------ | | 3147| 3.72k| YY_USER_ACTION | | ------------------ | | | | 61| 3.72k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.72k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.1k, False: 3.72k] | | | | ------------------ | | | | 64| 11.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.1k| } else { \ | | | | 70| 11.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.1k| } \ | | | | 72| 11.1k| } | | ------------------ ------------------ 3994| 3.72k|#line 210 "flex_lexer.l" 3995| 3.72k|TOKEN(TOP) ------------------ | | 2887| 3.72k|#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.04M] ------------------ 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| 645|case 152: ------------------ | Branch (4002:1): [True: 645, False: 4.04M] ------------------ 4003| 645|YY_RULE_SETUP ------------------ | | 3147| 645| YY_USER_ACTION | | ------------------ | | | | 61| 645| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 645| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 645| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 645| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 645| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 645| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.58k, False: 645] | | | | ------------------ | | | | 64| 2.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.58k] | | | | ------------------ | | | | 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.58k| } else { \ | | | | 70| 2.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.58k| } \ | | | | 72| 2.58k| } | | ------------------ ------------------ 4004| 645|#line 212 "flex_lexer.l" 4005| 645|TOKEN(TRUE) ------------------ | | 2887| 645|#define TOKEN(name) { return SQL_##name; } ------------------ 4006| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4007| 389|case 153: ------------------ | Branch (4007:1): [True: 389, False: 4.04M] ------------------ 4008| 389|YY_RULE_SETUP ------------------ | | 3147| 389| YY_USER_ACTION | | ------------------ | | | | 61| 389| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 389| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 389| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.11k, False: 389] | | | | ------------------ | | | | 64| 3.11k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.11k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.11k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.11k] | | | | ------------------ | | | | 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.11k| } else { \ | | | | 70| 3.11k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.11k| } \ | | | | 72| 3.11k| } | | ------------------ ------------------ 4009| 389|#line 213 "flex_lexer.l" 4010| 389|TOKEN(TRUNCATE) ------------------ | | 2887| 389|#define TOKEN(name) { return SQL_##name; } ------------------ 4011| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4012| 1.03k|case 154: ------------------ | Branch (4012:1): [True: 1.03k, False: 4.04M] ------------------ 4013| 1.03k|YY_RULE_SETUP ------------------ | | 3147| 1.03k| YY_USER_ACTION | | ------------------ | | | | 61| 1.03k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.03k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.03k| # 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: 9.27k, False: 1.03k] | | | | ------------------ | | | | 64| 9.27k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.27k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.27k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.27k| } else { \ | | | | 70| 9.27k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.27k| } \ | | | | 72| 9.27k| } | | ------------------ ------------------ 4014| 1.03k|#line 214 "flex_lexer.l" 4015| 1.03k|TOKEN(UNBOUNDED) ------------------ | | 2887| 1.03k|#define TOKEN(name) { return SQL_##name; } ------------------ 4016| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4017| 4.58k|case 155: ------------------ | Branch (4017:1): [True: 4.58k, False: 4.03M] ------------------ 4018| 4.58k|YY_RULE_SETUP ------------------ | | 3147| 4.58k| YY_USER_ACTION | | ------------------ | | | | 61| 4.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 27.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 27.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 22.9k, False: 4.58k] | | | | ------------------ | | | | 64| 22.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 22.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 22.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 22.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 22.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| 22.9k| } else { \ | | | | 70| 22.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 22.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 22.9k| } \ | | | | 72| 22.9k| } | | ------------------ ------------------ 4019| 4.58k|#line 215 "flex_lexer.l" 4020| 4.58k|TOKEN(UNION) ------------------ | | 2887| 4.58k|#define TOKEN(name) { return SQL_##name; } ------------------ 4021| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4022| 3.46k|case 156: ------------------ | Branch (4022:1): [True: 3.46k, False: 4.03M] ------------------ 4023| 3.46k|YY_RULE_SETUP ------------------ | | 3147| 3.46k| YY_USER_ACTION | | ------------------ | | | | 61| 3.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 24.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 24.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.7k, False: 3.46k] | | | | ------------------ | | | | 64| 20.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.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| 20.7k| } else { \ | | | | 70| 20.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.7k| } \ | | | | 72| 20.7k| } | | ------------------ ------------------ 4024| 3.46k|#line 216 "flex_lexer.l" 4025| 3.46k|TOKEN(UNIQUE) ------------------ | | 2887| 3.46k|#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.04M] ------------------ 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| 3.61k|case 158: ------------------ | Branch (4032:1): [True: 3.61k, False: 4.03M] ------------------ 4033| 3.61k|YY_RULE_SETUP ------------------ | | 3147| 3.61k| YY_USER_ACTION | | ------------------ | | | | 61| 3.61k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.61k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 25.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 25.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21.6k, False: 3.61k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4034| 3.61k|#line 218 "flex_lexer.l" 4035| 3.61k|TOKEN(UPDATE) ------------------ | | 2887| 3.61k|#define TOKEN(name) { return SQL_##name; } ------------------ 4036| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4037| 730|case 159: ------------------ | Branch (4037:1): [True: 730, False: 4.04M] ------------------ 4038| 730|YY_RULE_SETUP ------------------ | | 3147| 730| YY_USER_ACTION | | ------------------ | | | | 61| 730| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 730| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 730| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 730| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 730| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 730| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.38k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.65k, False: 730] | | | | ------------------ | | | | 64| 3.65k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.65k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.65k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.65k| } else { \ | | | | 70| 3.65k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.65k| } \ | | | | 72| 3.65k| } | | ------------------ ------------------ 4039| 730|#line 219 "flex_lexer.l" 4040| 730|TOKEN(USING) ------------------ | | 2887| 730|#define TOKEN(name) { return SQL_##name; } ------------------ 4041| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4042| 572|case 160: ------------------ | Branch (4042:1): [True: 572, False: 4.04M] ------------------ 4043| 572|YY_RULE_SETUP ------------------ | | 3147| 572| YY_USER_ACTION | | ------------------ | | | | 61| 572| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 572| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.43k, False: 572] | | | | ------------------ | | | | 64| 3.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.43k| } else { \ | | | | 70| 3.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.43k| } \ | | | | 72| 3.43k| } | | ------------------ ------------------ 4044| 572|#line 220 "flex_lexer.l" 4045| 572|TOKEN(VALUES) ------------------ | | 2887| 572|#define TOKEN(name) { return SQL_##name; } ------------------ 4046| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4047| 775|case 161: ------------------ | Branch (4047:1): [True: 775, False: 4.04M] ------------------ 4048| 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| 6.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.42k, False: 775] | | | | ------------------ | | | | 64| 5.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.42k| } else { \ | | | | 70| 5.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.42k| } \ | | | | 72| 5.42k| } | | ------------------ ------------------ 4049| 775|#line 221 "flex_lexer.l" 4050| 775|TOKEN(VARCHAR) ------------------ | | 2887| 775|#define TOKEN(name) { return SQL_##name; } ------------------ 4051| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4052| 4.08k|case 162: ------------------ | Branch (4052:1): [True: 4.08k, False: 4.03M] ------------------ 4053| 4.08k|YY_RULE_SETUP ------------------ | | 3147| 4.08k| YY_USER_ACTION | | ------------------ | | | | 61| 4.08k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.08k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.08k| # 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: 16.3k, False: 4.08k] | | | | ------------------ | | | | 64| 16.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.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| 16.3k| } else { \ | | | | 70| 16.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.3k| } \ | | | | 72| 16.3k| } | | ------------------ ------------------ 4054| 4.08k|#line 222 "flex_lexer.l" 4055| 4.08k|TOKEN(VIEW) ------------------ | | 2887| 4.08k|#define TOKEN(name) { return SQL_##name; } ------------------ 4056| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4057| 3|case 163: ------------------ | Branch (4057:1): [True: 3, False: 4.04M] ------------------ 4058| 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| } | | ------------------ ------------------ 4059| 3|#line 223 "flex_lexer.l" 4060| 3|TOKEN(VIRTUAL) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 4061| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4062| 3.39k|case 164: ------------------ | Branch (4062:1): [True: 3.39k, False: 4.04M] ------------------ 4063| 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| } | | ------------------ ------------------ 4064| 3.39k|#line 224 "flex_lexer.l" 4065| 3.39k|TOKEN(WHEN) ------------------ | | 2887| 3.39k|#define TOKEN(name) { return SQL_##name; } ------------------ 4066| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4067| 2.01k|case 165: ------------------ | Branch (4067:1): [True: 2.01k, False: 4.04M] ------------------ 4068| 2.01k|YY_RULE_SETUP ------------------ | | 3147| 2.01k| YY_USER_ACTION | | ------------------ | | | | 61| 2.01k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.01k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.01k| # 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.0k, False: 2.01k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4069| 2.01k|#line 225 "flex_lexer.l" 4070| 2.01k|TOKEN(WHERE) ------------------ | | 2887| 2.01k|#define TOKEN(name) { return SQL_##name; } ------------------ 4071| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4072| 2.40k|case 166: ------------------ | Branch (4072:1): [True: 2.40k, False: 4.04M] ------------------ 4073| 2.40k|YY_RULE_SETUP ------------------ | | 3147| 2.40k| YY_USER_ACTION | | ------------------ | | | | 61| 2.40k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.40k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.40k| # 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: 9.61k, False: 2.40k] | | | | ------------------ | | | | 64| 9.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.61k| } else { \ | | | | 70| 9.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.61k| } \ | | | | 72| 9.61k| } | | ------------------ ------------------ 4074| 2.40k|#line 226 "flex_lexer.l" 4075| 2.40k|TOKEN(WITH) ------------------ | | 2887| 2.40k|#define TOKEN(name) { return SQL_##name; } ------------------ 4076| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4077| 517|case 167: ------------------ | Branch (4077:1): [True: 517, False: 4.04M] ------------------ 4078| 517|YY_RULE_SETUP ------------------ | | 3147| 517| YY_USER_ACTION | | ------------------ | | | | 61| 517| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 517| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 517| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 517| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 517| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 517| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.58k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.06k, False: 517] | | | | ------------------ | | | | 64| 2.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.06k| } else { \ | | | | 70| 2.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.06k| } \ | | | | 72| 2.06k| } | | ------------------ ------------------ 4079| 517|#line 227 "flex_lexer.l" 4080| 517|TOKEN(YEAR) ------------------ | | 2887| 517|#define TOKEN(name) { return SQL_##name; } ------------------ 4081| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4082| 468|case 168: ------------------ | Branch (4082:1): [True: 468, False: 4.04M] ------------------ 4083| 468|YY_RULE_SETUP ------------------ | | 3147| 468| YY_USER_ACTION | | ------------------ | | | | 61| 468| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 468| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.34k, False: 468] | | | | ------------------ | | | | 64| 2.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.34k] | | | | ------------------ | | | | 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.34k| } else { \ | | | | 70| 2.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.34k| } \ | | | | 72| 2.34k| } | | ------------------ ------------------ 4084| 468|#line 228 "flex_lexer.l" 4085| 468|TOKEN(YEARS) ------------------ | | 2887| 468|#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.04M] ------------------ 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.04M] ------------------ 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| 496|case 171: ------------------ | Branch (4100:1): [True: 496, False: 4.04M] ------------------ 4101| 496|YY_RULE_SETUP ------------------ | | 3147| 496| YY_USER_ACTION | | ------------------ | | | | 61| 496| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 496| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 496| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 496| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 496| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 496| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.48k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 992, False: 496] | | | | ------------------ | | | | 64| 992| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 992| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 992| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 992|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 992] | | | | ------------------ | | | | 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| 992| } else { \ | | | | 70| 992| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 992| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 992| } \ | | | | 72| 992| } | | ------------------ ------------------ 4102| 496|#line 234 "flex_lexer.l" 4103| 496|TOKEN(EQUALS) ------------------ | | 2887| 496|#define TOKEN(name) { return SQL_##name; } ------------------ 4104| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4105| 1.18k|case 172: ------------------ | Branch (4105:1): [True: 1.18k, False: 4.04M] ------------------ 4106| 1.18k|YY_RULE_SETUP ------------------ | | 3147| 1.18k| YY_USER_ACTION | | ------------------ | | | | 61| 1.18k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.18k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.55k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.55k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.37k, False: 1.18k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4107| 1.18k|#line 235 "flex_lexer.l" 4108| 1.18k|TOKEN(NOTEQUALS) ------------------ | | 2887| 1.18k|#define TOKEN(name) { return SQL_##name; } ------------------ 4109| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4110| 267|case 173: ------------------ | Branch (4110:1): [True: 267, False: 4.04M] ------------------ 4111| 267|YY_RULE_SETUP ------------------ | | 3147| 267| YY_USER_ACTION | | ------------------ | | | | 61| 267| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 267| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 267| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 267| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 267| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 267| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 801| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 801|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 534, False: 267] | | | | ------------------ | | | | 64| 534| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 534| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 534| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 534| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 534| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 534|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 534] | | | | ------------------ | | | | 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| 534| } else { \ | | | | 70| 534| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 534| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 534| } \ | | | | 72| 534| } | | ------------------ ------------------ 4112| 267|#line 236 "flex_lexer.l" 4113| 267|TOKEN(NOTEQUALS) ------------------ | | 2887| 267|#define TOKEN(name) { return SQL_##name; } ------------------ 4114| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4115| 1.30k|case 174: ------------------ | Branch (4115:1): [True: 1.30k, False: 4.04M] ------------------ 4116| 1.30k|YY_RULE_SETUP ------------------ | | 3147| 1.30k| YY_USER_ACTION | | ------------------ | | | | 61| 1.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.91k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.91k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.60k, False: 1.30k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4117| 1.30k|#line 237 "flex_lexer.l" 4118| 1.30k|TOKEN(LESSEQ) ------------------ | | 2887| 1.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 4119| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4120| 747|case 175: ------------------ | Branch (4120:1): [True: 747, False: 4.04M] ------------------ 4121| 747|YY_RULE_SETUP ------------------ | | 3147| 747| YY_USER_ACTION | | ------------------ | | | | 61| 747| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 747| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 747| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 747| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 747| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 747| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.49k, False: 747] | | | | ------------------ | | | | 64| 1.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.49k] | | | | ------------------ | | | | 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.49k| } else { \ | | | | 70| 1.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.49k| } \ | | | | 72| 1.49k| } | | ------------------ ------------------ 4122| 747|#line 238 "flex_lexer.l" 4123| 747|TOKEN(GREATEREQ) ------------------ | | 2887| 747|#define TOKEN(name) { return SQL_##name; } ------------------ 4124| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4125| 3.50k|case 176: ------------------ | Branch (4125:1): [True: 3.50k, False: 4.03M] ------------------ 4126| 3.50k|YY_RULE_SETUP ------------------ | | 3147| 3.50k| YY_USER_ACTION | | ------------------ | | | | 61| 3.50k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.50k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.50k| # 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: 7.01k, False: 3.50k] | | | | ------------------ | | | | 64| 7.01k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.01k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.01k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.01k] | | | | ------------------ | | | | 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.01k| } else { \ | | | | 70| 7.01k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.01k| } \ | | | | 72| 7.01k| } | | ------------------ ------------------ 4127| 3.50k|#line 239 "flex_lexer.l" 4128| 3.50k|TOKEN(CONCAT) ------------------ | | 2887| 3.50k|#define TOKEN(name) { return SQL_##name; } ------------------ 4129| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4130| 2.36M|case 177: ------------------ | Branch (4130:1): [True: 2.36M, False: 1.68M] ------------------ 4131| 2.36M|YY_RULE_SETUP ------------------ | | 3147| 2.36M| YY_USER_ACTION | | ------------------ | | | | 61| 2.36M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.36M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.72M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.72M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.36M, False: 2.36M] | | | | ------------------ | | | | 64| 2.36M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.36M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.36M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.36M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.36M] | | | | ------------------ | | | | 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.36M| } else { \ | | | | 70| 2.36M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.36M| } \ | | | | 72| 2.36M| } | | ------------------ ------------------ 4132| 2.36M|#line 241 "flex_lexer.l" 4133| 2.36M|{ return yytext[0]; } ------------------ | | 122| 2.36M|#define yytext yyg->yytext_r ------------------ 4134| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4135| 234|case 178: ------------------ | Branch (4135:1): [True: 234, False: 4.04M] ------------------ 4136| 234|#line 244 "flex_lexer.l" 4137| 2.11k|case 179: ------------------ | Branch (4137:1): [True: 1.87k, False: 4.04M] ------------------ 4138| 2.11k|YY_RULE_SETUP ------------------ | | 3147| 2.11k| YY_USER_ACTION | | ------------------ | | | | 61| 2.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.11k| # 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: 13.7k, False: 2.11k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4139| 2.11k|#line 244 "flex_lexer.l" 4140| 2.11k|{ 4141| 2.11k| yylval->fval = atof(yytext); ------------------ | | 2964| 2.11k| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 122| 2.11k|#define yytext yyg->yytext_r ------------------ 4142| 2.11k| return SQL_FLOATVAL; 4143| 234|} 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| 524|case 180: ------------------ | Branch (4150:1): [True: 524, False: 4.04M] ------------------ 4151| 524|YY_RULE_SETUP ------------------ | | 3147| 524| YY_USER_ACTION | | ------------------ | | | | 61| 524| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 524| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 524| # 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.4k, False: 524] | | | | ------------------ | | | | 64| 10.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.4k| } else { \ | | | | 70| 10.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.4k| } \ | | | | 72| 10.4k| } | | ------------------ ------------------ 4152| 524|#line 254 "flex_lexer.l" 4153| 524|{ 4154| 524| yylval->ival = LLONG_MIN; ------------------ | | 2964| 524| # define yylval yyg->yylval_r ------------------ 4155| 524| return SQL_INTVAL; 4156| 234|} 4157| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4158| 25.2k|case 181: ------------------ | Branch (4158:1): [True: 25.2k, False: 4.01M] ------------------ 4159| 25.2k|YY_RULE_SETUP ------------------ | | 3147| 25.2k| YY_USER_ACTION | | ------------------ | | | | 61| 25.2k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 25.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 25.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 25.2k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 25.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 25.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 62.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 62.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 37.5k, False: 25.2k] | | | | ------------------ | | | | 64| 37.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 37.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 37.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 37.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 37.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 37.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 37.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| 37.5k| } else { \ | | | | 70| 37.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 37.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 37.5k| } \ | | | | 72| 37.5k| } | | ------------------ ------------------ 4160| 25.2k|#line 259 "flex_lexer.l" 4161| 25.2k|{ 4162| 25.2k| errno = 0; 4163| 25.2k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 2964| 25.2k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 122| 25.2k|#define yytext yyg->yytext_r ------------------ 4164| 25.2k| if (errno) { ------------------ | Branch (4164:7): [True: 5, False: 25.2k] ------------------ 4165| 5| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4166| 0| return 0; 4167| 5| } 4168| 25.2k| return SQL_INTVAL; 4169| 25.2k|} 4170| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4171| 1.49k|case 182: ------------------ | Branch (4171:1): [True: 1.49k, False: 4.04M] ------------------ 4172| 1.49k|YY_RULE_SETUP ------------------ | | 3147| 1.49k| YY_USER_ACTION | | ------------------ | | | | 61| 1.49k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.49k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 45.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 45.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 44.0k, False: 1.49k] | | | | ------------------ | | | | 64| 44.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 44.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 44.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 44.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 44.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 44.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 44.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| 44.0k| } else { \ | | | | 70| 44.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 44.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 44.0k| } \ | | | | 72| 44.0k| } | | ------------------ ------------------ 4173| 1.49k|#line 269 "flex_lexer.l" 4174| 1.49k|{ 4175| | // Crop the leading and trailing quote char 4176| 1.49k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 2964| 1.49k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.49k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.49k|#define yytext yyg->yytext_r ------------------ 4177| 1.49k| return SQL_IDENTIFIER; 4178| 25.2k|} 4179| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4180| 511k|case 183: ------------------ | Branch (4180:1): [True: 511k, False: 3.53M] ------------------ 4181| 511k|YY_RULE_SETUP ------------------ | | 3147| 511k| YY_USER_ACTION | | ------------------ | | | | 61| 511k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 511k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 511k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.79M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.79M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.28M, False: 511k] | | | | ------------------ | | | | 64| 5.28M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.28M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.28M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.28M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.28M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.28M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.28M] | | | | ------------------ | | | | 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.28M| } else { \ | | | | 70| 5.28M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.28M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.28M| } \ | | | | 72| 5.28M| } | | ------------------ ------------------ 4182| 511k|#line 275 "flex_lexer.l" 4183| 511k|{ 4184| 511k| yylval->sval = strdup(yytext); ------------------ | | 2964| 511k| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 122| 511k|#define yytext yyg->yytext_r ------------------ 4185| 511k| return SQL_IDENTIFIER; 4186| 25.2k|} 4187| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4188| 30.9k|case 184: ------------------ | Branch (4188:1): [True: 30.9k, False: 4.01M] ------------------ 4189| 30.9k|YY_RULE_SETUP ------------------ | | 3147| 30.9k| YY_USER_ACTION | | ------------------ | | | | 61| 30.9k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 30.9k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 61.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 61.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 30.9k, False: 30.9k] | | | | ------------------ | | | | 64| 30.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 30.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 30.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 30.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 30.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| 30.9k| } else { \ | | | | 70| 30.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 30.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 30.9k| } \ | | | | 72| 30.9k| } | | ------------------ ------------------ 4190| 30.9k|#line 280 "flex_lexer.l" 4191| 30.9k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 131| 30.9k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 2907| 30.9k|#define singlequotedstring 1 ------------------ 4192| 30.9k| YY_BREAK ------------------ | | 3143| 30.9k|#define YY_BREAK /*LINTED*/break; ------------------ 4193| 2.74k|case 185: ------------------ | Branch (4193:1): [True: 2.74k, False: 4.04M] ------------------ 4194| 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| 8.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.48k, False: 2.74k] | | | | ------------------ | | | | 64| 5.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.48k| } else { \ | | | | 70| 5.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.48k| } \ | | | | 72| 5.48k| } | | ------------------ ------------------ 4195| 2.74k|#line 281 "flex_lexer.l" 4196| 2.74k|{ strbuf << '\''; } 4197| 2.74k| YY_BREAK ------------------ | | 3143| 2.74k|#define YY_BREAK /*LINTED*/break; ------------------ 4198| 19.6k|case 186: ------------------ | Branch (4198:1): [True: 19.6k, False: 4.02M] ------------------ 4199| |/* rule 186 can match eol */ 4200| 19.6k|YY_RULE_SETUP ------------------ | | 3147| 19.6k| YY_USER_ACTION | | ------------------ | | | | 61| 19.6k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 19.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 19.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 19.6k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 19.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 19.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.89M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.89M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.87M, False: 19.6k] | | | | ------------------ | | | | 64| 2.87M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.87M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.87M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.87M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.87M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.87M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 9.00k, False: 2.86M] | | | | ------------------ | | | | 67| 9.00k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 9.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.00k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 9.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.86M| } else { \ | | | | 70| 2.86M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.86M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.86M| } \ | | | | 72| 2.87M| } | | ------------------ ------------------ 4201| 19.6k|#line 282 "flex_lexer.l" 4202| 19.6k|{ strbuf << yytext; } ------------------ | | 122| 19.6k|#define yytext yyg->yytext_r ------------------ 4203| 19.6k| YY_BREAK ------------------ | | 3143| 19.6k|#define YY_BREAK /*LINTED*/break; ------------------ 4204| 30.8k|case 187: ------------------ | Branch (4204:1): [True: 30.8k, False: 4.01M] ------------------ 4205| 30.8k|YY_RULE_SETUP ------------------ | | 3147| 30.8k| YY_USER_ACTION | | ------------------ | | | | 61| 30.8k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 30.8k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 61.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 61.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 30.8k, False: 30.8k] | | | | ------------------ | | | | 64| 30.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 30.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 30.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 30.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 30.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| 30.8k| } else { \ | | | | 70| 30.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 30.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 30.8k| } \ | | | | 72| 30.8k| } | | ------------------ ------------------ 4206| 30.8k|#line 283 "flex_lexer.l" 4207| 30.8k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 131| 30.8k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 2964| 30.8k| # define yylval yyg->yylval_r ------------------ 4208| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4209| 104|case YY_STATE_EOF(singlequotedstring): ------------------ | | 141| 104|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 104|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4209:1): [True: 104, False: 4.04M] ------------------ 4210| 104|#line 284 "flex_lexer.l" 4211| 104|{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } 4212| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4213| 151|case 188: ------------------ | Branch (4213:1): [True: 151, False: 4.04M] ------------------ 4214| 151|YY_RULE_SETUP ------------------ | | 3147| 151| YY_USER_ACTION | | ------------------ | | | | 61| 151| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 151| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 302| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 302|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 151, False: 151] | | | | ------------------ | | | | 64| 151| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 151| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 151| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 151|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 151] | | | | ------------------ | | | | 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| 151| } else { \ | | | | 70| 151| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 151| } \ | | | | 72| 151| } | | ------------------ ------------------ 4215| 151|#line 286 "flex_lexer.l" 4216| 151|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 122| 151|#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.04M] ------------------ 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.92k|case YY_STATE_EOF(INITIAL): ------------------ | | 141| 2.92k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.92k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4224:1): [True: 2.92k, False: 4.04M] ------------------ 4225| 2.98k|case YY_STATE_EOF(COMMENT): ------------------ | | 141| 2.98k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.98k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4225:1): [True: 56, False: 4.04M] ------------------ 4226| 2.98k| yyterminate(); ------------------ | | 3106| 2.98k|#define yyterminate() return YY_NULL | | ------------------ | | | | 101| 2.98k|#define YY_NULL 0 | | ------------------ ------------------ 4227| | 4228| 7.84k| case YY_END_OF_BUFFER: ------------------ | | 351| 7.84k|#define YY_END_OF_BUFFER 190 ------------------ | Branch (4228:2): [True: 7.84k, False: 4.03M] ------------------ 4229| 7.84k| { 4230| | /* Amount of text matched not including the EOB char. */ 4231| 7.84k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 333| 7.84k|#define yytext_ptr yytext_r ------------------ 4232| | 4233| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4234| 7.84k| *yy_cp = yyg->yy_hold_char; 4235| 7.84k| YY_RESTORE_YY_MORE_OFFSET 4236| | 4237| 7.84k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 276| 7.84k|#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.84k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4237:8): [True: 4.74k, False: 3.09k] ------------------ 4238| 4.74k| { 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.74k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 4.74k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4249| 4.74k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 276| 4.74k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 118| 4.74k|#define yyin yyg->yyin_r ------------------ 4250| 4.74k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 276| 4.74k|#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.74k|#define YY_BUFFER_NORMAL 1 ------------------ 4251| 4.74k| } 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.84k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 276| 7.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4260:8): [True: 0, False: 7.84k] ------------------ 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.84k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4297:17): [True: 7.84k, False: 0] ------------------ 4298| 7.84k| { 4299| 3.08k| case EOB_ACT_END_OF_FILE: ------------------ | | 176| 3.08k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4299:4): [True: 3.08k, False: 4.75k] ------------------ 4300| 3.08k| { 4301| 3.08k| yyg->yy_did_buffer_switch_on_eof = 0; 4302| | 4303| 3.08k| if ( hsql_wrap(yyscanner ) ) ------------------ | | 326| 3.08k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | ------------------ | | | Branch (326:30): [True: 3.08k, Folded] | | ------------------ ------------------ 4304| 3.08k| { 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.08k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 3.08k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 3.08k|#define YY_MORE_ADJ 0 ------------------ 4315| | 4316| 3.08k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 141| 3.08k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.08k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ 4317| 3.08k| goto do_action; 4318| 3.08k| } 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.08k| } 4327| | 4328| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 175| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4328:4): [True: 0, False: 7.84k] ------------------ 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.75k| case EOB_ACT_LAST_MATCH: ------------------ | | 177| 4.75k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4338:4): [True: 4.75k, False: 3.08k] ------------------ 4339| 4.75k| yyg->yy_c_buf_p = 4340| 4.75k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 276| 4.75k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4341| | 4342| 4.75k| yy_current_state = yy_get_previous_state( yyscanner ); 4343| | 4344| 4.75k| yy_cp = yyg->yy_c_buf_p; 4345| 4.75k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 4.75k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 4.75k|#define YY_MORE_ADJ 0 ------------------ 4346| 4.75k| goto yy_find_action; 4347| 7.84k| } 4348| 0| break; 4349| 7.84k| } 4350| | 4351| 0| default: ------------------ | Branch (4351:2): [True: 0, False: 4.04M] ------------------ 4352| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4353| 4.04M| "fatal flex scanner internal error--no action found" ); 4354| 4.04M| } /* end of action switch */ 4355| 4.04M| } /* end of scanning one token */ 4356| 3.49M| } /* end of user's declarations */ 4357| 3.49M|} /* 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| 21.7M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (4979:15): [True: 21.7M, False: 5.50k] ------------------ 4980| 21.7M| 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.84k|{ 4368| 7.84k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4369| 7.84k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 276| 7.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4370| 7.84k| char *source = yyg->yytext_ptr; ------------------ | | 333| 7.84k|#define yytext_ptr yytext_r ------------------ 4371| 7.84k| yy_size_t number_to_move, i; 4372| 7.84k| int ret_val; 4373| | 4374| 7.84k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 276| 7.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4374:7): [True: 0, False: 7.84k] ------------------ 4375| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4376| 7.84k| "fatal flex scanner internal error--end of buffer missed" ); 4377| | 4378| 7.84k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 276| 7.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4378:7): [True: 7.84k, False: 0] ------------------ 4379| 7.84k| { /* Don't try to fill the buffer, so this is an EOF. */ 4380| 7.84k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 333| 7.84k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 2868| 7.84k|#define YY_MORE_ADJ 0 ------------------ | Branch (4380:8): [True: 3.08k, False: 4.75k] ------------------ 4381| 3.08k| { 4382| | /* We matched a single character, the EOB, so 4383| | * treat this as a final EOF. 4384| | */ 4385| 3.08k| return EOB_ACT_END_OF_FILE; ------------------ | | 176| 3.08k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4386| 3.08k| } 4387| | 4388| 4.75k| else 4389| 4.75k| { 4390| | /* We matched some text prior to the EOB, first 4391| | * process it. 4392| | */ 4393| 4.75k| return EOB_ACT_LAST_MATCH; ------------------ | | 177| 4.75k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4394| 4.75k| } 4395| 7.84k| } 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.75k|{ 4503| 4.75k| yy_state_type yy_current_state; 4504| 4.75k| char *yy_cp; 4505| 4.75k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4506| | 4507| 4.75k| yy_current_state = yyg->yy_start; 4508| | 4509| 5.48M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 333| 4.75k|#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.75k|#define YY_MORE_ADJ 0 ------------------ | Branch (4509:47): [True: 5.47M, False: 4.75k] ------------------ 4510| 5.47M| { 4511| 5.47M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 108| 5.47M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ | Branch (4511:19): [True: 5.47M, False: 0] ------------------ 4512| 5.47M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4512:8): [True: 2.22M, False: 3.25M] ------------------ 4513| 2.22M| { 4514| 2.22M| yyg->yy_last_accepting_state = yy_current_state; 4515| 2.22M| yyg->yy_last_accepting_cpos = yy_cp; 4516| 2.22M| } 4517| 11.1M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4517:11): [True: 5.68M, False: 5.47M] ------------------ 4518| 5.68M| { 4519| 5.68M| yy_current_state = (int) yy_def[yy_current_state]; 4520| 5.68M| if ( yy_current_state >= 1368 ) ------------------ | Branch (4520:9): [True: 5.46M, False: 218k] ------------------ 4521| 5.46M| yy_c = yy_meta[(unsigned int) yy_c]; 4522| 5.68M| } 4523| 5.47M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 4524| 5.47M| } 4525| | 4526| 4.75k| return yy_current_state; 4527| 4.75k|} 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.67k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 31| 1.67k|TableConstraint::~TableConstraint() { 32| 1.92k| for (auto* column : *columnNames) { ------------------ | Branch (32:21): [True: 1.92k, False: 1.67k] ------------------ 33| 1.92k| free(column); 34| 1.92k| } 35| 1.67k| delete columnNames; 36| 1.67k|} _ZN4hsql17ColumnConstraintsC2Ev: 59| 21.2k| : 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| 21.2k| : column_constraints(column_constraints), name(name), type(type), nullable(true), references(references) {} _ZN4hsql16ColumnDefinitionD2Ev: 66| 21.2k|ColumnDefinition::~ColumnDefinition() { 67| 21.2k| free(name); 68| 21.2k| delete column_constraints; 69| 21.2k| if (references) { ------------------ | Branch (69:7): [True: 21.2k, False: 0] ------------------ 70| 21.2k| for (auto* ref : *references) { ------------------ | Branch (70:20): [True: 0, False: 21.2k] ------------------ 71| 0| delete ref; 72| 0| } 73| 21.2k| } 74| 21.2k| delete references; 75| 21.2k|} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 77| 21.2k|bool ColumnDefinition::trySetNullableExplicit() { 78| 21.2k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (78:7): [True: 1.78k, False: 19.4k] | Branch (78:7): [True: 2.49k, False: 18.7k] | Branch (78:61): [True: 714, False: 18.7k] ------------------ 79| 2.49k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (79:9): [True: 1.58k, False: 915] ------------------ 80| 1.58k| return false; 81| 1.58k| } 82| 915| nullable = false; 83| 915| } 84| | 85| 19.6k| return true; 86| 21.2k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 90| 8.92k| : SQLStatement(kStmtCreate), 91| 8.92k| type(type), 92| 8.92k| ifNotExists(false), 93| 8.92k| filePath(nullptr), 94| 8.92k| schema(nullptr), 95| 8.92k| tableName(nullptr), 96| 8.92k| indexName(nullptr), 97| 8.92k| indexColumns(nullptr), 98| 8.92k| columns(nullptr), 99| 8.92k| tableConstraints(nullptr), 100| 8.92k| viewColumns(nullptr), 101| 8.92k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 103| 8.92k|CreateStatement::~CreateStatement() { 104| 8.92k| free(filePath); 105| 8.92k| free(schema); 106| 8.92k| free(tableName); 107| 8.92k| free(indexName); 108| 8.92k| delete select; 109| | 110| 8.92k| if (columns) { ------------------ | Branch (110:7): [True: 5.24k, False: 3.67k] ------------------ 111| 6.11k| for (auto* def : *columns) { ------------------ | Branch (111:20): [True: 6.11k, False: 5.24k] ------------------ 112| 6.11k| delete def; 113| 6.11k| } 114| 5.24k| delete columns; 115| 5.24k| } 116| | 117| 8.92k| if (tableConstraints) { ------------------ | Branch (117:7): [True: 5.24k, False: 3.67k] ------------------ 118| 5.24k| for (auto* def : *tableConstraints) { ------------------ | Branch (118:20): [True: 1.45k, False: 5.24k] ------------------ 119| 1.45k| delete def; 120| 1.45k| } 121| 5.24k| delete tableConstraints; 122| 5.24k| } 123| | 124| 8.92k| if (indexColumns) { ------------------ | Branch (124:7): [True: 1.29k, False: 7.62k] ------------------ 125| 8.40k| for (char* column : *indexColumns) { ------------------ | Branch (125:23): [True: 8.40k, False: 1.29k] ------------------ 126| 8.40k| free(column); 127| 8.40k| } 128| 1.29k| delete indexColumns; 129| 1.29k| } 130| | 131| 8.92k| if (viewColumns) { ------------------ | Branch (131:7): [True: 917, False: 8.00k] ------------------ 132| 1.11k| for (char* column : *viewColumns) { ------------------ | Branch (132:23): [True: 1.11k, False: 917] ------------------ 133| 1.11k| free(column); 134| 1.11k| } 135| 917| delete viewColumns; 136| 917| } 137| 8.92k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 139| 5.24k|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 140| 5.24k| columns = new std::vector(); 141| 5.24k| tableConstraints = new std::vector(); 142| | 143| 7.56k| for (auto tableElem : *tableElements) { ------------------ | Branch (143:23): [True: 7.56k, False: 5.24k] ------------------ 144| 7.56k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (144:15): [True: 6.11k, False: 1.45k] ------------------ 145| 6.11k| columns->emplace_back(colDef); 146| 6.11k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (146:22): [True: 1.45k, False: 0] ------------------ 147| 1.45k| tableConstraints->emplace_back(tableConstraint); 148| 1.45k| } 149| 7.56k| } 150| 5.24k|} _ZN4hsql12TableElementD2Ev: 18| 22.9k| virtual ~TableElement() = default; _ZN4hsql10FrameBoundC2ElNS_14FrameBoundTypeEb: 12| 11.6k| : offset{offset}, type{type}, unbounded{unbounded} {} _ZN4hsql16FrameDescriptionC2ENS_9FrameTypeEPNS_10FrameBoundES3_: 15| 5.84k| : type{type}, start{start}, end{end} {} _ZN4hsql16FrameDescriptionD2Ev: 17| 5.84k|FrameDescription::~FrameDescription() { 18| 5.84k| delete start; 19| 5.84k| delete end; 20| 5.84k|} _ZN4hsql17WindowDescriptionC2EPNSt3__16vectorIPNS_4ExprENS1_9allocatorIS4_EEEEPNS2_IPNS_16OrderDescriptionENS5_ISA_EEEEPNS_16FrameDescriptionE: 24| 5.78k| : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {} _ZN4hsql17WindowDescriptionD2Ev: 26| 5.78k|WindowDescription::~WindowDescription() { 27| 5.78k| if (partitionList) { ------------------ | Branch (27:7): [True: 654, False: 5.12k] ------------------ 28| 1.11k| for (Expr* e : *partitionList) { ------------------ | Branch (28:18): [True: 1.11k, False: 654] ------------------ 29| 1.11k| delete e; 30| 1.11k| } 31| 654| delete partitionList; 32| 654| } 33| | 34| 5.78k| if (orderList) { ------------------ | Branch (34:7): [True: 979, False: 4.80k] ------------------ 35| 2.01k| for (OrderDescription* orderDescription : *orderList) { ------------------ | Branch (35:45): [True: 2.01k, False: 979] ------------------ 36| 2.01k| delete orderDescription; 37| 2.01k| } 38| 979| delete orderList; 39| 979| } 40| | 41| 5.78k| delete frameDescription; 42| 5.78k|} _ZN4hsql4ExprC2ENS_8ExprTypeE: 45| 2.08M| : type(type), 46| 2.08M| expr(nullptr), 47| 2.08M| expr2(nullptr), 48| 2.08M| exprList(nullptr), 49| 2.08M| select(nullptr), 50| 2.08M| name(nullptr), 51| 2.08M| table(nullptr), 52| 2.08M| schema(nullptr), 53| 2.08M| alias(nullptr), 54| 2.08M| fval(0), 55| 2.08M| ival(0), 56| 2.08M| ival2(0), 57| 2.08M| datetimeField(kDatetimeNone), 58| 2.08M| columnType(DataType::UNKNOWN, 0), 59| 2.08M| isBoolLiteral(false), 60| 2.08M| opType(kOpNone), 61| 2.08M| distinct(false), 62| 2.08M| windowDescription(nullptr) {} _ZN4hsql4ExprD2Ev: 64| 2.08M|Expr::~Expr() { 65| 2.08M| delete expr; 66| 2.08M| delete expr2; 67| 2.08M| delete select; 68| 2.08M| delete windowDescription; 69| | 70| 2.08M| free(name); 71| 2.08M| free(table); 72| 2.08M| free(schema); 73| 2.08M| free(alias); 74| | 75| 2.08M| if (exprList) { ------------------ | Branch (75:7): [True: 12.1k, False: 2.07M] ------------------ 76| 12.1k| for (Expr* e : *exprList) { ------------------ | Branch (76:18): [True: 11.0k, False: 12.1k] ------------------ 77| 11.0k| delete e; 78| 11.0k| } 79| 12.1k| delete exprList; 80| 12.1k| } 81| 2.08M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 83| 3.24k|Expr* Expr::make(ExprType type) { 84| 3.24k| Expr* e = new Expr(type); 85| 3.24k| return e; 86| 3.24k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 88| 11.9k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 89| 11.9k| Expr* e = new Expr(kExprOperator); 90| 11.9k| e->opType = op; 91| 11.9k| e->expr = expr; 92| 11.9k| e->expr2 = nullptr; 93| 11.9k| return e; 94| 11.9k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 96| 866k|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 97| 866k| Expr* e = new Expr(kExprOperator); 98| 866k| e->opType = op; 99| 866k| e->expr = expr1; 100| 866k| e->expr2 = expr2; 101| 866k| return e; 102| 866k|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 104| 359|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 105| 359| Expr* e = new Expr(kExprOperator); 106| 359| e->expr = expr; 107| 359| e->opType = kOpBetween; 108| 359| e->exprList = new std::vector(); 109| 359| e->exprList->push_back(left); 110| 359| e->exprList->push_back(right); 111| 359| return e; 112| 359|} _ZN4hsql4Expr12makeCaseListEPS0_: 114| 1.93k|Expr* Expr::makeCaseList(Expr* caseListElement) { 115| 1.93k| 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.93k| e->opType = kOpNone; 119| 1.93k| e->exprList = new std::vector(); 120| 1.93k| e->exprList->push_back(caseListElement); 121| 1.93k| return e; 122| 1.93k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 124| 3.32k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 125| 3.32k| Expr* e = new Expr(kExprOperator); 126| 3.32k| e->opType = kOpCaseListElement; 127| 3.32k| e->expr = when; 128| 3.32k| e->expr2 = then; 129| 3.32k| return e; 130| 3.32k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 132| 1.39k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 133| 1.39k| caseList->exprList->push_back(caseListElement); 134| 1.39k| return caseList; 135| 1.39k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 137| 1.70k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 138| 1.70k| Expr* e = new Expr(kExprOperator); 139| 1.70k| e->opType = kOpCase; 140| 1.70k| e->expr = expr; 141| 1.70k| e->expr2 = elseExpr; 142| 1.70k| e->exprList = caseList->exprList; 143| 1.70k| caseList->exprList = nullptr; 144| 1.70k| delete caseList; 145| 1.70k| return e; 146| 1.70k|} _ZN4hsql4Expr11makeLiteralEl: 148| 12.0k|Expr* Expr::makeLiteral(int64_t val) { 149| 12.0k| Expr* e = new Expr(kExprLiteralInt); 150| 12.0k| e->ival = val; 151| 12.0k| return e; 152| 12.0k|} _ZN4hsql4Expr11makeLiteralEd: 154| 2.08k|Expr* Expr::makeLiteral(double value) { 155| 2.08k| Expr* e = new Expr(kExprLiteralFloat); 156| 2.08k| e->fval = value; 157| 2.08k| return e; 158| 2.08k|} _ZN4hsql4Expr11makeLiteralEPc: 160| 5.24k|Expr* Expr::makeLiteral(char* string) { 161| 5.24k| Expr* e = new Expr(kExprLiteralString); 162| 5.24k| e->name = string; 163| 5.24k| return e; 164| 5.24k|} _ZN4hsql4Expr11makeLiteralEb: 166| 1.30k|Expr* Expr::makeLiteral(bool val) { 167| 1.30k| Expr* e = new Expr(kExprLiteralInt); 168| 1.30k| e->ival = (int)val; 169| 1.30k| e->isBoolLiteral = true; 170| 1.30k| return e; 171| 1.30k|} _ZN4hsql4Expr15makeNullLiteralEv: 173| 2.32k|Expr* Expr::makeNullLiteral() { 174| 2.32k| Expr* e = new Expr(kExprLiteralNull); 175| 2.32k| return e; 176| 2.32k|} _ZN4hsql4Expr15makeDateLiteralEPc: 178| 276|Expr* Expr::makeDateLiteral(char* string) { 179| 276| Expr* e = new Expr(kExprLiteralDate); 180| 276| e->name = string; 181| 276| return e; 182| 276|} _ZN4hsql4Expr19makeIntervalLiteralElNS_13DatetimeFieldE: 184| 12.9k|Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) { 185| 12.9k| Expr* e = new Expr(kExprLiteralInterval); 186| 12.9k| e->ival = duration; 187| 12.9k| e->datetimeField = unit; 188| 12.9k| return e; 189| 12.9k|} _ZN4hsql4Expr13makeColumnRefEPc: 191| 134k|Expr* Expr::makeColumnRef(char* name) { 192| 134k| Expr* e = new Expr(kExprColumnRef); 193| 134k| e->name = name; 194| 134k| return e; 195| 134k|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 197| 966|Expr* Expr::makeColumnRef(char* table, char* name) { 198| 966| Expr* e = new Expr(kExprColumnRef); 199| 966| e->name = name; 200| 966| e->table = table; 201| 966| return e; 202| 966|} _ZN4hsql4Expr8makeStarEv: 204| 785k|Expr* Expr::makeStar(void) { 205| 785k| Expr* e = new Expr(kExprStar); 206| 785k| return e; 207| 785k|} _ZN4hsql4Expr8makeStarEPc: 209| 705|Expr* Expr::makeStar(char* table) { 210| 705| Expr* e = new Expr(kExprStar); 211| 705| e->table = table; 212| 705| return e; 213| 705|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 215| 8.01k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct, WindowDescription* window) { 216| 8.01k| Expr* e = new Expr(kExprFunctionRef); 217| 8.01k| e->name = func_name; 218| 8.01k| e->exprList = exprList; 219| 8.01k| e->distinct = distinct; 220| 8.01k| e->windowDescription = window; 221| 8.01k| return e; 222| 8.01k|} _ZN4hsql4Expr15makeFunctionRefEPcS1_PNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 224| 406|Expr* Expr::makeFunctionRef(char* func_name, char* schema, std::vector* exprList, bool distinct, WindowDescription* window) { 225| 406| Expr* e = new Expr(kExprFunctionRef); 226| 406| e->name = func_name; 227| 406| e->schema = schema; 228| 406| e->exprList = exprList; 229| 406| e->distinct = distinct; 230| 406| e->windowDescription = window; 231| 406| return e; 232| 406|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 234| 518|Expr* Expr::makeArray(std::vector* exprList) { 235| 518| Expr* e = new Expr(kExprArray); 236| 518| e->exprList = exprList; 237| 518| return e; 238| 518|} _ZN4hsql4Expr14makeArrayIndexEPS0_l: 240| 202|Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) { 241| 202| Expr* e = new Expr(kExprArrayIndex); 242| 202| e->expr = expr; 243| 202| e->ival = index; 244| 202| return e; 245| 202|} _ZN4hsql4Expr13makeParameterEi: 247| 227k|Expr* Expr::makeParameter(int id) { 248| 227k| Expr* e = new Expr(kExprParameter); 249| 227k| e->ival = id; 250| 227k| return e; 251| 227k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 253| 704|Expr* Expr::makeSelect(SelectStatement* select) { 254| 704| Expr* e = new Expr(kExprSelect); 255| 704| e->select = select; 256| 704| return e; 257| 704|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 259| 665|Expr* Expr::makeExists(SelectStatement* select) { 260| 665| Expr* e = new Expr(kExprOperator); 261| 665| e->opType = kOpExists; 262| 665| e->select = select; 263| 665| return e; 264| 665|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 266| 568|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 267| 568| Expr* e = new Expr(kExprOperator); 268| 568| e->opType = kOpIn; 269| 568| e->expr = expr; 270| 568| e->exprList = exprList; 271| | 272| 568| return e; 273| 568|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 275| 464|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 276| 464| Expr* e = new Expr(kExprOperator); 277| 464| e->opType = kOpIn; 278| 464| e->expr = expr; 279| 464| e->select = select; 280| | 281| 464| return e; 282| 464|} _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.49k|char* substr(const char* source, int from, int to) { 317| 1.49k| int len = to - from; 318| 1.49k| char* copy = (char*)malloc(len + 1); 319| 1.49k| ; 320| 1.49k| strncpy(copy, source + from, len); 321| 1.49k| copy[len] = '\0'; 322| 1.49k| return copy; 323| 1.49k|} _ZN4hsql16PrepareStatementC2Ev: 6| 2.00k|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 2.00k|PrepareStatement::~PrepareStatement() { 9| 2.00k| free(name); 10| 2.00k| free(query); 11| 2.00k|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 106k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 106k|SQLStatement::~SQLStatement() { 10| 106k| if (hints) { ------------------ | Branch (10:7): [True: 939, False: 105k] ------------------ 11| 2.41k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 2.41k, False: 939] ------------------ 12| 2.41k| delete hint; 13| 2.41k| } 14| 939| } 15| 106k| delete hints; 16| 106k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 11| 2.10M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 77| 2.24k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 79| 2.24k|DeleteStatement::~DeleteStatement() { 80| 2.24k| free(schema); 81| 2.24k| free(tableName); 82| 2.24k| delete expr; 83| 2.24k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 87| 4.38k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 89| 4.38k|DropStatement::~DropStatement() { 90| 4.38k| free(schema); 91| 4.38k| free(name); 92| 4.38k| free(indexName); 93| 4.38k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 117| 11.6k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 119| 11.6k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 122| 4.82k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 124| 4.82k|ExecuteStatement::~ExecuteStatement() { 125| 4.82k| free(name); 126| | 127| 4.82k| if (parameters) { ------------------ | Branch (127:7): [True: 261, False: 4.56k] ------------------ 128| 778| for (Expr* param : *parameters) { ------------------ | Branch (128:22): [True: 778, False: 261] ------------------ 129| 778| delete param; 130| 778| } 131| 261| delete parameters; 132| 261| } 133| 4.82k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 137| 7.15k| : SQLStatement(kStmtExport), 138| 7.15k| type(type), 139| 7.15k| filePath(nullptr), 140| 7.15k| schema(nullptr), 141| 7.15k| tableName(nullptr), 142| 7.15k| select(nullptr), 143| 7.15k| encoding(nullptr), 144| 7.15k| csv_options(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 146| 7.15k|ExportStatement::~ExportStatement() { 147| 7.15k| free(filePath); 148| 7.15k| free(schema); 149| 7.15k| free(tableName); 150| 7.15k| delete select; 151| 7.15k| free(encoding); 152| 7.15k| delete csv_options; 153| 7.15k|} _ZN4hsql10CsvOptionsC2Ev: 155| 1.67k|CsvOptions::CsvOptions() : delimiter(nullptr), null(nullptr), quote(nullptr) {} _ZN4hsql10CsvOptionsD2Ev: 156| 1.67k|CsvOptions::~CsvOptions() { 157| 1.67k| free(delimiter); 158| 1.67k| free(null); 159| 1.67k| free(quote); 160| 1.67k|} _ZN4hsql10CsvOptions17accept_csv_optionEPNSt3__14pairINS_13CsvOptionTypeEPcEE: 162| 1.95k|bool CsvOptions::accept_csv_option(std::pair* option) { 163| 1.95k| switch (option->first) { ------------------ | Branch (163:11): [True: 1.95k, False: 0] ------------------ 164| 206| case CsvOptionType::Delimiter: ------------------ | Branch (164:5): [True: 206, False: 1.74k] ------------------ 165| 206| if (delimiter != nullptr) { ------------------ | Branch (165:11): [True: 1, False: 205] ------------------ 166| 1| return false; 167| 1| } 168| 205| delimiter = option->second; 169| 205| break; 170| 1.16k| case CsvOptionType::Null: ------------------ | Branch (170:5): [True: 1.16k, False: 787] ------------------ 171| 1.16k| if (null != nullptr) { ------------------ | Branch (171:11): [True: 4, False: 1.16k] ------------------ 172| 4| return false; 173| 4| } 174| 1.16k| null = option->second; 175| 1.16k| break; 176| 581| case CsvOptionType::Quote: ------------------ | Branch (176:5): [True: 581, False: 1.37k] ------------------ 177| 581| if (quote != nullptr) { ------------------ | Branch (177:11): [True: 7, False: 574] ------------------ 178| 7| return false; 179| 7| } 180| 574| quote = option->second; 181| 574| break; 182| 1.95k| } 183| | 184| 1.94k| return true; 185| 1.95k|} _ZN4hsql19ImportExportOptionsC2Ev: 187| 14.9k|ImportExportOptions::ImportExportOptions() : format(kImportAuto), encoding(nullptr), csv_options(nullptr) {} _ZN4hsql19ImportExportOptionsD2Ev: 189| 14.9k|ImportExportOptions::~ImportExportOptions() { 190| 14.9k| free(encoding); 191| 14.9k| delete csv_options; 192| 14.9k|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 196| 7.71k| : SQLStatement(kStmtImport), 197| 7.71k| type(type), 198| 7.71k| filePath(nullptr), 199| 7.71k| schema(nullptr), 200| 7.71k| tableName(nullptr), 201| 7.71k| whereClause(nullptr), 202| 7.71k| encoding(nullptr), 203| 7.71k| csv_options(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 205| 7.71k|ImportStatement::~ImportStatement() { 206| 7.71k| free(filePath); 207| 7.71k| free(schema); 208| 7.71k| free(tableName); 209| 7.71k| delete whereClause; 210| 7.71k| free(encoding); 211| 7.71k| delete csv_options; 212| 7.71k|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 216| 3.81k| : SQLStatement(kStmtInsert), 217| 3.81k| type(type), 218| 3.81k| schema(nullptr), 219| 3.81k| tableName(nullptr), 220| 3.81k| columns(nullptr), 221| 3.81k| values(nullptr), 222| 3.81k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 224| 3.81k|InsertStatement::~InsertStatement() { 225| 3.81k| free(schema); 226| 3.81k| free(tableName); 227| 3.81k| delete select; 228| | 229| 3.81k| if (columns) { ------------------ | Branch (229:7): [True: 81, False: 3.73k] ------------------ 230| 275| for (char* column : *columns) { ------------------ | Branch (230:23): [True: 275, False: 81] ------------------ 231| 275| free(column); 232| 275| } 233| 81| delete columns; 234| 81| } 235| | 236| 3.81k| if (values) { ------------------ | Branch (236:7): [True: 557, False: 3.25k] ------------------ 237| 973| for (Expr* expr : *values) { ------------------ | Branch (237:21): [True: 973, False: 557] ------------------ 238| 973| delete expr; 239| 973| } 240| 557| delete values; 241| 557| } 242| 3.81k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 245| 7.67k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 247| 7.67k|ShowStatement::~ShowStatement() { 248| 7.67k| free(schema); 249| 7.67k| free(name); 250| 7.67k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprENS_12NullOrderingE: 256| 8.52k| : type(type), expr(expr), null_ordering(null_ordering) {} _ZN4hsql16OrderDescriptionD2Ev: 258| 8.52k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 261| 10.1k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 263| 10.1k|LimitDescription::~LimitDescription() { 264| 10.1k| delete limit; 265| 10.1k| delete offset; 266| 10.1k|} _ZN4hsql18GroupByDescriptionC2Ev: 269| 3.73k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 271| 3.73k|GroupByDescription::~GroupByDescription() { 272| 3.73k| delete having; 273| | 274| 3.73k| if (columns) { ------------------ | Branch (274:7): [True: 3.73k, False: 0] ------------------ 275| 24.2k| for (Expr* expr : *columns) { ------------------ | Branch (275:21): [True: 24.2k, False: 3.73k] ------------------ 276| 24.2k| delete expr; 277| 24.2k| } 278| 3.73k| delete columns; 279| 3.73k| } 280| 3.73k|} _ZN4hsql15WithDescriptionD2Ev: 282| 1.73k|WithDescription::~WithDescription() { 283| 1.73k| free(alias); 284| 1.73k| delete select; 285| 1.73k|} _ZN4hsql15SelectStatementC2Ev: 289| 43.4k| : SQLStatement(kStmtSelect), 290| 43.4k| fromTable(nullptr), 291| 43.4k| selectDistinct(false), 292| 43.4k| selectList(nullptr), 293| 43.4k| whereClause(nullptr), 294| 43.4k| groupBy(nullptr), 295| 43.4k| setOperations(nullptr), 296| 43.4k| order(nullptr), 297| 43.4k| withDescriptions(nullptr), 298| 43.4k| limit(nullptr), 299| 43.4k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 301| 43.1k|SelectStatement::~SelectStatement() { 302| 43.1k| delete fromTable; 303| 43.1k| delete whereClause; 304| 43.1k| delete groupBy; 305| 43.1k| delete limit; 306| | 307| | // Delete each element in the select list. 308| 43.1k| if (selectList) { ------------------ | Branch (308:7): [True: 43.1k, False: 0] ------------------ 309| 127k| for (Expr* expr : *selectList) { ------------------ | Branch (309:21): [True: 127k, False: 43.1k] ------------------ 310| 127k| delete expr; 311| 127k| } 312| 43.1k| delete selectList; 313| 43.1k| } 314| | 315| 43.1k| if (order) { ------------------ | Branch (315:7): [True: 632, False: 42.4k] ------------------ 316| 1.79k| for (OrderDescription* desc : *order) { ------------------ | Branch (316:33): [True: 1.79k, False: 632] ------------------ 317| 1.79k| delete desc; 318| 1.79k| } 319| 632| delete order; 320| 632| } 321| | 322| 43.1k| if (withDescriptions) { ------------------ | Branch (322:7): [True: 1.10k, False: 42.0k] ------------------ 323| 1.73k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (323:32): [True: 1.73k, False: 1.10k] ------------------ 324| 1.73k| delete desc; 325| 1.73k| } 326| 1.10k| delete withDescriptions; 327| 1.10k| } 328| | 329| 43.1k| if (setOperations) { ------------------ | Branch (329:7): [True: 4.73k, False: 38.3k] ------------------ 330| 5.03k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (330:37): [True: 5.03k, False: 4.73k] ------------------ 331| 5.03k| delete setOperation; 332| 5.03k| } 333| 4.73k| delete setOperations; 334| 4.73k| } 335| | 336| 43.1k| if (lockings) { ------------------ | Branch (336:7): [True: 425, False: 42.6k] ------------------ 337| 3.10k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (337:39): [True: 3.10k, False: 425] ------------------ 338| 3.10k| if (lockingClause->tables) { ------------------ | Branch (338:11): [True: 202, False: 2.90k] ------------------ 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.10k| delete lockingClause; 345| 3.10k| } 346| 425| delete lockings; 347| 425| } 348| 43.1k|} _ZN4hsql15UpdateStatementC2Ev: 351| 2.82k|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 353| 2.82k|UpdateStatement::~UpdateStatement() { 354| 2.82k| delete table; 355| 2.82k| delete where; 356| | 357| 2.82k| if (updates) { ------------------ | Branch (357:7): [True: 2.82k, False: 0] ------------------ 358| 4.25k| for (UpdateClause* update : *updates) { ------------------ | Branch (358:31): [True: 4.25k, False: 2.82k] ------------------ 359| 4.25k| free(update->column); 360| 4.25k| delete update->value; 361| 4.25k| delete update; 362| 4.25k| } 363| 2.82k| delete updates; 364| 2.82k| } 365| 2.82k|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 368| 24.9k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 370| 24.9k|Alias::~Alias() { 371| 24.9k| free(name); 372| 24.9k| if (columns) { ------------------ | Branch (372:7): [True: 314, False: 24.6k] ------------------ 373| 965| for (char* column : *columns) { ------------------ | Branch (373:23): [True: 965, False: 314] ------------------ 374| 965| free(column); 375| 965| } 376| 314| delete columns; 377| 314| } 378| 24.9k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 382| 346k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 384| 346k|TableRef::~TableRef() { 385| 346k| free(schema); 386| 346k| free(name); 387| | 388| 346k| delete select; 389| 346k| delete join; 390| 346k| delete alias; 391| | 392| 346k| if (list) { ------------------ | Branch (392:7): [True: 1.98k, False: 344k] ------------------ 393| 113k| for (TableRef* table : *list) { ------------------ | Branch (393:26): [True: 113k, False: 1.98k] ------------------ 394| 113k| delete table; 395| 113k| } 396| 1.98k| delete list; 397| 1.98k| } 398| 346k|} _ZN4hsql14JoinDefinitionC2Ev: 411| 111k| : left(nullptr), right(nullptr), condition(nullptr), namedColumns(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 413| 111k|JoinDefinition::~JoinDefinition() { 414| 111k| delete left; 415| 111k| delete right; 416| 111k| delete condition; 417| | 418| 111k| if (namedColumns) { ------------------ | Branch (418:7): [True: 716, False: 111k] ------------------ 419| 910| for (auto* column : *namedColumns) { ------------------ | Branch (419:23): [True: 910, False: 716] ------------------ 420| 910| free(column); 421| 910| } 422| 716| delete namedColumns; 423| 716| } 424| 111k|} _ZN4hsql12SetOperationC2Ev: 426| 6.18k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 428| 6.18k|SetOperation::~SetOperation() { 429| 6.18k| delete nestedSelectStatement; 430| 6.18k| delete resultLimit; 431| | 432| 6.18k| if (resultOrder) { ------------------ | Branch (432:7): [True: 944, False: 5.24k] ------------------ 433| 2.57k| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (433:33): [True: 2.57k, False: 944] ------------------ 434| 2.57k| delete desc; 435| 2.57k| } 436| 944| delete resultOrder; 437| 944| } 438| 6.18k|}