LLVMFuzzerTestOneInput: 21| 5.29k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 22| 5.29k| std::string input(reinterpret_cast(data), size); 23| 5.29k| SQLParserResult res; 24| 5.29k| SQLParser::parse(input, &res); 25| 5.29k| return 0; 26| 5.29k|} _ZN4hsql9SQLParser5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15SQLParserResultE: 13| 5.29k|bool SQLParser::parse(const std::string& sql, SQLParserResult* result) { 14| 5.29k| yyscan_t scanner; 15| 5.29k| YY_BUFFER_STATE state; 16| | 17| 5.29k| if (hsql_lex_init(&scanner)) { ------------------ | Branch (17:7): [True: 0, False: 5.29k] ------------------ 18| | // Couldn't initialize the lexer. 19| 0| fprintf(stderr, "SQLParser: Error when initializing lexer!\n"); 20| 0| return false; 21| 0| } 22| 5.29k| const char* text = sql.c_str(); 23| 5.29k| state = hsql__scan_string(text, scanner); 24| | 25| | // Parse the tokens. 26| | // If parsing fails, the result will contain an error object. 27| 5.29k| int ret = hsql_parse(result, scanner); 28| 5.29k| bool success = (ret == 0); 29| 5.29k| result->setIsValid(success); 30| | 31| 5.29k| hsql__delete_buffer(state, scanner); 32| 5.29k| hsql_lex_destroy(scanner); 33| | 34| 5.29k| return true; 35| 5.29k|} _ZN4hsql15SQLParserResultC2Ev: 7| 5.29k|SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) {} _ZN4hsql15SQLParserResultD2Ev: 24| 5.29k|SQLParserResult::~SQLParserResult() { reset(); } _ZN4hsql15SQLParserResult12addStatementEPNS_12SQLStatementE: 26| 36.6k|void SQLParserResult::addStatement(SQLStatement* stmt) { statements_.push_back(stmt); } _ZNK4hsql15SQLParserResult8errorMsgEv: 36| 3.98k|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 10.6k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.36k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.36k| errorMsg_ = errorMsg; 46| 5.36k| errorLine_ = errorLine; 47| 5.36k| errorColumn_ = errorColumn; 48| 5.36k|} _ZN4hsql15SQLParserResult5resetEv: 60| 5.29k|void SQLParserResult::reset() { 61| 36.6k| for (SQLStatement* statement : statements_) { ------------------ | Branch (61:32): [True: 36.6k, False: 5.29k] ------------------ 62| 36.6k| delete statement; 63| 36.6k| } 64| 5.29k| statements_.clear(); 65| | 66| 5.29k| isValid_ = false; 67| | 68| 5.29k| free(errorMsg_); 69| 5.29k| errorMsg_ = nullptr; 70| 5.29k| errorLine_ = -1; 71| 5.29k| errorColumn_ = -1; 72| 5.29k|} _ZN4hsql15SQLParserResult12addParameterEPNS_4ExprE: 75| 109k|void SQLParserResult::addParameter(Expr* parameter) { 76| 109k| parameters_.push_back(parameter); 77| 109k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 109k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 483M| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 97| 5.36k| int yyerror(YYLTYPE * llocp, SQLParserResult * result, yyscan_t scanner, const char* msg) { 98| 5.36k| result->setIsValid(false); 99| 5.36k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 100| 5.36k| return 0; 101| 5.36k| } _Z10hsql_parsePN4hsql15SQLParserResultEPv: 2886| 5.29k|{ 2887| |/* The lookahead symbol. */ 2888| 5.29k|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.29k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 564| 5.29k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2895| 5.29k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 11| 5.29k|#define YYSTYPE HSQL_STYPE ------------------ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 564| 5.29k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2896| | 2897| |/* Location data for the lookahead symbol. */ 2898| 5.29k|static YYLTYPE yyloc_default 2899| |# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL 2900| | = { 1, 1, 1, 1 } 2901| |# endif 2902| 5.29k|; 2903| 5.29k|YYLTYPE yylloc = yyloc_default; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2904| | 2905| | /* Number of syntax errors so far. */ 2906| 5.29k| int yynerrs; 2907| | 2908| 5.29k| int yystate; 2909| | /* Number of tokens to shift before error messages enabled. */ 2910| 5.29k| 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.29k| yytype_int16 yyssa[YYINITDEPTH]; 2922| 5.29k| yytype_int16 *yyss; 2923| 5.29k| yytype_int16 *yyssp; 2924| | 2925| | /* The semantic value stack. */ 2926| 5.29k| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 11| 5.29k|#define YYSTYPE HSQL_STYPE ------------------ 2927| 5.29k| YYSTYPE *yyvs; ------------------ | | 11| 5.29k|#define YYSTYPE HSQL_STYPE ------------------ 2928| 5.29k| YYSTYPE *yyvsp; ------------------ | | 11| 5.29k|#define YYSTYPE HSQL_STYPE ------------------ 2929| | 2930| | /* The location stack. */ 2931| 5.29k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2932| 5.29k| YYLTYPE *yyls; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2933| 5.29k| YYLTYPE *yylsp; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2934| | 2935| | /* The locations where the error started and ended. */ 2936| 5.29k| YYLTYPE yyerror_range[3]; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2937| | 2938| 5.29k| YYSIZE_T yystacksize; ------------------ | | 496| 5.29k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2939| | 2940| 5.29k| int yyn; 2941| 5.29k| int yyresult; 2942| | /* Lookahead token as an internal (translated) token number. */ 2943| 5.29k| int yytoken = 0; 2944| | /* The variables used to return semantic value and location from the 2945| | action routines. */ 2946| 5.29k| YYSTYPE yyval; ------------------ | | 11| 5.29k|#define YYSTYPE HSQL_STYPE ------------------ 2947| 5.29k| YYLTYPE yyloc; ------------------ | | 12| 5.29k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.29k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2948| | 2949| 5.29k|#if YYERROR_VERBOSE 2950| | /* Buffer for error messages, and its allocated size. */ 2951| 5.29k| char yymsgbuf[128]; 2952| 5.29k| char *yymsg = yymsgbuf; 2953| 5.29k| YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 496| 5.29k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2954| 5.29k|#endif 2955| | 2956| 5.29k|#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.29k| int yylen = 0; 2961| | 2962| 5.29k| yyssp = yyss = yyssa; 2963| 5.29k| yyvsp = yyvs = yyvsa; 2964| 5.29k| yylsp = yyls = yylsa; 2965| 5.29k| yystacksize = YYINITDEPTH; ------------------ | | 1688| 5.29k|# define YYINITDEPTH 200 ------------------ 2966| | 2967| 5.29k| YYDPRINTF ((stderr, "Starting parse\n")); 2968| | 2969| 5.29k| yystate = 0; 2970| 5.29k| yyerrstatus = 0; 2971| 5.29k| yynerrs = 0; ------------------ | | 69| 5.29k|#define yynerrs hsql_nerrs ------------------ 2972| 5.29k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 1453| 5.29k|#define YYEMPTY (-2) ------------------ 2973| | 2974| |/* User initialization code. */ 2975| 5.29k|#line 81 "bison_parser.y" /* yacc.c:1429 */ 2976| 5.29k|{ 2977| | // Initialize 2978| 5.29k| yylloc.first_column = 0; 2979| 5.29k| yylloc.last_column = 0; 2980| 5.29k| yylloc.first_line = 0; 2981| 5.29k| yylloc.last_line = 0; 2982| 5.29k| yylloc.total_column = 0; 2983| 5.29k| yylloc.string_length = 0; 2984| 5.29k|} 2985| | 2986| 5.29k|#line 2987 "bison_parser.cpp" /* yacc.c:1429 */ 2987| 5.29k| yylsp[0] = yylloc; 2988| 5.29k| goto yysetstate; 2989| | 2990| |/*------------------------------------------------------------. 2991| || yynewstate -- Push a new state, which is found in yystate. | 2992| |`------------------------------------------------------------*/ 2993| 15.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| 15.0M| yyssp++; 2997| | 2998| 15.0M| yysetstate: 2999| 15.0M| *yyssp = yystate; 3000| | 3001| 15.0M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3001:7): [True: 19, False: 15.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| 15.0M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3068| | 3069| 15.0M| if (yystate == YYFINAL) ------------------ | | 706| 15.0M|#define YYFINAL 69 ------------------ | Branch (3069:7): [True: 1.35k, False: 15.0M] ------------------ 3070| 1.35k| YYACCEPT; ------------------ | | 1456| 1.35k|#define YYACCEPT goto yyacceptlab ------------------ 3071| | 3072| 15.0M| goto yybackup; 3073| | 3074| |/*-----------. 3075| || yybackup. | 3076| |`-----------*/ 3077| 15.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| 15.0M| yyn = yypact[yystate]; 3084| 15.0M| if (yypact_value_is_default (yyn)) ------------------ | | 923| 15.0M| (!!((Yystate) == (-529))) | | ------------------ | | | Branch (923:3): [True: 7.64M, False: 7.42M] | | ------------------ ------------------ 3085| 7.64M| 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| 7.42M| if (yychar == YYEMPTY) ------------------ | | 1453| 7.42M|#define YYEMPTY (-2) ------------------ | Branch (3090:7): [True: 3.96M, False: 3.46M] ------------------ 3091| 3.96M| { 3092| 3.96M| YYDPRINTF ((stderr, "Reading a token: ")); 3093| 3.96M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 66| 3.96M|#define yylex hsql_lex ------------------ 3094| 3.96M| } 3095| | 3096| 7.42M| if (yychar <= YYEOF) ------------------ | | 1454| 7.42M|#define YYEOF 0 ------------------ | Branch (3096:7): [True: 23.8k, False: 7.40M] ------------------ 3097| 23.8k| { 3098| 23.8k| yychar = yytoken = YYEOF; ------------------ | | 1454| 23.8k|#define YYEOF 0 ------------------ 3099| 23.8k| YYDPRINTF ((stderr, "Now at end of input.\n")); 3100| 23.8k| } 3101| 7.40M| else 3102| 7.40M| { 3103| 7.40M| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 7.40M| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 7.40M|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 7.40M, False: 0] | | ------------------ ------------------ 3104| 7.40M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3105| 7.40M| } 3106| | 3107| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3108| | detect an error, take that action. */ 3109| 7.42M| yyn += yytoken; 3110| 7.42M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 708| 7.41M|#define YYLAST 856 ------------------ | Branch (3110:7): [True: 4.98k, False: 7.41M] | Branch (3110:18): [True: 7.00k, False: 7.41M] | Branch (3110:34): [True: 3.23M, False: 4.17M] ------------------ 3111| 3.24M| goto yydefault; 3112| 4.17M| yyn = yytable[yyn]; 3113| 4.17M| if (yyn <= 0) ------------------ | Branch (3113:7): [True: 217k, False: 3.95M] ------------------ 3114| 217k| { 3115| 217k| if (yytable_value_is_error (yyn)) ------------------ | | 928| 217k| (!!((Yytable_value) == (-355))) | | ------------------ | | | Branch (928:3): [True: 13, False: 217k] | | ------------------ ------------------ 3116| 13| goto yyerrlab; 3117| 217k| yyn = -yyn; 3118| 217k| goto yyreduce; 3119| 217k| } 3120| | 3121| | /* Count tokens shifted since error; after three, turn off error 3122| | status. */ 3123| 3.95M| if (yyerrstatus) ------------------ | Branch (3123:7): [True: 0, False: 3.95M] ------------------ 3124| 0| yyerrstatus--; 3125| | 3126| | /* Shift the lookahead token. */ 3127| 3.95M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3128| | 3129| | /* Discard the shifted token. */ 3130| 3.95M| yychar = YYEMPTY; ------------------ | | 1453| 3.95M|#define YYEMPTY (-2) ------------------ 3131| | 3132| 3.95M| yystate = yyn; 3133| 3.95M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3134| 3.95M| *++yyvsp = yylval; 3135| 3.95M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3136| 3.95M| *++yylsp = yylloc; 3137| 3.95M| goto yynewstate; 3138| | 3139| | 3140| |/*-----------------------------------------------------------. 3141| || yydefault -- do the default action for the current state. | 3142| |`-----------------------------------------------------------*/ 3143| 10.8M|yydefault: 3144| 10.8M| yyn = yydefact[yystate]; 3145| 10.8M| if (yyn == 0) ------------------ | Branch (3145:7): [True: 3.28k, False: 10.8M] ------------------ 3146| 3.28k| goto yyerrlab; 3147| 10.8M| goto yyreduce; 3148| | 3149| | 3150| |/*-----------------------------. 3151| || yyreduce -- Do a reduction. | 3152| |`-----------------------------*/ 3153| 11.1M|yyreduce: 3154| | /* yyn is the number of a rule to reduce with. */ 3155| 11.1M| 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| 11.1M| yyval = yyvsp[1-yylen]; 3166| | 3167| | /* Default location. */ 3168| 11.1M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1491| 11.1M| do \ | | 1492| 11.1M| if (N) \ | | ------------------ | | | Branch (1492:11): [True: 10.0M, False: 1.11M] | | ------------------ | | 1493| 11.1M| { \ | | 1494| 10.0M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1509| 10.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1495| 10.0M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1509| 10.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1496| 10.0M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1509| 10.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1497| 10.0M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1509| 10.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1498| 10.0M| } \ | | 1499| 11.1M| else \ | | 1500| 11.1M| { \ | | 1501| 1.11M| (Current).first_line = (Current).last_line = \ | | 1502| 1.11M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1509| 1.11M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1503| 1.11M| (Current).first_column = (Current).last_column = \ | | 1504| 1.11M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1509| 1.11M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1505| 1.11M| } \ | | 1506| 11.1M| while (0) | | ------------------ | | | Branch (1506:12): [Folded, False: 11.1M] | | ------------------ ------------------ 3169| 11.1M| YY_REDUCE_PRINT (yyn); 3170| 11.1M| switch (yyn) 3171| 11.1M| { 3172| 1.61k| case 2: ------------------ | Branch (3172:9): [True: 1.61k, False: 11.1M] ------------------ 3173| 1.61k|#line 343 "bison_parser.y" /* yacc.c:1646 */ 3174| 1.61k| { 3175| 36.6k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3175:27): [True: 36.6k, False: 1.61k] ------------------ 3176| | // Transfers ownership of the statement. 3177| 36.6k| result->addStatement(stmt); 3178| 36.6k| } 3179| | 3180| 1.61k| unsigned param_id = 0; 3181| 109k| for (void* param : yyloc.param_list) { ------------------ | Branch (3181:20): [True: 109k, False: 1.61k] ------------------ 3182| 109k| if (param) { ------------------ | Branch (3182:9): [True: 109k, False: 0] ------------------ 3183| 109k| Expr* expr = (Expr*)param; 3184| 109k| expr->ival = param_id; 3185| 109k| result->addParameter(expr); 3186| 109k| ++param_id; 3187| 109k| } 3188| 109k| } 3189| 1.61k| delete (yyvsp[-1].stmt_vec); 3190| 1.61k| } 3191| 1.61k|#line 3192 "bison_parser.cpp" /* yacc.c:1646 */ 3192| 1.61k| break; 3193| | 3194| 2.13k| case 3: ------------------ | Branch (3194:3): [True: 2.13k, False: 11.1M] ------------------ 3195| 2.13k|#line 362 "bison_parser.y" /* yacc.c:1646 */ 3196| 2.13k| { 3197| 2.13k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3198| 2.13k| yylloc.string_length = 0; 3199| 2.13k| (yyval.stmt_vec) = new std::vector(); 3200| 2.13k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3201| 2.13k|} 3202| 2.13k|#line 3203 "bison_parser.cpp" /* yacc.c:1646 */ 3203| 2.13k| break; 3204| | 3205| 69.5k| case 4: ------------------ | Branch (3205:3): [True: 69.5k, False: 11.0M] ------------------ 3206| 69.5k|#line 368 "bison_parser.y" /* yacc.c:1646 */ 3207| 69.5k| { 3208| 69.5k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3209| 69.5k| yylloc.string_length = 0; 3210| 69.5k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3211| 69.5k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3212| 69.5k|} 3213| 69.5k|#line 3214 "bison_parser.cpp" /* yacc.c:1646 */ 3214| 69.5k| break; 3215| | 3216| 1.24k| case 5: ------------------ | Branch (3216:3): [True: 1.24k, False: 11.1M] ------------------ 3217| 1.24k|#line 375 "bison_parser.y" /* yacc.c:1646 */ 3218| 1.24k| { 3219| 1.24k| (yyval.statement) = (yyvsp[-1].prep_stmt); 3220| 1.24k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3221| 1.24k|} 3222| 1.24k|#line 3223 "bison_parser.cpp" /* yacc.c:1646 */ 3223| 1.24k| break; 3224| | 3225| 51.5k| case 6: ------------------ | Branch (3225:3): [True: 51.5k, False: 11.0M] ------------------ 3226| 51.5k|#line 379 "bison_parser.y" /* yacc.c:1646 */ 3227| 51.5k| { 3228| 51.5k| (yyval.statement) = (yyvsp[-1].statement); 3229| 51.5k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3230| 51.5k|} 3231| 51.5k|#line 3232 "bison_parser.cpp" /* yacc.c:1646 */ 3232| 51.5k| break; 3233| | 3234| 6.42k| case 7: ------------------ | Branch (3234:3): [True: 6.42k, False: 11.1M] ------------------ 3235| 6.42k|#line 383 "bison_parser.y" /* yacc.c:1646 */ 3236| 6.42k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3237| 6.42k|#line 3238 "bison_parser.cpp" /* yacc.c:1646 */ 3238| 6.42k| break; 3239| | 3240| 6.17k| case 8: ------------------ | Branch (3240:3): [True: 6.17k, False: 11.1M] ------------------ 3241| 6.17k|#line 384 "bison_parser.y" /* yacc.c:1646 */ 3242| 6.17k| { (yyval.statement) = (yyvsp[0].import_stmt); } 3243| 6.17k|#line 3244 "bison_parser.cpp" /* yacc.c:1646 */ 3244| 6.17k| break; 3245| | 3246| 6.33k| case 9: ------------------ | Branch (3246:3): [True: 6.33k, False: 11.1M] ------------------ 3247| 6.33k|#line 385 "bison_parser.y" /* yacc.c:1646 */ 3248| 6.33k| { (yyval.statement) = (yyvsp[0].export_stmt); } 3249| 6.33k|#line 3250 "bison_parser.cpp" /* yacc.c:1646 */ 3250| 6.33k| break; 3251| | 3252| 21.0k| case 10: ------------------ | Branch (3252:3): [True: 21.0k, False: 11.0M] ------------------ 3253| 21.0k|#line 387 "bison_parser.y" /* yacc.c:1646 */ 3254| 21.0k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3255| 21.0k|#line 3256 "bison_parser.cpp" /* yacc.c:1646 */ 3256| 21.0k| break; 3257| | 3258| 6.56k| case 11: ------------------ | Branch (3258:3): [True: 6.56k, False: 11.1M] ------------------ 3259| 6.56k|#line 388 "bison_parser.y" /* yacc.c:1646 */ 3260| 6.56k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3261| 6.56k|#line 3262 "bison_parser.cpp" /* yacc.c:1646 */ 3262| 6.56k| break; 3263| | 3264| 3.32k| case 12: ------------------ | Branch (3264:3): [True: 3.32k, False: 11.1M] ------------------ 3265| 3.32k|#line 389 "bison_parser.y" /* yacc.c:1646 */ 3266| 3.32k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3267| 3.32k|#line 3268 "bison_parser.cpp" /* yacc.c:1646 */ 3268| 3.32k| break; 3269| | 3270| 1.49k| case 13: ------------------ | Branch (3270:3): [True: 1.49k, False: 11.1M] ------------------ 3271| 1.49k|#line 390 "bison_parser.y" /* yacc.c:1646 */ 3272| 1.49k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3273| 1.49k|#line 3274 "bison_parser.cpp" /* yacc.c:1646 */ 3274| 1.49k| break; 3275| | 3276| 253| case 14: ------------------ | Branch (3276:3): [True: 253, False: 11.1M] ------------------ 3277| 253|#line 391 "bison_parser.y" /* yacc.c:1646 */ 3278| 253| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3279| 253|#line 3280 "bison_parser.cpp" /* yacc.c:1646 */ 3280| 253| break; 3281| | 3282| 2.18k| case 15: ------------------ | Branch (3282:3): [True: 2.18k, False: 11.1M] ------------------ 3283| 2.18k|#line 392 "bison_parser.y" /* yacc.c:1646 */ 3284| 2.18k| { (yyval.statement) = (yyvsp[0].update_stmt); } 3285| 2.18k|#line 3286 "bison_parser.cpp" /* yacc.c:1646 */ 3286| 2.18k| break; 3287| | 3288| 3.74k| case 16: ------------------ | Branch (3288:3): [True: 3.74k, False: 11.1M] ------------------ 3289| 3.74k|#line 393 "bison_parser.y" /* yacc.c:1646 */ 3290| 3.74k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3291| 3.74k|#line 3292 "bison_parser.cpp" /* yacc.c:1646 */ 3292| 3.74k| break; 3293| | 3294| 0| case 17: ------------------ | Branch (3294:3): [True: 0, False: 11.1M] ------------------ 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| 3.62k| case 18: ------------------ | Branch (3300:3): [True: 3.62k, False: 11.1M] ------------------ 3301| 3.62k|#line 395 "bison_parser.y" /* yacc.c:1646 */ 3302| 3.62k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3303| 3.62k|#line 3304 "bison_parser.cpp" /* yacc.c:1646 */ 3304| 3.62k| break; 3305| | 3306| 9.30k| case 19: ------------------ | Branch (3306:3): [True: 9.30k, False: 11.1M] ------------------ 3307| 9.30k|#line 396 "bison_parser.y" /* yacc.c:1646 */ 3308| 9.30k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3309| 9.30k|#line 3310 "bison_parser.cpp" /* yacc.c:1646 */ 3310| 9.30k| break; 3311| | 3312| 676| case 20: ------------------ | Branch (3312:3): [True: 676, False: 11.1M] ------------------ 3313| 676|#line 402 "bison_parser.y" /* yacc.c:1646 */ 3314| 676| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3315| 676|#line 3316 "bison_parser.cpp" /* yacc.c:1646 */ 3316| 676| break; 3317| | 3318| 52.0k| case 21: ------------------ | Branch (3318:3): [True: 52.0k, False: 11.0M] ------------------ 3319| 52.0k|#line 403 "bison_parser.y" /* yacc.c:1646 */ 3320| 52.0k| { (yyval.expr_vec) = nullptr; } 3321| 52.0k|#line 3322 "bison_parser.cpp" /* yacc.c:1646 */ 3322| 52.0k| break; 3323| | 3324| 710| case 22: ------------------ | Branch (3324:3): [True: 710, False: 11.1M] ------------------ 3325| 710|#line 405 "bison_parser.y" /* yacc.c:1646 */ 3326| 710| { 3327| 710| (yyval.expr_vec) = new std::vector(); 3328| 710| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3329| 710|} 3330| 710|#line 3331 "bison_parser.cpp" /* yacc.c:1646 */ 3331| 710| break; 3332| | 3333| 1.49k| case 23: ------------------ | Branch (3333:3): [True: 1.49k, False: 11.1M] ------------------ 3334| 1.49k|#line 409 "bison_parser.y" /* yacc.c:1646 */ 3335| 1.49k| { 3336| 1.49k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3337| 1.49k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3338| 1.49k|} 3339| 1.49k|#line 3340 "bison_parser.cpp" /* yacc.c:1646 */ 3340| 1.49k| break; 3341| | 3342| 1.87k| case 24: ------------------ | Branch (3342:3): [True: 1.87k, False: 11.1M] ------------------ 3343| 1.87k|#line 414 "bison_parser.y" /* yacc.c:1646 */ 3344| 1.87k| { 3345| 1.87k| (yyval.expr) = Expr::make(kExprHint); 3346| 1.87k| (yyval.expr)->name = (yyvsp[0].sval); 3347| 1.87k|} 3348| 1.87k|#line 3349 "bison_parser.cpp" /* yacc.c:1646 */ 3349| 1.87k| break; 3350| | 3351| 326| case 25: ------------------ | Branch (3351:3): [True: 326, False: 11.1M] ------------------ 3352| 326|#line 418 "bison_parser.y" /* yacc.c:1646 */ 3353| 326| { 3354| 326| (yyval.expr) = Expr::make(kExprHint); 3355| 326| (yyval.expr)->name = (yyvsp[-3].sval); 3356| 326| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3357| 326|} 3358| 326|#line 3359 "bison_parser.cpp" /* yacc.c:1646 */ 3359| 326| break; 3360| | 3361| 3.62k| case 26: ------------------ | Branch (3361:3): [True: 3.62k, False: 11.1M] ------------------ 3362| 3.62k|#line 428 "bison_parser.y" /* yacc.c:1646 */ 3363| 3.62k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3364| 3.62k|#line 3365 "bison_parser.cpp" /* yacc.c:1646 */ 3365| 3.62k| break; 3366| | 3367| 2.36k| case 27: ------------------ | Branch (3367:3): [True: 2.36k, False: 11.1M] ------------------ 3368| 2.36k|#line 429 "bison_parser.y" /* yacc.c:1646 */ 3369| 2.36k| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3370| 2.36k|#line 3371 "bison_parser.cpp" /* yacc.c:1646 */ 3371| 2.36k| break; 3372| | 3373| 3.31k| case 28: ------------------ | Branch (3373:3): [True: 3.31k, False: 11.1M] ------------------ 3374| 3.31k|#line 430 "bison_parser.y" /* yacc.c:1646 */ 3375| 3.31k| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3376| 3.31k|#line 3377 "bison_parser.cpp" /* yacc.c:1646 */ 3377| 3.31k| break; 3378| | 3379| 1.24k| case 31: ------------------ | Branch (3379:3): [True: 1.24k, False: 11.1M] ------------------ 3380| 1.24k|#line 438 "bison_parser.y" /* yacc.c:1646 */ 3381| 1.24k| { 3382| 1.24k| (yyval.prep_stmt) = new PrepareStatement(); 3383| 1.24k| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3384| 1.24k| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3385| 1.24k|} 3386| 1.24k|#line 3387 "bison_parser.cpp" /* yacc.c:1646 */ 3387| 1.24k| break; 3388| | 3389| 3.13k| case 33: ------------------ | Branch (3389:3): [True: 3.13k, False: 11.1M] ------------------ 3390| 3.13k|#line 446 "bison_parser.y" /* yacc.c:1646 */ 3391| 3.13k| { 3392| 3.13k| (yyval.exec_stmt) = new ExecuteStatement(); 3393| 3.13k| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3394| 3.13k|} 3395| 3.13k|#line 3396 "bison_parser.cpp" /* yacc.c:1646 */ 3396| 3.13k| break; 3397| | 3398| 492| case 34: ------------------ | Branch (3398:3): [True: 492, False: 11.1M] ------------------ 3399| 492|#line 450 "bison_parser.y" /* yacc.c:1646 */ 3400| 492| { 3401| 492| (yyval.exec_stmt) = new ExecuteStatement(); 3402| 492| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3403| 492| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3404| 492|} 3405| 492|#line 3406 "bison_parser.cpp" /* yacc.c:1646 */ 3406| 492| break; 3407| | 3408| 0| case 35: ------------------ | Branch (3408:3): [True: 0, False: 11.1M] ------------------ 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| 6.17k| case 36: ------------------ | Branch (3419:3): [True: 6.17k, False: 11.1M] ------------------ 3420| 6.17k|#line 468 "bison_parser.y" /* yacc.c:1646 */ 3421| 6.17k| { 3422| 6.17k| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_export_option_t)->format); 3423| 6.17k| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3424| 6.17k| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3425| 6.17k| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3426| 6.17k| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3427| 6.17k| if ((yyvsp[-1].import_export_option_t)->encoding) { ------------------ | Branch (3427:7): [True: 305, False: 5.87k] ------------------ 3428| 305| (yyval.import_stmt)->encoding = (yyvsp[-1].import_export_option_t)->encoding; 3429| 305| (yyvsp[-1].import_export_option_t)->encoding = nullptr; 3430| 305| } 3431| 6.17k| if ((yyvsp[-1].import_export_option_t)->csv_options) { ------------------ | Branch (3431:7): [True: 196, False: 5.97k] ------------------ 3432| 196| (yyval.import_stmt)->csv_options = (yyvsp[-1].import_export_option_t)->csv_options; 3433| 196| (yyvsp[-1].import_export_option_t)->csv_options = nullptr; 3434| 196| } 3435| 6.17k| delete (yyvsp[-1].import_export_option_t); 3436| 6.17k|} 3437| 6.17k|#line 3438 "bison_parser.cpp" /* yacc.c:1646 */ 3438| 6.17k| break; 3439| | 3440| 1.84k| case 37: ------------------ | Branch (3440:3): [True: 1.84k, False: 11.1M] ------------------ 3441| 1.84k|#line 485 "bison_parser.y" /* yacc.c:1646 */ 3442| 1.84k| { 3443| 1.84k| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3443:7): [True: 788, False: 1.05k] ------------------ 3444| 788| (yyval.import_type_t) = kImportCSV; 3445| 1.05k| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3445:14): [True: 251, False: 806] ------------------ 3446| 251| (yyval.import_type_t) = kImportTbl; 3447| 806| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3447:14): [True: 195, False: 611] | Branch (3447:60): [True: 507, False: 104] ------------------ 3448| 702| (yyval.import_type_t) = kImportBinary; 3449| 702| } else { 3450| 104| free((yyvsp[0].sval)); 3451| 104| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 67| 104|#define yyerror hsql_error ------------------ 3452| 104| YYERROR; ------------------ | | 1458| 104|#define YYERROR goto yyerrorlab ------------------ 3453| 104| } 3454| 1.74k| free((yyvsp[0].sval)); 3455| 1.74k|} 3456| 0|#line 3457 "bison_parser.cpp" /* yacc.c:1646 */ 3457| 0| break; 3458| | 3459| 12.7k| case 38: ------------------ | Branch (3459:3): [True: 12.7k, False: 11.1M] ------------------ 3460| 12.7k|#line 500 "bison_parser.y" /* yacc.c:1646 */ 3461| 12.7k| { (yyval.sval) = (yyvsp[0].sval); } 3462| 12.7k|#line 3463 "bison_parser.cpp" /* yacc.c:1646 */ 3463| 12.7k| break; 3464| | 3465| 66| case 39: ------------------ | Branch (3465:3): [True: 66, False: 11.1M] ------------------ 3466| 66|#line 502 "bison_parser.y" /* yacc.c:1646 */ 3467| 66| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3468| 66|#line 3469 "bison_parser.cpp" /* yacc.c:1646 */ 3469| 66| break; 3470| | 3471| 3.66k| case 40: ------------------ | Branch (3471:3): [True: 3.66k, False: 11.1M] ------------------ 3472| 3.66k|#line 503 "bison_parser.y" /* yacc.c:1646 */ 3473| 3.66k| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3474| 3.66k|#line 3475 "bison_parser.cpp" /* yacc.c:1646 */ 3475| 3.66k| break; 3476| | 3477| 8.78k| case 41: ------------------ | Branch (3477:3): [True: 8.78k, False: 11.1M] ------------------ 3478| 8.78k|#line 504 "bison_parser.y" /* yacc.c:1646 */ 3479| 8.78k| { (yyval.import_export_option_t) = new ImportExportOptions{}; } 3480| 8.78k|#line 3481 "bison_parser.cpp" /* yacc.c:1646 */ 3481| 8.78k| break; 3482| | 3483| 524| case 42: ------------------ | Branch (3483:3): [True: 524, False: 11.1M] ------------------ 3484| 524|#line 506 "bison_parser.y" /* yacc.c:1646 */ 3485| 524| { 3486| 524| if ((yyvsp[-3].import_export_option_t)->format != kImportAuto) { ------------------ | Branch (3486:7): [True: 6, False: 518] ------------------ 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| 518| 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: 484, False: 34] | Branch (3491:58): [True: 1, False: 483] | 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| 517| (yyvsp[-3].import_export_option_t)->format = (yyvsp[0].import_type_t); 3497| 517| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3498| 517|} 3499| 0|#line 3500 "bison_parser.cpp" /* yacc.c:1646 */ 3500| 0| break; 3501| | 3502| 1.21k| case 43: ------------------ | Branch (3502:3): [True: 1.21k, False: 11.1M] ------------------ 3503| 1.21k|#line 520 "bison_parser.y" /* yacc.c:1646 */ 3504| 1.21k| { 3505| 1.21k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3506| 1.21k| (yyval.import_export_option_t)->format = (yyvsp[0].import_type_t); 3507| 1.21k|} 3508| 1.21k|#line 3509 "bison_parser.cpp" /* yacc.c:1646 */ 3509| 1.21k| break; 3510| | 3511| 472| case 44: ------------------ | Branch (3511:3): [True: 472, False: 11.1M] ------------------ 3512| 472|#line 524 "bison_parser.y" /* yacc.c:1646 */ 3513| 472| { 3514| 472| if ((yyvsp[-3].import_export_option_t)->encoding) { ------------------ | Branch (3514:7): [True: 1, False: 471] ------------------ 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| 471| (yyvsp[-3].import_export_option_t)->encoding = (yyvsp[0].sval); 3521| 471| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3522| 471|} 3523| 0|#line 3524 "bison_parser.cpp" /* yacc.c:1646 */ 3524| 0| break; 3525| | 3526| 999| case 45: ------------------ | Branch (3526:3): [True: 999, False: 11.1M] ------------------ 3527| 999|#line 534 "bison_parser.y" /* yacc.c:1646 */ 3528| 999| { 3529| 999| (yyval.import_export_option_t) = new ImportExportOptions{}; 3530| 999| (yyval.import_export_option_t)->encoding = (yyvsp[0].sval); 3531| 999|} 3532| 999|#line 3533 "bison_parser.cpp" /* yacc.c:1646 */ 3533| 999| break; 3534| | 3535| 523| case 46: ------------------ | Branch (3535:3): [True: 523, False: 11.1M] ------------------ 3536| 523|#line 538 "bison_parser.y" /* yacc.c:1646 */ 3537| 523| { 3538| 523| if ((yyvsp[-2].import_export_option_t)->format != kImportAuto && (yyvsp[-2].import_export_option_t)->format != kImportCSV) { ------------------ | Branch (3538:7): [True: 262, False: 261] | Branch (3538:68): [True: 1, False: 261] ------------------ 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| 522| if ((yyvsp[-2].import_export_option_t)->csv_options == nullptr) { ------------------ | Branch (3546:7): [True: 254, False: 268] ------------------ 3547| 254| (yyvsp[-2].import_export_option_t)->csv_options = new CsvOptions{}; 3548| 254| } 3549| | 3550| 522| if (!(yyvsp[-2].import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t))) { ------------------ | Branch (3550:7): [True: 10, False: 512] ------------------ 3551| 10| free((yyvsp[0].csv_option_t)->second); 3552| 10| delete (yyvsp[0].csv_option_t); 3553| 10| delete (yyvsp[-2].import_export_option_t); 3554| 10| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) cannot be provided more than once."); ------------------ | | 67| 10|#define yyerror hsql_error ------------------ 3555| 10| YYERROR; ------------------ | | 1458| 10|#define YYERROR goto yyerrorlab ------------------ 3556| 10| } 3557| | 3558| 512| delete (yyvsp[0].csv_option_t); 3559| 512| (yyval.import_export_option_t) = (yyvsp[-2].import_export_option_t); 3560| 512|} 3561| 0|#line 3562 "bison_parser.cpp" /* yacc.c:1646 */ 3562| 0| break; 3563| | 3564| 1.58k| case 47: ------------------ | Branch (3564:3): [True: 1.58k, False: 11.1M] ------------------ 3565| 1.58k|#line 562 "bison_parser.y" /* yacc.c:1646 */ 3566| 1.58k| { 3567| 1.58k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3568| 1.58k| (yyval.import_export_option_t)->csv_options = new CsvOptions{}; 3569| 1.58k| (yyval.import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t)); 3570| | 3571| 1.58k| delete (yyvsp[0].csv_option_t); 3572| 1.58k|} 3573| 1.58k|#line 3574 "bison_parser.cpp" /* yacc.c:1646 */ 3574| 1.58k| break; 3575| | 3576| 1.15k| case 48: ------------------ | Branch (3576:3): [True: 1.15k, False: 11.1M] ------------------ 3577| 1.15k|#line 570 "bison_parser.y" /* yacc.c:1646 */ 3578| 1.15k| { 3579| 1.15k| if (strcasecmp((yyvsp[-1].sval), "DELIMITER") == 0) { ------------------ | Branch (3579:7): [True: 436, False: 722] ------------------ 3580| 436| (yyval.csv_option_t) = new std::pair(CsvOptionType::Delimiter, (yyvsp[0].sval)); 3581| 722| } else if (strcasecmp((yyvsp[-1].sval), "QUOTE") == 0) { ------------------ | Branch (3581:14): [True: 613, False: 109] ------------------ 3582| 613| (yyval.csv_option_t) = new std::pair(CsvOptionType::Quote, (yyvsp[0].sval)); 3583| 613| } else { 3584| 109| free((yyvsp[-1].sval)); 3585| 109| free((yyvsp[0].sval)); 3586| 109| yyerror(&yyloc, result, scanner, "Unknown CSV option."); ------------------ | | 67| 109|#define yyerror hsql_error ------------------ 3587| 109| YYERROR; ------------------ | | 1458| 109|#define YYERROR goto yyerrorlab ------------------ 3588| 109| } 3589| 1.04k| free((yyvsp[-1].sval)); 3590| 1.04k|} 3591| 0|#line 3592 "bison_parser.cpp" /* yacc.c:1646 */ 3592| 0| break; 3593| | 3594| 1.06k| case 49: ------------------ | Branch (3594:3): [True: 1.06k, False: 11.1M] ------------------ 3595| 1.06k|#line 583 "bison_parser.y" /* yacc.c:1646 */ 3596| 1.06k| { (yyval.csv_option_t) = new std::pair(CsvOptionType::Null, (yyvsp[0].sval)); } 3597| 1.06k|#line 3598 "bison_parser.cpp" /* yacc.c:1646 */ 3598| 1.06k| break; 3599| | 3600| 5.37k| case 50: ------------------ | Branch (3600:3): [True: 5.37k, False: 11.1M] ------------------ 3601| 5.37k|#line 590 "bison_parser.y" /* yacc.c:1646 */ 3602| 5.37k| { 3603| 5.37k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3604| 5.37k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3605| 5.37k| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3606| 5.37k| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3607| 5.37k| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3607:7): [True: 934, False: 4.43k] ------------------ 3608| 934| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3609| 934| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3610| 934| } 3611| 5.37k| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3611:7): [True: 1.16k, False: 4.20k] ------------------ 3612| 1.16k| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3613| 1.16k| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3614| 1.16k| } 3615| 5.37k| delete (yyvsp[0].import_export_option_t); 3616| 5.37k|} 3617| 5.37k|#line 3618 "bison_parser.cpp" /* yacc.c:1646 */ 3618| 5.37k| break; 3619| | 3620| 963| case 51: ------------------ | Branch (3620:3): [True: 963, False: 11.1M] ------------------ 3621| 963|#line 605 "bison_parser.y" /* yacc.c:1646 */ 3622| 963| { 3623| 963| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3624| 963| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3625| 963| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3626| 963| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3626:7): [True: 218, False: 745] ------------------ 3627| 218| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3628| 218| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3629| 218| } 3630| 963| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3630:7): [True: 431, False: 532] ------------------ 3631| 431| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3632| 431| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3633| 431| } 3634| 963| delete (yyvsp[0].import_export_option_t); 3635| 963|} 3636| 963|#line 3637 "bison_parser.cpp" /* yacc.c:1646 */ 3637| 963| break; 3638| | 3639| 1.47k| case 52: ------------------ | Branch (3639:3): [True: 1.47k, False: 11.1M] ------------------ 3640| 1.47k|#line 625 "bison_parser.y" /* yacc.c:1646 */ 3641| 1.47k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3642| 1.47k|#line 3643 "bison_parser.cpp" /* yacc.c:1646 */ 3643| 1.47k| break; 3644| | 3645| 1.16k| case 53: ------------------ | Branch (3645:3): [True: 1.16k, False: 11.1M] ------------------ 3646| 1.16k|#line 626 "bison_parser.y" /* yacc.c:1646 */ 3647| 1.16k| { 3648| 1.16k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3649| 1.16k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3650| 1.16k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3651| 1.16k|} 3652| 1.16k|#line 3653 "bison_parser.cpp" /* yacc.c:1646 */ 3653| 1.16k| break; 3654| | 3655| 3.78k| case 54: ------------------ | Branch (3655:3): [True: 3.78k, False: 11.1M] ------------------ 3656| 3.78k|#line 631 "bison_parser.y" /* yacc.c:1646 */ 3657| 3.78k| { 3658| 3.78k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3659| 3.78k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3660| 3.78k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3661| 3.78k|} 3662| 3.78k|#line 3663 "bison_parser.cpp" /* yacc.c:1646 */ 3663| 3.78k| break; 3664| | 3665| 0| case 55: ------------------ | Branch (3665:3): [True: 0, False: 11.1M] ------------------ 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| 3.98k| case 56: ------------------ | Branch (3683:3): [True: 3.98k, False: 11.1M] ------------------ 3684| 3.98k|#line 655 "bison_parser.y" /* yacc.c:1646 */ 3685| 3.98k| { 3686| 3.98k| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3687| 3.98k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3688| 3.98k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3689| 3.98k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3690| 3.98k| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3691| 3.98k| delete (yyvsp[-1].table_element_vec); 3692| 3.98k| if (result->errorMsg()) { ------------------ | Branch (3692:7): [True: 3, False: 3.97k] ------------------ 3693| 3| delete (yyval.create_stmt); 3694| 3| YYERROR; ------------------ | | 1458| 3|#define YYERROR goto yyerrorlab ------------------ 3695| 3| } 3696| 3.98k|} 3697| 3.97k|#line 3698 "bison_parser.cpp" /* yacc.c:1646 */ 3698| 3.97k| break; 3699| | 3700| 3.97k| case 57: ------------------ | Branch (3700:3): [True: 200, False: 11.1M] ------------------ 3701| 200|#line 667 "bison_parser.y" /* yacc.c:1646 */ 3702| 200| { 3703| 200| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3704| 200| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3705| 200| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3706| 200| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3707| 200| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3708| 200|} 3709| 200|#line 3710 "bison_parser.cpp" /* yacc.c:1646 */ 3710| 200| break; 3711| | 3712| 683| case 58: ------------------ | Branch (3712:3): [True: 683, False: 11.1M] ------------------ 3713| 683|#line 674 "bison_parser.y" /* yacc.c:1646 */ 3714| 683| { 3715| 683| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3716| 683| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3717| 683| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3718| 683| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3719| 683| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3720| 683|} 3721| 683|#line 3722 "bison_parser.cpp" /* yacc.c:1646 */ 3722| 683| break; 3723| | 3724| 1.70k| case 59: ------------------ | Branch (3724:3): [True: 1.70k, False: 11.1M] ------------------ 3725| 1.70k|#line 681 "bison_parser.y" /* yacc.c:1646 */ 3726| 1.70k| { 3727| 1.70k| (yyval.create_stmt) = new CreateStatement(kCreateView); 3728| 1.70k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3729| 1.70k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3730| 1.70k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3731| 1.70k| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3732| 1.70k| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3733| 1.70k|} 3734| 1.70k|#line 3735 "bison_parser.cpp" /* yacc.c:1646 */ 3735| 1.70k| break; 3736| | 3737| 121| case 60: ------------------ | Branch (3737:3): [True: 121, False: 11.1M] ------------------ 3738| 121|#line 690 "bison_parser.y" /* yacc.c:1646 */ 3739| 121| { (yyval.bval) = true; } 3740| 121|#line 3741 "bison_parser.cpp" /* yacc.c:1646 */ 3741| 121| break; 3742| | 3743| 7.02k| case 61: ------------------ | Branch (3743:3): [True: 7.02k, False: 11.1M] ------------------ 3744| 7.02k|#line 691 "bison_parser.y" /* yacc.c:1646 */ 3745| 7.02k| { (yyval.bval) = false; } 3746| 7.02k|#line 3747 "bison_parser.cpp" /* yacc.c:1646 */ 3747| 7.02k| break; 3748| | 3749| 4.49k| case 62: ------------------ | Branch (3749:3): [True: 4.49k, False: 11.1M] ------------------ 3750| 4.49k|#line 693 "bison_parser.y" /* yacc.c:1646 */ 3751| 4.49k| { 3752| 4.49k| (yyval.table_element_vec) = new std::vector(); 3753| 4.49k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3754| 4.49k|} 3755| 4.49k|#line 3756 "bison_parser.cpp" /* yacc.c:1646 */ 3756| 4.49k| break; 3757| | 3758| 16.4k| case 63: ------------------ | Branch (3758:3): [True: 16.4k, False: 11.0M] ------------------ 3759| 16.4k|#line 697 "bison_parser.y" /* yacc.c:1646 */ 3760| 16.4k| { 3761| 16.4k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3762| 16.4k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3763| 16.4k|} 3764| 16.4k|#line 3765 "bison_parser.cpp" /* yacc.c:1646 */ 3765| 16.4k| break; 3766| | 3767| 19.2k| case 64: ------------------ | Branch (3767:3): [True: 19.2k, False: 11.0M] ------------------ 3768| 19.2k|#line 702 "bison_parser.y" /* yacc.c:1646 */ 3769| 19.2k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3770| 19.2k|#line 3771 "bison_parser.cpp" /* yacc.c:1646 */ 3771| 19.2k| break; 3772| | 3773| 1.66k| case 65: ------------------ | Branch (3773:3): [True: 1.66k, False: 11.1M] ------------------ 3774| 1.66k|#line 703 "bison_parser.y" /* yacc.c:1646 */ 3775| 1.66k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3776| 1.66k|#line 3777 "bison_parser.cpp" /* yacc.c:1646 */ 3777| 1.66k| break; 3778| | 3779| 19.2k| case 66: ------------------ | Branch (3779:3): [True: 19.2k, False: 11.0M] ------------------ 3780| 19.2k|#line 705 "bison_parser.y" /* yacc.c:1646 */ 3781| 19.2k| { 3782| 19.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| 19.2k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3783:7): [True: 1.42k, False: 17.8k] ------------------ 3784| 1.42k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 67| 1.42k|#define yyerror hsql_error ------------------ 3785| 1.42k| } 3786| 19.2k| delete (yyvsp[0].column_constraints_t); 3787| 19.2k|} 3788| 19.2k|#line 3789 "bison_parser.cpp" /* yacc.c:1646 */ 3789| 19.2k| break; 3790| | 3791| 724| case 67: ------------------ | Branch (3791:3): [True: 724, False: 11.1M] ------------------ 3792| 724|#line 713 "bison_parser.y" /* yacc.c:1646 */ 3793| 724| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3794| 724|#line 3795 "bison_parser.cpp" /* yacc.c:1646 */ 3795| 724| break; 3796| | 3797| 569| case 68: ------------------ | Branch (3797:3): [True: 569, False: 11.1M] ------------------ 3798| 569|#line 714 "bison_parser.y" /* yacc.c:1646 */ 3799| 569| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3800| 569|#line 3801 "bison_parser.cpp" /* yacc.c:1646 */ 3801| 569| break; 3802| | 3803| 486| case 69: ------------------ | Branch (3803:3): [True: 486, False: 11.1M] ------------------ 3804| 486|#line 715 "bison_parser.y" /* yacc.c:1646 */ 3805| 486| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3806| 486|#line 3807 "bison_parser.cpp" /* yacc.c:1646 */ 3807| 486| break; 3808| | 3809| 0| case 70: ------------------ | Branch (3809:3): [True: 0, False: 11.1M] ------------------ 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| 2.72k| case 71: ------------------ | Branch (3815:3): [True: 2.72k, False: 11.1M] ------------------ 3816| 2.72k|#line 717 "bison_parser.y" /* yacc.c:1646 */ 3817| 2.72k| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3818| 2.72k|#line 3819 "bison_parser.cpp" /* yacc.c:1646 */ 3819| 2.72k| break; 3820| | 3821| 391| case 72: ------------------ | Branch (3821:3): [True: 391, False: 11.1M] ------------------ 3822| 391|#line 718 "bison_parser.y" /* yacc.c:1646 */ 3823| 391| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3824| 391|#line 3825 "bison_parser.cpp" /* yacc.c:1646 */ 3825| 391| break; 3826| | 3827| 899| case 73: ------------------ | Branch (3827:3): [True: 899, False: 11.1M] ------------------ 3828| 899|#line 719 "bison_parser.y" /* yacc.c:1646 */ 3829| 899| { 3830| 899| (yyval.column_type_t) = ColumnType{DataType::DECIMAL, 0, (yyvsp[0].ival_pair)->first, (yyvsp[0].ival_pair)->second}; 3831| 899| delete (yyvsp[0].ival_pair); 3832| 899|} 3833| 899|#line 3834 "bison_parser.cpp" /* yacc.c:1646 */ 3834| 899| break; 3835| | 3836| 780| case 74: ------------------ | Branch (3836:3): [True: 780, False: 11.1M] ------------------ 3837| 780|#line 723 "bison_parser.y" /* yacc.c:1646 */ 3838| 780| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3839| 780|#line 3840 "bison_parser.cpp" /* yacc.c:1646 */ 3840| 780| break; 3841| | 3842| 722| case 75: ------------------ | Branch (3842:3): [True: 722, False: 11.1M] ------------------ 3843| 722|#line 724 "bison_parser.y" /* yacc.c:1646 */ 3844| 722| { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } 3845| 722|#line 3846 "bison_parser.cpp" /* yacc.c:1646 */ 3846| 722| break; 3847| | 3848| 7.22k| case 76: ------------------ | Branch (3848:3): [True: 7.22k, False: 11.1M] ------------------ 3849| 7.22k|#line 725 "bison_parser.y" /* yacc.c:1646 */ 3850| 7.22k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3851| 7.22k|#line 3852 "bison_parser.cpp" /* yacc.c:1646 */ 3852| 7.22k| break; 3853| | 3854| 773| case 77: ------------------ | Branch (3854:3): [True: 773, False: 11.1M] ------------------ 3855| 773|#line 726 "bison_parser.y" /* yacc.c:1646 */ 3856| 773| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3857| 773|#line 3858 "bison_parser.cpp" /* yacc.c:1646 */ 3858| 773| break; 3859| | 3860| 926| case 78: ------------------ | Branch (3860:3): [True: 926, False: 11.1M] ------------------ 3861| 926|#line 727 "bison_parser.y" /* yacc.c:1646 */ 3862| 926| { (yyval.column_type_t) = ColumnType{DataType::LONG}; } 3863| 926|#line 3864 "bison_parser.cpp" /* yacc.c:1646 */ 3864| 926| break; 3865| | 3866| 583| case 79: ------------------ | Branch (3866:3): [True: 583, False: 11.1M] ------------------ 3867| 583|#line 728 "bison_parser.y" /* yacc.c:1646 */ 3868| 583| { (yyval.column_type_t) = ColumnType{DataType::REAL}; } 3869| 583|#line 3870 "bison_parser.cpp" /* yacc.c:1646 */ 3870| 583| break; 3871| | 3872| 513| case 80: ------------------ | Branch (3872:3): [True: 513, False: 11.1M] ------------------ 3873| 513|#line 729 "bison_parser.y" /* yacc.c:1646 */ 3874| 513| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3875| 513|#line 3876 "bison_parser.cpp" /* yacc.c:1646 */ 3876| 513| break; 3877| | 3878| 397| case 81: ------------------ | Branch (3878:3): [True: 397, False: 11.1M] ------------------ 3879| 397|#line 730 "bison_parser.y" /* yacc.c:1646 */ 3880| 397| { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } 3881| 397|#line 3882 "bison_parser.cpp" /* yacc.c:1646 */ 3882| 397| break; 3883| | 3884| 983| case 82: ------------------ | Branch (3884:3): [True: 983, False: 11.1M] ------------------ 3885| 983|#line 731 "bison_parser.y" /* yacc.c:1646 */ 3886| 983| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3887| 983|#line 3888 "bison_parser.cpp" /* yacc.c:1646 */ 3888| 983| break; 3889| | 3890| 457| case 83: ------------------ | Branch (3890:3): [True: 457, False: 11.1M] ------------------ 3891| 457|#line 732 "bison_parser.y" /* yacc.c:1646 */ 3892| 457| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3893| 457|#line 3894 "bison_parser.cpp" /* yacc.c:1646 */ 3894| 457| break; 3895| | 3896| 583| case 84: ------------------ | Branch (3896:3): [True: 583, False: 11.1M] ------------------ 3897| 583|#line 733 "bison_parser.y" /* yacc.c:1646 */ 3898| 583| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3899| 583|#line 3900 "bison_parser.cpp" /* yacc.c:1646 */ 3900| 583| break; 3901| | 3902| 344| case 85: ------------------ | Branch (3902:3): [True: 344, False: 11.1M] ------------------ 3903| 344|#line 735 "bison_parser.y" /* yacc.c:1646 */ 3904| 344| { (yyval.ival) = (yyvsp[-1].ival); } 3905| 344|#line 3906 "bison_parser.cpp" /* yacc.c:1646 */ 3906| 344| break; 3907| | 3908| 639| case 86: ------------------ | Branch (3908:3): [True: 639, False: 11.1M] ------------------ 3909| 639|#line 736 "bison_parser.y" /* yacc.c:1646 */ 3910| 639| { (yyval.ival) = 0; } 3911| 639|#line 3912 "bison_parser.cpp" /* yacc.c:1646 */ 3912| 639| break; 3913| | 3914| 200| case 87: ------------------ | Branch (3914:3): [True: 200, False: 11.1M] ------------------ 3915| 200|#line 738 "bison_parser.y" /* yacc.c:1646 */ 3916| 200| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3917| 200|#line 3918 "bison_parser.cpp" /* yacc.c:1646 */ 3918| 200| break; 3919| | 3920| 204| case 88: ------------------ | Branch (3920:3): [True: 204, False: 11.1M] ------------------ 3921| 204|#line 739 "bison_parser.y" /* yacc.c:1646 */ 3922| 204| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3923| 204|#line 3924 "bison_parser.cpp" /* yacc.c:1646 */ 3924| 204| break; 3925| | 3926| 495| case 89: ------------------ | Branch (3926:3): [True: 495, False: 11.1M] ------------------ 3927| 495|#line 740 "bison_parser.y" /* yacc.c:1646 */ 3928| 495| { (yyval.ival_pair) = new std::pair{0, 0}; } 3929| 495|#line 3930 "bison_parser.cpp" /* yacc.c:1646 */ 3930| 495| break; 3931| | 3932| 3.10k| case 90: ------------------ | Branch (3932:3): [True: 3.10k, False: 11.1M] ------------------ 3933| 3.10k|#line 742 "bison_parser.y" /* yacc.c:1646 */ 3934| 3.10k| { (yyval.column_constraints_t) = (yyvsp[0].column_constraints_t); } 3935| 3.10k|#line 3936 "bison_parser.cpp" /* yacc.c:1646 */ 3936| 3.10k| break; 3937| | 3938| 16.1k| case 91: ------------------ | Branch (3938:3): [True: 16.1k, False: 11.0M] ------------------ 3939| 16.1k|#line 743 "bison_parser.y" /* yacc.c:1646 */ 3940| 16.1k| { (yyval.column_constraints_t) = new ColumnConstraints(); } 3941| 16.1k|#line 3942 "bison_parser.cpp" /* yacc.c:1646 */ 3942| 16.1k| break; 3943| | 3944| 3.11k| case 92: ------------------ | Branch (3944:3): [True: 3.11k, False: 11.1M] ------------------ 3945| 3.11k|#line 745 "bison_parser.y" /* yacc.c:1646 */ 3946| 3.11k| { 3947| 3.11k| (yyval.column_constraints_t) = new ColumnConstraints(); 3948| 3.11k| (yyval.column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3949| 3.11k|} 3950| 3.11k|#line 3951 "bison_parser.cpp" /* yacc.c:1646 */ 3951| 3.11k| break; 3952| | 3953| 4.84k| case 93: ------------------ | Branch (3953:3): [True: 4.84k, False: 11.1M] ------------------ 3954| 4.84k|#line 749 "bison_parser.y" /* yacc.c:1646 */ 3955| 4.84k| { 3956| 4.84k| (yyvsp[-1].column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3957| 4.84k| (yyval.column_constraints_t) = (yyvsp[-1].column_constraints_t); 3958| 4.84k|} 3959| 4.84k|#line 3960 "bison_parser.cpp" /* yacc.c:1646 */ 3960| 4.84k| break; 3961| | 3962| 0| case 94: ------------------ | Branch (3962:3): [True: 0, False: 11.1M] ------------------ 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: 11.1M] ------------------ 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.52k| case 96: ------------------ | Branch (3984:3): [True: 1.52k, False: 11.1M] ------------------ 3985| 1.52k|#line 766 "bison_parser.y" /* yacc.c:1646 */ 3986| 1.52k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3987| 1.52k|#line 3988 "bison_parser.cpp" /* yacc.c:1646 */ 3988| 1.52k| break; 3989| | 3990| 1.94k| case 97: ------------------ | Branch (3990:3): [True: 1.94k, False: 11.1M] ------------------ 3991| 1.94k|#line 767 "bison_parser.y" /* yacc.c:1646 */ 3992| 1.94k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3993| 1.94k|#line 3994 "bison_parser.cpp" /* yacc.c:1646 */ 3994| 1.94k| break; 3995| | 3996| 2.65k| case 98: ------------------ | Branch (3996:3): [True: 2.65k, False: 11.1M] ------------------ 3997| 2.65k|#line 768 "bison_parser.y" /* yacc.c:1646 */ 3998| 2.65k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3999| 2.65k|#line 4000 "bison_parser.cpp" /* yacc.c:1646 */ 4000| 2.65k| break; 4001| | 4002| 1.82k| case 99: ------------------ | Branch (4002:3): [True: 1.82k, False: 11.1M] ------------------ 4003| 1.82k|#line 769 "bison_parser.y" /* yacc.c:1646 */ 4004| 1.82k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 4005| 1.82k|#line 4006 "bison_parser.cpp" /* yacc.c:1646 */ 4006| 1.82k| break; 4007| | 4008| 212| case 100: ------------------ | Branch (4008:3): [True: 212, False: 11.1M] ------------------ 4009| 212|#line 771 "bison_parser.y" /* yacc.c:1646 */ 4010| 212| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 4011| 212|#line 4012 "bison_parser.cpp" /* yacc.c:1646 */ 4012| 212| break; 4013| | 4014| 1.45k| case 101: ------------------ | Branch (4014:3): [True: 1.45k, False: 11.1M] ------------------ 4015| 1.45k|#line 772 "bison_parser.y" /* yacc.c:1646 */ 4016| 1.45k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 4017| 1.45k|#line 4018 "bison_parser.cpp" /* yacc.c:1646 */ 4018| 1.45k| break; 4019| | 4020| 0| case 102: ------------------ | Branch (4020:3): [True: 0, False: 11.1M] ------------------ 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: 11.1M] ------------------ 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| 790| case 104: ------------------ | Branch (4032:3): [True: 790, False: 11.1M] ------------------ 4033| 790|#line 783 "bison_parser.y" /* yacc.c:1646 */ 4034| 790| { 4035| 790| (yyval.drop_stmt) = new DropStatement(kDropTable); 4036| 790| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4037| 790| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4038| 790| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4039| 790|} 4040| 790|#line 4041 "bison_parser.cpp" /* yacc.c:1646 */ 4041| 790| break; 4042| | 4043| 1.55k| case 105: ------------------ | Branch (4043:3): [True: 1.55k, False: 11.1M] ------------------ 4044| 1.55k|#line 789 "bison_parser.y" /* yacc.c:1646 */ 4045| 1.55k| { 4046| 1.55k| (yyval.drop_stmt) = new DropStatement(kDropView); 4047| 1.55k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4048| 1.55k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4049| 1.55k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4050| 1.55k|} 4051| 1.55k|#line 4052 "bison_parser.cpp" /* yacc.c:1646 */ 4052| 1.55k| break; 4053| | 4054| 809| case 106: ------------------ | Branch (4054:3): [True: 809, False: 11.1M] ------------------ 4055| 809|#line 795 "bison_parser.y" /* yacc.c:1646 */ 4056| 809| { 4057| 809| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 4058| 809| (yyval.drop_stmt)->ifExists = false; 4059| 809| (yyval.drop_stmt)->name = (yyvsp[0].sval); 4060| 809|} 4061| 809|#line 4062 "bison_parser.cpp" /* yacc.c:1646 */ 4062| 809| break; 4063| | 4064| 595| case 107: ------------------ | Branch (4064:3): [True: 595, False: 11.1M] ------------------ 4065| 595|#line 801 "bison_parser.y" /* yacc.c:1646 */ 4066| 595| { 4067| 595| (yyval.drop_stmt) = new DropStatement(kDropIndex); 4068| 595| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4069| 595| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 4070| 595|} 4071| 595|#line 4072 "bison_parser.cpp" /* yacc.c:1646 */ 4072| 595| break; 4073| | 4074| 371| case 108: ------------------ | Branch (4074:3): [True: 371, False: 11.1M] ------------------ 4075| 371|#line 807 "bison_parser.y" /* yacc.c:1646 */ 4076| 371| { (yyval.bval) = true; } 4077| 371|#line 4078 "bison_parser.cpp" /* yacc.c:1646 */ 4078| 371| break; 4079| | 4080| 2.59k| case 109: ------------------ | Branch (4080:3): [True: 2.59k, False: 11.1M] ------------------ 4081| 2.59k|#line 808 "bison_parser.y" /* yacc.c:1646 */ 4082| 2.59k| { (yyval.bval) = false; } 4083| 2.59k|#line 4084 "bison_parser.cpp" /* yacc.c:1646 */ 4084| 2.59k| break; 4085| | 4086| 0| case 110: ------------------ | Branch (4086:3): [True: 0, False: 11.1M] ------------------ 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: 11.1M] ------------------ 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: 11.1M] ------------------ 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.49k| case 113: ------------------ | Branch (4111:3): [True: 1.49k, False: 11.1M] ------------------ 4112| 1.49k|#line 833 "bison_parser.y" /* yacc.c:1646 */ 4113| 1.49k| { 4114| 1.49k| (yyval.delete_stmt) = new DeleteStatement(); 4115| 1.49k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 4116| 1.49k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 4117| 1.49k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 4118| 1.49k|} 4119| 1.49k|#line 4120 "bison_parser.cpp" /* yacc.c:1646 */ 4120| 1.49k| break; 4121| | 4122| 253| case 114: ------------------ | Branch (4122:3): [True: 253, False: 11.1M] ------------------ 4123| 253|#line 840 "bison_parser.y" /* yacc.c:1646 */ 4124| 253| { 4125| 253| (yyval.delete_stmt) = new DeleteStatement(); 4126| 253| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 4127| 253| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 4128| 253|} 4129| 253|#line 4130 "bison_parser.cpp" /* yacc.c:1646 */ 4130| 253| break; 4131| | 4132| 637| case 115: ------------------ | Branch (4132:3): [True: 637, False: 11.1M] ------------------ 4133| 637|#line 851 "bison_parser.y" /* yacc.c:1646 */ 4134| 637| { 4135| 637| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 4136| 637| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 4137| 637| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 4138| 637| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 4139| 637| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 4140| 637|} 4141| 637|#line 4142 "bison_parser.cpp" /* yacc.c:1646 */ 4142| 637| break; 4143| | 4144| 2.69k| case 116: ------------------ | Branch (4144:3): [True: 2.69k, False: 11.1M] ------------------ 4145| 2.69k|#line 858 "bison_parser.y" /* yacc.c:1646 */ 4146| 2.69k| { 4147| 2.69k| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 4148| 2.69k| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 4149| 2.69k| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 4150| 2.69k| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 4151| 2.69k| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 4152| 2.69k|} 4153| 2.69k|#line 4154 "bison_parser.cpp" /* yacc.c:1646 */ 4154| 2.69k| break; 4155| | 4156| 1.01k| case 117: ------------------ | Branch (4156:3): [True: 1.01k, False: 11.1M] ------------------ 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| 4.05k| case 118: ------------------ | Branch (4162:3): [True: 4.05k, False: 11.1M] ------------------ 4163| 4.05k|#line 867 "bison_parser.y" /* yacc.c:1646 */ 4164| 4.05k| { (yyval.str_vec) = nullptr; } 4165| 4.05k|#line 4166 "bison_parser.cpp" /* yacc.c:1646 */ 4166| 4.05k| break; 4167| | 4168| 2.18k| case 119: ------------------ | Branch (4168:3): [True: 2.18k, False: 11.1M] ------------------ 4169| 2.18k|#line 874 "bison_parser.y" /* yacc.c:1646 */ 4170| 2.18k| { 4171| 2.18k| (yyval.update_stmt) = new UpdateStatement(); 4172| 2.18k| (yyval.update_stmt)->table = (yyvsp[-3].table); 4173| 2.18k| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4174| 2.18k| (yyval.update_stmt)->where = (yyvsp[0].expr); 4175| 2.18k|} 4176| 2.18k|#line 4177 "bison_parser.cpp" /* yacc.c:1646 */ 4177| 2.18k| break; 4178| | 4179| 2.19k| case 120: ------------------ | Branch (4179:3): [True: 2.19k, False: 11.1M] ------------------ 4180| 2.19k|#line 881 "bison_parser.y" /* yacc.c:1646 */ 4181| 2.19k| { 4182| 2.19k| (yyval.update_vec) = new std::vector(); 4183| 2.19k| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4184| 2.19k|} 4185| 2.19k|#line 4186 "bison_parser.cpp" /* yacc.c:1646 */ 4186| 2.19k| break; 4187| | 4188| 1.41k| case 121: ------------------ | Branch (4188:3): [True: 1.41k, False: 11.1M] ------------------ 4189| 1.41k|#line 885 "bison_parser.y" /* yacc.c:1646 */ 4190| 1.41k| { 4191| 1.41k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4192| 1.41k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4193| 1.41k|} 4194| 1.41k|#line 4195 "bison_parser.cpp" /* yacc.c:1646 */ 4195| 1.41k| break; 4196| | 4197| 3.61k| case 122: ------------------ | Branch (4197:3): [True: 3.61k, False: 11.1M] ------------------ 4198| 3.61k|#line 890 "bison_parser.y" /* yacc.c:1646 */ 4199| 3.61k| { 4200| 3.61k| (yyval.update_t) = new UpdateClause(); 4201| 3.61k| (yyval.update_t)->column = (yyvsp[-2].sval); 4202| 3.61k| (yyval.update_t)->value = (yyvsp[0].expr); 4203| 3.61k|} 4204| 3.61k|#line 4205 "bison_parser.cpp" /* yacc.c:1646 */ 4205| 3.61k| break; 4206| | 4207| 505| case 123: ------------------ | Branch (4207:3): [True: 505, False: 11.1M] ------------------ 4208| 505|#line 900 "bison_parser.y" /* yacc.c:1646 */ 4209| 505| { 4210| 505| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4211| 505| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4212| 505|} 4213| 505|#line 4214 "bison_parser.cpp" /* yacc.c:1646 */ 4214| 505| break; 4215| | 4216| 21.6k| case 124: ------------------ | Branch (4216:3): [True: 21.6k, False: 11.0M] ------------------ 4217| 21.6k|#line 904 "bison_parser.y" /* yacc.c:1646 */ 4218| 21.6k| { 4219| 21.6k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4220| 21.6k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4221| 21.6k|} 4222| 21.6k|#line 4223 "bison_parser.cpp" /* yacc.c:1646 */ 4223| 21.6k| break; 4224| | 4225| 1.52k| case 125: ------------------ | Branch (4225:3): [True: 1.52k, False: 11.1M] ------------------ 4226| 1.52k|#line 908 "bison_parser.y" /* yacc.c:1646 */ 4227| 1.52k| { 4228| 1.52k| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4229| 1.52k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4229:7): [True: 1.23k, False: 297] ------------------ 4230| 1.23k| (yyval.select_stmt)->setOperations = new std::vector(); 4231| 1.23k| } 4232| 1.52k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4233| 1.52k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4234| 1.52k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4235| 1.52k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4236| 1.52k| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4237| 1.52k|} 4238| 1.52k|#line 4239 "bison_parser.cpp" /* yacc.c:1646 */ 4239| 1.52k| break; 4240| | 4241| 2.90k| case 128: ------------------ | Branch (4241:3): [True: 2.90k, False: 11.1M] ------------------ 4242| 2.90k|#line 922 "bison_parser.y" /* yacc.c:1646 */ 4243| 2.90k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4244| 2.90k|#line 4245 "bison_parser.cpp" /* yacc.c:1646 */ 4245| 2.90k| break; 4246| | 4247| 2.89k| case 129: ------------------ | Branch (4247:3): [True: 2.89k, False: 11.1M] ------------------ 4248| 2.89k|#line 923 "bison_parser.y" /* yacc.c:1646 */ 4249| 2.89k| { 4250| 2.89k| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4251| 2.89k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4251:7): [True: 2.89k, False: 0] ------------------ 4252| 2.89k| (yyval.select_stmt)->setOperations = new std::vector(); 4253| 2.89k| } 4254| 2.89k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4255| 2.89k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4256| 2.89k|} 4257| 2.89k|#line 4258 "bison_parser.cpp" /* yacc.c:1646 */ 4258| 2.89k| break; 4259| | 4260| 4.81k| case 130: ------------------ | Branch (4260:3): [True: 4.81k, False: 11.1M] ------------------ 4261| 4.81k|#line 932 "bison_parser.y" /* yacc.c:1646 */ 4262| 4.81k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4263| 4.81k|#line 4264 "bison_parser.cpp" /* yacc.c:1646 */ 4264| 4.81k| break; 4265| | 4266| 201| case 131: ------------------ | Branch (4266:3): [True: 201, False: 11.1M] ------------------ 4267| 201|#line 933 "bison_parser.y" /* yacc.c:1646 */ 4268| 201| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4269| 201|#line 4270 "bison_parser.cpp" /* yacc.c:1646 */ 4270| 201| break; 4271| | 4272| 30.1k| case 132: ------------------ | Branch (4272:3): [True: 30.1k, False: 11.0M] ------------------ 4273| 30.1k|#line 935 "bison_parser.y" /* yacc.c:1646 */ 4274| 30.1k| { 4275| 30.1k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4276| 30.1k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4277| | 4278| | // Limit could have been set by TOP. 4279| 30.1k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4279:7): [True: 4.22k, False: 25.9k] ------------------ 4280| 4.22k| delete (yyval.select_stmt)->limit; 4281| 4.22k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4282| 4.22k| } 4283| | 4284| 30.1k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4284:7): [True: 401, False: 29.7k] ------------------ 4285| 401| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4286| 401| } 4287| 30.1k|} 4288| 30.1k|#line 4289 "bison_parser.cpp" /* yacc.c:1646 */ 4289| 30.1k| break; 4290| | 4291| 1.33k| case 133: ------------------ | Branch (4291:3): [True: 1.33k, False: 11.1M] ------------------ 4292| 1.33k|#line 949 "bison_parser.y" /* yacc.c:1646 */ 4293| 1.33k| { 4294| 1.33k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4295| 1.33k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4295:7): [True: 1.33k, False: 0] ------------------ 4296| 1.33k| (yyval.select_stmt)->setOperations = new std::vector(); 4297| 1.33k| } 4298| 1.33k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4299| 1.33k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4300| 1.33k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4301| 1.33k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4302| 1.33k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4303| 1.33k|} 4304| 1.33k|#line 4305 "bison_parser.cpp" /* yacc.c:1646 */ 4305| 1.33k| break; 4306| | 4307| 6.85k| case 134: ------------------ | Branch (4307:3): [True: 6.85k, False: 11.1M] ------------------ 4308| 6.85k|#line 961 "bison_parser.y" /* yacc.c:1646 */ 4309| 6.85k| { 4310| 6.85k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4311| 6.85k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4312| 6.85k|} 4313| 6.85k|#line 4314 "bison_parser.cpp" /* yacc.c:1646 */ 4314| 6.85k| break; 4315| | 4316| 5.28k| case 135: ------------------ | Branch (4316:3): [True: 5.28k, False: 11.1M] ------------------ 4317| 5.28k|#line 966 "bison_parser.y" /* yacc.c:1646 */ 4318| 5.28k| { 4319| 5.28k| (yyval.set_operator_t) = new SetOperation(); 4320| 5.28k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4321| 5.28k|} 4322| 5.28k|#line 4323 "bison_parser.cpp" /* yacc.c:1646 */ 4323| 5.28k| break; 4324| | 4325| 635| case 136: ------------------ | Branch (4325:3): [True: 635, False: 11.1M] ------------------ 4326| 635|#line 970 "bison_parser.y" /* yacc.c:1646 */ 4327| 635| { 4328| 635| (yyval.set_operator_t) = new SetOperation(); 4329| 635| (yyval.set_operator_t)->setType = SetType::kSetIntersect; 4330| 635|} 4331| 635|#line 4332 "bison_parser.cpp" /* yacc.c:1646 */ 4332| 635| break; 4333| | 4334| 936| case 137: ------------------ | Branch (4334:3): [True: 936, False: 11.1M] ------------------ 4335| 936|#line 974 "bison_parser.y" /* yacc.c:1646 */ 4336| 936| { 4337| 936| (yyval.set_operator_t) = new SetOperation(); 4338| 936| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4339| 936|} 4340| 936|#line 4341 "bison_parser.cpp" /* yacc.c:1646 */ 4341| 936| break; 4342| | 4343| 393| case 138: ------------------ | Branch (4343:3): [True: 393, False: 11.1M] ------------------ 4344| 393|#line 979 "bison_parser.y" /* yacc.c:1646 */ 4345| 393| { (yyval.bval) = true; } 4346| 393|#line 4347 "bison_parser.cpp" /* yacc.c:1646 */ 4347| 393| break; 4348| | 4349| 6.46k| case 139: ------------------ | Branch (4349:3): [True: 6.46k, False: 11.1M] ------------------ 4350| 6.46k|#line 980 "bison_parser.y" /* yacc.c:1646 */ 4351| 6.46k| { (yyval.bval) = false; } 4352| 6.46k|#line 4353 "bison_parser.cpp" /* yacc.c:1646 */ 4353| 6.46k| break; 4354| | 4355| 38.9k| case 140: ------------------ | Branch (4355:3): [True: 38.9k, False: 11.0M] ------------------ 4356| 38.9k|#line 982 "bison_parser.y" /* yacc.c:1646 */ 4357| 38.9k| { 4358| 38.9k| (yyval.select_stmt) = new SelectStatement(); 4359| 38.9k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4360| 38.9k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4361| 38.9k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4362| 38.9k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4363| 38.9k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4364| 38.9k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4365| 38.9k|} 4366| 38.9k|#line 4367 "bison_parser.cpp" /* yacc.c:1646 */ 4367| 38.9k| break; 4368| | 4369| 549| case 141: ------------------ | Branch (4369:3): [True: 549, False: 11.1M] ------------------ 4370| 549|#line 992 "bison_parser.y" /* yacc.c:1646 */ 4371| 549| { (yyval.bval) = true; } 4372| 549|#line 4373 "bison_parser.cpp" /* yacc.c:1646 */ 4373| 549| break; 4374| | 4375| 44.6k| case 142: ------------------ | Branch (4375:3): [True: 44.6k, False: 11.0M] ------------------ 4376| 44.6k|#line 993 "bison_parser.y" /* yacc.c:1646 */ 4377| 44.6k| { (yyval.bval) = false; } 4378| 44.6k|#line 4379 "bison_parser.cpp" /* yacc.c:1646 */ 4379| 44.6k| break; 4380| | 4381| 2.84k| case 144: ------------------ | Branch (4381:3): [True: 2.84k, False: 11.1M] ------------------ 4382| 2.84k|#line 997 "bison_parser.y" /* yacc.c:1646 */ 4383| 2.84k| { (yyval.table) = (yyvsp[0].table); } 4384| 2.84k|#line 4385 "bison_parser.cpp" /* yacc.c:1646 */ 4385| 2.84k| break; 4386| | 4387| 36.2k| case 145: ------------------ | Branch (4387:3): [True: 36.2k, False: 11.0M] ------------------ 4388| 36.2k|#line 998 "bison_parser.y" /* yacc.c:1646 */ 4389| 36.2k| { (yyval.table) = nullptr; } 4390| 36.2k|#line 4391 "bison_parser.cpp" /* yacc.c:1646 */ 4391| 36.2k| break; 4392| | 4393| 2.84k| case 146: ------------------ | Branch (4393:3): [True: 2.84k, False: 11.1M] ------------------ 4394| 2.84k|#line 1000 "bison_parser.y" /* yacc.c:1646 */ 4395| 2.84k| { (yyval.table) = (yyvsp[0].table); } 4396| 2.84k|#line 4397 "bison_parser.cpp" /* yacc.c:1646 */ 4397| 2.84k| break; 4398| | 4399| 3.22k| case 147: ------------------ | Branch (4399:3): [True: 3.22k, False: 11.1M] ------------------ 4400| 3.22k|#line 1002 "bison_parser.y" /* yacc.c:1646 */ 4401| 3.22k| { (yyval.expr) = (yyvsp[0].expr); } 4402| 3.22k|#line 4403 "bison_parser.cpp" /* yacc.c:1646 */ 4403| 3.22k| break; 4404| | 4405| 45.6k| case 148: ------------------ | Branch (4405:3): [True: 45.6k, False: 11.0M] ------------------ 4406| 45.6k|#line 1003 "bison_parser.y" /* yacc.c:1646 */ 4407| 45.6k| { (yyval.expr) = nullptr; } 4408| 45.6k|#line 4409 "bison_parser.cpp" /* yacc.c:1646 */ 4409| 45.6k| break; 4410| | 4411| 3.04k| case 149: ------------------ | Branch (4411:3): [True: 3.04k, False: 11.1M] ------------------ 4412| 3.04k|#line 1005 "bison_parser.y" /* yacc.c:1646 */ 4413| 3.04k| { 4414| 3.04k| (yyval.group_t) = new GroupByDescription(); 4415| 3.04k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4416| 3.04k| (yyval.group_t)->having = (yyvsp[0].expr); 4417| 3.04k|} 4418| 3.04k|#line 4419 "bison_parser.cpp" /* yacc.c:1646 */ 4419| 3.04k| break; 4420| | 4421| 35.8k| case 150: ------------------ | Branch (4421:3): [True: 35.8k, False: 11.0M] ------------------ 4422| 35.8k|#line 1010 "bison_parser.y" /* yacc.c:1646 */ 4423| 35.8k| { (yyval.group_t) = nullptr; } 4424| 35.8k|#line 4425 "bison_parser.cpp" /* yacc.c:1646 */ 4425| 35.8k| break; 4426| | 4427| 667| case 151: ------------------ | Branch (4427:3): [True: 667, False: 11.1M] ------------------ 4428| 667|#line 1012 "bison_parser.y" /* yacc.c:1646 */ 4429| 667| { (yyval.expr) = (yyvsp[0].expr); } 4430| 667|#line 4431 "bison_parser.cpp" /* yacc.c:1646 */ 4431| 667| break; 4432| | 4433| 2.38k| case 152: ------------------ | Branch (4433:3): [True: 2.38k, False: 11.1M] ------------------ 4434| 2.38k|#line 1013 "bison_parser.y" /* yacc.c:1646 */ 4435| 2.38k| { (yyval.expr) = nullptr; } 4436| 2.38k|#line 4437 "bison_parser.cpp" /* yacc.c:1646 */ 4437| 2.38k| break; 4438| | 4439| 2.59k| case 153: ------------------ | Branch (4439:3): [True: 2.59k, False: 11.1M] ------------------ 4440| 2.59k|#line 1015 "bison_parser.y" /* yacc.c:1646 */ 4441| 2.59k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4442| 2.59k|#line 4443 "bison_parser.cpp" /* yacc.c:1646 */ 4443| 2.59k| break; 4444| | 4445| 35.6k| case 154: ------------------ | Branch (4445:3): [True: 35.6k, False: 11.0M] ------------------ 4446| 35.6k|#line 1016 "bison_parser.y" /* yacc.c:1646 */ 4447| 35.6k| { (yyval.order_vec) = nullptr; } 4448| 35.6k|#line 4449 "bison_parser.cpp" /* yacc.c:1646 */ 4449| 35.6k| break; 4450| | 4451| 2.74k| case 155: ------------------ | Branch (4451:3): [True: 2.74k, False: 11.1M] ------------------ 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.52k| case 156: ------------------ | Branch (4460:3): [True: 5.52k, False: 11.1M] ------------------ 4461| 5.52k|#line 1022 "bison_parser.y" /* yacc.c:1646 */ 4462| 5.52k| { 4463| 5.52k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4464| 5.52k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4465| 5.52k|} 4466| 5.52k|#line 4467 "bison_parser.cpp" /* yacc.c:1646 */ 4467| 5.52k| break; 4468| | 4469| 8.26k| case 157: ------------------ | Branch (4469:3): [True: 8.26k, False: 11.1M] ------------------ 4470| 8.26k|#line 1027 "bison_parser.y" /* yacc.c:1646 */ 4471| 8.26k| { (yyval.order) = new OrderDescription((yyvsp[-1].order_type), (yyvsp[-2].expr), (yyvsp[0].null_ordering_t)); } 4472| 8.26k|#line 4473 "bison_parser.cpp" /* yacc.c:1646 */ 4473| 8.26k| break; 4474| | 4475| 579| case 158: ------------------ | Branch (4475:3): [True: 579, False: 11.1M] ------------------ 4476| 579|#line 1029 "bison_parser.y" /* yacc.c:1646 */ 4477| 579| { (yyval.order_type) = kOrderAsc; } 4478| 579|#line 4479 "bison_parser.cpp" /* yacc.c:1646 */ 4479| 579| break; 4480| | 4481| 625| case 159: ------------------ | Branch (4481:3): [True: 625, False: 11.1M] ------------------ 4482| 625|#line 1030 "bison_parser.y" /* yacc.c:1646 */ 4483| 625| { (yyval.order_type) = kOrderDesc; } 4484| 625|#line 4485 "bison_parser.cpp" /* yacc.c:1646 */ 4485| 625| break; 4486| | 4487| 7.18k| case 160: ------------------ | Branch (4487:3): [True: 7.18k, False: 11.1M] ------------------ 4488| 7.18k|#line 1031 "bison_parser.y" /* yacc.c:1646 */ 4489| 7.18k| { (yyval.order_type) = kOrderAsc; } 4490| 7.18k|#line 4491 "bison_parser.cpp" /* yacc.c:1646 */ 4491| 7.18k| break; 4492| | 4493| 7.95k| case 161: ------------------ | Branch (4493:3): [True: 7.95k, False: 11.1M] ------------------ 4494| 7.95k|#line 1033 "bison_parser.y" /* yacc.c:1646 */ 4495| 7.95k| { (yyval.null_ordering_t) = NullOrdering::Undefined; } 4496| 7.95k|#line 4497 "bison_parser.cpp" /* yacc.c:1646 */ 4497| 7.95k| break; 4498| | 4499| 424| case 162: ------------------ | Branch (4499:3): [True: 424, False: 11.1M] ------------------ 4500| 424|#line 1034 "bison_parser.y" /* yacc.c:1646 */ 4501| 424| { 4502| 424| auto null_ordering = NullOrdering::Undefined; 4503| 424| if (strcasecmp((yyvsp[-1].sval), "nulls") == 0) { ------------------ | Branch (4503:7): [True: 381, False: 43] ------------------ 4504| 381| if (strcasecmp((yyvsp[0].sval), "first") == 0) { ------------------ | Branch (4504:9): [True: 202, False: 179] ------------------ 4505| 202| null_ordering = NullOrdering::First; 4506| 202| } else if (strcasecmp((yyvsp[0].sval), "last") == 0) { ------------------ | Branch (4506:16): [True: 112, False: 67] ------------------ 4507| 112| null_ordering = NullOrdering::Last; 4508| 112| } 4509| 381| } 4510| 424| free((yyvsp[-1].sval)); 4511| 424| free((yyvsp[0].sval)); 4512| | 4513| 424| if (null_ordering == NullOrdering::Undefined) { ------------------ | Branch (4513:7): [True: 110, False: 314] ------------------ 4514| 110| yyerror(&yyloc, result, scanner, "Expected NULLS FIRST or NULLS LAST ordering."); ------------------ | | 67| 110|#define yyerror hsql_error ------------------ 4515| 110| YYERROR; ------------------ | | 1458| 110|#define YYERROR goto yyerrorlab ------------------ 4516| 110| } 4517| | 4518| 314| (yyval.null_ordering_t) = null_ordering; 4519| 314|} 4520| 0|#line 4521 "bison_parser.cpp" /* yacc.c:1646 */ 4521| 0| break; 4522| | 4523| 3.05k| case 163: ------------------ | Branch (4523:3): [True: 3.05k, False: 11.1M] ------------------ 4524| 3.05k|#line 1056 "bison_parser.y" /* yacc.c:1646 */ 4525| 3.05k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4526| 3.05k|#line 4527 "bison_parser.cpp" /* yacc.c:1646 */ 4527| 3.05k| break; 4528| | 4529| 37.9k| case 164: ------------------ | Branch (4529:3): [True: 37.9k, False: 11.0M] ------------------ 4530| 37.9k|#line 1057 "bison_parser.y" /* yacc.c:1646 */ 4531| 37.9k| { (yyval.limit) = nullptr; } 4532| 37.9k|#line 4533 "bison_parser.cpp" /* yacc.c:1646 */ 4533| 37.9k| break; 4534| | 4535| 1.53k| case 165: ------------------ | Branch (4535:3): [True: 1.53k, False: 11.1M] ------------------ 4536| 1.53k|#line 1059 "bison_parser.y" /* yacc.c:1646 */ 4537| 1.53k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4538| 1.53k|#line 4539 "bison_parser.cpp" /* yacc.c:1646 */ 4539| 1.53k| break; 4540| | 4541| 1.64k| case 166: ------------------ | Branch (4541:3): [True: 1.64k, False: 11.1M] ------------------ 4542| 1.64k|#line 1060 "bison_parser.y" /* yacc.c:1646 */ 4543| 1.64k| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4544| 1.64k|#line 4545 "bison_parser.cpp" /* yacc.c:1646 */ 4545| 1.64k| break; 4546| | 4547| 400| case 167: ------------------ | Branch (4547:3): [True: 400, False: 11.1M] ------------------ 4548| 400|#line 1061 "bison_parser.y" /* yacc.c:1646 */ 4549| 400| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4550| 400|#line 4551 "bison_parser.cpp" /* yacc.c:1646 */ 4551| 400| break; 4552| | 4553| 1.50k| case 168: ------------------ | Branch (4553:3): [True: 1.50k, False: 11.1M] ------------------ 4554| 1.50k|#line 1062 "bison_parser.y" /* yacc.c:1646 */ 4555| 1.50k| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4556| 1.50k|#line 4557 "bison_parser.cpp" /* yacc.c:1646 */ 4557| 1.50k| break; 4558| | 4559| 342| case 169: ------------------ | Branch (4559:3): [True: 342, False: 11.1M] ------------------ 4560| 342|#line 1063 "bison_parser.y" /* yacc.c:1646 */ 4561| 342| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4562| 342|#line 4563 "bison_parser.cpp" /* yacc.c:1646 */ 4563| 342| break; 4564| | 4565| 27.6k| case 170: ------------------ | Branch (4565:3): [True: 27.6k, False: 11.0M] ------------------ 4566| 27.6k|#line 1064 "bison_parser.y" /* yacc.c:1646 */ 4567| 27.6k| { (yyval.limit) = nullptr; } 4568| 27.6k|#line 4569 "bison_parser.cpp" /* yacc.c:1646 */ 4569| 27.6k| break; 4570| | 4571| 47.8k| case 171: ------------------ | Branch (4571:3): [True: 47.8k, False: 11.0M] ------------------ 4572| 47.8k|#line 1069 "bison_parser.y" /* yacc.c:1646 */ 4573| 47.8k| { 4574| 47.8k| (yyval.expr_vec) = new std::vector(); 4575| 47.8k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4576| 47.8k|} 4577| 47.8k|#line 4578 "bison_parser.cpp" /* yacc.c:1646 */ 4578| 47.8k| break; 4579| | 4580| 293k| case 172: ------------------ | Branch (4580:3): [True: 293k, False: 10.8M] ------------------ 4581| 293k|#line 1073 "bison_parser.y" /* yacc.c:1646 */ 4582| 293k| { 4583| 293k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4584| 293k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4585| 293k|} 4586| 293k|#line 4587 "bison_parser.cpp" /* yacc.c:1646 */ 4587| 293k| break; 4588| | 4589| 259| case 173: ------------------ | Branch (4589:3): [True: 259, False: 11.1M] ------------------ 4590| 259|#line 1079 "bison_parser.y" /* yacc.c:1646 */ 4591| 259| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4592| 259|#line 4593 "bison_parser.cpp" /* yacc.c:1646 */ 4593| 259| break; 4594| | 4595| 283| case 174: ------------------ | Branch (4595:3): [True: 283, False: 11.1M] ------------------ 4596| 283|#line 1080 "bison_parser.y" /* yacc.c:1646 */ 4597| 283| { (yyval.expr_vec) = nullptr; } 4598| 283|#line 4599 "bison_parser.cpp" /* yacc.c:1646 */ 4599| 283| break; 4600| | 4601| 1.24k| case 175: ------------------ | Branch (4601:3): [True: 1.24k, False: 11.1M] ------------------ 4602| 1.24k|#line 1082 "bison_parser.y" /* yacc.c:1646 */ 4603| 1.24k| { 4604| 1.24k| (yyval.expr_vec) = new std::vector(); 4605| 1.24k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4606| 1.24k|} 4607| 1.24k|#line 4608 "bison_parser.cpp" /* yacc.c:1646 */ 4608| 1.24k| break; 4609| | 4610| 3.06k| case 176: ------------------ | Branch (4610:3): [True: 3.06k, False: 11.1M] ------------------ 4611| 3.06k|#line 1086 "bison_parser.y" /* yacc.c:1646 */ 4612| 3.06k| { 4613| 3.06k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4614| 3.06k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4615| 3.06k|} 4616| 3.06k|#line 4617 "bison_parser.cpp" /* yacc.c:1646 */ 4617| 3.06k| break; 4618| | 4619| 364| case 178: ------------------ | Branch (4619:3): [True: 364, False: 11.1M] ------------------ 4620| 364|#line 1091 "bison_parser.y" /* yacc.c:1646 */ 4621| 364| { 4622| 364| (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); 4623| 364|} 4624| 364|#line 4625 "bison_parser.cpp" /* yacc.c:1646 */ 4625| 364| break; 4626| | 4627| 3.66k| case 179: ------------------ | Branch (4627:3): [True: 3.66k, False: 11.1M] ------------------ 4628| 3.66k|#line 1095 "bison_parser.y" /* yacc.c:1646 */ 4629| 3.66k| { 4630| 3.66k| if ((yyvsp[0].expr)->type == ExprType::kExprParameter) { ------------------ | Branch (4630:7): [True: 2, False: 3.66k] ------------------ 4631| 2| delete (yyvsp[0].expr); 4632| 2| yyerror(&yyloc, result, scanner, "Parameter ? is not a valid literal."); ------------------ | | 67| 2|#define yyerror hsql_error ------------------ 4633| 2| YYERROR; ------------------ | | 1458| 2|#define YYERROR goto yyerrorlab ------------------ 4634| 2| } 4635| 3.66k| (yyval.expr) = (yyvsp[0].expr); 4636| 3.66k|} 4637| 0|#line 4638 "bison_parser.cpp" /* yacc.c:1646 */ 4638| 0| break; 4639| | 4640| 424| case 180: ------------------ | Branch (4640:3): [True: 424, False: 11.1M] ------------------ 4641| 424|#line 1103 "bison_parser.y" /* yacc.c:1646 */ 4642| 424| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4643| 424|#line 4644 "bison_parser.cpp" /* yacc.c:1646 */ 4644| 424| break; 4645| | 4646| 218| case 181: ------------------ | Branch (4646:3): [True: 218, False: 11.1M] ------------------ 4647| 218|#line 1104 "bison_parser.y" /* yacc.c:1646 */ 4648| 218| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4649| 218|#line 4650 "bison_parser.cpp" /* yacc.c:1646 */ 4650| 218| break; 4651| | 4652| 341k| case 182: ------------------ | Branch (4652:3): [True: 341k, False: 10.7M] ------------------ 4653| 341k|#line 1106 "bison_parser.y" /* yacc.c:1646 */ 4654| 341k| { 4655| 341k| (yyval.expr) = (yyvsp[-1].expr); 4656| 341k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4656:7): [True: 12.9k, False: 328k] ------------------ 4657| 12.9k| (yyval.expr)->alias = (yyvsp[0].alias_t)->name; 4658| 12.9k| (yyvsp[0].alias_t)->name = nullptr; 4659| 12.9k| delete (yyvsp[0].alias_t); 4660| 12.9k| } 4661| 341k|} 4662| 341k|#line 4663 "bison_parser.cpp" /* yacc.c:1646 */ 4663| 341k| break; 4664| | 4665| 904| case 188: ------------------ | Branch (4665:3): [True: 904, False: 11.1M] ------------------ 4666| 904|#line 1117 "bison_parser.y" /* yacc.c:1646 */ 4667| 904| { (yyval.expr) = (yyvsp[-1].expr); } 4668| 904|#line 4669 "bison_parser.cpp" /* yacc.c:1646 */ 4669| 904| break; 4670| | 4671| 1.08k| case 198: ------------------ | Branch (4671:3): [True: 1.08k, False: 11.1M] ------------------ 4672| 1.08k|#line 1119 "bison_parser.y" /* yacc.c:1646 */ 4673| 1.08k| { 4674| 1.08k| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4675| 1.08k|} 4676| 1.08k|#line 4677 "bison_parser.cpp" /* yacc.c:1646 */ 4677| 1.08k| break; 4678| | 4679| 7.06k| case 201: ------------------ | Branch (4679:3): [True: 7.06k, False: 11.1M] ------------------ 4680| 7.06k|#line 1125 "bison_parser.y" /* yacc.c:1646 */ 4681| 7.06k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4682| 7.06k|#line 4683 "bison_parser.cpp" /* yacc.c:1646 */ 4683| 7.06k| break; 4684| | 4685| 1.75k| case 202: ------------------ | Branch (4685:3): [True: 1.75k, False: 11.1M] ------------------ 4686| 1.75k|#line 1126 "bison_parser.y" /* yacc.c:1646 */ 4687| 1.75k| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4688| 1.75k|#line 4689 "bison_parser.cpp" /* yacc.c:1646 */ 4689| 1.75k| break; 4690| | 4691| 556| case 203: ------------------ | Branch (4691:3): [True: 556, False: 11.1M] ------------------ 4692| 556|#line 1127 "bison_parser.y" /* yacc.c:1646 */ 4693| 556| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } 4694| 556|#line 4695 "bison_parser.cpp" /* yacc.c:1646 */ 4695| 556| break; 4696| | 4697| 437| case 204: ------------------ | Branch (4697:3): [True: 437, False: 11.1M] ------------------ 4698| 437|#line 1128 "bison_parser.y" /* yacc.c:1646 */ 4699| 437| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } 4700| 437|#line 4701 "bison_parser.cpp" /* yacc.c:1646 */ 4701| 437| break; 4702| | 4703| 66| case 205: ------------------ | Branch (4703:3): [True: 66, False: 11.1M] ------------------ 4704| 66|#line 1129 "bison_parser.y" /* yacc.c:1646 */ 4705| 66| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } 4706| 66|#line 4707 "bison_parser.cpp" /* yacc.c:1646 */ 4707| 66| break; 4708| | 4709| 18.5k| case 207: ------------------ | Branch (4709:3): [True: 18.5k, False: 11.0M] ------------------ 4710| 18.5k|#line 1131 "bison_parser.y" /* yacc.c:1646 */ 4711| 18.5k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4712| 18.5k|#line 4713 "bison_parser.cpp" /* yacc.c:1646 */ 4713| 18.5k| break; 4714| | 4715| 4.82k| case 208: ------------------ | Branch (4715:3): [True: 4.82k, False: 11.1M] ------------------ 4716| 4.82k|#line 1132 "bison_parser.y" /* yacc.c:1646 */ 4717| 4.82k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4718| 4.82k|#line 4719 "bison_parser.cpp" /* yacc.c:1646 */ 4719| 4.82k| break; 4720| | 4721| 164k| case 209: ------------------ | Branch (4721:3): [True: 164k, False: 10.9M] ------------------ 4722| 164k|#line 1133 "bison_parser.y" /* yacc.c:1646 */ 4723| 164k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4724| 164k|#line 4725 "bison_parser.cpp" /* yacc.c:1646 */ 4725| 164k| break; 4726| | 4727| 780k| case 210: ------------------ | Branch (4727:3): [True: 780k, False: 10.3M] ------------------ 4728| 780k|#line 1134 "bison_parser.y" /* yacc.c:1646 */ 4729| 780k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4730| 780k|#line 4731 "bison_parser.cpp" /* yacc.c:1646 */ 4731| 780k| break; 4732| | 4733| 6.26k| case 211: ------------------ | Branch (4733:3): [True: 6.26k, False: 11.1M] ------------------ 4734| 6.26k|#line 1135 "bison_parser.y" /* yacc.c:1646 */ 4735| 6.26k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4736| 6.26k|#line 4737 "bison_parser.cpp" /* yacc.c:1646 */ 4737| 6.26k| break; 4738| | 4739| 4.98k| case 212: ------------------ | Branch (4739:3): [True: 4.98k, False: 11.1M] ------------------ 4740| 4.98k|#line 1136 "bison_parser.y" /* yacc.c:1646 */ 4741| 4.98k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4742| 4.98k|#line 4743 "bison_parser.cpp" /* yacc.c:1646 */ 4743| 4.98k| break; 4744| | 4745| 510| case 213: ------------------ | Branch (4745:3): [True: 510, False: 11.1M] ------------------ 4746| 510|#line 1137 "bison_parser.y" /* yacc.c:1646 */ 4747| 510| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4748| 510|#line 4749 "bison_parser.cpp" /* yacc.c:1646 */ 4749| 510| break; 4750| | 4751| 205| case 214: ------------------ | Branch (4751:3): [True: 205, False: 11.1M] ------------------ 4752| 205|#line 1138 "bison_parser.y" /* yacc.c:1646 */ 4753| 205| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4754| 205|#line 4755 "bison_parser.cpp" /* yacc.c:1646 */ 4755| 205| break; 4756| | 4757| 640| case 215: ------------------ | Branch (4757:3): [True: 640, False: 11.1M] ------------------ 4758| 640|#line 1139 "bison_parser.y" /* yacc.c:1646 */ 4759| 640| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4760| 640|#line 4761 "bison_parser.cpp" /* yacc.c:1646 */ 4761| 640| break; 4762| | 4763| 1.87k| case 216: ------------------ | Branch (4763:3): [True: 1.87k, False: 11.1M] ------------------ 4764| 1.87k|#line 1140 "bison_parser.y" /* yacc.c:1646 */ 4765| 1.87k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4766| 1.87k|#line 4767 "bison_parser.cpp" /* yacc.c:1646 */ 4767| 1.87k| break; 4768| | 4769| 741| case 217: ------------------ | Branch (4769:3): [True: 741, False: 11.1M] ------------------ 4770| 741|#line 1142 "bison_parser.y" /* yacc.c:1646 */ 4771| 741| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4772| 741|#line 4773 "bison_parser.cpp" /* yacc.c:1646 */ 4773| 741| break; 4774| | 4775| 558| case 218: ------------------ | Branch (4775:3): [True: 558, False: 11.1M] ------------------ 4776| 558|#line 1143 "bison_parser.y" /* yacc.c:1646 */ 4777| 558| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } 4778| 558|#line 4779 "bison_parser.cpp" /* yacc.c:1646 */ 4779| 558| break; 4780| | 4781| 386| case 219: ------------------ | Branch (4781:3): [True: 386, False: 11.1M] ------------------ 4782| 386|#line 1145 "bison_parser.y" /* yacc.c:1646 */ 4783| 386| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4784| 386|#line 4785 "bison_parser.cpp" /* yacc.c:1646 */ 4785| 386| break; 4786| | 4787| 216| case 220: ------------------ | Branch (4787:3): [True: 216, False: 11.1M] ------------------ 4788| 216|#line 1146 "bison_parser.y" /* yacc.c:1646 */ 4789| 216| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4790| 216|#line 4791 "bison_parser.cpp" /* yacc.c:1646 */ 4791| 216| break; 4792| | 4793| 274| case 221: ------------------ | Branch (4793:3): [True: 274, False: 11.1M] ------------------ 4794| 274|#line 1147 "bison_parser.y" /* yacc.c:1646 */ 4795| 274| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4796| 274|#line 4797 "bison_parser.cpp" /* yacc.c:1646 */ 4797| 274| break; 4798| | 4799| 197| case 222: ------------------ | Branch (4799:3): [True: 197, False: 11.1M] ------------------ 4800| 197|#line 1148 "bison_parser.y" /* yacc.c:1646 */ 4801| 197| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4802| 197|#line 4803 "bison_parser.cpp" /* yacc.c:1646 */ 4803| 197| break; 4804| | 4805| 305| case 223: ------------------ | Branch (4805:3): [True: 305, False: 11.1M] ------------------ 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| 334| case 224: ------------------ | Branch (4811:3): [True: 334, False: 11.1M] ------------------ 4812| 334|#line 1153 "bison_parser.y" /* yacc.c:1646 */ 4813| 334| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4814| 334|#line 4815 "bison_parser.cpp" /* yacc.c:1646 */ 4815| 334| break; 4816| | 4817| 689| case 225: ------------------ | Branch (4817:3): [True: 689, False: 11.1M] ------------------ 4818| 689|#line 1154 "bison_parser.y" /* yacc.c:1646 */ 4819| 689| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4820| 689|#line 4821 "bison_parser.cpp" /* yacc.c:1646 */ 4821| 689| break; 4822| | 4823| 318| case 226: ------------------ | Branch (4823:3): [True: 318, False: 11.1M] ------------------ 4824| 318|#line 1155 "bison_parser.y" /* yacc.c:1646 */ 4825| 318| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4826| 318|#line 4827 "bison_parser.cpp" /* yacc.c:1646 */ 4827| 318| break; 4828| | 4829| 1.85k| case 227: ------------------ | Branch (4829:3): [True: 1.85k, False: 11.1M] ------------------ 4830| 1.85k|#line 1157 "bison_parser.y" /* yacc.c:1646 */ 4831| 1.85k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4832| 1.85k|#line 4833 "bison_parser.cpp" /* yacc.c:1646 */ 4833| 1.85k| break; 4834| | 4835| 1.77k| case 228: ------------------ | Branch (4835:3): [True: 1.77k, False: 11.1M] ------------------ 4836| 1.77k|#line 1158 "bison_parser.y" /* yacc.c:1646 */ 4837| 1.77k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4838| 1.77k|#line 4839 "bison_parser.cpp" /* yacc.c:1646 */ 4839| 1.77k| break; 4840| | 4841| 421| case 229: ------------------ | Branch (4841:3): [True: 421, False: 11.1M] ------------------ 4842| 421|#line 1160 "bison_parser.y" /* yacc.c:1646 */ 4843| 421| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4844| 421|#line 4845 "bison_parser.cpp" /* yacc.c:1646 */ 4845| 421| break; 4846| | 4847| 211| case 230: ------------------ | Branch (4847:3): [True: 211, False: 11.1M] ------------------ 4848| 211|#line 1161 "bison_parser.y" /* yacc.c:1646 */ 4849| 211| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4850| 211|#line 4851 "bison_parser.cpp" /* yacc.c:1646 */ 4851| 211| break; 4852| | 4853| 2.00k| case 231: ------------------ | Branch (4853:3): [True: 2.00k, False: 11.1M] ------------------ 4854| 2.00k|#line 1163 "bison_parser.y" /* yacc.c:1646 */ 4855| 2.00k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4856| 2.00k|#line 4857 "bison_parser.cpp" /* yacc.c:1646 */ 4857| 2.00k| break; 4858| | 4859| 846| case 232: ------------------ | Branch (4859:3): [True: 846, False: 11.1M] ------------------ 4860| 846|#line 1164 "bison_parser.y" /* yacc.c:1646 */ 4861| 846| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4862| 846|#line 4863 "bison_parser.cpp" /* yacc.c:1646 */ 4863| 846| break; 4864| | 4865| 1.23k| case 233: ------------------ | Branch (4865:3): [True: 1.23k, False: 11.1M] ------------------ 4866| 1.23k|#line 1165 "bison_parser.y" /* yacc.c:1646 */ 4867| 1.23k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4868| 1.23k|#line 4869 "bison_parser.cpp" /* yacc.c:1646 */ 4869| 1.23k| break; 4870| | 4871| 1.81k| case 234: ------------------ | Branch (4871:3): [True: 1.81k, False: 11.1M] ------------------ 4872| 1.81k|#line 1166 "bison_parser.y" /* yacc.c:1646 */ 4873| 1.81k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4874| 1.81k|#line 4875 "bison_parser.cpp" /* yacc.c:1646 */ 4875| 1.81k| break; 4876| | 4877| 4.47k| case 235: ------------------ | Branch (4877:3): [True: 4.47k, False: 11.1M] ------------------ 4878| 4.47k|#line 1167 "bison_parser.y" /* yacc.c:1646 */ 4879| 4.47k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4880| 4.47k|#line 4881 "bison_parser.cpp" /* yacc.c:1646 */ 4881| 4.47k| break; 4882| | 4883| 425| case 236: ------------------ | Branch (4883:3): [True: 425, False: 11.1M] ------------------ 4884| 425|#line 1168 "bison_parser.y" /* yacc.c:1646 */ 4885| 425| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4886| 425|#line 4887 "bison_parser.cpp" /* yacc.c:1646 */ 4887| 425| break; 4888| | 4889| 652| case 237: ------------------ | Branch (4889:3): [True: 652, False: 11.1M] ------------------ 4890| 652|#line 1169 "bison_parser.y" /* yacc.c:1646 */ 4891| 652| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4892| 652|#line 4893 "bison_parser.cpp" /* yacc.c:1646 */ 4893| 652| break; 4894| | 4895| 3.88k| case 238: ------------------ | Branch (4895:3): [True: 3.88k, False: 11.1M] ------------------ 4896| 3.88k|#line 1173 "bison_parser.y" /* yacc.c:1646 */ 4897| 3.88k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4898| 3.88k|#line 4899 "bison_parser.cpp" /* yacc.c:1646 */ 4899| 3.88k| break; 4900| | 4901| 2.70k| case 239: ------------------ | Branch (4901:3): [True: 2.70k, False: 11.1M] ------------------ 4902| 2.70k|#line 1174 "bison_parser.y" /* yacc.c:1646 */ 4903| 2.70k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4904| 2.70k|#line 4905 "bison_parser.cpp" /* yacc.c:1646 */ 4905| 2.70k| break; 4906| | 4907| 213| case 240: ------------------ | Branch (4907:3): [True: 213, False: 11.1M] ------------------ 4908| 213|#line 1175 "bison_parser.y" /* yacc.c:1646 */ 4909| 213| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), (yyvsp[-5].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4910| 213|#line 4911 "bison_parser.cpp" /* yacc.c:1646 */ 4911| 213| break; 4912| | 4913| 197| case 241: ------------------ | Branch (4913:3): [True: 197, False: 11.1M] ------------------ 4914| 197|#line 1176 "bison_parser.y" /* yacc.c:1646 */ 4915| 197| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-7].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4916| 197|#line 4917 "bison_parser.cpp" /* yacc.c:1646 */ 4917| 197| break; 4918| | 4919| 4.75k| case 242: ------------------ | Branch (4919:3): [True: 4.75k, False: 11.1M] ------------------ 4920| 4.75k|#line 1180 "bison_parser.y" /* yacc.c:1646 */ 4921| 4.75k| { (yyval.window_description) = new WindowDescription((yyvsp[-3].expr_vec), (yyvsp[-2].order_vec), (yyvsp[-1].frame_description)); } 4922| 4.75k|#line 4923 "bison_parser.cpp" /* yacc.c:1646 */ 4923| 4.75k| break; 4924| | 4925| 2.25k| case 243: ------------------ | Branch (4925:3): [True: 2.25k, False: 11.1M] ------------------ 4926| 2.25k|#line 1181 "bison_parser.y" /* yacc.c:1646 */ 4927| 2.25k| { (yyval.window_description) = nullptr; } 4928| 2.25k|#line 4929 "bison_parser.cpp" /* yacc.c:1646 */ 4929| 2.25k| break; 4930| | 4931| 724| case 244: ------------------ | Branch (4931:3): [True: 724, False: 11.1M] ------------------ 4932| 724|#line 1183 "bison_parser.y" /* yacc.c:1646 */ 4933| 724| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4934| 724|#line 4935 "bison_parser.cpp" /* yacc.c:1646 */ 4935| 724| break; 4936| | 4937| 4.23k| case 245: ------------------ | Branch (4937:3): [True: 4.23k, False: 11.1M] ------------------ 4938| 4.23k|#line 1184 "bison_parser.y" /* yacc.c:1646 */ 4939| 4.23k| { (yyval.expr_vec) = nullptr; } 4940| 4.23k|#line 4941 "bison_parser.cpp" /* yacc.c:1646 */ 4941| 4.23k| break; 4942| | 4943| 2.64k| case 246: ------------------ | Branch (4943:3): [True: 2.64k, False: 11.1M] ------------------ 4944| 2.64k|#line 1189 "bison_parser.y" /* yacc.c:1646 */ 4945| 2.64k| { (yyval.frame_description) = new FrameDescription{(yyvsp[-1].frame_type), (yyvsp[0].frame_bound), new FrameBound{0, kCurrentRow, false}}; } 4946| 2.64k|#line 4947 "bison_parser.cpp" /* yacc.c:1646 */ 4947| 2.64k| break; 4948| | 4949| 194| case 247: ------------------ | Branch (4949:3): [True: 194, False: 11.1M] ------------------ 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| 1.97k| case 248: ------------------ | Branch (4955:3): [True: 1.97k, False: 11.1M] ------------------ 4956| 1.97k|#line 1191 "bison_parser.y" /* yacc.c:1646 */ 4957| 1.97k| { 4958| 1.97k| (yyval.frame_description) = new FrameDescription{kRange, new FrameBound{0, kPreceding, true}, new FrameBound{0, kCurrentRow, false}}; 4959| 1.97k|} 4960| 1.97k|#line 4961 "bison_parser.cpp" /* yacc.c:1646 */ 4961| 1.97k| break; 4962| | 4963| 1.10k| case 249: ------------------ | Branch (4963:3): [True: 1.10k, False: 11.1M] ------------------ 4964| 1.10k|#line 1195 "bison_parser.y" /* yacc.c:1646 */ 4965| 1.10k| { (yyval.frame_type) = kRange; } 4966| 1.10k|#line 4967 "bison_parser.cpp" /* yacc.c:1646 */ 4967| 1.10k| break; 4968| | 4969| 1.27k| case 250: ------------------ | Branch (4969:3): [True: 1.27k, False: 11.1M] ------------------ 4970| 1.27k|#line 1196 "bison_parser.y" /* yacc.c:1646 */ 4971| 1.27k| { (yyval.frame_type) = kRows; } 4972| 1.27k|#line 4973 "bison_parser.cpp" /* yacc.c:1646 */ 4973| 1.27k| break; 4974| | 4975| 495| case 251: ------------------ | Branch (4975:3): [True: 495, False: 11.1M] ------------------ 4976| 495|#line 1197 "bison_parser.y" /* yacc.c:1646 */ 4977| 495| { (yyval.frame_type) = kGroups; } 4978| 495|#line 4979 "bison_parser.cpp" /* yacc.c:1646 */ 4979| 495| break; 4980| | 4981| 568| case 252: ------------------ | Branch (4981:3): [True: 568, False: 11.1M] ------------------ 4982| 568|#line 1199 "bison_parser.y" /* yacc.c:1646 */ 4983| 568| { (yyval.frame_bound) = new FrameBound{0, kPreceding, true}; } 4984| 568|#line 4985 "bison_parser.cpp" /* yacc.c:1646 */ 4985| 568| break; 4986| | 4987| 573| case 253: ------------------ | Branch (4987:3): [True: 573, False: 11.1M] ------------------ 4988| 573|#line 1200 "bison_parser.y" /* yacc.c:1646 */ 4989| 573| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kPreceding, false}; } 4990| 573|#line 4991 "bison_parser.cpp" /* yacc.c:1646 */ 4991| 573| break; 4992| | 4993| 238| case 254: ------------------ | Branch (4993:3): [True: 238, False: 11.1M] ------------------ 4994| 238|#line 1201 "bison_parser.y" /* yacc.c:1646 */ 4995| 238| { (yyval.frame_bound) = new FrameBound{0, kFollowing, true}; } 4996| 238|#line 4997 "bison_parser.cpp" /* yacc.c:1646 */ 4997| 238| break; 4998| | 4999| 1.65k| case 255: ------------------ | Branch (4999:3): [True: 1.65k, False: 11.1M] ------------------ 5000| 1.65k|#line 1202 "bison_parser.y" /* yacc.c:1646 */ 5001| 1.65k| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kFollowing, false}; } 5002| 1.65k|#line 5003 "bison_parser.cpp" /* yacc.c:1646 */ 5003| 1.65k| break; 5004| | 5005| 0| case 256: ------------------ | Branch (5005:3): [True: 0, False: 11.1M] ------------------ 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| 581| case 257: ------------------ | Branch (5011:3): [True: 581, False: 11.1M] ------------------ 5012| 581|#line 1205 "bison_parser.y" /* yacc.c:1646 */ 5013| 581| { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } 5014| 581|#line 5015 "bison_parser.cpp" /* yacc.c:1646 */ 5015| 581| break; 5016| | 5017| 71| case 258: ------------------ | Branch (5017:3): [True: 71, False: 11.1M] ------------------ 5018| 71|#line 1207 "bison_parser.y" /* yacc.c:1646 */ 5019| 71| { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } 5020| 71|#line 5021 "bison_parser.cpp" /* yacc.c:1646 */ 5021| 71| break; 5022| | 5023| 735| case 259: ------------------ | Branch (5023:3): [True: 735, False: 11.1M] ------------------ 5024| 735|#line 1209 "bison_parser.y" /* yacc.c:1646 */ 5025| 735| { (yyval.datetime_field) = kDatetimeSecond; } 5026| 735|#line 5027 "bison_parser.cpp" /* yacc.c:1646 */ 5027| 735| break; 5028| | 5029| 1.07k| case 260: ------------------ | Branch (5029:3): [True: 1.07k, False: 11.1M] ------------------ 5030| 1.07k|#line 1210 "bison_parser.y" /* yacc.c:1646 */ 5031| 1.07k| { (yyval.datetime_field) = kDatetimeMinute; } 5032| 1.07k|#line 5033 "bison_parser.cpp" /* yacc.c:1646 */ 5033| 1.07k| break; 5034| | 5035| 828| case 261: ------------------ | Branch (5035:3): [True: 828, False: 11.1M] ------------------ 5036| 828|#line 1211 "bison_parser.y" /* yacc.c:1646 */ 5037| 828| { (yyval.datetime_field) = kDatetimeHour; } 5038| 828|#line 5039 "bison_parser.cpp" /* yacc.c:1646 */ 5039| 828| break; 5040| | 5041| 1.80k| case 262: ------------------ | Branch (5041:3): [True: 1.80k, False: 11.1M] ------------------ 5042| 1.80k|#line 1212 "bison_parser.y" /* yacc.c:1646 */ 5043| 1.80k| { (yyval.datetime_field) = kDatetimeDay; } 5044| 1.80k|#line 5045 "bison_parser.cpp" /* yacc.c:1646 */ 5045| 1.80k| break; 5046| | 5047| 649| case 263: ------------------ | Branch (5047:3): [True: 649, False: 11.1M] ------------------ 5048| 649|#line 1213 "bison_parser.y" /* yacc.c:1646 */ 5049| 649| { (yyval.datetime_field) = kDatetimeMonth; } 5050| 649|#line 5051 "bison_parser.cpp" /* yacc.c:1646 */ 5051| 649| break; 5052| | 5053| 357| case 264: ------------------ | Branch (5053:3): [True: 357, False: 11.1M] ------------------ 5054| 357|#line 1214 "bison_parser.y" /* yacc.c:1646 */ 5055| 357| { (yyval.datetime_field) = kDatetimeYear; } 5056| 357|#line 5057 "bison_parser.cpp" /* yacc.c:1646 */ 5057| 357| break; 5058| | 5059| 782| case 265: ------------------ | Branch (5059:3): [True: 782, False: 11.1M] ------------------ 5060| 782|#line 1216 "bison_parser.y" /* yacc.c:1646 */ 5061| 782| { (yyval.datetime_field) = kDatetimeSecond; } 5062| 782|#line 5063 "bison_parser.cpp" /* yacc.c:1646 */ 5063| 782| break; 5064| | 5065| 1.07k| case 266: ------------------ | Branch (5065:3): [True: 1.07k, False: 11.1M] ------------------ 5066| 1.07k|#line 1217 "bison_parser.y" /* yacc.c:1646 */ 5067| 1.07k| { (yyval.datetime_field) = kDatetimeMinute; } 5068| 1.07k|#line 5069 "bison_parser.cpp" /* yacc.c:1646 */ 5069| 1.07k| break; 5070| | 5071| 1.08k| case 267: ------------------ | Branch (5071:3): [True: 1.08k, False: 11.1M] ------------------ 5072| 1.08k|#line 1218 "bison_parser.y" /* yacc.c:1646 */ 5073| 1.08k| { (yyval.datetime_field) = kDatetimeHour; } 5074| 1.08k|#line 5075 "bison_parser.cpp" /* yacc.c:1646 */ 5075| 1.08k| break; 5076| | 5077| 399| case 268: ------------------ | Branch (5077:3): [True: 399, False: 11.1M] ------------------ 5078| 399|#line 1219 "bison_parser.y" /* yacc.c:1646 */ 5079| 399| { (yyval.datetime_field) = kDatetimeDay; } 5080| 399|#line 5081 "bison_parser.cpp" /* yacc.c:1646 */ 5081| 399| break; 5082| | 5083| 744| case 269: ------------------ | Branch (5083:3): [True: 744, False: 11.1M] ------------------ 5084| 744|#line 1220 "bison_parser.y" /* yacc.c:1646 */ 5085| 744| { (yyval.datetime_field) = kDatetimeMonth; } 5086| 744|#line 5087 "bison_parser.cpp" /* yacc.c:1646 */ 5087| 744| break; 5088| | 5089| 361| case 270: ------------------ | Branch (5089:3): [True: 361, False: 11.1M] ------------------ 5090| 361|#line 1221 "bison_parser.y" /* yacc.c:1646 */ 5091| 361| { (yyval.datetime_field) = kDatetimeYear; } 5092| 361|#line 5093 "bison_parser.cpp" /* yacc.c:1646 */ 5093| 361| break; 5094| | 5095| 507| case 273: ------------------ | Branch (5095:3): [True: 507, False: 11.1M] ------------------ 5096| 507|#line 1225 "bison_parser.y" /* yacc.c:1646 */ 5097| 507| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 5098| 507|#line 5099 "bison_parser.cpp" /* yacc.c:1646 */ 5099| 507| break; 5100| | 5101| 194| case 274: ------------------ | Branch (5101:3): [True: 194, False: 11.1M] ------------------ 5102| 194|#line 1227 "bison_parser.y" /* yacc.c:1646 */ 5103| 194| { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } 5104| 194|#line 5105 "bison_parser.cpp" /* yacc.c:1646 */ 5105| 194| break; 5106| | 5107| 491| case 275: ------------------ | Branch (5107:3): [True: 491, False: 11.1M] ------------------ 5108| 491|#line 1229 "bison_parser.y" /* yacc.c:1646 */ 5109| 491| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 5110| 491|#line 5111 "bison_parser.cpp" /* yacc.c:1646 */ 5111| 491| break; 5112| | 5113| 298k| case 276: ------------------ | Branch (5113:3): [True: 298k, False: 10.8M] ------------------ 5114| 298k|#line 1231 "bison_parser.y" /* yacc.c:1646 */ 5115| 298k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 5116| 298k|#line 5117 "bison_parser.cpp" /* yacc.c:1646 */ 5117| 298k| break; 5118| | 5119| 1.67k| case 277: ------------------ | Branch (5119:3): [True: 1.67k, False: 11.1M] ------------------ 5120| 1.67k|#line 1232 "bison_parser.y" /* yacc.c:1646 */ 5121| 1.67k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 5122| 1.67k|#line 5123 "bison_parser.cpp" /* yacc.c:1646 */ 5123| 1.67k| break; 5124| | 5125| 913k| case 278: ------------------ | Branch (5125:3): [True: 913k, False: 10.1M] ------------------ 5126| 913k|#line 1233 "bison_parser.y" /* yacc.c:1646 */ 5127| 913k| { (yyval.expr) = Expr::makeStar(); } 5128| 913k|#line 5129 "bison_parser.cpp" /* yacc.c:1646 */ 5129| 913k| break; 5130| | 5131| 397| case 279: ------------------ | Branch (5131:3): [True: 397, False: 11.1M] ------------------ 5132| 397|#line 1234 "bison_parser.y" /* yacc.c:1646 */ 5133| 397| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 5134| 397|#line 5135 "bison_parser.cpp" /* yacc.c:1646 */ 5135| 397| break; 5136| | 5137| 5.08k| case 287: ------------------ | Branch (5137:3): [True: 5.08k, False: 11.1M] ------------------ 5138| 5.08k|#line 1238 "bison_parser.y" /* yacc.c:1646 */ 5139| 5.08k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 5140| 5.08k|#line 5141 "bison_parser.cpp" /* yacc.c:1646 */ 5141| 5.08k| break; 5142| | 5143| 473| case 288: ------------------ | Branch (5143:3): [True: 473, False: 11.1M] ------------------ 5144| 473|#line 1240 "bison_parser.y" /* yacc.c:1646 */ 5145| 473| { (yyval.expr) = Expr::makeLiteral(true); } 5146| 473|#line 5147 "bison_parser.cpp" /* yacc.c:1646 */ 5147| 473| break; 5148| | 5149| 523| case 289: ------------------ | Branch (5149:3): [True: 523, False: 11.1M] ------------------ 5150| 523|#line 1241 "bison_parser.y" /* yacc.c:1646 */ 5151| 523| { (yyval.expr) = Expr::makeLiteral(false); } 5152| 523|#line 5153 "bison_parser.cpp" /* yacc.c:1646 */ 5153| 523| break; 5154| | 5155| 1.53k| case 290: ------------------ | Branch (5155:3): [True: 1.53k, False: 11.1M] ------------------ 5156| 1.53k|#line 1243 "bison_parser.y" /* yacc.c:1646 */ 5157| 1.53k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 5158| 1.53k|#line 5159 "bison_parser.cpp" /* yacc.c:1646 */ 5159| 1.53k| break; 5160| | 5161| 14.1k| case 292: ------------------ | Branch (5161:3): [True: 14.1k, False: 11.0M] ------------------ 5162| 14.1k|#line 1246 "bison_parser.y" /* yacc.c:1646 */ 5163| 14.1k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 5164| 14.1k|#line 5165 "bison_parser.cpp" /* yacc.c:1646 */ 5165| 14.1k| break; 5166| | 5167| 1.84k| case 293: ------------------ | Branch (5167:3): [True: 1.84k, False: 11.1M] ------------------ 5168| 1.84k|#line 1248 "bison_parser.y" /* yacc.c:1646 */ 5169| 1.84k| { (yyval.expr) = Expr::makeNullLiteral(); } 5170| 1.84k|#line 5171 "bison_parser.cpp" /* yacc.c:1646 */ 5171| 1.84k| break; 5172| | 5173| 204| case 294: ------------------ | Branch (5173:3): [True: 204, False: 11.1M] ------------------ 5174| 204|#line 1250 "bison_parser.y" /* yacc.c:1646 */ 5175| 204| { 5176| 204| 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| 204| 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: 2, False: 202] | Branch (5178:92): [True: 6, False: 196] ------------------ 5179| 8| free((yyvsp[0].sval)); 5180| 8| yyerror(&yyloc, result, scanner, "Found incorrect date format. Expected format: YYYY-MM-DD"); ------------------ | | 67| 8|#define yyerror hsql_error ------------------ 5181| 8| YYERROR; ------------------ | | 1458| 8|#define YYERROR goto yyerrorlab ------------------ 5182| 8| } 5183| 196| (yyval.expr) = Expr::makeDateLiteral((yyvsp[0].sval)); 5184| 196|} 5185| 0|#line 5186 "bison_parser.cpp" /* yacc.c:1646 */ 5186| 0| break; 5187| | 5188| 8.72k| case 295: ------------------ | Branch (5188:3): [True: 8.72k, False: 11.1M] ------------------ 5189| 8.72k|#line 1261 "bison_parser.y" /* yacc.c:1646 */ 5190| 8.72k| { (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].ival), (yyvsp[0].datetime_field)); } 5191| 8.72k|#line 5192 "bison_parser.cpp" /* yacc.c:1646 */ 5192| 8.72k| break; 5193| | 5194| 349| case 296: ------------------ | Branch (5194:3): [True: 349, False: 11.1M] ------------------ 5195| 349|#line 1262 "bison_parser.y" /* yacc.c:1646 */ 5196| 349| { 5197| 349| int duration{0}, chars_parsed{0}; 5198| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5199| 349| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (5199:7): [True: 2, False: 347] | Branch (5199:74): [True: 6, False: 341] ------------------ 5200| 8| free((yyvsp[-1].sval)); 5201| 8| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER"); ------------------ | | 67| 8|#define yyerror hsql_error ------------------ 5202| 8| YYERROR; ------------------ | | 1458| 8|#define YYERROR goto yyerrorlab ------------------ 5203| 8| } 5204| 341| free((yyvsp[-1].sval)); 5205| 341| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 5206| 341|} 5207| 0|#line 5208 "bison_parser.cpp" /* yacc.c:1646 */ 5208| 0| break; 5209| | 5210| 4.17k| case 297: ------------------ | Branch (5210:3): [True: 4.17k, False: 11.1M] ------------------ 5211| 4.17k|#line 1273 "bison_parser.y" /* yacc.c:1646 */ 5212| 4.17k| { 5213| 4.17k| int duration{0}, chars_parsed{0}; 5214| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 5215| 4.17k| 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.17k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5217:7): [True: 5, False: 4.16k] | Branch (5217:90): [True: 6, False: 4.15k] ------------------ 5218| 11| free((yyvsp[0].sval)); 5219| 11| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER INTERVAL_QUALIIFIER"); ------------------ | | 67| 11|#define yyerror hsql_error ------------------ 5220| 11| YYERROR; ------------------ | | 1458| 11|#define YYERROR goto yyerrorlab ------------------ 5221| 11| } 5222| 4.15k| free((yyvsp[0].sval)); 5223| | 5224| 4.15k| DatetimeField unit; 5225| 4.15k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (5225:7): [True: 770, False: 3.38k] | Branch (5225:49): [True: 297, False: 3.09k] ------------------ 5226| 1.06k| unit = kDatetimeSecond; 5227| 3.09k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (5227:14): [True: 66, False: 3.02k] | Branch (5227:56): [True: 195, False: 2.83k] ------------------ 5228| 261| unit = kDatetimeMinute; 5229| 2.83k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (5229:14): [True: 199, False: 2.63k] | Branch (5229:54): [True: 883, False: 1.74k] ------------------ 5230| 1.08k| unit = kDatetimeHour; 5231| 1.74k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (5231:14): [True: 119, False: 1.63k] | Branch (5231:53): [True: 219, False: 1.41k] ------------------ 5232| 338| unit = kDatetimeDay; 5233| 1.41k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (5233:14): [True: 194, False: 1.21k] | Branch (5233:55): [True: 387, False: 830] ------------------ 5234| 581| unit = kDatetimeMonth; 5235| 830| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (5235:14): [True: 266, False: 564] | Branch (5235:54): [True: 312, False: 252] ------------------ 5236| 578| unit = kDatetimeYear; 5237| 578| } else { 5238| 252| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 67| 252|#define yyerror hsql_error ------------------ 5239| 252| YYERROR; ------------------ | | 1458| 252|#define YYERROR goto yyerrorlab ------------------ 5240| 252| } 5241| 3.90k| (yyval.expr) = Expr::makeIntervalLiteral(duration, unit); 5242| 3.90k|} 5243| 0|#line 5244 "bison_parser.cpp" /* yacc.c:1646 */ 5244| 0| break; 5245| | 5246| 223k| case 298: ------------------ | Branch (5246:3): [True: 223k, False: 10.8M] ------------------ 5247| 223k|#line 1305 "bison_parser.y" /* yacc.c:1646 */ 5248| 223k| { 5249| 223k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 5250| 223k| (yyval.expr)->ival2 = yyloc.param_list.size(); 5251| 223k| yyloc.param_list.push_back((yyval.expr)); 5252| 223k|} 5253| 223k|#line 5254 "bison_parser.cpp" /* yacc.c:1646 */ 5254| 223k| break; 5255| | 5256| 1.67k| case 300: ------------------ | Branch (5256:3): [True: 1.67k, False: 11.1M] ------------------ 5257| 1.67k|#line 1314 "bison_parser.y" /* yacc.c:1646 */ 5258| 1.67k| { 5259| 1.67k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5260| 1.67k| auto tbl = new TableRef(kTableCrossProduct); 5261| 1.67k| tbl->list = (yyvsp[-2].table_vec); 5262| 1.67k| (yyval.table) = tbl; 5263| 1.67k|} 5264| 1.67k|#line 5265 "bison_parser.cpp" /* yacc.c:1646 */ 5265| 1.67k| break; 5266| | 5267| 732| case 304: ------------------ | Branch (5267:3): [True: 732, False: 11.1M] ------------------ 5268| 732|#line 1323 "bison_parser.y" /* yacc.c:1646 */ 5269| 732| { 5270| 732| auto tbl = new TableRef(kTableSelect); 5271| 732| tbl->select = (yyvsp[-2].select_stmt); 5272| 732| tbl->alias = (yyvsp[0].alias_t); 5273| 732| (yyval.table) = tbl; 5274| 732|} 5275| 732|#line 5276 "bison_parser.cpp" /* yacc.c:1646 */ 5276| 732| break; 5277| | 5278| 1.75k| case 305: ------------------ | Branch (5278:3): [True: 1.75k, False: 11.1M] ------------------ 5279| 1.75k|#line 1330 "bison_parser.y" /* yacc.c:1646 */ 5280| 1.75k| { 5281| 1.75k| (yyval.table_vec) = new std::vector(); 5282| 1.75k| (yyval.table_vec)->push_back((yyvsp[0].table)); 5283| 1.75k|} 5284| 1.75k|#line 5285 "bison_parser.cpp" /* yacc.c:1646 */ 5285| 1.75k| break; 5286| | 5287| 107k| case 306: ------------------ | Branch (5287:3): [True: 107k, False: 11.0M] ------------------ 5288| 107k|#line 1334 "bison_parser.y" /* yacc.c:1646 */ 5289| 107k| { 5290| 107k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5291| 107k| (yyval.table_vec) = (yyvsp[-2].table_vec); 5292| 107k|} 5293| 107k|#line 5294 "bison_parser.cpp" /* yacc.c:1646 */ 5294| 107k| break; 5295| | 5296| 224k| case 307: ------------------ | Branch (5296:3): [True: 224k, False: 10.8M] ------------------ 5297| 224k|#line 1339 "bison_parser.y" /* yacc.c:1646 */ 5298| 224k| { 5299| 224k| auto tbl = new TableRef(kTableName); 5300| 224k| tbl->schema = (yyvsp[-1].table_name).schema; 5301| 224k| tbl->name = (yyvsp[-1].table_name).name; 5302| 224k| tbl->alias = (yyvsp[0].alias_t); 5303| 224k| (yyval.table) = tbl; 5304| 224k|} 5305| 224k|#line 5306 "bison_parser.cpp" /* yacc.c:1646 */ 5306| 224k| break; 5307| | 5308| 2.21k| case 308: ------------------ | Branch (5308:3): [True: 2.21k, False: 11.1M] ------------------ 5309| 2.21k|#line 1347 "bison_parser.y" /* yacc.c:1646 */ 5310| 2.21k| { 5311| 2.21k| (yyval.table) = new TableRef(kTableName); 5312| 2.21k| (yyval.table)->schema = (yyvsp[0].table_name).schema; 5313| 2.21k| (yyval.table)->name = (yyvsp[0].table_name).name; 5314| 2.21k|} 5315| 2.21k|#line 5316 "bison_parser.cpp" /* yacc.c:1646 */ 5316| 2.21k| break; 5317| | 5318| 257k| case 309: ------------------ | Branch (5318:3): [True: 257k, False: 10.8M] ------------------ 5319| 257k|#line 1353 "bison_parser.y" /* yacc.c:1646 */ 5320| 257k| { 5321| 257k| (yyval.table_name).schema = nullptr; 5322| 257k| (yyval.table_name).name = (yyvsp[0].sval); 5323| 257k|} 5324| 257k|#line 5325 "bison_parser.cpp" /* yacc.c:1646 */ 5325| 257k| break; 5326| | 5327| 259| case 310: ------------------ | Branch (5327:3): [True: 259, False: 11.1M] ------------------ 5328| 259|#line 1357 "bison_parser.y" /* yacc.c:1646 */ 5329| 259| { 5330| 259| (yyval.table_name).schema = (yyvsp[-2].sval); 5331| 259| (yyval.table_name).name = (yyvsp[0].sval); 5332| 259|} 5333| 259|#line 5334 "bison_parser.cpp" /* yacc.c:1646 */ 5334| 259| break; 5335| | 5336| 209| case 311: ------------------ | Branch (5336:3): [True: 209, False: 11.1M] ------------------ 5337| 209|#line 1362 "bison_parser.y" /* yacc.c:1646 */ 5338| 209| { (yyval.sval) = (yyvsp[0].sval); } 5339| 209|#line 5340 "bison_parser.cpp" /* yacc.c:1646 */ 5340| 209| break; 5341| | 5342| 491| case 312: ------------------ | Branch (5342:3): [True: 491, False: 11.1M] ------------------ 5343| 491|#line 1363 "bison_parser.y" /* yacc.c:1646 */ 5344| 491| { (yyval.sval) = nullptr; } 5345| 491|#line 5346 "bison_parser.cpp" /* yacc.c:1646 */ 5346| 491| break; 5347| | 5348| 187| case 314: ------------------ | Branch (5348:3): [True: 187, False: 11.1M] ------------------ 5349| 187|#line 1365 "bison_parser.y" /* yacc.c:1646 */ 5350| 187| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5351| 187|#line 5352 "bison_parser.cpp" /* yacc.c:1646 */ 5352| 187| break; 5353| | 5354| 216k| case 316: ------------------ | Branch (5354:3): [True: 216k, False: 10.8M] ------------------ 5355| 216k|#line 1367 "bison_parser.y" /* yacc.c:1646 */ 5356| 216k| { (yyval.alias_t) = nullptr; } 5357| 216k|#line 5358 "bison_parser.cpp" /* yacc.c:1646 */ 5358| 216k| break; 5359| | 5360| 311| case 317: ------------------ | Branch (5360:3): [True: 311, False: 11.1M] ------------------ 5361| 311|#line 1369 "bison_parser.y" /* yacc.c:1646 */ 5362| 311| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5363| 311|#line 5364 "bison_parser.cpp" /* yacc.c:1646 */ 5364| 311| break; 5365| | 5366| 21.3k| case 318: ------------------ | Branch (5366:3): [True: 21.3k, False: 11.0M] ------------------ 5367| 21.3k|#line 1370 "bison_parser.y" /* yacc.c:1646 */ 5368| 21.3k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5369| 21.3k|#line 5370 "bison_parser.cpp" /* yacc.c:1646 */ 5370| 21.3k| break; 5371| | 5372| 328k| case 320: ------------------ | Branch (5372:3): [True: 328k, False: 10.7M] ------------------ 5373| 328k|#line 1372 "bison_parser.y" /* yacc.c:1646 */ 5374| 328k| { (yyval.alias_t) = nullptr; } 5375| 328k|#line 5376 "bison_parser.cpp" /* yacc.c:1646 */ 5376| 328k| break; 5377| | 5378| 401| case 321: ------------------ | Branch (5378:3): [True: 401, False: 11.1M] ------------------ 5379| 401|#line 1378 "bison_parser.y" /* yacc.c:1646 */ 5380| 401| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5381| 401|#line 5382 "bison_parser.cpp" /* yacc.c:1646 */ 5382| 401| break; 5383| | 5384| 31.0k| case 322: ------------------ | Branch (5384:3): [True: 31.0k, False: 11.0M] ------------------ 5385| 31.0k|#line 1379 "bison_parser.y" /* yacc.c:1646 */ 5386| 31.0k| { (yyval.locking_clause_vec) = nullptr; } 5387| 31.0k|#line 5388 "bison_parser.cpp" /* yacc.c:1646 */ 5388| 31.0k| break; 5389| | 5390| 421| case 323: ------------------ | Branch (5390:3): [True: 421, False: 11.1M] ------------------ 5391| 421|#line 1381 "bison_parser.y" /* yacc.c:1646 */ 5392| 421| { 5393| 421| (yyval.locking_clause_vec) = new std::vector(); 5394| 421| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5395| 421|} 5396| 421|#line 5397 "bison_parser.cpp" /* yacc.c:1646 */ 5397| 421| break; 5398| | 5399| 3.32k| case 324: ------------------ | Branch (5399:3): [True: 3.32k, False: 11.1M] ------------------ 5400| 3.32k|#line 1385 "bison_parser.y" /* yacc.c:1646 */ 5401| 3.32k| { 5402| 3.32k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5403| 3.32k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5404| 3.32k|} 5405| 3.32k|#line 5406 "bison_parser.cpp" /* yacc.c:1646 */ 5406| 3.32k| break; 5407| | 5408| 3.47k| case 325: ------------------ | Branch (5408:3): [True: 3.47k, False: 11.1M] ------------------ 5409| 3.47k|#line 1390 "bison_parser.y" /* yacc.c:1646 */ 5410| 3.47k| { 5411| 3.47k| (yyval.locking_t) = new LockingClause(); 5412| 3.47k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5413| 3.47k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5414| 3.47k| (yyval.locking_t)->tables = nullptr; 5415| 3.47k|} 5416| 3.47k|#line 5417 "bison_parser.cpp" /* yacc.c:1646 */ 5417| 3.47k| break; 5418| | 5419| 276| case 326: ------------------ | Branch (5419:3): [True: 276, False: 11.1M] ------------------ 5420| 276|#line 1396 "bison_parser.y" /* yacc.c:1646 */ 5421| 276| { 5422| 276| (yyval.locking_t) = new LockingClause(); 5423| 276| (yyval.locking_t)->rowLockMode = (yyvsp[-3].lock_mode_t); 5424| 276| (yyval.locking_t)->tables = (yyvsp[-1].str_vec); 5425| 276| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5426| 276|} 5427| 276|#line 5428 "bison_parser.cpp" /* yacc.c:1646 */ 5428| 276| break; 5429| | 5430| 453| case 327: ------------------ | Branch (5430:3): [True: 453, False: 11.1M] ------------------ 5431| 453|#line 1403 "bison_parser.y" /* yacc.c:1646 */ 5432| 453| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5433| 453|#line 5434 "bison_parser.cpp" /* yacc.c:1646 */ 5434| 453| break; 5435| | 5436| 0| case 328: ------------------ | Branch (5436:3): [True: 0, False: 11.1M] ------------------ 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.09k| case 329: ------------------ | Branch (5442:3): [True: 3.09k, False: 11.1M] ------------------ 5443| 3.09k|#line 1405 "bison_parser.y" /* yacc.c:1646 */ 5444| 3.09k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5445| 3.09k|#line 5446 "bison_parser.cpp" /* yacc.c:1646 */ 5446| 3.09k| break; 5447| | 5448| 206| case 330: ------------------ | Branch (5448:3): [True: 206, False: 11.1M] ------------------ 5449| 206|#line 1406 "bison_parser.y" /* yacc.c:1646 */ 5450| 206| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5451| 206|#line 5452 "bison_parser.cpp" /* yacc.c:1646 */ 5452| 206| break; 5453| | 5454| 0| case 331: ------------------ | Branch (5454:3): [True: 0, False: 11.1M] ------------------ 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| 905| case 332: ------------------ | Branch (5460:3): [True: 905, False: 11.1M] ------------------ 5461| 905|#line 1409 "bison_parser.y" /* yacc.c:1646 */ 5462| 905| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5463| 905|#line 5464 "bison_parser.cpp" /* yacc.c:1646 */ 5464| 905| break; 5465| | 5466| 2.84k| case 333: ------------------ | Branch (5466:3): [True: 2.84k, False: 11.1M] ------------------ 5467| 2.84k|#line 1410 "bison_parser.y" /* yacc.c:1646 */ 5468| 2.84k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5469| 2.84k|#line 5470 "bison_parser.cpp" /* yacc.c:1646 */ 5470| 2.84k| break; 5471| | 5472| 25.4k| case 335: ------------------ | Branch (5472:3): [True: 25.4k, False: 11.0M] ------------------ 5473| 25.4k|#line 1416 "bison_parser.y" /* yacc.c:1646 */ 5474| 25.4k| { (yyval.with_description_vec) = nullptr; } 5475| 25.4k|#line 5476 "bison_parser.cpp" /* yacc.c:1646 */ 5476| 25.4k| break; 5477| | 5478| 832| case 336: ------------------ | Branch (5478:3): [True: 832, False: 11.1M] ------------------ 5479| 832|#line 1418 "bison_parser.y" /* yacc.c:1646 */ 5480| 832| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5481| 832|#line 5482 "bison_parser.cpp" /* yacc.c:1646 */ 5482| 832| break; 5483| | 5484| 873| case 337: ------------------ | Branch (5484:3): [True: 873, False: 11.1M] ------------------ 5485| 873|#line 1420 "bison_parser.y" /* yacc.c:1646 */ 5486| 873| { 5487| 873| (yyval.with_description_vec) = new std::vector(); 5488| 873| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5489| 873|} 5490| 873|#line 5491 "bison_parser.cpp" /* yacc.c:1646 */ 5491| 873| break; 5492| | 5493| 878| case 338: ------------------ | Branch (5493:3): [True: 878, False: 11.1M] ------------------ 5494| 878|#line 1424 "bison_parser.y" /* yacc.c:1646 */ 5495| 878| { 5496| 878| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5497| 878| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5498| 878|} 5499| 878|#line 5500 "bison_parser.cpp" /* yacc.c:1646 */ 5500| 878| break; 5501| | 5502| 1.75k| case 339: ------------------ | Branch (5502:3): [True: 1.75k, False: 11.1M] ------------------ 5503| 1.75k|#line 1429 "bison_parser.y" /* yacc.c:1646 */ 5504| 1.75k| { 5505| 1.75k| (yyval.with_description_t) = new WithDescription(); 5506| 1.75k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5507| 1.75k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5508| 1.75k|} 5509| 1.75k|#line 5510 "bison_parser.cpp" /* yacc.c:1646 */ 5510| 1.75k| break; 5511| | 5512| 609| case 340: ------------------ | Branch (5512:3): [True: 609, False: 11.1M] ------------------ 5513| 609|#line 1439 "bison_parser.y" /* yacc.c:1646 */ 5514| 609| { 5515| 609| (yyval.table) = new TableRef(kTableJoin); 5516| 609| (yyval.table)->join = new JoinDefinition(); 5517| 609| (yyval.table)->join->type = kJoinNatural; 5518| 609| (yyval.table)->join->left = (yyvsp[-3].table); 5519| 609| (yyval.table)->join->right = (yyvsp[0].table); 5520| 609|} 5521| 609|#line 5522 "bison_parser.cpp" /* yacc.c:1646 */ 5522| 609| break; 5523| | 5524| 109k| case 341: ------------------ | Branch (5524:3): [True: 109k, False: 11.0M] ------------------ 5525| 109k|#line 1446 "bison_parser.y" /* yacc.c:1646 */ 5526| 109k| { 5527| 109k| (yyval.table) = new TableRef(kTableJoin); 5528| 109k| (yyval.table)->join = new JoinDefinition(); 5529| 109k| (yyval.table)->join->type = (JoinType)(yyvsp[-4].join_type); 5530| 109k| (yyval.table)->join->left = (yyvsp[-5].table); 5531| 109k| (yyval.table)->join->right = (yyvsp[-2].table); 5532| 109k| (yyval.table)->join->condition = (yyvsp[0].expr); 5533| 109k|} 5534| 109k|#line 5535 "bison_parser.cpp" /* yacc.c:1646 */ 5535| 109k| break; 5536| | 5537| 720| case 342: ------------------ | Branch (5537:3): [True: 720, False: 11.1M] ------------------ 5538| 720|#line 1454 "bison_parser.y" /* yacc.c:1646 */ 5539| 720| { 5540| 720| (yyval.table) = new TableRef(kTableJoin); 5541| 720| (yyval.table)->join = new JoinDefinition(); 5542| 720| (yyval.table)->join->type = (yyvsp[-6].join_type); 5543| 720| (yyval.table)->join->left = (yyvsp[-7].table); 5544| 720| (yyval.table)->join->right = (yyvsp[-4].table); 5545| 720| (yyval.table)->join->namedColumns = (yyvsp[-1].str_vec); 5546| 720|} 5547| 720|#line 5548 "bison_parser.cpp" /* yacc.c:1646 */ 5548| 720| break; 5549| | 5550| 717| case 343: ------------------ | Branch (5550:3): [True: 717, False: 11.1M] ------------------ 5551| 717|#line 1463 "bison_parser.y" /* yacc.c:1646 */ 5552| 717| { (yyval.join_type) = kJoinInner; } 5553| 717|#line 5554 "bison_parser.cpp" /* yacc.c:1646 */ 5554| 717| break; 5555| | 5556| 84| case 344: ------------------ | Branch (5556:3): [True: 84, False: 11.1M] ------------------ 5557| 84|#line 1464 "bison_parser.y" /* yacc.c:1646 */ 5558| 84| { (yyval.join_type) = kJoinLeft; } 5559| 84|#line 5560 "bison_parser.cpp" /* yacc.c:1646 */ 5560| 84| break; 5561| | 5562| 534| case 345: ------------------ | Branch (5562:3): [True: 534, False: 11.1M] ------------------ 5563| 534|#line 1465 "bison_parser.y" /* yacc.c:1646 */ 5564| 534| { (yyval.join_type) = kJoinLeft; } 5565| 534|#line 5566 "bison_parser.cpp" /* yacc.c:1646 */ 5566| 534| break; 5567| | 5568| 67| case 346: ------------------ | Branch (5568:3): [True: 67, False: 11.1M] ------------------ 5569| 67|#line 1466 "bison_parser.y" /* yacc.c:1646 */ 5570| 67| { (yyval.join_type) = kJoinRight; } 5571| 67|#line 5572 "bison_parser.cpp" /* yacc.c:1646 */ 5572| 67| break; 5573| | 5574| 491| case 347: ------------------ | Branch (5574:3): [True: 491, False: 11.1M] ------------------ 5575| 491|#line 1467 "bison_parser.y" /* yacc.c:1646 */ 5576| 491| { (yyval.join_type) = kJoinRight; } 5577| 491|#line 5578 "bison_parser.cpp" /* yacc.c:1646 */ 5578| 491| break; 5579| | 5580| 120| case 348: ------------------ | Branch (5580:3): [True: 120, False: 11.1M] ------------------ 5581| 120|#line 1468 "bison_parser.y" /* yacc.c:1646 */ 5582| 120| { (yyval.join_type) = kJoinFull; } 5583| 120|#line 5584 "bison_parser.cpp" /* yacc.c:1646 */ 5584| 120| break; 5585| | 5586| 777| case 349: ------------------ | Branch (5586:3): [True: 777, False: 11.1M] ------------------ 5587| 777|#line 1469 "bison_parser.y" /* yacc.c:1646 */ 5588| 777| { (yyval.join_type) = kJoinFull; } 5589| 777|#line 5590 "bison_parser.cpp" /* yacc.c:1646 */ 5590| 777| break; 5591| | 5592| 83| case 350: ------------------ | Branch (5592:3): [True: 83, False: 11.1M] ------------------ 5593| 83|#line 1470 "bison_parser.y" /* yacc.c:1646 */ 5594| 83| { (yyval.join_type) = kJoinFull; } 5595| 83|#line 5596 "bison_parser.cpp" /* yacc.c:1646 */ 5596| 83| break; 5597| | 5598| 671| case 351: ------------------ | Branch (5598:3): [True: 671, False: 11.1M] ------------------ 5599| 671|#line 1471 "bison_parser.y" /* yacc.c:1646 */ 5600| 671| { (yyval.join_type) = kJoinCross; } 5601| 671|#line 5602 "bison_parser.cpp" /* yacc.c:1646 */ 5602| 671| break; 5603| | 5604| 108k| case 352: ------------------ | Branch (5604:3): [True: 108k, False: 11.0M] ------------------ 5605| 108k|#line 1472 "bison_parser.y" /* yacc.c:1646 */ 5606| 108k| { (yyval.join_type) = kJoinInner; } 5607| 108k|#line 5608 "bison_parser.cpp" /* yacc.c:1646 */ 5608| 108k| break; 5609| | 5610| 4.56k| case 356: ------------------ | Branch (5610:3): [True: 4.56k, False: 11.1M] ------------------ 5611| 4.56k|#line 1483 "bison_parser.y" /* yacc.c:1646 */ 5612| 4.56k| { 5613| 4.56k| (yyval.str_vec) = new std::vector(); 5614| 4.56k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5615| 4.56k|} 5616| 4.56k|#line 5617 "bison_parser.cpp" /* yacc.c:1646 */ 5617| 4.56k| break; 5618| | 5619| 11.7k| case 357: ------------------ | Branch (5619:3): [True: 11.7k, False: 11.1M] ------------------ 5620| 11.7k|#line 1487 "bison_parser.y" /* yacc.c:1646 */ 5621| 11.7k| { 5622| 11.7k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5623| 11.7k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5624| 11.7k|} 5625| 11.7k|#line 5626 "bison_parser.cpp" /* yacc.c:1646 */ 5626| 11.7k| break; 5627| | 5628| | 5629| 0|#line 5630 "bison_parser.cpp" /* yacc.c:1646 */ 5630| 5.48M| default: break; ------------------ | Branch (5630:7): [True: 5.48M, False: 5.63M] ------------------ 5631| 11.1M| } 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| 11.1M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5644| | 5645| 11.1M| YYPOPSTACK (yylen); ------------------ | | 2956| 11.1M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5646| 11.1M| yylen = 0; 5647| 11.1M| YY_STACK_PRINT (yyss, yyssp); 5648| | 5649| 11.1M| *++yyvsp = yyval; 5650| 11.1M| *++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| 11.1M| yyn = yyr1[yyn]; 5657| | 5658| 11.1M| yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ------------------ | | 711| 11.1M|#define YYNTOKENS 199 ------------------ 5659| 11.1M| if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ------------------ | | 708| 16.5M|#define YYLAST 856 ------------------ | Branch (5659:7): [True: 5.40M, False: 5.70M] | Branch (5659:23): [True: 5.37M, False: 35.6k] | Branch (5659:44): [True: 2.82M, False: 2.55M] ------------------ 5660| 2.82M| yystate = yytable[yystate]; 5661| 8.29M| else 5662| 8.29M| yystate = yydefgoto[yyn - YYNTOKENS]; ------------------ | | 711| 8.29M|#define YYNTOKENS 199 ------------------ 5663| | 5664| 11.1M| goto yynewstate; 5665| | 5666| | 5667| |/*--------------------------------------. 5668| || yyerrlab -- here on detecting error. | 5669| |`--------------------------------------*/ 5670| 3.29k|yyerrlab: 5671| | /* Make sure we have latest lookahead translation. See comments at 5672| | user semantic actions for why this is necessary. */ 5673| 3.29k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 3.29k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 725| 6.59k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.29k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.29k, False: 0] | | ------------------ ------------------ | Branch (5673:13): [True: 0, False: 3.29k] ------------------ 5674| | 5675| | /* If not already recovering from an error, report this error. */ 5676| 3.29k| if (!yyerrstatus) ------------------ | Branch (5676:7): [True: 3.29k, False: 0] ------------------ 5677| 3.29k| { 5678| 3.29k| ++yynerrs; ------------------ | | 69| 3.29k|#define yynerrs hsql_nerrs ------------------ 5679| |#if ! YYERROR_VERBOSE 5680| | yyerror (&yylloc, result, scanner, YY_("syntax error")); 5681| |#else 5682| 3.29k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5683| 3.29k| yyssp, yytoken) 5684| 3.29k| { 5685| 3.29k| char const *yymsgp = YY_("syntax error"); ------------------ | | 517| 3.29k|# define YY_(Msgid) Msgid ------------------ 5686| 3.29k| int yysyntax_error_status; 5687| 3.29k| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 5682| 3.29k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 5683| 3.29k| yyssp, yytoken) ------------------ 5688| 3.29k| if (yysyntax_error_status == 0) ------------------ | Branch (5688:13): [True: 3.29k, False: 0] ------------------ 5689| 3.29k| 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.29k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 67| 3.29k|#define yyerror hsql_error ------------------ 5708| 3.29k| if (yysyntax_error_status == 2) ------------------ | Branch (5708:13): [True: 0, False: 3.29k] ------------------ 5709| 0| goto yyexhaustedlab; 5710| 3.29k| } 5711| 3.29k|# undef YYSYNTAX_ERROR 5712| 3.29k|#endif 5713| 3.29k| } 5714| | 5715| 3.29k| yyerror_range[1] = yylloc; 5716| | 5717| 3.29k| if (yyerrstatus == 3) ------------------ | Branch (5717:7): [True: 0, False: 3.29k] ------------------ 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.29k| goto yyerrlab1; 5739| | 5740| | 5741| |/*---------------------------------------------------. 5742| || yyerrorlab -- error raised explicitly by YYERROR. | 5743| |`---------------------------------------------------*/ 5744| 3.29k|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| 626| if (/*CONSTCOND*/ 0) ------------------ | Branch (5749:21): [Folded, False: 626] ------------------ 5750| 0| goto yyerrorlab; 5751| | 5752| 626| yyerror_range[1] = yylsp[1-yylen]; 5753| | /* Do not reclaim the symbols of the rule whose action triggered 5754| | this YYERROR. */ 5755| 626| YYPOPSTACK (yylen); ------------------ | | 2956| 626|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5756| 626| yylen = 0; 5757| 626| YY_STACK_PRINT (yyss, yyssp); 5758| 626| yystate = *yyssp; 5759| 626| goto yyerrlab1; 5760| | 5761| | 5762| |/*-------------------------------------------------------------. 5763| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5764| |`-------------------------------------------------------------*/ 5765| 3.92k|yyerrlab1: 5766| 3.92k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5767| | 5768| 3.92k| for (;;) 5769| 48.2k| { 5770| 48.2k| yyn = yypact[yystate]; 5771| 48.2k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 48.2k| (!!((Yystate) == (-529))) ------------------ | Branch (5771:11): [True: 48.2k, False: 0] ------------------ 5772| 48.2k| { 5773| 48.2k| yyn += YYTERROR; ------------------ | | 1481| 48.2k|#define YYTERROR 1 ------------------ 5774| 48.2k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 708| 90.8k|#define YYLAST 856 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 1481| 42.5k|#define YYTERROR 1 ------------------ | Branch (5774:15): [True: 42.5k, False: 5.66k] | Branch (5774:27): [True: 42.5k, False: 0] | Branch (5774:44): [True: 0, False: 42.5k] ------------------ 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| 48.2k| } 5781| | 5782| | /* Pop the current state because it cannot handle the error token. */ 5783| 48.2k| if (yyssp == yyss) ------------------ | Branch (5783:11): [True: 3.92k, False: 44.3k] ------------------ 5784| 3.92k| YYABORT; ------------------ | | 1457| 3.92k|#define YYABORT goto yyabortlab ------------------ 5785| | 5786| 44.3k| yyerror_range[1] = *yylsp; 5787| 44.3k| yydestruct ("Error: popping", 5788| 44.3k| yystos[yystate], yyvsp, yylsp, result, scanner); 5789| 44.3k| YYPOPSTACK (1); ------------------ | | 2956| 44.3k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5790| 44.3k| yystate = *yyssp; 5791| 44.3k| YY_STACK_PRINT (yyss, yyssp); 5792| 44.3k| } 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.35k|yyacceptlab: 5815| 1.35k| yyresult = 0; 5816| 1.35k| goto yyreturn; 5817| | 5818| |/*-----------------------------------. 5819| || yyabortlab -- YYABORT comes here. | 5820| |`-----------------------------------*/ 5821| 3.92k|yyabortlab: 5822| 3.92k| yyresult = 1; 5823| 3.92k| 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.29k|yyreturn: 5836| 5.29k| if (yychar != YYEMPTY) ------------------ | | 1453| 5.29k|#define YYEMPTY (-2) ------------------ | Branch (5836:7): [True: 3.57k, False: 1.72k] ------------------ 5837| 3.57k| { 5838| | /* Make sure we have latest lookahead translation. See comments at 5839| | user semantic actions for why this is necessary. */ 5840| 3.57k| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 3.57k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.57k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.57k, False: 0] | | ------------------ ------------------ 5841| 3.57k| yydestruct ("Cleanup: discarding lookahead", 5842| 3.57k| yytoken, &yylval, &yylloc, result, scanner); 5843| 3.57k| } 5844| | /* Do not reclaim the symbols of the rule whose action triggered 5845| | this YYABORT or YYACCEPT. */ 5846| 5.29k| YYPOPSTACK (yylen); ------------------ | | 2956| 5.29k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5847| 5.29k| YY_STACK_PRINT (yyss, yyssp); 5848| 11.7k| while (yyssp != yyss) ------------------ | Branch (5848:10): [True: 6.49k, False: 5.29k] ------------------ 5849| 6.49k| { 5850| 6.49k| yydestruct ("Cleanup: popping", 5851| 6.49k| yystos[*yyssp], yyvsp, yylsp, result, scanner); 5852| 6.49k| YYPOPSTACK (1); ------------------ | | 2956| 6.49k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5853| 6.49k| } 5854| 5.29k|#ifndef yyoverflow 5855| 5.29k| if (yyss != yyssa) ------------------ | Branch (5855:7): [True: 0, False: 5.29k] ------------------ 5856| 0| YYSTACK_FREE (yyss); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5857| 5.29k|#endif 5858| 5.29k|#if YYERROR_VERBOSE 5859| 5.29k| if (yymsg != yymsgbuf) ------------------ | Branch (5859:7): [True: 0, False: 5.29k] ------------------ 5860| 0| YYSTACK_FREE (yymsg); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5861| 5.29k|#endif 5862| 5.29k| return yyresult; 5863| 19|} bison_parser.cpp:_ZL14yysyntax_errorPmPPcPsi: 1800| 3.29k|{ 1801| 3.29k| YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 496| 3.29k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 108| 3.29k|# define YY_NULLPTR nullptr ------------------ 1802| 3.29k| YYSIZE_T yysize = yysize0; ------------------ | | 496| 3.29k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1803| 3.29k| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1804| | /* Internationalized format string. */ 1805| 3.29k| const char *yyformat = YY_NULLPTR; ------------------ | | 108| 3.29k|# define YY_NULLPTR nullptr ------------------ 1806| | /* Arguments of yyformat. */ 1807| 3.29k| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1808| | /* Number of reported tokens (one for the "unexpected", one per 1809| | "expected"). */ 1810| 3.29k| 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.29k| if (yytoken != YYEMPTY) ------------------ | | 1453| 3.29k|#define YYEMPTY (-2) ------------------ | Branch (1835:7): [True: 3.29k, False: 0] ------------------ 1836| 3.29k| { 1837| 3.29k| int yyn = yypact[*yyssp]; 1838| 3.29k| yyarg[yycount++] = yytname[yytoken]; 1839| 3.29k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 3.29k| (!!((Yystate) == (-529))) ------------------ | Branch (1839:11): [True: 3.29k, False: 0] ------------------ 1840| 3.29k| { 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.29k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1844:26): [True: 922, False: 2.37k] ------------------ 1845| | /* Stay within bounds of both yycheck and yytname. */ 1846| 3.29k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 708| 3.29k|#define YYLAST 856 ------------------ 1847| 3.29k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.29k|#define YYNTOKENS 199 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.18k|#define YYNTOKENS 199 ------------------ | Branch (1847:24): [True: 113, False: 3.18k] ------------------ 1848| 3.29k| int yyx; 1849| | 1850| 557k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1850:32): [True: 554k, False: 2.77k] ------------------ 1851| 554k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 1481| 562k|#define YYTERROR 1 ------------------ | Branch (1851:17): [True: 7.57k, False: 547k] | Branch (1851:46): [True: 7.57k, False: 0] ------------------ 1852| 7.57k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 928| 7.57k| (!!((Yytable_value) == (-355))) ------------------ | Branch (1852:20): [True: 7.50k, False: 62] ------------------ 1853| 7.50k| { 1854| 7.50k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1854:21): [True: 526, False: 6.98k] ------------------ 1855| 526| { 1856| 526| yycount = 1; 1857| 526| yysize = yysize0; 1858| 526| break; 1859| 526| } 1860| 6.98k| yyarg[yycount++] = yytname[yyx]; 1861| 6.98k| { 1862| 6.98k| YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 496| 6.98k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 108| 6.98k|# define YY_NULLPTR nullptr ------------------ 1863| 6.98k| if (! (yysize <= yysize1 ------------------ | Branch (1863:26): [True: 6.98k, False: 0] ------------------ 1864| 6.98k| && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 6.98k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 6.98k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1864:29): [True: 6.98k, False: 0] ------------------ 1865| 0| return 2; 1866| 6.98k| yysize = yysize1; 1867| 6.98k| } 1868| 6.98k| } 1869| 3.29k| } 1870| 3.29k| } 1871| | 1872| 3.29k| switch (yycount) ------------------ | Branch (1872:11): [True: 3.29k, False: 0] ------------------ 1873| 3.29k| { 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.29k] | | ------------------ | | 1876| 0| yyformat = S; \ | | 1877| 0| break ------------------ 1879| 526| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1875| 526| case N: \ | | ------------------ | | | Branch (1875:7): [True: 526, False: 2.77k] | | ------------------ | | 1876| 526| yyformat = S; \ | | 1877| 526| break ------------------ 1880| 1.05k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1875| 1.05k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.05k, False: 2.24k] | | ------------------ | | 1876| 1.05k| yyformat = S; \ | | 1877| 1.05k| break ------------------ 1881| 1.44k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1875| 1.44k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.44k, False: 1.85k] | | ------------------ | | 1876| 1.44k| yyformat = S; \ | | 1877| 1.44k| break ------------------ 1882| 153| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1875| 153| case N: \ | | ------------------ | | | Branch (1875:7): [True: 153, False: 3.14k] | | ------------------ | | 1876| 153| yyformat = S; \ | | 1877| 153| break ------------------ 1883| 3.29k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1875| 119| case N: \ | | ------------------ | | | Branch (1875:7): [True: 119, False: 3.17k] | | ------------------ | | 1876| 119| yyformat = S; \ | | 1877| 119| break ------------------ 1884| 3.29k|# undef YYCASE_ 1885| 3.29k| } 1886| | 1887| 3.29k| { 1888| 3.29k| YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 496| 3.29k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 1707| 3.29k|# define yystrlen strlen ------------------ 1889| 3.29k| if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 3.29k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 3.29k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1889:12): [True: 3.29k, False: 0] | Branch (1889:33): [True: 3.29k, False: 0] ------------------ 1890| 0| return 2; 1891| 3.29k| yysize = yysize1; 1892| 3.29k| } 1893| | 1894| 3.29k| if (*yymsg_alloc < yysize) ------------------ | Branch (1894:7): [True: 0, False: 3.29k] ------------------ 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.29k| { 1907| 3.29k| char *yyp = *yymsg; 1908| 3.29k| int yyi = 0; 1909| 135k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1909:12): [True: 132k, False: 3.29k] ------------------ 1910| 132k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1910:11): [True: 8.17k, False: 124k] | Branch (1910:26): [True: 8.17k, False: 0] | Branch (1910:48): [True: 8.17k, False: 0] ------------------ 1911| 8.17k| { 1912| 8.17k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1913| 8.17k| yyformat += 2; 1914| 8.17k| } 1915| 124k| else 1916| 124k| { 1917| 124k| yyp++; 1918| 124k| yyformat++; 1919| 124k| } 1920| 3.29k| } 1921| 3.29k| return 0; 1922| 3.29k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1751| 18.4k|{ 1752| 18.4k| if (*yystr == '"') ------------------ | Branch (1752:7): [True: 0, False: 18.4k] ------------------ 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| 18.4k| if (! yyres) ------------------ | Branch (1782:7): [True: 10.2k, False: 8.17k] ------------------ 1783| 10.2k| return yystrlen (yystr); ------------------ | | 1707| 10.2k|# define yystrlen strlen ------------------ 1784| | 1785| 8.17k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1723| 8.17k|# define yystpcpy stpcpy ------------------ 1786| 18.4k|} bison_parser.cpp:_ZL10yydestructPKciP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 1931| 54.3k|{ 1932| 54.3k| YYUSE (yyvaluep); ------------------ | | 550| 54.3k|# define YYUSE(E) ((void) (E)) ------------------ 1933| 54.3k| YYUSE (yylocationp); ------------------ | | 550| 54.3k|# define YYUSE(E) ((void) (E)) ------------------ 1934| 54.3k| YYUSE (result); ------------------ | | 550| 54.3k|# define YYUSE(E) ((void) (E)) ------------------ 1935| 54.3k| YYUSE (scanner); ------------------ | | 550| 54.3k|# define YYUSE(E) ((void) (E)) ------------------ 1936| 54.3k| if (!yymsg) ------------------ | Branch (1936:7): [True: 0, False: 54.3k] ------------------ 1937| 0| yymsg = "Deleting"; 1938| 54.3k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1939| | 1940| 54.3k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1941| 54.3k| switch (yytype) 1942| 54.3k| { 1943| 2.48k| case 3: /* IDENTIFIER */ ------------------ | Branch (1943:11): [True: 2.48k, False: 51.8k] ------------------ 1944| 2.48k|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1945| 2.48k| { free(((*yyvaluep).sval)); } 1946| 2.48k|#line 1947 "bison_parser.cpp" /* yacc.c:1257 */ 1947| 2.48k| break; 1948| | 1949| 16| case 4: /* STRING */ ------------------ | Branch (1949:5): [True: 16, False: 54.3k] ------------------ 1950| 16|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1951| 16| { free(((*yyvaluep).sval)); } 1952| 16|#line 1953 "bison_parser.cpp" /* yacc.c:1257 */ 1953| 16| break; 1954| | 1955| 21| case 5: /* FLOATVAL */ ------------------ | Branch (1955:5): [True: 21, False: 54.3k] ------------------ 1956| 21|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1957| 21| { } 1958| 21|#line 1959 "bison_parser.cpp" /* yacc.c:1257 */ 1959| 21| break; 1960| | 1961| 46| case 6: /* INTVAL */ ------------------ | Branch (1961:5): [True: 46, False: 54.3k] ------------------ 1962| 46|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1963| 46| { } 1964| 46|#line 1965 "bison_parser.cpp" /* yacc.c:1257 */ 1965| 46| break; 1966| | 1967| 516| case 201: /* statement_list */ ------------------ | Branch (1967:5): [True: 516, False: 53.8k] ------------------ 1968| 516|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1969| 516| { 1970| 516| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (1970:7): [True: 516, False: 0] ------------------ 1971| 35.0k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (1971:19): [True: 35.0k, False: 516] ------------------ 1972| 35.0k| delete ptr; 1973| 35.0k| } 1974| 516| } 1975| 516| delete (((*yyvaluep).stmt_vec)); 1976| 516|} 1977| 516|#line 1978 "bison_parser.cpp" /* yacc.c:1257 */ 1978| 516| break; 1979| | 1980| 0| case 202: /* statement */ ------------------ | Branch (1980:5): [True: 0, False: 54.3k] ------------------ 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| 50| case 203: /* preparable_statement */ ------------------ | Branch (1986:5): [True: 50, False: 54.3k] ------------------ 1987| 50|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1988| 50| { delete (((*yyvaluep).statement)); } 1989| 50|#line 1990 "bison_parser.cpp" /* yacc.c:1257 */ 1990| 50| break; 1991| | 1992| 0| case 204: /* opt_hints */ ------------------ | Branch (1992:5): [True: 0, False: 54.3k] ------------------ 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| 34| case 205: /* hint_list */ ------------------ | Branch (2005:5): [True: 34, False: 54.3k] ------------------ 2006| 34|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2007| 34| { 2008| 34| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2008:7): [True: 34, False: 0] ------------------ 2009| 858| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2009:19): [True: 858, False: 34] ------------------ 2010| 858| delete ptr; 2011| 858| } 2012| 34| } 2013| 34| delete (((*yyvaluep).expr_vec)); 2014| 34|} 2015| 34|#line 2016 "bison_parser.cpp" /* yacc.c:1257 */ 2016| 34| break; 2017| | 2018| 0| case 206: /* hint */ ------------------ | Branch (2018:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 199| case 214: /* file_path */ ------------------ | Branch (2060:5): [True: 199, False: 54.1k] ------------------ 2061| 199|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2062| 199| { free(((*yyvaluep).sval)); } 2063| 199|#line 2064 "bison_parser.cpp" /* yacc.c:1257 */ 2064| 199| break; 2065| | 2066| 1| case 215: /* opt_import_export_options */ ------------------ | Branch (2066:5): [True: 1, False: 54.3k] ------------------ 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| 50| case 216: /* import_export_options */ ------------------ | Branch (2072:5): [True: 50, False: 54.3k] ------------------ 2073| 50|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2074| 50| { delete (((*yyvaluep).import_export_option_t)); } 2075| 50|#line 2076 "bison_parser.cpp" /* yacc.c:1257 */ 2076| 50| break; 2077| | 2078| 0| case 217: /* csv_option */ ------------------ | Branch (2078:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 583| case 221: /* opt_not_exists */ ------------------ | Branch (2105:5): [True: 583, False: 53.7k] ------------------ 2106| 583|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2107| 583| { } 2108| 583|#line 2109 "bison_parser.cpp" /* yacc.c:1257 */ 2109| 583| break; 2110| | 2111| 515| case 222: /* table_elem_commalist */ ------------------ | Branch (2111:5): [True: 515, False: 53.8k] ------------------ 2112| 515|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2113| 515| { 2114| 515| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2114:7): [True: 515, False: 0] ------------------ 2115| 14.8k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2115:19): [True: 14.8k, False: 515] ------------------ 2116| 14.8k| delete ptr; 2117| 14.8k| } 2118| 515| } 2119| 515| delete (((*yyvaluep).table_element_vec)); 2120| 515|} 2121| 515|#line 2122 "bison_parser.cpp" /* yacc.c:1257 */ 2122| 515| break; 2123| | 2124| 0| case 223: /* table_elem */ ------------------ | Branch (2124:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 11| case 225: /* column_type */ ------------------ | Branch (2136:5): [True: 11, False: 54.3k] ------------------ 2137| 11|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2138| 11| { } 2139| 11|#line 2140 "bison_parser.cpp" /* yacc.c:1257 */ 2140| 11| break; 2141| | 2142| 0| case 226: /* opt_time_precision */ ------------------ | Branch (2142:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 9| case 229: /* column_constraints */ ------------------ | Branch (2160:5): [True: 9, False: 54.3k] ------------------ 2161| 9|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2162| 9| { delete (((*yyvaluep).column_constraints_t)); } 2163| 9|#line 2164 "bison_parser.cpp" /* yacc.c:1257 */ 2164| 9| break; 2165| | 2166| 0| case 230: /* column_constraint */ ------------------ | Branch (2166:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 21| case 234: /* opt_exists */ ------------------ | Branch (2190:5): [True: 21, False: 54.3k] ------------------ 2191| 21|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2192| 21| { } 2193| 21|#line 2194 "bison_parser.cpp" /* yacc.c:1257 */ 2194| 21| break; 2195| | 2196| 0| case 235: /* alter_statement */ ------------------ | Branch (2196:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 31| case 241: /* opt_column_list */ ------------------ | Branch (2232:5): [True: 31, False: 54.3k] ------------------ 2233| 31|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2234| 31| { 2235| 31| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2235:7): [True: 16, False: 15] ------------------ 2236| 374| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2236:19): [True: 374, False: 16] ------------------ 2237| 374| free(ptr); 2238| 374| } 2239| 16| } 2240| 31| delete (((*yyvaluep).str_vec)); 2241| 31|} 2242| 31|#line 2243 "bison_parser.cpp" /* yacc.c:1257 */ 2243| 31| break; 2244| | 2245| 0| case 242: /* update_statement */ ------------------ | Branch (2245:5): [True: 0, False: 54.3k] ------------------ 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| 14| case 243: /* update_clause_commalist */ ------------------ | Branch (2251:5): [True: 14, False: 54.3k] ------------------ 2252| 14|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2253| 14| { 2254| 14| if (((*yyvaluep).update_vec)) { ------------------ | Branch (2254:7): [True: 14, False: 0] ------------------ 2255| 358| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2255:19): [True: 358, False: 14] ------------------ 2256| 358| delete ptr; 2257| 358| } 2258| 14| } 2259| 14| delete (((*yyvaluep).update_vec)); 2260| 14|} 2261| 14|#line 2262 "bison_parser.cpp" /* yacc.c:1257 */ 2262| 14| break; 2263| | 2264| 0| case 244: /* update_clause */ ------------------ | Branch (2264:5): [True: 0, False: 54.3k] ------------------ 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| 3| case 245: /* select_statement */ ------------------ | Branch (2270:5): [True: 3, False: 54.3k] ------------------ 2271| 3|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2272| 3| { delete (((*yyvaluep).select_stmt)); } 2273| 3|#line 2274 "bison_parser.cpp" /* yacc.c:1257 */ 2274| 3| break; 2275| | 2276| 67| case 246: /* select_within_set_operation */ ------------------ | Branch (2276:5): [True: 67, False: 54.3k] ------------------ 2277| 67|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2278| 67| { delete (((*yyvaluep).select_stmt)); } 2279| 67|#line 2280 "bison_parser.cpp" /* yacc.c:1257 */ 2280| 67| break; 2281| | 2282| 0| case 247: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2282:5): [True: 0, False: 54.3k] ------------------ 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| 41| case 248: /* select_with_paren */ ------------------ | Branch (2288:5): [True: 41, False: 54.3k] ------------------ 2289| 41|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2290| 41| { delete (((*yyvaluep).select_stmt)); } 2291| 41|#line 2292 "bison_parser.cpp" /* yacc.c:1257 */ 2292| 41| break; 2293| | 2294| 115| case 249: /* select_no_paren */ ------------------ | Branch (2294:5): [True: 115, False: 54.2k] ------------------ 2295| 115|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2296| 115| { delete (((*yyvaluep).select_stmt)); } 2297| 115|#line 2298 "bison_parser.cpp" /* yacc.c:1257 */ 2298| 115| break; 2299| | 2300| 1.09k| case 250: /* set_operator */ ------------------ | Branch (2300:5): [True: 1.09k, False: 53.2k] ------------------ 2301| 1.09k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2302| 1.09k| { delete (((*yyvaluep).set_operator_t)); } 2303| 1.09k|#line 2304 "bison_parser.cpp" /* yacc.c:1257 */ 2304| 1.09k| break; 2305| | 2306| 0| case 251: /* set_type */ ------------------ | Branch (2306:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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.66k| case 253: /* select_clause */ ------------------ | Branch (2318:5): [True: 1.66k, False: 52.7k] ------------------ 2319| 1.66k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2320| 1.66k| { delete (((*yyvaluep).select_stmt)); } 2321| 1.66k|#line 2322 "bison_parser.cpp" /* yacc.c:1257 */ 2322| 1.66k| break; 2323| | 2324| 3.39k| case 254: /* opt_distinct */ ------------------ | Branch (2324:5): [True: 3.39k, False: 50.9k] ------------------ 2325| 3.39k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2326| 3.39k| { } 2327| 3.39k|#line 2328 "bison_parser.cpp" /* yacc.c:1257 */ 2328| 3.39k| break; 2329| | 2330| 593| case 255: /* select_list */ ------------------ | Branch (2330:5): [True: 593, False: 53.7k] ------------------ 2331| 593|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2332| 593| { 2333| 593| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2333:7): [True: 593, False: 0] ------------------ 2334| 973| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2334:19): [True: 973, False: 593] ------------------ 2335| 973| delete ptr; 2336| 973| } 2337| 593| } 2338| 593| delete (((*yyvaluep).expr_vec)); 2339| 593|} 2340| 593|#line 2341 "bison_parser.cpp" /* yacc.c:1257 */ 2341| 593| break; 2342| | 2343| 167| case 256: /* opt_from_clause */ ------------------ | Branch (2343:5): [True: 167, False: 54.2k] ------------------ 2344| 167|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2345| 167| { delete (((*yyvaluep).table)); } 2346| 167|#line 2347 "bison_parser.cpp" /* yacc.c:1257 */ 2347| 167| break; 2348| | 2349| 0| case 257: /* from_clause */ ------------------ | Branch (2349:5): [True: 0, False: 54.3k] ------------------ 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| 89| case 258: /* opt_where */ ------------------ | Branch (2355:5): [True: 89, False: 54.2k] ------------------ 2356| 89|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2357| 89| { delete (((*yyvaluep).expr)); } 2358| 89|#line 2359 "bison_parser.cpp" /* yacc.c:1257 */ 2359| 89| break; 2360| | 2361| 1| case 259: /* opt_group */ ------------------ | Branch (2361:5): [True: 1, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 529| case 261: /* opt_order */ ------------------ | Branch (2373:5): [True: 529, False: 53.8k] ------------------ 2374| 529|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2375| 529| { 2376| 529| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2376:7): [True: 96, False: 433] ------------------ 2377| 360| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2377:19): [True: 360, False: 96] ------------------ 2378| 360| delete ptr; 2379| 360| } 2380| 96| } 2381| 529| delete (((*yyvaluep).order_vec)); 2382| 529|} 2383| 529|#line 2384 "bison_parser.cpp" /* yacc.c:1257 */ 2384| 529| break; 2385| | 2386| 154| case 262: /* order_list */ ------------------ | Branch (2386:5): [True: 154, False: 54.2k] ------------------ 2387| 154|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2388| 154| { 2389| 154| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2389:7): [True: 154, False: 0] ------------------ 2390| 1.83k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2390:19): [True: 1.83k, False: 154] ------------------ 2391| 1.83k| delete ptr; 2392| 1.83k| } 2393| 154| } 2394| 154| delete (((*yyvaluep).order_vec)); 2395| 154|} 2396| 154|#line 2397 "bison_parser.cpp" /* yacc.c:1257 */ 2397| 154| break; 2398| | 2399| 0| case 263: /* order_desc */ ------------------ | Branch (2399:5): [True: 0, False: 54.3k] ------------------ 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| 122| case 264: /* opt_order_type */ ------------------ | Branch (2405:5): [True: 122, False: 54.2k] ------------------ 2406| 122|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2407| 122| { } 2408| 122|#line 2409 "bison_parser.cpp" /* yacc.c:1257 */ 2409| 122| break; 2410| | 2411| 1| case 265: /* opt_null_ordering */ ------------------ | Branch (2411:5): [True: 1, False: 54.3k] ------------------ 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.05k| case 266: /* opt_top */ ------------------ | Branch (2417:5): [True: 2.05k, False: 52.3k] ------------------ 2418| 2.05k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2419| 2.05k| { delete (((*yyvaluep).limit)); } 2420| 2.05k|#line 2421 "bison_parser.cpp" /* yacc.c:1257 */ 2421| 2.05k| break; 2422| | 2423| 37| case 267: /* opt_limit */ ------------------ | Branch (2423:5): [True: 37, False: 54.3k] ------------------ 2424| 37|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2425| 37| { delete (((*yyvaluep).limit)); } 2426| 37|#line 2427 "bison_parser.cpp" /* yacc.c:1257 */ 2427| 37| break; 2428| | 2429| 547| case 268: /* expr_list */ ------------------ | Branch (2429:5): [True: 547, False: 53.8k] ------------------ 2430| 547|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2431| 547| { 2432| 547| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2432:7): [True: 547, False: 0] ------------------ 2433| 15.9k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2433:19): [True: 15.9k, False: 547] ------------------ 2434| 15.9k| delete ptr; 2435| 15.9k| } 2436| 547| } 2437| 547| delete (((*yyvaluep).expr_vec)); 2438| 547|} 2439| 547|#line 2440 "bison_parser.cpp" /* yacc.c:1257 */ 2440| 547| break; 2441| | 2442| 50| case 269: /* opt_extended_literal_list */ ------------------ | Branch (2442:5): [True: 50, False: 54.3k] ------------------ 2443| 50|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2444| 50| { 2445| 50| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2445:7): [True: 42, False: 8] ------------------ 2446| 986| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2446:19): [True: 986, False: 42] ------------------ 2447| 986| delete ptr; 2448| 986| } 2449| 42| } 2450| 50| delete (((*yyvaluep).expr_vec)); 2451| 50|} 2452| 50|#line 2453 "bison_parser.cpp" /* yacc.c:1257 */ 2453| 50| break; 2454| | 2455| 23| case 270: /* extended_literal_list */ ------------------ | Branch (2455:5): [True: 23, False: 54.3k] ------------------ 2456| 23|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2457| 23| { 2458| 23| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2458:7): [True: 23, False: 0] ------------------ 2459| 722| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2459:19): [True: 722, False: 23] ------------------ 2460| 722| delete ptr; 2461| 722| } 2462| 23| } 2463| 23| delete (((*yyvaluep).expr_vec)); 2464| 23|} 2465| 23|#line 2466 "bison_parser.cpp" /* yacc.c:1257 */ 2466| 23| break; 2467| | 2468| 0| case 271: /* casted_extended_literal */ ------------------ | Branch (2468:5): [True: 0, False: 54.3k] ------------------ 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| 2| case 272: /* extended_literal */ ------------------ | Branch (2474:5): [True: 2, False: 54.3k] ------------------ 2475| 2|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2476| 2| { delete (((*yyvaluep).expr)); } 2477| 2|#line 2478 "bison_parser.cpp" /* yacc.c:1257 */ 2478| 2| break; 2479| | 2480| 0| case 273: /* expr_alias */ ------------------ | Branch (2480:5): [True: 0, False: 54.3k] ------------------ 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| 494| case 274: /* expr */ ------------------ | Branch (2486:5): [True: 494, False: 53.8k] ------------------ 2487| 494|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2488| 494| { delete (((*yyvaluep).expr)); } 2489| 494|#line 2490 "bison_parser.cpp" /* yacc.c:1257 */ 2490| 494| break; 2491| | 2492| 1.56k| case 275: /* operand */ ------------------ | Branch (2492:5): [True: 1.56k, False: 52.8k] ------------------ 2493| 1.56k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2494| 1.56k| { delete (((*yyvaluep).expr)); } 2495| 1.56k|#line 2496 "bison_parser.cpp" /* yacc.c:1257 */ 2496| 1.56k| break; 2497| | 2498| 0| case 276: /* scalar_expr */ ------------------ | Branch (2498:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 204| case 282: /* case_list */ ------------------ | Branch (2534:5): [True: 204, False: 54.1k] ------------------ 2535| 204|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2536| 204| { delete (((*yyvaluep).expr)); } 2537| 204|#line 2538 "bison_parser.cpp" /* yacc.c:1257 */ 2538| 204| break; 2539| | 2540| 0| case 283: /* exists_expr */ ------------------ | Branch (2540:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 202| case 287: /* opt_partition */ ------------------ | Branch (2564:5): [True: 202, False: 54.1k] ------------------ 2565| 202|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2566| 202| { 2567| 202| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2567:7): [True: 57, False: 145] ------------------ 2568| 307| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2568:19): [True: 307, False: 57] ------------------ 2569| 307| delete ptr; 2570| 307| } 2571| 57| } 2572| 202| delete (((*yyvaluep).expr_vec)); 2573| 202|} 2574| 202|#line 2575 "bison_parser.cpp" /* yacc.c:1257 */ 2575| 202| break; 2576| | 2577| 63| case 288: /* opt_frame_clause */ ------------------ | Branch (2577:5): [True: 63, False: 54.3k] ------------------ 2578| 63|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2579| 63| { delete (((*yyvaluep).frame_description)); } 2580| 63|#line 2581 "bison_parser.cpp" /* yacc.c:1257 */ 2581| 63| break; 2582| | 2583| 40| case 289: /* frame_type */ ------------------ | Branch (2583:5): [True: 40, False: 54.3k] ------------------ 2584| 40|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2585| 40| { } 2586| 40|#line 2587 "bison_parser.cpp" /* yacc.c:1257 */ 2587| 40| break; 2588| | 2589| 2| case 290: /* frame_bound */ ------------------ | Branch (2589:5): [True: 2, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 242| case 293: /* datetime_field */ ------------------ | Branch (2607:5): [True: 242, False: 54.1k] ------------------ 2608| 242|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2609| 242| { } 2610| 242|#line 2611 "bison_parser.cpp" /* yacc.c:1257 */ 2611| 242| break; 2612| | 2613| 0| case 294: /* datetime_field_plural */ ------------------ | Branch (2613:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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.15k| case 310: /* table_ref_atomic */ ------------------ | Branch (2709:5): [True: 2.15k, False: 52.2k] ------------------ 2710| 2.15k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2711| 2.15k| { delete (((*yyvaluep).table)); } 2712| 2.15k|#line 2713 "bison_parser.cpp" /* yacc.c:1257 */ 2713| 2.15k| break; 2714| | 2715| 0| case 311: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2715:5): [True: 0, False: 54.3k] ------------------ 2716| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2717| 0| { delete (((*yyvaluep).table)); } 2718| 0|#line 2719 "bison_parser.cpp" /* yacc.c:1257 */ 2719| 0| break; 2720| | 2721| 75| case 312: /* table_ref_commalist */ ------------------ | Branch (2721:5): [True: 75, False: 54.3k] ------------------ 2722| 75|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2723| 75| { 2724| 75| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2724:7): [True: 75, False: 0] ------------------ 2725| 1.45k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2725:19): [True: 1.45k, False: 75] ------------------ 2726| 1.45k| delete ptr; 2727| 1.45k| } 2728| 75| } 2729| 75| delete (((*yyvaluep).table_vec)); 2730| 75|} 2731| 75|#line 2732 "bison_parser.cpp" /* yacc.c:1257 */ 2732| 75| break; 2733| | 2734| 0| case 313: /* table_ref_name */ ------------------ | Branch (2734:5): [True: 0, False: 54.3k] ------------------ 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| 31| case 314: /* table_ref_name_no_alias */ ------------------ | Branch (2740:5): [True: 31, False: 54.3k] ------------------ 2741| 31|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2742| 31| { delete (((*yyvaluep).table)); } 2743| 31|#line 2744 "bison_parser.cpp" /* yacc.c:1257 */ 2744| 31| break; 2745| | 2746| 822| case 315: /* table_name */ ------------------ | Branch (2746:5): [True: 822, False: 53.5k] ------------------ 2747| 822|#line 182 "bison_parser.y" /* yacc.c:1257 */ 2748| 822| { 2749| 822| free(((*yyvaluep).table_name).name); 2750| 822| free(((*yyvaluep).table_name).schema); 2751| 822|} 2752| 822|#line 2753 "bison_parser.cpp" /* yacc.c:1257 */ 2753| 822| break; 2754| | 2755| 17| case 316: /* opt_index_name */ ------------------ | Branch (2755:5): [True: 17, False: 54.3k] ------------------ 2756| 17|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2757| 17| { free(((*yyvaluep).sval)); } 2758| 17|#line 2759 "bison_parser.cpp" /* yacc.c:1257 */ 2759| 17| break; 2760| | 2761| 0| case 317: /* table_alias */ ------------------ | Branch (2761:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 54.3k] ------------------ 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| 20| case 322: /* opt_locking_clause_list */ ------------------ | Branch (2791:5): [True: 20, False: 54.3k] ------------------ 2792| 20|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2793| 20| { delete (((*yyvaluep).locking_clause_vec)); } 2794| 20|#line 2795 "bison_parser.cpp" /* yacc.c:1257 */ 2795| 20| break; 2796| | 2797| 0| case 323: /* locking_clause */ ------------------ | Branch (2797:5): [True: 0, False: 54.3k] ------------------ 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| 6| case 324: /* row_lock_mode */ ------------------ | Branch (2803:5): [True: 6, False: 54.3k] ------------------ 2804| 6|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2805| 6| { } 2806| 6|#line 2807 "bison_parser.cpp" /* yacc.c:1257 */ 2807| 6| break; 2808| | 2809| 1| case 325: /* opt_row_lock_policy */ ------------------ | Branch (2809:5): [True: 1, False: 54.3k] ------------------ 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.54k| case 326: /* opt_with_clause */ ------------------ | Branch (2815:5): [True: 2.54k, False: 51.8k] ------------------ 2816| 2.54k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2817| 2.54k| { delete (((*yyvaluep).with_description_vec)); } 2818| 2.54k|#line 2819 "bison_parser.cpp" /* yacc.c:1257 */ 2819| 2.54k| break; 2820| | 2821| 0| case 327: /* with_clause */ ------------------ | Branch (2821:5): [True: 0, False: 54.3k] ------------------ 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| 41| case 328: /* with_description_list */ ------------------ | Branch (2827:5): [True: 41, False: 54.3k] ------------------ 2828| 41|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2829| 41| { delete (((*yyvaluep).with_description_vec)); } 2830| 41|#line 2831 "bison_parser.cpp" /* yacc.c:1257 */ 2831| 41| break; 2832| | 2833| 0| case 329: /* with_description */ ------------------ | Branch (2833:5): [True: 0, False: 54.3k] ------------------ 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: 54.3k] ------------------ 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: 52.2k] ------------------ 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: 54.3k] ------------------ 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| 23| case 334: /* ident_commalist */ ------------------ | Branch (2857:5): [True: 23, False: 54.3k] ------------------ 2858| 23|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2859| 23| { 2860| 23| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2860:7): [True: 23, False: 0] ------------------ 2861| 1.30k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2861:19): [True: 1.30k, False: 23] ------------------ 2862| 1.30k| free(ptr); 2863| 1.30k| } 2864| 23| } 2865| 23| delete (((*yyvaluep).str_vec)); 2866| 23|} 2867| 23|#line 2868 "bison_parser.cpp" /* yacc.c:1257 */ 2868| 23| break; 2869| | 2870| | 2871| 28.3k| default: ------------------ | Branch (2871:7): [True: 28.3k, False: 26.0k] ------------------ 2872| 28.3k| break; 2873| 54.3k| } 2874| 54.3k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2875| 54.3k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3152| 3.96M|{ 3153| 3.96M| yy_state_type yy_current_state; 3154| 3.96M| char *yy_cp, *yy_bp; 3155| 3.96M| int yy_act; 3156| 3.96M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3157| | 3158| 3.96M| yylval = yylval_param; ------------------ | | 2964| 3.96M| # define yylval yyg->yylval_r ------------------ 3159| | 3160| 3.96M| yylloc = yylloc_param; ------------------ | | 2966| 3.96M| # define yylloc yyg->yylloc_r ------------------ 3161| | 3162| 3.96M| if ( !yyg->yy_init ) ------------------ | Branch (3162:7): [True: 5.29k, False: 3.95M] ------------------ 3163| 5.29k| { 3164| 5.29k| yyg->yy_init = 1; 3165| | 3166| |#ifdef YY_USER_INIT 3167| | YY_USER_INIT; 3168| |#endif 3169| | 3170| 5.29k| if ( ! yyg->yy_start ) ------------------ | Branch (3170:8): [True: 5.29k, False: 0] ------------------ 3171| 5.29k| yyg->yy_start = 1; /* first start state */ 3172| | 3173| 5.29k| if ( ! yyin ) ------------------ | | 118| 5.29k|#define yyin yyg->yyin_r ------------------ | Branch (3173:8): [True: 5.29k, False: 0] ------------------ 3174| 5.29k| yyin = stdin; ------------------ | | 118| 5.29k|#define yyin yyg->yyin_r ------------------ 3175| | 3176| 5.29k| if ( ! yyout ) ------------------ | | 119| 5.29k|#define yyout yyg->yyout_r ------------------ | Branch (3176:8): [True: 5.29k, False: 0] ------------------ 3177| 5.29k| yyout = stdout; ------------------ | | 119| 5.29k|#define yyout yyg->yyout_r ------------------ 3178| | 3179| 5.29k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 269| 5.29k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.29k, False: 0] | | ------------------ | | 270| 5.29k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.29k| : NULL) ------------------ | Branch (3179:8): [True: 0, False: 5.29k] ------------------ 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.29k| hsql__load_buffer_state(yyscanner ); 3186| 5.29k| } 3187| | 3188| 3.96M| { 3189| 3.96M|#line 57 "flex_lexer.l" 3190| | 3191| | 3192| 3.96M|#line 3193 "flex_lexer.cpp" 3193| | 3194| 4.45M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3194:23): [True: 4.45M, Folded] ------------------ 3195| 4.45M| { 3196| 4.45M| yy_cp = yyg->yy_c_buf_p; 3197| | 3198| | /* Support of yytext. */ 3199| 4.45M| *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.45M| yy_bp = yy_cp; 3205| | 3206| 4.45M| yy_current_state = yyg->yy_start; 3207| 4.45M|yy_match: 3208| 4.45M| do 3209| 24.4M| { 3210| 24.4M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 108| 24.4M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ 3211| 24.4M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3211:9): [True: 16.0M, False: 8.40M] ------------------ 3212| 16.0M| { 3213| 16.0M| yyg->yy_last_accepting_state = yy_current_state; 3214| 16.0M| yyg->yy_last_accepting_cpos = yy_cp; 3215| 16.0M| } 3216| 44.4M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3216:12): [True: 20.0M, False: 24.4M] ------------------ 3217| 20.0M| { 3218| 20.0M| yy_current_state = (int) yy_def[yy_current_state]; 3219| 20.0M| if ( yy_current_state >= 1368 ) ------------------ | Branch (3219:10): [True: 15.0M, False: 4.98M] ------------------ 3220| 15.0M| yy_c = yy_meta[(unsigned int) yy_c]; 3221| 20.0M| } 3222| 24.4M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 3223| 24.4M| ++yy_cp; 3224| 24.4M| } 3225| 24.4M| while ( yy_current_state != 1367 ); ------------------ | Branch (3225:11): [True: 19.9M, False: 4.45M] ------------------ 3226| 4.45M| yy_cp = yyg->yy_last_accepting_cpos; 3227| 4.45M| yy_current_state = yyg->yy_last_accepting_state; 3228| | 3229| 4.45M|yy_find_action: 3230| 4.45M| yy_act = yy_accept[yy_current_state]; 3231| | 3232| 4.45M| YY_DO_BEFORE_ACTION; ------------------ | | 344| 4.45M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 333| 4.45M|#define yytext_ptr yytext_r | | ------------------ | | 345| 4.45M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 121| 4.45M|#define yyleng yyg->yyleng_r | | ------------------ | | 346| 4.45M| yyg->yy_hold_char = *yy_cp; \ | | 347| 4.45M| *yy_cp = '\0'; \ | | 348| 4.45M| yyg->yy_c_buf_p = yy_cp; ------------------ 3233| | 3234| 4.46M|do_action: /* This label is used only to access EOF actions. */ 3235| | 3236| 4.46M| switch ( yy_act ) 3237| 4.46M| { /* beginning of action switch */ 3238| 20| case 0: /* must back up */ ------------------ | Branch (3238:4): [True: 20, False: 4.46M] ------------------ 3239| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3240| 20| *yy_cp = yyg->yy_hold_char; 3241| 20| yy_cp = yyg->yy_last_accepting_cpos; 3242| 20| yy_current_state = yyg->yy_last_accepting_state; 3243| 20| goto yy_find_action; 3244| | 3245| 3.72k|case 1: ------------------ | Branch (3245:1): [True: 3.72k, False: 4.45M] ------------------ 3246| 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| 11.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.44k, False: 3.72k] | | | | ------------------ | | | | 64| 7.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.44k| } else { \ | | | | 70| 7.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.44k| } \ | | | | 72| 7.44k| } | | ------------------ ------------------ 3247| 3.72k|#line 59 "flex_lexer.l" 3248| 3.72k|BEGIN(COMMENT); ------------------ | | 131| 3.72k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 2908| 3.72k|#define COMMENT 2 ------------------ 3249| 3.72k| YY_BREAK ------------------ | | 3143| 3.72k|#define YY_BREAK /*LINTED*/break; ------------------ 3250| 3.55k|case 2: ------------------ | Branch (3250:1): [True: 3.55k, False: 4.45M] ------------------ 3251| 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| 1.56M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.56M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.55M, False: 3.55k] | | | | ------------------ | | | | 64| 1.55M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.55M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.55M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.55M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.55M] | | | | ------------------ | | | | 67| 0| 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.55M| } else { \ | | | | 70| 1.55M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.55M| } \ | | | | 72| 1.55M| } | | ------------------ ------------------ 3252| 3.55k|#line 60 "flex_lexer.l" 3253| 3.55k|/* skipping comment content until a end of line is read */; 3254| 3.55k| YY_BREAK ------------------ | | 3143| 3.55k|#define YY_BREAK /*LINTED*/break; ------------------ 3255| 3.53k|case 3: ------------------ | Branch (3255:1): [True: 3.53k, False: 4.45M] ------------------ 3256| |/* rule 3 can match eol */ 3257| 3.53k|YY_RULE_SETUP ------------------ | | 3147| 3.53k| YY_USER_ACTION | | ------------------ | | | | 61| 3.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.07k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.53k, False: 3.53k] | | | | ------------------ | | | | 64| 3.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 3.53k, False: 0] | | | | ------------------ | | | | 67| 3.53k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.53k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.53k| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 3.53k| } | | ------------------ ------------------ 3258| 3.53k|#line 61 "flex_lexer.l" 3259| 3.53k|BEGIN(INITIAL); ------------------ | | 131| 3.53k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2906| 3.53k|#define INITIAL 0 ------------------ 3260| 3.53k| YY_BREAK ------------------ | | 3143| 3.53k|#define YY_BREAK /*LINTED*/break; ------------------ 3261| 438k|case 4: ------------------ | Branch (3261:1): [True: 438k, False: 4.02M] ------------------ 3262| |/* rule 4 can match eol */ 3263| 438k|YY_RULE_SETUP ------------------ | | 3147| 438k| YY_USER_ACTION | | ------------------ | | | | 61| 438k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 438k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 438k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 438k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 438k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 438k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 889k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 889k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 451k, False: 438k] | | | | ------------------ | | | | 64| 451k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 451k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 451k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 451k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 451k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 451k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 197k, False: 253k] | | | | ------------------ | | | | 67| 197k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 197k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 197k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 197k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 253k| } else { \ | | | | 70| 253k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 253k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 253k| } \ | | | | 72| 451k| } | | ------------------ ------------------ 3264| 438k|#line 63 "flex_lexer.l" 3265| 438k|/* skip whitespace */; 3266| 438k| YY_BREAK ------------------ | | 3143| 438k|#define YY_BREAK /*LINTED*/break; ------------------ 3267| 2|case 5: ------------------ | Branch (3267:1): [True: 2, False: 4.46M] ------------------ 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.46M] ------------------ 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.24k|case 7: ------------------ | Branch (3277:1): [True: 2.24k, False: 4.45M] ------------------ 3278| 2.24k|YY_RULE_SETUP ------------------ | | 3147| 2.24k| YY_USER_ACTION | | ------------------ | | | | 61| 2.24k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.24k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.74k, False: 2.24k] | | | | ------------------ | | | | 64| 6.74k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.74k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.74k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.74k| } else { \ | | | | 70| 6.74k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.74k| } \ | | | | 72| 6.74k| } | | ------------------ ------------------ 3279| 2.24k|#line 67 "flex_lexer.l" 3280| 2.24k|TOKEN(ALL) ------------------ | | 2887| 2.24k|#define TOKEN(name) { return SQL_##name; } ------------------ 3281| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3282| 4|case 8: ------------------ | Branch (3282:1): [True: 4, False: 4.46M] ------------------ 3283| 4|YY_RULE_SETUP ------------------ | | 3147| 4| YY_USER_ACTION | | ------------------ | | | | 61| 4| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4| # 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: 20, False: 4] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3284| 4|#line 68 "flex_lexer.l" 3285| 4|TOKEN(ALTER) ------------------ | | 2887| 4|#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.46M] ------------------ 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.46k|case 10: ------------------ | Branch (3292:1): [True: 1.46k, False: 4.46M] ------------------ 3293| 1.46k|YY_RULE_SETUP ------------------ | | 3147| 1.46k| YY_USER_ACTION | | ------------------ | | | | 61| 1.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.38k, False: 1.46k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3294| 1.46k|#line 70 "flex_lexer.l" 3295| 1.46k|TOKEN(AND) ------------------ | | 2887| 1.46k|#define TOKEN(name) { return SQL_##name; } ------------------ 3296| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3297| 949|case 11: ------------------ | Branch (3297:1): [True: 949, False: 4.46M] ------------------ 3298| 949|YY_RULE_SETUP ------------------ | | 3147| 949| YY_USER_ACTION | | ------------------ | | | | 61| 949| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 949| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 949| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 949| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 949| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 949| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.74k, False: 949] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3299| 949|#line 71 "flex_lexer.l" 3300| 949|TOKEN(ARRAY) ------------------ | | 2887| 949|#define TOKEN(name) { return SQL_##name; } ------------------ 3301| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3302| 4.65k|case 12: ------------------ | Branch (3302:1): [True: 4.65k, False: 4.45M] ------------------ 3303| 4.65k|YY_RULE_SETUP ------------------ | | 3147| 4.65k| YY_USER_ACTION | | ------------------ | | | | 61| 4.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.31k, False: 4.65k] | | | | ------------------ | | | | 64| 9.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.31k| } else { \ | | | | 70| 9.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.31k| } \ | | | | 72| 9.31k| } | | ------------------ ------------------ 3304| 4.65k|#line 72 "flex_lexer.l" 3305| 4.65k|TOKEN(AS) ------------------ | | 2887| 4.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 3306| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3307| 586|case 13: ------------------ | Branch (3307:1): [True: 586, False: 4.46M] ------------------ 3308| 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.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.75k, False: 586] | | | | ------------------ | | | | 64| 1.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.75k| } else { \ | | | | 70| 1.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.75k| } \ | | | | 72| 1.75k| } | | ------------------ ------------------ 3309| 586|#line 73 "flex_lexer.l" 3310| 586|TOKEN(ASC) ------------------ | | 2887| 586|#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.46M] ------------------ 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| 3.62k|case 15: ------------------ | Branch (3317:1): [True: 3.62k, False: 4.45M] ------------------ 3318| 3.62k|YY_RULE_SETUP ------------------ | | 3147| 3.62k| YY_USER_ACTION | | ------------------ | | | | 61| 3.62k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.62k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 21.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.1k, False: 3.62k] | | | | ------------------ | | | | 64| 18.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 18.1k| } else { \ | | | | 70| 18.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.1k| } \ | | | | 72| 18.1k| } | | ------------------ ------------------ 3319| 3.62k|#line 75 "flex_lexer.l" 3320| 3.62k|TOKEN(BEGIN) ------------------ | | 2887| 3.62k|#define TOKEN(name) { return SQL_##name; } ------------------ 3321| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3322| 881|case 16: ------------------ | Branch (3322:1): [True: 881, False: 4.46M] ------------------ 3323| 881|YY_RULE_SETUP ------------------ | | 3147| 881| YY_USER_ACTION | | ------------------ | | | | 61| 881| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 881| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 881| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 881| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 881| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 881| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.16k, False: 881] | | | | ------------------ | | | | 64| 6.16k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.16k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.16k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.16k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.16k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.16k| } else { \ | | | | 70| 6.16k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.16k| } \ | | | | 72| 6.16k| } | | ------------------ ------------------ 3324| 881|#line 76 "flex_lexer.l" 3325| 881|TOKEN(BETWEEN) ------------------ | | 2887| 881|#define TOKEN(name) { return SQL_##name; } ------------------ 3326| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3327| 732|case 17: ------------------ | Branch (3327:1): [True: 732, False: 4.46M] ------------------ 3328| 732|YY_RULE_SETUP ------------------ | | 3147| 732| YY_USER_ACTION | | ------------------ | | | | 61| 732| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 732| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.39k, False: 732] | | | | ------------------ | | | | 64| 4.39k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.39k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.39k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.39k| } else { \ | | | | 70| 4.39k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.39k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.39k| } \ | | | | 72| 4.39k| } | | ------------------ ------------------ 3329| 732|#line 77 "flex_lexer.l" 3330| 732|TOKEN(BIGINT) ------------------ | | 2887| 732|#define TOKEN(name) { return SQL_##name; } ------------------ 3331| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3332| 576|case 18: ------------------ | Branch (3332:1): [True: 576, False: 4.46M] ------------------ 3333| 576|YY_RULE_SETUP ------------------ | | 3147| 576| YY_USER_ACTION | | ------------------ | | | | 61| 576| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 576| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.03k, False: 576] | | | | ------------------ | | | | 64| 4.03k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.03k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.03k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.03k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.03k| } else { \ | | | | 70| 4.03k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.03k| } \ | | | | 72| 4.03k| } | | ------------------ ------------------ 3334| 576|#line 78 "flex_lexer.l" 3335| 576|TOKEN(BOOLEAN) ------------------ | | 2887| 576|#define TOKEN(name) { return SQL_##name; } ------------------ 3336| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3337| 6.88k|case 19: ------------------ | Branch (3337:1): [True: 6.88k, False: 4.45M] ------------------ 3338| 6.88k|YY_RULE_SETUP ------------------ | | 3147| 6.88k| YY_USER_ACTION | | ------------------ | | | | 61| 6.88k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.88k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.88k| # 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: 13.7k, False: 6.88k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3339| 6.88k|#line 79 "flex_lexer.l" 3340| 6.88k|TOKEN(BY) ------------------ | | 2887| 6.88k|#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.46M] ------------------ 3343| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 3] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3344| 3|#line 80 "flex_lexer.l" 3345| 3|TOKEN(CALL) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3346| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3347| 1|case 21: ------------------ | Branch (3347:1): [True: 1, False: 4.46M] ------------------ 3348| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7, False: 1] | | | | ------------------ | | | | 64| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7| } else { \ | | | | 70| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| } \ | | | | 72| 7| } | | ------------------ ------------------ 3349| 1|#line 81 "flex_lexer.l" 3350| 1|TOKEN(CASCADE) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3351| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3352| 2.20k|case 22: ------------------ | Branch (3352:1): [True: 2.20k, False: 4.45M] ------------------ 3353| 2.20k|YY_RULE_SETUP ------------------ | | 3147| 2.20k| YY_USER_ACTION | | ------------------ | | | | 61| 2.20k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.20k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.20k| # 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: 8.80k, False: 2.20k] | | | | ------------------ | | | | 64| 8.80k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.80k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.80k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.80k| } else { \ | | | | 70| 8.80k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.80k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.80k| } \ | | | | 72| 8.80k| } | | ------------------ ------------------ 3354| 2.20k|#line 82 "flex_lexer.l" 3355| 2.20k|TOKEN(CASE) ------------------ | | 2887| 2.20k|#define TOKEN(name) { return SQL_##name; } ------------------ 3356| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3357| 634|case 23: ------------------ | Branch (3357:1): [True: 634, False: 4.46M] ------------------ 3358| 634|YY_RULE_SETUP ------------------ | | 3147| 634| YY_USER_ACTION | | ------------------ | | | | 61| 634| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 634| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 634| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 634| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 634| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 634| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.53k, False: 634] | | | | ------------------ | | | | 64| 2.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.53k] | | | | ------------------ | | | | 67| 0| 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.53k| } else { \ | | | | 70| 2.53k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.53k| } \ | | | | 72| 2.53k| } | | ------------------ ------------------ 3359| 634|#line 83 "flex_lexer.l" 3360| 634|TOKEN(CAST) ------------------ | | 2887| 634|#define TOKEN(name) { return SQL_##name; } ------------------ 3361| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3362| 500|case 24: ------------------ | Branch (3362:1): [True: 500, False: 4.46M] ------------------ 3363| 500|YY_RULE_SETUP ------------------ | | 3147| 500| YY_USER_ACTION | | ------------------ | | | | 61| 500| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 500| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 500| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.50k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.00k, False: 500] | | | | ------------------ | | | | 64| 2.00k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.00k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.00k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.00k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.00k| } else { \ | | | | 70| 2.00k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.00k| } \ | | | | 72| 2.00k| } | | ------------------ ------------------ 3364| 500|#line 84 "flex_lexer.l" 3365| 500|TOKEN(CHAR) ------------------ | | 2887| 500|#define TOKEN(name) { return SQL_##name; } ------------------ 3366| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3367| 2|case 25: ------------------ | Branch (3367:1): [True: 2, False: 4.46M] ------------------ 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.18k|case 26: ------------------ | Branch (3372:1): [True: 1.18k, False: 4.46M] ------------------ 3373| 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| 9.45k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.27k, False: 1.18k] | | | | ------------------ | | | | 64| 8.27k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.27k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.27k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.27k| } else { \ | | | | 70| 8.27k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.27k| } \ | | | | 72| 8.27k| } | | ------------------ ------------------ 3374| 1.18k|#line 86 "flex_lexer.l" 3375| 1.18k|TOKEN(COLUMNS) ------------------ | | 2887| 1.18k|#define TOKEN(name) { return SQL_##name; } ------------------ 3376| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3377| 3.31k|case 27: ------------------ | Branch (3377:1): [True: 3.31k, False: 4.45M] ------------------ 3378| 3.31k|YY_RULE_SETUP ------------------ | | 3147| 3.31k| YY_USER_ACTION | | ------------------ | | | | 61| 3.31k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.31k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.31k| # 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: 19.9k, False: 3.31k] | | | | ------------------ | | | | 64| 19.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 19.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 19.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 19.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 19.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 19.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 19.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| 19.9k| } else { \ | | | | 70| 19.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 19.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 19.9k| } \ | | | | 72| 19.9k| } | | ------------------ ------------------ 3379| 3.31k|#line 87 "flex_lexer.l" 3380| 3.31k|TOKEN(COMMIT) ------------------ | | 2887| 3.31k|#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.46M] ------------------ 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| 12.7k|case 29: ------------------ | Branch (3387:1): [True: 12.7k, False: 4.44M] ------------------ 3388| 12.7k|YY_RULE_SETUP ------------------ | | 3147| 12.7k| YY_USER_ACTION | | ------------------ | | | | 61| 12.7k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 12.7k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 63.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 63.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 51.0k, False: 12.7k] | | | | ------------------ | | | | 64| 51.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 51.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 51.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 51.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 51.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 51.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 51.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| 51.0k| } else { \ | | | | 70| 51.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 51.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 51.0k| } \ | | | | 72| 51.0k| } | | ------------------ ------------------ 3389| 12.7k|#line 89 "flex_lexer.l" 3390| 12.7k|TOKEN(COPY) ------------------ | | 2887| 12.7k|#define TOKEN(name) { return SQL_##name; } ------------------ 3391| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3392| 7.16k|case 30: ------------------ | Branch (3392:1): [True: 7.16k, False: 4.45M] ------------------ 3393| 7.16k|YY_RULE_SETUP ------------------ | | 3147| 7.16k| YY_USER_ACTION | | ------------------ | | | | 61| 7.16k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.16k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 50.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 50.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 43.0k, False: 7.16k] | | | | ------------------ | | | | 64| 43.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 43.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 43.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 43.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 43.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 43.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 43.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| 43.0k| } else { \ | | | | 70| 43.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 43.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 43.0k| } \ | | | | 72| 43.0k| } | | ------------------ ------------------ 3394| 7.16k|#line 90 "flex_lexer.l" 3395| 7.16k|TOKEN(CREATE) ------------------ | | 2887| 7.16k|#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.46M] ------------------ 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| 2.93k|case 32: ------------------ | Branch (3402:1): [True: 2.93k, False: 4.45M] ------------------ 3403| 2.93k|YY_RULE_SETUP ------------------ | | 3147| 2.93k| YY_USER_ACTION | | ------------------ | | | | 61| 2.93k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.93k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.93k| # 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: 11.7k, False: 2.93k] | | | | ------------------ | | | | 64| 11.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.7k| } else { \ | | | | 70| 11.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.7k| } \ | | | | 72| 11.7k| } | | ------------------ ------------------ 3404| 2.93k|#line 92 "flex_lexer.l" 3405| 2.93k|TOKEN(DATE) ------------------ | | 2887| 2.93k|#define TOKEN(name) { return SQL_##name; } ------------------ 3406| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3407| 396|case 33: ------------------ | Branch (3407:1): [True: 396, False: 4.46M] ------------------ 3408| 396|YY_RULE_SETUP ------------------ | | 3147| 396| YY_USER_ACTION | | ------------------ | | | | 61| 396| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 396| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 396| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 396| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 396| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 396| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.16k, False: 396] | | | | ------------------ | | | | 64| 3.16k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.16k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.16k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.16k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.16k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.16k| } else { \ | | | | 70| 3.16k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.16k| } \ | | | | 72| 3.16k| } | | ------------------ ------------------ 3409| 396|#line 93 "flex_lexer.l" 3410| 396|TOKEN(DATETIME) ------------------ | | 2887| 396|#define TOKEN(name) { return SQL_##name; } ------------------ 3411| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3412| 1.81k|case 34: ------------------ | Branch (3412:1): [True: 1.81k, False: 4.46M] ------------------ 3413| 1.81k|YY_RULE_SETUP ------------------ | | 3147| 1.81k| YY_USER_ACTION | | ------------------ | | | | 61| 1.81k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.81k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.25k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.43k, False: 1.81k] | | | | ------------------ | | | | 64| 5.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.43k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.43k| } else { \ | | | | 70| 5.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.43k| } \ | | | | 72| 5.43k| } | | ------------------ ------------------ 3414| 1.81k|#line 94 "flex_lexer.l" 3415| 1.81k|TOKEN(DAY) ------------------ | | 2887| 1.81k|#define TOKEN(name) { return SQL_##name; } ------------------ 3416| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3417| 407|case 35: ------------------ | Branch (3417:1): [True: 407, False: 4.46M] ------------------ 3418| 407|YY_RULE_SETUP ------------------ | | 3147| 407| YY_USER_ACTION | | ------------------ | | | | 61| 407| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 407| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 407| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 407| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 407| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 407| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.62k, False: 407] | | | | ------------------ | | | | 64| 1.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.62k] | | | | ------------------ | | | | 67| 0| 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.62k| } else { \ | | | | 70| 1.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.62k| } \ | | | | 72| 1.62k| } | | ------------------ ------------------ 3419| 407|#line 95 "flex_lexer.l" 3420| 407|TOKEN(DAYS) ------------------ | | 2887| 407|#define TOKEN(name) { return SQL_##name; } ------------------ 3421| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3422| 829|case 36: ------------------ | Branch (3422:1): [True: 829, False: 4.46M] ------------------ 3423| 829|YY_RULE_SETUP ------------------ | | 3147| 829| YY_USER_ACTION | | ------------------ | | | | 61| 829| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 829| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 829| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 829| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 829| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 829| # 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: 8.29k, False: 829] | | | | ------------------ | | | | 64| 8.29k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.29k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.29k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.29k] | | | | ------------------ | | | | 67| 0| 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.29k| } else { \ | | | | 70| 8.29k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.29k| } \ | | | | 72| 8.29k| } | | ------------------ ------------------ 3424| 829|#line 96 "flex_lexer.l" 3425| 829|TOKEN(DEALLOCATE) ------------------ | | 2887| 829|#define TOKEN(name) { return SQL_##name; } ------------------ 3426| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3427| 909|case 37: ------------------ | Branch (3427:1): [True: 909, False: 4.46M] ------------------ 3428| 909|YY_RULE_SETUP ------------------ | | 3147| 909| YY_USER_ACTION | | ------------------ | | | | 61| 909| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 909| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 909| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.27k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.36k, False: 909] | | | | ------------------ | | | | 64| 6.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.36k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.36k| } else { \ | | | | 70| 6.36k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.36k| } \ | | | | 72| 6.36k| } | | ------------------ ------------------ 3429| 909|#line 97 "flex_lexer.l" 3430| 909|TOKEN(DECIMAL) ------------------ | | 2887| 909|#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.46M] ------------------ 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.51k|case 39: ------------------ | Branch (3437:1): [True: 1.51k, False: 4.46M] ------------------ 3438| 1.51k|YY_RULE_SETUP ------------------ | | 3147| 1.51k| YY_USER_ACTION | | ------------------ | | | | 61| 1.51k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.51k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.11k, False: 1.51k] | | | | ------------------ | | | | 64| 9.11k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.11k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.11k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.11k| } else { \ | | | | 70| 9.11k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.11k| } \ | | | | 72| 9.11k| } | | ------------------ ------------------ 3439| 1.51k|#line 99 "flex_lexer.l" 3440| 1.51k|TOKEN(DELETE) ------------------ | | 2887| 1.51k|#define TOKEN(name) { return SQL_##name; } ------------------ 3441| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3442| 2|case 40: ------------------ | Branch (3442:1): [True: 2, False: 4.46M] ------------------ 3443| 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| } | | ------------------ ------------------ 3444| 2|#line 100 "flex_lexer.l" 3445| 2|TOKEN(DELTA) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3446| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3447| 632|case 41: ------------------ | Branch (3447:1): [True: 632, False: 4.46M] ------------------ 3448| 632|YY_RULE_SETUP ------------------ | | 3147| 632| YY_USER_ACTION | | ------------------ | | | | 61| 632| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 632| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.16k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.16k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.52k, False: 632] | | | | ------------------ | | | | 64| 2.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.52k| } else { \ | | | | 70| 2.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.52k| } \ | | | | 72| 2.52k| } | | ------------------ ------------------ 3449| 632|#line 101 "flex_lexer.l" 3450| 632|TOKEN(DESC) ------------------ | | 2887| 632|#define TOKEN(name) { return SQL_##name; } ------------------ 3451| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3452| 3.79k|case 42: ------------------ | Branch (3452:1): [True: 3.79k, False: 4.45M] ------------------ 3453| 3.79k|YY_RULE_SETUP ------------------ | | 3147| 3.79k| YY_USER_ACTION | | ------------------ | | | | 61| 3.79k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.79k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 34.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 34.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 30.3k, False: 3.79k] | | | | ------------------ | | | | 64| 30.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 30.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 30.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 30.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 30.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 30.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 30.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| 30.3k| } else { \ | | | | 70| 30.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 30.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 30.3k| } \ | | | | 72| 30.3k| } | | ------------------ ------------------ 3454| 3.79k|#line 102 "flex_lexer.l" 3455| 3.79k|TOKEN(DESCRIBE) ------------------ | | 2887| 3.79k|#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.46M] ------------------ 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| 554|case 44: ------------------ | Branch (3462:1): [True: 554, False: 4.46M] ------------------ 3463| 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| } | | ------------------ ------------------ 3464| 554|#line 104 "flex_lexer.l" 3465| 554|TOKEN(DISTINCT) ------------------ | | 2887| 554|#define TOKEN(name) { return SQL_##name; } ------------------ 3466| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3467| 790|case 45: ------------------ | Branch (3467:1): [True: 790, False: 4.46M] ------------------ 3468| 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| } | | ------------------ ------------------ 3469| 790|#line 105 "flex_lexer.l" 3470| 790|TOKEN(DOUBLE) ------------------ | | 2887| 790|#define TOKEN(name) { return SQL_##name; } ------------------ 3471| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3472| 2.98k|case 46: ------------------ | Branch (3472:1): [True: 2.98k, False: 4.45M] ------------------ 3473| 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| 14.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.9k, False: 2.98k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3474| 2.98k|#line 106 "flex_lexer.l" 3475| 2.98k|TOKEN(DROP) ------------------ | | 2887| 2.98k|#define TOKEN(name) { return SQL_##name; } ------------------ 3476| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3477| 767|case 47: ------------------ | Branch (3477:1): [True: 767, False: 4.46M] ------------------ 3478| 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| 3.83k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.06k, False: 767] | | | | ------------------ | | | | 64| 3.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.06k| } else { \ | | | | 70| 3.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.06k| } \ | | | | 72| 3.06k| } | | ------------------ ------------------ 3479| 767|#line 107 "flex_lexer.l" 3480| 767|TOKEN(ELSE) ------------------ | | 2887| 767|#define TOKEN(name) { return SQL_##name; } ------------------ 3481| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3482| 1.48k|case 48: ------------------ | Branch (3482:1): [True: 1.48k, False: 4.46M] ------------------ 3483| 1.48k|YY_RULE_SETUP ------------------ | | 3147| 1.48k| YY_USER_ACTION | | ------------------ | | | | 61| 1.48k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.48k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.8k, False: 1.48k] | | | | ------------------ | | | | 64| 11.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.8k| } else { \ | | | | 70| 11.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.8k| } \ | | | | 72| 11.8k| } | | ------------------ ------------------ 3484| 1.48k|#line 108 "flex_lexer.l" 3485| 1.48k|TOKEN(ENCODING) ------------------ | | 2887| 1.48k|#define TOKEN(name) { return SQL_##name; } ------------------ 3486| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3487| 1.65k|case 49: ------------------ | Branch (3487:1): [True: 1.65k, False: 4.46M] ------------------ 3488| 1.65k|YY_RULE_SETUP ------------------ | | 3147| 1.65k| YY_USER_ACTION | | ------------------ | | | | 61| 1.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.63k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.97k, False: 1.65k] | | | | ------------------ | | | | 64| 4.97k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.97k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.97k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.97k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.97k] | | | | ------------------ | | | | 67| 0| 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.97k| } else { \ | | | | 70| 4.97k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.97k| } \ | | | | 72| 4.97k| } | | ------------------ ------------------ 3489| 1.65k|#line 109 "flex_lexer.l" 3490| 1.65k|TOKEN(END) ------------------ | | 2887| 1.65k|#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.46M] ------------------ 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| 944|case 51: ------------------ | Branch (3497:1): [True: 944, False: 4.46M] ------------------ 3498| 944|YY_RULE_SETUP ------------------ | | 3147| 944| YY_USER_ACTION | | ------------------ | | | | 61| 944| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 944| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 944| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 944| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 944| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 944| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.66k, False: 944] | | | | ------------------ | | | | 64| 5.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.66k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.66k| } else { \ | | | | 70| 5.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.66k| } \ | | | | 72| 5.66k| } | | ------------------ ------------------ 3499| 944|#line 111 "flex_lexer.l" 3500| 944|TOKEN(EXCEPT) ------------------ | | 2887| 944|#define TOKEN(name) { return SQL_##name; } ------------------ 3501| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3502| 3.71k|case 52: ------------------ | Branch (3502:1): [True: 3.71k, False: 4.45M] ------------------ 3503| 3.71k|YY_RULE_SETUP ------------------ | | 3147| 3.71k| YY_USER_ACTION | | ------------------ | | | | 61| 3.71k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.71k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 29.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 29.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 25.9k, False: 3.71k] | | | | ------------------ | | | | 64| 25.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 25.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 25.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 25.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 25.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 25.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 25.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| 25.9k| } else { \ | | | | 70| 25.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 25.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 25.9k| } \ | | | | 72| 25.9k| } | | ------------------ ------------------ 3504| 3.71k|#line 112 "flex_lexer.l" 3505| 3.71k|TOKEN(EXECUTE) ------------------ | | 2887| 3.71k|#define TOKEN(name) { return SQL_##name; } ------------------ 3506| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3507| 1.26k|case 53: ------------------ | Branch (3507:1): [True: 1.26k, False: 4.46M] ------------------ 3508| 1.26k|YY_RULE_SETUP ------------------ | | 3147| 1.26k| YY_USER_ACTION | | ------------------ | | | | 61| 1.26k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.26k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.59k, False: 1.26k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3509| 1.26k|#line 113 "flex_lexer.l" 3510| 1.26k|TOKEN(EXISTS) ------------------ | | 2887| 1.26k|#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.46M] ------------------ 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| 840|case 55: ------------------ | Branch (3517:1): [True: 840, False: 4.46M] ------------------ 3518| 840|YY_RULE_SETUP ------------------ | | 3147| 840| YY_USER_ACTION | | ------------------ | | | | 61| 840| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 840| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 840| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 840| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 840| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 840| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.72k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.88k, False: 840] | | | | ------------------ | | | | 64| 5.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.88k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.88k| } else { \ | | | | 70| 5.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.88k| } \ | | | | 72| 5.88k| } | | ------------------ ------------------ 3519| 840|#line 115 "flex_lexer.l" 3520| 840|TOKEN(EXTRACT) ------------------ | | 2887| 840|#define TOKEN(name) { return SQL_##name; } ------------------ 3521| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3522| 525|case 56: ------------------ | Branch (3522:1): [True: 525, False: 4.46M] ------------------ 3523| 525|YY_RULE_SETUP ------------------ | | 3147| 525| YY_USER_ACTION | | ------------------ | | | | 61| 525| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 525| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 525| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 525| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 525| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 525| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.15k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.62k, False: 525] | | | | ------------------ | | | | 64| 2.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.62k] | | | | ------------------ | | | | 67| 0| 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.62k| } else { \ | | | | 70| 2.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.62k| } \ | | | | 72| 2.62k| } | | ------------------ ------------------ 3524| 525|#line 116 "flex_lexer.l" 3525| 525|TOKEN(FALSE) ------------------ | | 2887| 525|#define TOKEN(name) { return SQL_##name; } ------------------ 3526| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3527| 2|case 57: ------------------ | Branch (3527:1): [True: 2, False: 4.46M] ------------------ 3528| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8, False: 2] | | | | ------------------ | | | | 64| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8| } else { \ | | | | 70| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| } \ | | | | 72| 8| } | | ------------------ ------------------ 3529| 2|#line 117 "flex_lexer.l" 3530| 2|TOKEN(FILE) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3531| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3532| 727|case 58: ------------------ | Branch (3532:1): [True: 727, False: 4.46M] ------------------ 3533| 727|YY_RULE_SETUP ------------------ | | 3147| 727| YY_USER_ACTION | | ------------------ | | | | 61| 727| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 727| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 727| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 727| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 727| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 727| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.63k, False: 727] | | | | ------------------ | | | | 64| 3.63k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.63k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.63k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.63k] | | | | ------------------ | | | | 67| 0| 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.63k| } else { \ | | | | 70| 3.63k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.63k| } \ | | | | 72| 3.63k| } | | ------------------ ------------------ 3534| 727|#line 118 "flex_lexer.l" 3535| 727|TOKEN(FLOAT) ------------------ | | 2887| 727|#define TOKEN(name) { return SQL_##name; } ------------------ 3536| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3537| 1.90k|case 59: ------------------ | Branch (3537:1): [True: 1.90k, False: 4.46M] ------------------ 3538| 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| 19.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 17.1k, False: 1.90k] | | | | ------------------ | | | | 64| 17.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 17.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 17.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 17.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 17.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| 17.1k| } else { \ | | | | 70| 17.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.1k| } \ | | | | 72| 17.1k| } | | ------------------ ------------------ 3539| 1.90k|#line 119 "flex_lexer.l" 3540| 1.90k|TOKEN(FOLLOWING) ------------------ | | 2887| 1.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 3541| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3542| 3.79k|case 60: ------------------ | Branch (3542:1): [True: 3.79k, False: 4.45M] ------------------ 3543| 3.79k|YY_RULE_SETUP ------------------ | | 3147| 3.79k| YY_USER_ACTION | | ------------------ | | | | 61| 3.79k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.79k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.3k, False: 3.79k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3544| 3.79k|#line 120 "flex_lexer.l" 3545| 3.79k|TOKEN(FOR) ------------------ | | 2887| 3.79k|#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.46M] ------------------ 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.74k|case 62: ------------------ | Branch (3552:1): [True: 1.74k, False: 4.46M] ------------------ 3553| 1.74k|YY_RULE_SETUP ------------------ | | 3147| 1.74k| YY_USER_ACTION | | ------------------ | | | | 61| 1.74k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.74k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.74k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.74k| # 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: 10.4k, False: 1.74k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3554| 1.74k|#line 122 "flex_lexer.l" 3555| 1.74k|TOKEN(FORMAT) ------------------ | | 2887| 1.74k|#define TOKEN(name) { return SQL_##name; } ------------------ 3556| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3557| 13.1k|case 63: ------------------ | Branch (3557:1): [True: 13.1k, False: 4.44M] ------------------ 3558| 13.1k|YY_RULE_SETUP ------------------ | | 3147| 13.1k| YY_USER_ACTION | | ------------------ | | | | 61| 13.1k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 13.1k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 65.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 65.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 52.5k, False: 13.1k] | | | | ------------------ | | | | 64| 52.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 52.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 52.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 52.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 52.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 52.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 52.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| 52.5k| } else { \ | | | | 70| 52.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 52.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 52.5k| } \ | | | | 72| 52.5k| } | | ------------------ ------------------ 3559| 13.1k|#line 123 "flex_lexer.l" 3560| 13.1k|TOKEN(FROM) ------------------ | | 2887| 13.1k|#define TOKEN(name) { return SQL_##name; } ------------------ 3561| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3562| 207|case 64: ------------------ | Branch (3562:1): [True: 207, False: 4.46M] ------------------ 3563| 207|YY_RULE_SETUP ------------------ | | 3147| 207| YY_USER_ACTION | | ------------------ | | | | 61| 207| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 207| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 207| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 207| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 207| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 207| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 828, False: 207] | | | | ------------------ | | | | 64| 828| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 828| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 828| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 828| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 828| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 828|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 828] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 828| } else { \ | | | | 70| 828| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 828| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 828| } \ | | | | 72| 828| } | | ------------------ ------------------ 3564| 207|#line 124 "flex_lexer.l" 3565| 207|TOKEN(FULL) ------------------ | | 2887| 207|#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.46M] ------------------ 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.14k|case 66: ------------------ | Branch (3572:1): [True: 3.14k, False: 4.45M] ------------------ 3573| 3.14k|YY_RULE_SETUP ------------------ | | 3147| 3.14k| YY_USER_ACTION | | ------------------ | | | | 61| 3.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.7k, False: 3.14k] | | | | ------------------ | | | | 64| 15.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.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| 15.7k| } else { \ | | | | 70| 15.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.7k| } \ | | | | 72| 15.7k| } | | ------------------ ------------------ 3574| 3.14k|#line 126 "flex_lexer.l" 3575| 3.14k|TOKEN(GROUP) ------------------ | | 2887| 3.14k|#define TOKEN(name) { return SQL_##name; } ------------------ 3576| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3577| 503|case 67: ------------------ | Branch (3577:1): [True: 503, False: 4.46M] ------------------ 3578| 503|YY_RULE_SETUP ------------------ | | 3147| 503| YY_USER_ACTION | | ------------------ | | | | 61| 503| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 503| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 503| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 503| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 503| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 503| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.01k, False: 503] | | | | ------------------ | | | | 64| 3.01k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.01k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.01k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.01k| } else { \ | | | | 70| 3.01k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.01k| } \ | | | | 72| 3.01k| } | | ------------------ ------------------ 3579| 503|#line 127 "flex_lexer.l" 3580| 503|TOKEN(GROUPS) ------------------ | | 2887| 503|#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.46M] ------------------ 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| 680|case 69: ------------------ | Branch (3587:1): [True: 680, False: 4.46M] ------------------ 3588| 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| 4.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.08k, False: 680] | | | | ------------------ | | | | 64| 4.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.08k| } else { \ | | | | 70| 4.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.08k| } \ | | | | 72| 4.08k| } | | ------------------ ------------------ 3589| 680|#line 129 "flex_lexer.l" 3590| 680|TOKEN(HAVING) ------------------ | | 2887| 680|#define TOKEN(name) { return SQL_##name; } ------------------ 3591| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3592| 728|case 70: ------------------ | Branch (3592:1): [True: 728, False: 4.46M] ------------------ 3593| 728|YY_RULE_SETUP ------------------ | | 3147| 728| YY_USER_ACTION | | ------------------ | | | | 61| 728| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 728| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 728| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 728| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 728| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 728| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.64k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.91k, False: 728] | | | | ------------------ | | | | 64| 2.91k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.91k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.91k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.91k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.91k] | | | | ------------------ | | | | 67| 0| 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.91k| } else { \ | | | | 70| 2.91k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.91k| } \ | | | | 72| 2.91k| } | | ------------------ ------------------ 3594| 728|#line 130 "flex_lexer.l" 3595| 728|TOKEN(HINT) ------------------ | | 2887| 728|#define TOKEN(name) { return SQL_##name; } ------------------ 3596| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3597| 835|case 71: ------------------ | Branch (3597:1): [True: 835, False: 4.46M] ------------------ 3598| 835|YY_RULE_SETUP ------------------ | | 3147| 835| YY_USER_ACTION | | ------------------ | | | | 61| 835| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 835| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 835| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 835| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 835| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 835| # 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.34k, False: 835] | | | | ------------------ | | | | 64| 3.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.34k| } else { \ | | | | 70| 3.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.34k| } \ | | | | 72| 3.34k| } | | ------------------ ------------------ 3599| 835|#line 131 "flex_lexer.l" 3600| 835|TOKEN(HOUR) ------------------ | | 2887| 835|#define TOKEN(name) { return SQL_##name; } ------------------ 3601| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3602| 1.09k|case 72: ------------------ | Branch (3602:1): [True: 1.09k, False: 4.46M] ------------------ 3603| 1.09k|YY_RULE_SETUP ------------------ | | 3147| 1.09k| YY_USER_ACTION | | ------------------ | | | | 61| 1.09k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.09k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.47k, False: 1.09k] | | | | ------------------ | | | | 64| 5.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.47k| } else { \ | | | | 70| 5.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.47k| } \ | | | | 72| 5.47k| } | | ------------------ ------------------ 3604| 1.09k|#line 132 "flex_lexer.l" 3605| 1.09k|TOKEN(HOURS) ------------------ | | 2887| 1.09k|#define TOKEN(name) { return SQL_##name; } ------------------ 3606| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3607| 506|case 73: ------------------ | Branch (3607:1): [True: 506, False: 4.46M] ------------------ 3608| 506|YY_RULE_SETUP ------------------ | | 3147| 506| YY_USER_ACTION | | ------------------ | | | | 61| 506| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 506| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 506| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 506| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 506| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 506| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.01k, False: 506] | | | | ------------------ | | | | 64| 1.01k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.01k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.01k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.01k| } else { \ | | | | 70| 1.01k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.01k| } \ | | | | 72| 1.01k| } | | ------------------ ------------------ 3609| 506|#line 133 "flex_lexer.l" 3610| 506|TOKEN(IF) ------------------ | | 2887| 506|#define TOKEN(name) { return SQL_##name; } ------------------ 3611| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3612| 662|case 74: ------------------ | Branch (3612:1): [True: 662, False: 4.46M] ------------------ 3613| 662|YY_RULE_SETUP ------------------ | | 3147| 662| YY_USER_ACTION | | ------------------ | | | | 61| 662| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 662| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.97k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.97k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.31k, False: 662] | | | | ------------------ | | | | 64| 3.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.31k| } else { \ | | | | 70| 3.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.31k| } \ | | | | 72| 3.31k| } | | ------------------ ------------------ 3614| 662|#line 134 "flex_lexer.l" 3615| 662|TOKEN(ILIKE) ------------------ | | 2887| 662|#define TOKEN(name) { return SQL_##name; } ------------------ 3616| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3617| 109|case 75: ------------------ | Branch (3617:1): [True: 109, False: 4.46M] ------------------ 3618| 109|YY_RULE_SETUP ------------------ | | 3147| 109| YY_USER_ACTION | | ------------------ | | | | 61| 109| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 109| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 109| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 109| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 109| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 109| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 763| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 763|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 654, False: 109] | | | | ------------------ | | | | 64| 654| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 654| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 654| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 654| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 654| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 654|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 654] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 654| } else { \ | | | | 70| 654| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 654| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 654| } \ | | | | 72| 654| } | | ------------------ ------------------ 3619| 109|#line 135 "flex_lexer.l" 3620| 109|TOKEN(IMPORT) ------------------ | | 2887| 109|#define TOKEN(name) { return SQL_##name; } ------------------ 3621| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3622| 1.36k|case 76: ------------------ | Branch (3622:1): [True: 1.36k, False: 4.46M] ------------------ 3623| 1.36k|YY_RULE_SETUP ------------------ | | 3147| 1.36k| YY_USER_ACTION | | ------------------ | | | | 61| 1.36k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.36k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.08k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.72k, False: 1.36k] | | | | ------------------ | | | | 64| 2.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.72k| } else { \ | | | | 70| 2.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.72k| } \ | | | | 72| 2.72k| } | | ------------------ ------------------ 3624| 1.36k|#line 136 "flex_lexer.l" 3625| 1.36k|TOKEN(IN) ------------------ | | 2887| 1.36k|#define TOKEN(name) { return SQL_##name; } ------------------ 3626| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3627| 1.31k|case 77: ------------------ | Branch (3627:1): [True: 1.31k, False: 4.46M] ------------------ 3628| 1.31k|YY_RULE_SETUP ------------------ | | 3147| 1.31k| YY_USER_ACTION | | ------------------ | | | | 61| 1.31k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.31k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.86k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.55k, False: 1.31k] | | | | ------------------ | | | | 64| 6.55k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.55k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.55k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.55k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.55k] | | | | ------------------ | | | | 67| 0| 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.55k| } else { \ | | | | 70| 6.55k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.55k| } \ | | | | 72| 6.55k| } | | ------------------ ------------------ 3629| 1.31k|#line 137 "flex_lexer.l" 3630| 1.31k|TOKEN(INDEX) ------------------ | | 2887| 1.31k|#define TOKEN(name) { return SQL_##name; } ------------------ 3631| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3632| 724|case 78: ------------------ | Branch (3632:1): [True: 724, False: 4.46M] ------------------ 3633| 724|YY_RULE_SETUP ------------------ | | 3147| 724| YY_USER_ACTION | | ------------------ | | | | 61| 724| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 724| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 724| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.62k, False: 724] | | | | ------------------ | | | | 64| 3.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.62k] | | | | ------------------ | | | | 67| 0| 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.62k| } else { \ | | | | 70| 3.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.62k| } \ | | | | 72| 3.62k| } | | ------------------ ------------------ 3634| 724|#line 138 "flex_lexer.l" 3635| 724|TOKEN(INNER) ------------------ | | 2887| 724|#define TOKEN(name) { return SQL_##name; } ------------------ 3636| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3637| 3.38k|case 79: ------------------ | Branch (3637:1): [True: 3.38k, False: 4.45M] ------------------ 3638| 3.38k|YY_RULE_SETUP ------------------ | | 3147| 3.38k| YY_USER_ACTION | | ------------------ | | | | 61| 3.38k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.38k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 23.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.3k, False: 3.38k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3639| 3.38k|#line 139 "flex_lexer.l" 3640| 3.38k|TOKEN(INSERT) ------------------ | | 2887| 3.38k|#define TOKEN(name) { return SQL_##name; } ------------------ 3641| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3642| 7.23k|case 80: ------------------ | Branch (3642:1): [True: 7.23k, False: 4.45M] ------------------ 3643| 7.23k|YY_RULE_SETUP ------------------ | | 3147| 7.23k| YY_USER_ACTION | | ------------------ | | | | 61| 7.23k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.23k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 28.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 28.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21.7k, False: 7.23k] | | | | ------------------ | | | | 64| 21.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 21.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 21.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 21.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 21.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 21.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 21.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| 21.7k| } else { \ | | | | 70| 21.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 21.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21.7k| } \ | | | | 72| 21.7k| } | | ------------------ ------------------ 3644| 7.23k|#line 140 "flex_lexer.l" 3645| 7.23k|TOKEN(INT) ------------------ | | 2887| 7.23k|#define TOKEN(name) { return SQL_##name; } ------------------ 3646| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3647| 784|case 81: ------------------ | Branch (3647:1): [True: 784, False: 4.46M] ------------------ 3648| 784|YY_RULE_SETUP ------------------ | | 3147| 784| YY_USER_ACTION | | ------------------ | | | | 61| 784| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 784| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 784| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 784| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 784| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 784| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.27k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.48k, False: 784] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3649| 784|#line 141 "flex_lexer.l" 3650| 784|TOKEN(INTEGER) ------------------ | | 2887| 784|#define TOKEN(name) { return SQL_##name; } ------------------ 3651| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3652| 640|case 82: ------------------ | Branch (3652:1): [True: 640, False: 4.46M] ------------------ 3653| 640|YY_RULE_SETUP ------------------ | | 3147| 640| YY_USER_ACTION | | ------------------ | | | | 61| 640| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 640| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 640| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 640| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 640| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 640| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.40k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.40k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.76k, False: 640] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3654| 640|#line 142 "flex_lexer.l" 3655| 640|TOKEN(INTERSECT) ------------------ | | 2887| 640|#define TOKEN(name) { return SQL_##name; } ------------------ 3656| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3657| 4.53k|case 83: ------------------ | Branch (3657:1): [True: 4.53k, False: 4.45M] ------------------ 3658| 4.53k|YY_RULE_SETUP ------------------ | | 3147| 4.53k| YY_USER_ACTION | | ------------------ | | | | 61| 4.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 40.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 40.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 36.2k, False: 4.53k] | | | | ------------------ | | | | 64| 36.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 36.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 36.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 36.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 36.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 36.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 36.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| 36.2k| } else { \ | | | | 70| 36.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 36.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 36.2k| } \ | | | | 72| 36.2k| } | | ------------------ ------------------ 3659| 4.53k|#line 143 "flex_lexer.l" 3660| 4.53k|TOKEN(INTERVAL) ------------------ | | 2887| 4.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3661| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3662| 3.37k|case 84: ------------------ | Branch (3662:1): [True: 3.37k, False: 4.45M] ------------------ 3663| 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| 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.37k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3664| 3.37k|#line 144 "flex_lexer.l" 3665| 3.37k|TOKEN(INTO) ------------------ | | 2887| 3.37k|#define TOKEN(name) { return SQL_##name; } ------------------ 3666| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3667| 521|case 85: ------------------ | Branch (3667:1): [True: 521, False: 4.46M] ------------------ 3668| 521|YY_RULE_SETUP ------------------ | | 3147| 521| YY_USER_ACTION | | ------------------ | | | | 61| 521| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 521| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 521| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 521| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 521| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 521| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.04k, False: 521] | | | | ------------------ | | | | 64| 1.04k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.04k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.04k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.04k] | | | | ------------------ | | | | 67| 0| 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.04k| } else { \ | | | | 70| 1.04k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.04k| } \ | | | | 72| 1.04k| } | | ------------------ ------------------ 3669| 521|#line 145 "flex_lexer.l" 3670| 521|TOKEN(IS) ------------------ | | 2887| 521|#define TOKEN(name) { return SQL_##name; } ------------------ 3671| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3672| 560|case 86: ------------------ | Branch (3672:1): [True: 560, False: 4.46M] ------------------ 3673| 560|YY_RULE_SETUP ------------------ | | 3147| 560| YY_USER_ACTION | | ------------------ | | | | 61| 560| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 560| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.36k, False: 560] | | | | ------------------ | | | | 64| 3.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.36k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.36k| } else { \ | | | | 70| 3.36k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.36k| } \ | | | | 72| 3.36k| } | | ------------------ ------------------ 3674| 560|#line 146 "flex_lexer.l" 3675| 560|TOKEN(ISNULL) ------------------ | | 2887| 560|#define TOKEN(name) { return SQL_##name; } ------------------ 3676| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3677| 112k|case 87: ------------------ | Branch (3677:1): [True: 112k, False: 4.34M] ------------------ 3678| 112k|YY_RULE_SETUP ------------------ | | 3147| 112k| YY_USER_ACTION | | ------------------ | | | | 61| 112k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 112k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 112k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 563k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 563k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 450k, False: 112k] | | | | ------------------ | | | | 64| 450k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 450k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 450k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 450k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 450k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 450k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 450k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 450k| } else { \ | | | | 70| 450k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 450k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 450k| } \ | | | | 72| 450k| } | | ------------------ ------------------ 3679| 112k|#line 147 "flex_lexer.l" 3680| 112k|TOKEN(JOIN) ------------------ | | 2887| 112k|#define TOKEN(name) { return SQL_##name; } ------------------ 3681| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3682| 1.96k|case 88: ------------------ | Branch (3682:1): [True: 1.96k, False: 4.45M] ------------------ 3683| 1.96k|YY_RULE_SETUP ------------------ | | 3147| 1.96k| YY_USER_ACTION | | ------------------ | | | | 61| 1.96k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.96k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.88k, False: 1.96k] | | | | ------------------ | | | | 64| 5.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.88k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.88k| } else { \ | | | | 70| 5.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.88k| } \ | | | | 72| 5.88k| } | | ------------------ ------------------ 3684| 1.96k|#line 148 "flex_lexer.l" 3685| 1.96k|TOKEN(KEY) ------------------ | | 2887| 1.96k|#define TOKEN(name) { return SQL_##name; } ------------------ 3686| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3687| 625|case 89: ------------------ | Branch (3687:1): [True: 625, False: 4.46M] ------------------ 3688| 625|YY_RULE_SETUP ------------------ | | 3147| 625| YY_USER_ACTION | | ------------------ | | | | 61| 625| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 625| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 625| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 625| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 625| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 625| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.50k, False: 625] | | | | ------------------ | | | | 64| 2.50k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.50k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.50k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.50k| } else { \ | | | | 70| 2.50k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.50k| } \ | | | | 72| 2.50k| } | | ------------------ ------------------ 3689| 625|#line 149 "flex_lexer.l" 3690| 625|TOKEN(LEFT) ------------------ | | 2887| 625|#define TOKEN(name) { return SQL_##name; } ------------------ 3691| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3692| 753|case 90: ------------------ | Branch (3692:1): [True: 753, False: 4.46M] ------------------ 3693| 753|YY_RULE_SETUP ------------------ | | 3147| 753| YY_USER_ACTION | | ------------------ | | | | 61| 753| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 753| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 753| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 753| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 753| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 753| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.01k, False: 753] | | | | ------------------ | | | | 64| 3.01k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.01k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.01k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.01k| } else { \ | | | | 70| 3.01k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.01k| } \ | | | | 72| 3.01k| } | | ------------------ ------------------ 3694| 753|#line 150 "flex_lexer.l" 3695| 753|TOKEN(LIKE) ------------------ | | 2887| 753|#define TOKEN(name) { return SQL_##name; } ------------------ 3696| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3697| 4.03k|case 91: ------------------ | Branch (3697:1): [True: 4.03k, False: 4.45M] ------------------ 3698| 4.03k|YY_RULE_SETUP ------------------ | | 3147| 4.03k| YY_USER_ACTION | | ------------------ | | | | 61| 4.03k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.03k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.03k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.03k| # 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.1k, False: 4.03k] | | | | ------------------ | | | | 64| 20.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.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| 20.1k| } else { \ | | | | 70| 20.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.1k| } \ | | | | 72| 20.1k| } | | ------------------ ------------------ 3699| 4.03k|#line 151 "flex_lexer.l" 3700| 4.03k|TOKEN(LIMIT) ------------------ | | 2887| 4.03k|#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.46M] ------------------ 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.46M] ------------------ 3708| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3709| 2|#line 153 "flex_lexer.l" 3710| 2|TOKEN(LOCAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3711| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3712| 3|case 94: ------------------ | Branch (3712:1): [True: 3, False: 4.46M] ------------------ 3713| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 21| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18, False: 3] | | | | ------------------ | | | | 64| 18| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 18| } else { \ | | | | 70| 18| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18| } \ | | | | 72| 18| } | | ------------------ ------------------ 3714| 3|#line 154 "flex_lexer.l" 3715| 3|TOKEN(LOCKED) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3716| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3717| 933|case 95: ------------------ | Branch (3717:1): [True: 933, False: 4.46M] ------------------ 3718| 933|YY_RULE_SETUP ------------------ | | 3147| 933| YY_USER_ACTION | | ------------------ | | | | 61| 933| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 933| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 933| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 933| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 933| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 933| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.73k, False: 933] | | | | ------------------ | | | | 64| 3.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.73k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.73k| } else { \ | | | | 70| 3.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.73k| } \ | | | | 72| 3.73k| } | | ------------------ ------------------ 3719| 933|#line 155 "flex_lexer.l" 3720| 933|TOKEN(LONG) ------------------ | | 2887| 933|#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.46M] ------------------ 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.46M] ------------------ 3728| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3729| 2|#line 157 "flex_lexer.l" 3730| 2|TOKEN(MINUS) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3731| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3732| 1.07k|case 98: ------------------ | Branch (3732:1): [True: 1.07k, False: 4.46M] ------------------ 3733| 1.07k|YY_RULE_SETUP ------------------ | | 3147| 1.07k| YY_USER_ACTION | | ------------------ | | | | 61| 1.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.51k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.51k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.44k, False: 1.07k] | | | | ------------------ | | | | 64| 6.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.44k| } else { \ | | | | 70| 6.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.44k| } \ | | | | 72| 6.44k| } | | ------------------ ------------------ 3734| 1.07k|#line 158 "flex_lexer.l" 3735| 1.07k|TOKEN(MINUTE) ------------------ | | 2887| 1.07k|#define TOKEN(name) { return SQL_##name; } ------------------ 3736| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3737| 1.07k|case 99: ------------------ | Branch (3737:1): [True: 1.07k, False: 4.46M] ------------------ 3738| 1.07k|YY_RULE_SETUP ------------------ | | 3147| 1.07k| YY_USER_ACTION | | ------------------ | | | | 61| 1.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.53k, False: 1.07k] | | | | ------------------ | | | | 64| 7.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.53k] | | | | ------------------ | | | | 67| 0| 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.53k| } else { \ | | | | 70| 7.53k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.53k| } \ | | | | 72| 7.53k| } | | ------------------ ------------------ 3739| 1.07k|#line 159 "flex_lexer.l" 3740| 1.07k|TOKEN(MINUTES) ------------------ | | 2887| 1.07k|#define TOKEN(name) { return SQL_##name; } ------------------ 3741| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3742| 657|case 100: ------------------ | Branch (3742:1): [True: 657, False: 4.46M] ------------------ 3743| 657|YY_RULE_SETUP ------------------ | | 3147| 657| YY_USER_ACTION | | ------------------ | | | | 61| 657| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 657| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 657| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 657| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 657| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 657| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.94k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.94k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.28k, False: 657] | | | | ------------------ | | | | 64| 3.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.28k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.28k| } else { \ | | | | 70| 3.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.28k| } \ | | | | 72| 3.28k| } | | ------------------ ------------------ 3744| 657|#line 160 "flex_lexer.l" 3745| 657|TOKEN(MONTH) ------------------ | | 2887| 657|#define TOKEN(name) { return SQL_##name; } ------------------ 3746| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3747| 748|case 101: ------------------ | Branch (3747:1): [True: 748, False: 4.46M] ------------------ 3748| 748|YY_RULE_SETUP ------------------ | | 3147| 748| YY_USER_ACTION | | ------------------ | | | | 61| 748| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 748| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.23k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.23k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.48k, False: 748] | | | | ------------------ | | | | 64| 4.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.48k| } else { \ | | | | 70| 4.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.48k| } \ | | | | 72| 4.48k| } | | ------------------ ------------------ 3749| 748|#line 161 "flex_lexer.l" 3750| 748|TOKEN(MONTHS) ------------------ | | 2887| 748|#define TOKEN(name) { return SQL_##name; } ------------------ 3751| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3752| 631|case 102: ------------------ | Branch (3752:1): [True: 631, False: 4.46M] ------------------ 3753| 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| } | | ------------------ ------------------ 3754| 631|#line 162 "flex_lexer.l" 3755| 631|TOKEN(NATURAL) ------------------ | | 2887| 631|#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.46M] ------------------ 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| 4.81k|case 104: ------------------ | Branch (3762:1): [True: 4.81k, False: 4.45M] ------------------ 3763| 4.81k|YY_RULE_SETUP ------------------ | | 3147| 4.81k| YY_USER_ACTION | | ------------------ | | | | 61| 4.81k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.81k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.81k| # 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: 14.4k, False: 4.81k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3764| 4.81k|#line 164 "flex_lexer.l" 3765| 4.81k|TOKEN(NOT) ------------------ | | 2887| 4.81k|#define TOKEN(name) { return SQL_##name; } ------------------ 3766| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3767| 915|case 105: ------------------ | Branch (3767:1): [True: 915, False: 4.46M] ------------------ 3768| 915|YY_RULE_SETUP ------------------ | | 3147| 915| YY_USER_ACTION | | ------------------ | | | | 61| 915| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 915| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 915| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 915| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 915| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 915| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.40k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.40k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.49k, False: 915] | | | | ------------------ | | | | 64| 5.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.49k| } else { \ | | | | 70| 5.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.49k| } \ | | | | 72| 5.49k| } | | ------------------ ------------------ 3769| 915|#line 165 "flex_lexer.l" 3770| 915|TOKEN(NOWAIT) ------------------ | | 2887| 915|#define TOKEN(name) { return SQL_##name; } ------------------ 3771| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3772| 7.89k|case 106: ------------------ | Branch (3772:1): [True: 7.89k, False: 4.45M] ------------------ 3773| 7.89k|YY_RULE_SETUP ------------------ | | 3147| 7.89k| YY_USER_ACTION | | ------------------ | | | | 61| 7.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 39.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 39.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 31.5k, False: 7.89k] | | | | ------------------ | | | | 64| 31.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 31.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 31.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 31.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 31.5k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 31.5k| } else { \ | | | | 70| 31.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 31.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 31.5k| } \ | | | | 72| 31.5k| } | | ------------------ ------------------ 3774| 7.89k|#line 166 "flex_lexer.l" 3775| 7.89k|TOKEN(NULL) ------------------ | | 2887| 7.89k|#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.46M] ------------------ 3778| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16, False: 2] | | | | ------------------ | | | | 64| 16| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 16| } else { \ | | | | 70| 16| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16| } \ | | | | 72| 16| } | | ------------------ ------------------ 3779| 2|#line 167 "flex_lexer.l" 3780| 2|TOKEN(NVARCHAR) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3781| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3782| 287|case 108: ------------------ | Branch (3782:1): [True: 287, False: 4.46M] ------------------ 3783| 287|YY_RULE_SETUP ------------------ | | 3147| 287| YY_USER_ACTION | | ------------------ | | | | 61| 287| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 287| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 287| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 861| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 861|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 574, False: 287] | | | | ------------------ | | | | 64| 574| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 574| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 574| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 574|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 574] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 574| } else { \ | | | | 70| 574| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 574| } \ | | | | 72| 574| } | | ------------------ ------------------ 3784| 287|#line 168 "flex_lexer.l" 3785| 287|TOKEN(OF) ------------------ | | 2887| 287|#define TOKEN(name) { return SQL_##name; } ------------------ 3786| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3787| 2|case 109: ------------------ | Branch (3787:1): [True: 2, False: 4.46M] ------------------ 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.54k|case 110: ------------------ | Branch (3792:1): [True: 2.54k, False: 4.45M] ------------------ 3793| 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| 17.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.2k, False: 2.54k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3794| 2.54k|#line 170 "flex_lexer.l" 3795| 2.54k|TOKEN(OFFSET) ------------------ | | 2887| 2.54k|#define TOKEN(name) { return SQL_##name; } ------------------ 3796| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3797| 110k|case 111: ------------------ | Branch (3797:1): [True: 110k, False: 4.35M] ------------------ 3798| 110k|YY_RULE_SETUP ------------------ | | 3147| 110k| YY_USER_ACTION | | ------------------ | | | | 61| 110k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 110k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 330k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 330k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 220k, False: 110k] | | | | ------------------ | | | | 64| 220k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 220k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 220k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 220k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 220k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 220k| } else { \ | | | | 70| 220k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 220k| } \ | | | | 72| 220k| } | | ------------------ ------------------ 3799| 110k|#line 171 "flex_lexer.l" 3800| 110k|TOKEN(ON) ------------------ | | 2887| 110k|#define TOKEN(name) { return SQL_##name; } ------------------ 3801| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3802| 661|case 112: ------------------ | Branch (3802:1): [True: 661, False: 4.46M] ------------------ 3803| 661|YY_RULE_SETUP ------------------ | | 3147| 661| YY_USER_ACTION | | ------------------ | | | | 61| 661| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 661| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 661| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 661| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 661| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 661| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.32k, False: 661] | | | | ------------------ | | | | 64| 1.32k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.32k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.32k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.32k| } else { \ | | | | 70| 1.32k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.32k| } \ | | | | 72| 1.32k| } | | ------------------ ------------------ 3804| 661|#line 172 "flex_lexer.l" 3805| 661|TOKEN(OR) ------------------ | | 2887| 661|#define TOKEN(name) { return SQL_##name; } ------------------ 3806| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3807| 2.94k|case 113: ------------------ | Branch (3807:1): [True: 2.94k, False: 4.45M] ------------------ 3808| 2.94k|YY_RULE_SETUP ------------------ | | 3147| 2.94k| YY_USER_ACTION | | ------------------ | | | | 61| 2.94k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.94k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 17.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.7k, False: 2.94k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3809| 2.94k|#line 173 "flex_lexer.l" 3810| 2.94k|TOKEN(ORDER) ------------------ | | 2887| 2.94k|#define TOKEN(name) { return SQL_##name; } ------------------ 3811| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3812| 1.05k|case 114: ------------------ | Branch (3812:1): [True: 1.05k, False: 4.46M] ------------------ 3813| 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| 6.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.28k, False: 1.05k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3814| 1.05k|#line 174 "flex_lexer.l" 3815| 1.05k|TOKEN(OUTER) ------------------ | | 2887| 1.05k|#define TOKEN(name) { return SQL_##name; } ------------------ 3816| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3817| 5.07k|case 115: ------------------ | Branch (3817:1): [True: 5.07k, False: 4.45M] ------------------ 3818| 5.07k|YY_RULE_SETUP ------------------ | | 3147| 5.07k| YY_USER_ACTION | | ------------------ | | | | 61| 5.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.07k| # 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: 20.3k, False: 5.07k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3819| 5.07k|#line 175 "flex_lexer.l" 3820| 5.07k|TOKEN(OVER) ------------------ | | 2887| 5.07k|#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.46M] ------------------ 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| 843|case 117: ------------------ | Branch (3827:1): [True: 843, False: 4.46M] ------------------ 3828| 843|YY_RULE_SETUP ------------------ | | 3147| 843| YY_USER_ACTION | | ------------------ | | | | 61| 843| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 843| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 843| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 843| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 843| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 843| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.58k, False: 843] | | | | ------------------ | | | | 64| 7.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.58k| } else { \ | | | | 70| 7.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.58k| } \ | | | | 72| 7.58k| } | | ------------------ ------------------ 3829| 843|#line 177 "flex_lexer.l" 3830| 843|TOKEN(PARTITION) ------------------ | | 2887| 843|#define TOKEN(name) { return SQL_##name; } ------------------ 3831| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3832| 2|case 118: ------------------ | Branch (3832:1): [True: 2, False: 4.46M] ------------------ 3833| 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| } | | ------------------ ------------------ 3834| 2|#line 178 "flex_lexer.l" 3835| 2|TOKEN(PLAN) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3836| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3837| 1.14k|case 119: ------------------ | Branch (3837:1): [True: 1.14k, False: 4.46M] ------------------ 3838| 1.14k|YY_RULE_SETUP ------------------ | | 3147| 1.14k| YY_USER_ACTION | | ------------------ | | | | 61| 1.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.3k, False: 1.14k] | | | | ------------------ | | | | 64| 10.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.3k| } else { \ | | | | 70| 10.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.3k| } \ | | | | 72| 10.3k| } | | ------------------ ------------------ 3839| 1.14k|#line 179 "flex_lexer.l" 3840| 1.14k|TOKEN(PRECEDING) ------------------ | | 2887| 1.14k|#define TOKEN(name) { return SQL_##name; } ------------------ 3841| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3842| 2.07k|case 120: ------------------ | Branch (3842:1): [True: 2.07k, False: 4.45M] ------------------ 3843| 2.07k|YY_RULE_SETUP ------------------ | | 3147| 2.07k| YY_USER_ACTION | | ------------------ | | | | 61| 2.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.5k, False: 2.07k] | | | | ------------------ | | | | 64| 14.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.5k| } else { \ | | | | 70| 14.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.5k| } \ | | | | 72| 14.5k| } | | ------------------ ------------------ 3844| 2.07k|#line 180 "flex_lexer.l" 3845| 2.07k|TOKEN(PREPARE) ------------------ | | 2887| 2.07k|#define TOKEN(name) { return SQL_##name; } ------------------ 3846| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3847| 1.75k|case 121: ------------------ | Branch (3847:1): [True: 1.75k, False: 4.46M] ------------------ 3848| 1.75k|YY_RULE_SETUP ------------------ | | 3147| 1.75k| YY_USER_ACTION | | ------------------ | | | | 61| 1.75k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.75k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.2k, False: 1.75k] | | | | ------------------ | | | | 64| 12.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.2k| } else { \ | | | | 70| 12.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.2k| } \ | | | | 72| 12.2k| } | | ------------------ ------------------ 3849| 1.75k|#line 181 "flex_lexer.l" 3850| 1.75k|TOKEN(PRIMARY) ------------------ | | 2887| 1.75k|#define TOKEN(name) { return SQL_##name; } ------------------ 3851| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3852| 1.11k|case 122: ------------------ | Branch (3852:1): [True: 1.11k, False: 4.46M] ------------------ 3853| 1.11k|YY_RULE_SETUP ------------------ | | 3147| 1.11k| YY_USER_ACTION | | ------------------ | | | | 61| 1.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.67k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.56k, False: 1.11k] | | | | ------------------ | | | | 64| 5.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.56k| } else { \ | | | | 70| 5.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.56k| } \ | | | | 72| 5.56k| } | | ------------------ ------------------ 3854| 1.11k|#line 182 "flex_lexer.l" 3855| 1.11k|TOKEN(RANGE) ------------------ | | 2887| 1.11k|#define TOKEN(name) { return SQL_##name; } ------------------ 3856| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3857| 594|case 123: ------------------ | Branch (3857:1): [True: 594, False: 4.46M] ------------------ 3858| 594|YY_RULE_SETUP ------------------ | | 3147| 594| YY_USER_ACTION | | ------------------ | | | | 61| 594| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 594| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 594| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 594| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 594| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 594| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.97k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.97k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.37k, False: 594] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3859| 594|#line 183 "flex_lexer.l" 3860| 594|TOKEN(REAL) ------------------ | | 2887| 594|#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.46M] ------------------ 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.46M] ------------------ 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.46M] ------------------ 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| 566|case 127: ------------------ | Branch (3877:1): [True: 566, False: 4.46M] ------------------ 3878| 566|YY_RULE_SETUP ------------------ | | 3147| 566| YY_USER_ACTION | | ------------------ | | | | 61| 566| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 566| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.83k, False: 566] | | | | ------------------ | | | | 64| 2.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.83k| } else { \ | | | | 70| 2.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.83k| } \ | | | | 72| 2.83k| } | | ------------------ ------------------ 3879| 566|#line 187 "flex_lexer.l" 3880| 566|TOKEN(RIGHT) ------------------ | | 2887| 566|#define TOKEN(name) { return SQL_##name; } ------------------ 3881| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3882| 2.36k|case 128: ------------------ | Branch (3882:1): [True: 2.36k, False: 4.45M] ------------------ 3883| 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| 21.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 21.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.9k, False: 2.36k] | | | | ------------------ | | | | 64| 18.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.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| 18.9k| } else { \ | | | | 70| 18.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.9k| } \ | | | | 72| 18.9k| } | | ------------------ ------------------ 3884| 2.36k|#line 188 "flex_lexer.l" 3885| 2.36k|TOKEN(ROLLBACK) ------------------ | | 2887| 2.36k|#define TOKEN(name) { return SQL_##name; } ------------------ 3886| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3887| 1.28k|case 129: ------------------ | Branch (3887:1): [True: 1.28k, False: 4.46M] ------------------ 3888| 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| 6.41k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.41k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.12k, False: 1.28k] | | | | ------------------ | | | | 64| 5.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.12k| } else { \ | | | | 70| 5.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.12k| } \ | | | | 72| 5.12k| } | | ------------------ ------------------ 3889| 1.28k|#line 189 "flex_lexer.l" 3890| 1.28k|TOKEN(ROWS) ------------------ | | 2887| 1.28k|#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.46M] ------------------ 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.46M] ------------------ 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| 740|case 132: ------------------ | Branch (3902:1): [True: 740, False: 4.46M] ------------------ 3903| 740|YY_RULE_SETUP ------------------ | | 3147| 740| YY_USER_ACTION | | ------------------ | | | | 61| 740| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 740| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 740| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.44k, False: 740] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3904| 740|#line 192 "flex_lexer.l" 3905| 740|TOKEN(SECOND) ------------------ | | 2887| 740|#define TOKEN(name) { return SQL_##name; } ------------------ 3906| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3907| 787|case 133: ------------------ | Branch (3907:1): [True: 787, False: 4.46M] ------------------ 3908| 787|YY_RULE_SETUP ------------------ | | 3147| 787| YY_USER_ACTION | | ------------------ | | | | 61| 787| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 787| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 787| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.29k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.50k, False: 787] | | | | ------------------ | | | | 64| 5.50k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.50k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.50k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.50k| } else { \ | | | | 70| 5.50k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.50k| } \ | | | | 72| 5.50k| } | | ------------------ ------------------ 3909| 787|#line 193 "flex_lexer.l" 3910| 787|TOKEN(SECONDS) ------------------ | | 2887| 787|#define TOKEN(name) { return SQL_##name; } ------------------ 3911| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3912| 41.0k|case 134: ------------------ | Branch (3912:1): [True: 41.0k, False: 4.42M] ------------------ 3913| 41.0k|YY_RULE_SETUP ------------------ | | 3147| 41.0k| YY_USER_ACTION | | ------------------ | | | | 61| 41.0k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 41.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 41.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 41.0k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 41.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 41.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 287k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 287k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 246k, False: 41.0k] | | | | ------------------ | | | | 64| 246k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 246k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 246k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 246k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 246k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 246k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 246k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 246k| } else { \ | | | | 70| 246k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 246k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 246k| } \ | | | | 72| 246k| } | | ------------------ ------------------ 3914| 41.0k|#line 194 "flex_lexer.l" 3915| 41.0k|TOKEN(SELECT) ------------------ | | 2887| 41.0k|#define TOKEN(name) { return SQL_##name; } ------------------ 3916| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3917| 2.21k|case 135: ------------------ | Branch (3917:1): [True: 2.21k, False: 4.45M] ------------------ 3918| 2.21k|YY_RULE_SETUP ------------------ | | 3147| 2.21k| YY_USER_ACTION | | ------------------ | | | | 61| 2.21k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.21k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.63k, False: 2.21k] | | | | ------------------ | | | | 64| 6.63k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.63k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.63k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.63k] | | | | ------------------ | | | | 67| 0| 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.63k| } else { \ | | | | 70| 6.63k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.63k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.63k| } \ | | | | 72| 6.63k| } | | ------------------ ------------------ 3919| 2.21k|#line 195 "flex_lexer.l" 3920| 2.21k|TOKEN(SET) ------------------ | | 2887| 2.21k|#define TOKEN(name) { return SQL_##name; } ------------------ 3921| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3922| 3.30k|case 136: ------------------ | Branch (3922:1): [True: 3.30k, False: 4.45M] ------------------ 3923| 3.30k|YY_RULE_SETUP ------------------ | | 3147| 3.30k| YY_USER_ACTION | | ------------------ | | | | 61| 3.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.5k, False: 3.30k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3924| 3.30k|#line 196 "flex_lexer.l" 3925| 3.30k|TOKEN(SHARE) ------------------ | | 2887| 3.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 3926| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3927| 2.67k|case 137: ------------------ | Branch (3927:1): [True: 2.67k, False: 4.45M] ------------------ 3928| 2.67k|YY_RULE_SETUP ------------------ | | 3147| 2.67k| YY_USER_ACTION | | ------------------ | | | | 61| 2.67k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.67k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.6k, False: 2.67k] | | | | ------------------ | | | | 64| 10.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.6k| } else { \ | | | | 70| 10.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.6k| } \ | | | | 72| 10.6k| } | | ------------------ ------------------ 3929| 2.67k|#line 197 "flex_lexer.l" 3930| 2.67k|TOKEN(SHOW) ------------------ | | 2887| 2.67k|#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.46M] ------------------ 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| 516|case 139: ------------------ | Branch (3937:1): [True: 516, False: 4.46M] ------------------ 3938| 516|YY_RULE_SETUP ------------------ | | 3147| 516| YY_USER_ACTION | | ------------------ | | | | 61| 516| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 516| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 516| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 516| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 516| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 516| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.64k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.12k, False: 516] | | | | ------------------ | | | | 64| 4.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.12k| } else { \ | | | | 70| 4.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.12k| } \ | | | | 72| 4.12k| } | | ------------------ ------------------ 3939| 516|#line 199 "flex_lexer.l" 3940| 516|TOKEN(SMALLINT) ------------------ | | 2887| 516|#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.46M] ------------------ 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.46M] ------------------ 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| 5.52k|case 142: ------------------ | Branch (3952:1): [True: 5.52k, False: 4.45M] ------------------ 3953| 5.52k|YY_RULE_SETUP ------------------ | | 3147| 5.52k| YY_USER_ACTION | | ------------------ | | | | 61| 5.52k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.52k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 33.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 33.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 27.6k, False: 5.52k] | | | | ------------------ | | | | 64| 27.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 27.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 27.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 27.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 27.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 27.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 27.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| 27.6k| } else { \ | | | | 70| 27.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 27.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 27.6k| } \ | | | | 72| 27.6k| } | | ------------------ ------------------ 3954| 5.52k|#line 202 "flex_lexer.l" 3955| 5.52k|TOKEN(TABLE) ------------------ | | 2887| 5.52k|#define TOKEN(name) { return SQL_##name; } ------------------ 3956| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3957| 1.48k|case 143: ------------------ | Branch (3957:1): [True: 1.48k, False: 4.46M] ------------------ 3958| 1.48k|YY_RULE_SETUP ------------------ | | 3147| 1.48k| YY_USER_ACTION | | ------------------ | | | | 61| 1.48k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.48k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.91k, False: 1.48k] | | | | ------------------ | | | | 64| 8.91k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.91k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.91k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.91k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.91k] | | | | ------------------ | | | | 67| 0| 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.91k| } else { \ | | | | 70| 8.91k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.91k| } \ | | | | 72| 8.91k| } | | ------------------ ------------------ 3959| 1.48k|#line 203 "flex_lexer.l" 3960| 1.48k|TOKEN(TABLES) ------------------ | | 2887| 1.48k|#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.46M] ------------------ 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| 404|case 145: ------------------ | Branch (3967:1): [True: 404, False: 4.46M] ------------------ 3968| 404|YY_RULE_SETUP ------------------ | | 3147| 404| YY_USER_ACTION | | ------------------ | | | | 61| 404| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 404| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 404| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 404| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 404| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 404| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.61k, False: 404] | | | | ------------------ | | | | 64| 1.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.61k| } else { \ | | | | 70| 1.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.61k| } \ | | | | 72| 1.61k| } | | ------------------ ------------------ 3969| 404|#line 205 "flex_lexer.l" 3970| 404|TOKEN(TEXT) ------------------ | | 2887| 404|#define TOKEN(name) { return SQL_##name; } ------------------ 3971| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3972| 3.65k|case 146: ------------------ | Branch (3972:1): [True: 3.65k, False: 4.45M] ------------------ 3973| 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| } | | ------------------ ------------------ 3974| 3.65k|#line 206 "flex_lexer.l" 3975| 3.65k|TOKEN(THEN) ------------------ | | 2887| 3.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 3976| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3977| 991|case 147: ------------------ | Branch (3977:1): [True: 991, False: 4.46M] ------------------ 3978| 991|YY_RULE_SETUP ------------------ | | 3147| 991| YY_USER_ACTION | | ------------------ | | | | 61| 991| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 991| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 991| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 991| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 991| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 991| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.95k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.96k, False: 991] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3979| 991|#line 207 "flex_lexer.l" 3980| 991|TOKEN(TIME) ------------------ | | 2887| 991|#define TOKEN(name) { return SQL_##name; } ------------------ 3981| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3982| 466|case 148: ------------------ | Branch (3982:1): [True: 466, False: 4.46M] ------------------ 3983| 466|YY_RULE_SETUP ------------------ | | 3147| 466| YY_USER_ACTION | | ------------------ | | | | 61| 466| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 466| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 466| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 466| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 466| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 466| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.19k, False: 466] | | | | ------------------ | | | | 64| 4.19k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.19k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.19k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.19k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.19k| } else { \ | | | | 70| 4.19k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.19k| } \ | | | | 72| 4.19k| } | | ------------------ ------------------ 3984| 466|#line 208 "flex_lexer.l" 3985| 466|TOKEN(TIMESTAMP) ------------------ | | 2887| 466|#define TOKEN(name) { return SQL_##name; } ------------------ 3986| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3987| 6.53k|case 149: ------------------ | Branch (3987:1): [True: 6.53k, False: 4.45M] ------------------ 3988| 6.53k|YY_RULE_SETUP ------------------ | | 3147| 6.53k| YY_USER_ACTION | | ------------------ | | | | 61| 6.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.0k, False: 6.53k] | | | | ------------------ | | | | 64| 13.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.0k| } else { \ | | | | 70| 13.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.0k| } \ | | | | 72| 13.0k| } | | ------------------ ------------------ 3989| 6.53k|#line 209 "flex_lexer.l" 3990| 6.53k|TOKEN(TO) ------------------ | | 2887| 6.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3991| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3992| 3.06k|case 150: ------------------ | Branch (3992:1): [True: 3.06k, False: 4.45M] ------------------ 3993| 3.06k|YY_RULE_SETUP ------------------ | | 3147| 3.06k| YY_USER_ACTION | | ------------------ | | | | 61| 3.06k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.06k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.06k| # 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.20k, False: 3.06k] | | | | ------------------ | | | | 64| 9.20k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.20k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.20k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.20k] | | | | ------------------ | | | | 67| 0| 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.20k| } else { \ | | | | 70| 9.20k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.20k| } \ | | | | 72| 9.20k| } | | ------------------ ------------------ 3994| 3.06k|#line 210 "flex_lexer.l" 3995| 3.06k|TOKEN(TOP) ------------------ | | 2887| 3.06k|#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.46M] ------------------ 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| 476|case 152: ------------------ | Branch (4002:1): [True: 476, False: 4.46M] ------------------ 4003| 476|YY_RULE_SETUP ------------------ | | 3147| 476| YY_USER_ACTION | | ------------------ | | | | 61| 476| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 476| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 476| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 476| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 476| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 476| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.38k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.90k, False: 476] | | | | ------------------ | | | | 64| 1.90k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.90k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.90k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.90k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.90k| } else { \ | | | | 70| 1.90k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.90k| } \ | | | | 72| 1.90k| } | | ------------------ ------------------ 4004| 476|#line 212 "flex_lexer.l" 4005| 476|TOKEN(TRUE) ------------------ | | 2887| 476|#define TOKEN(name) { return SQL_##name; } ------------------ 4006| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4007| 263|case 153: ------------------ | Branch (4007:1): [True: 263, False: 4.46M] ------------------ 4008| 263|YY_RULE_SETUP ------------------ | | 3147| 263| YY_USER_ACTION | | ------------------ | | | | 61| 263| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 263| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 263| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 263| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 263| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 263| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.10k, False: 263] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4009| 263|#line 213 "flex_lexer.l" 4010| 263|TOKEN(TRUNCATE) ------------------ | | 2887| 263|#define TOKEN(name) { return SQL_##name; } ------------------ 4011| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4012| 818|case 154: ------------------ | Branch (4012:1): [True: 818, False: 4.46M] ------------------ 4013| 818|YY_RULE_SETUP ------------------ | | 3147| 818| YY_USER_ACTION | | ------------------ | | | | 61| 818| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 818| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 818| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 818| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 818| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 818| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.36k, False: 818] | | | | ------------------ | | | | 64| 7.36k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.36k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.36k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.36k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7.36k| } else { \ | | | | 70| 7.36k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.36k| } \ | | | | 72| 7.36k| } | | ------------------ ------------------ 4014| 818|#line 214 "flex_lexer.l" 4015| 818|TOKEN(UNBOUNDED) ------------------ | | 2887| 818|#define TOKEN(name) { return SQL_##name; } ------------------ 4016| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4017| 5.28k|case 155: ------------------ | Branch (4017:1): [True: 5.28k, False: 4.45M] ------------------ 4018| 5.28k|YY_RULE_SETUP ------------------ | | 3147| 5.28k| YY_USER_ACTION | | ------------------ | | | | 61| 5.28k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.28k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 31.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 31.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 26.4k, False: 5.28k] | | | | ------------------ | | | | 64| 26.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 26.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 26.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 26.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 26.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 26.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 26.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| 26.4k| } else { \ | | | | 70| 26.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 26.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 26.4k| } \ | | | | 72| 26.4k| } | | ------------------ ------------------ 4019| 5.28k|#line 215 "flex_lexer.l" 4020| 5.28k|TOKEN(UNION) ------------------ | | 2887| 5.28k|#define TOKEN(name) { return SQL_##name; } ------------------ 4021| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4022| 3.40k|case 156: ------------------ | Branch (4022:1): [True: 3.40k, False: 4.45M] ------------------ 4023| 3.40k|YY_RULE_SETUP ------------------ | | 3147| 3.40k| YY_USER_ACTION | | ------------------ | | | | 61| 3.40k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.40k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 23.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 23.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.4k, False: 3.40k] | | | | ------------------ | | | | 64| 20.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.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| 20.4k| } else { \ | | | | 70| 20.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.4k| } \ | | | | 72| 20.4k| } | | ------------------ ------------------ 4024| 3.40k|#line 216 "flex_lexer.l" 4025| 3.40k|TOKEN(UNIQUE) ------------------ | | 2887| 3.40k|#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.46M] ------------------ 4028| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 4029| 1|#line 217 "flex_lexer.l" 4030| 1|TOKEN(UNLOAD) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 4031| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4032| 2.67k|case 158: ------------------ | Branch (4032:1): [True: 2.67k, False: 4.45M] ------------------ 4033| 2.67k|YY_RULE_SETUP ------------------ | | 3147| 2.67k| YY_USER_ACTION | | ------------------ | | | | 61| 2.67k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.67k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.0k, False: 2.67k] | | | | ------------------ | | | | 64| 16.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 16.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 16.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 16.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 16.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 16.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 16.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| 16.0k| } else { \ | | | | 70| 16.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 16.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.0k| } \ | | | | 72| 16.0k| } | | ------------------ ------------------ 4034| 2.67k|#line 218 "flex_lexer.l" 4035| 2.67k|TOKEN(UPDATE) ------------------ | | 2887| 2.67k|#define TOKEN(name) { return SQL_##name; } ------------------ 4036| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4037| 735|case 159: ------------------ | Branch (4037:1): [True: 735, False: 4.46M] ------------------ 4038| 735|YY_RULE_SETUP ------------------ | | 3147| 735| YY_USER_ACTION | | ------------------ | | | | 61| 735| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 735| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 735| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 735| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 735| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 735| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.41k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.41k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.67k, False: 735] | | | | ------------------ | | | | 64| 3.67k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.67k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.67k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.67k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.67k| } else { \ | | | | 70| 3.67k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.67k| } \ | | | | 72| 3.67k| } | | ------------------ ------------------ 4039| 735|#line 219 "flex_lexer.l" 4040| 735|TOKEN(USING) ------------------ | | 2887| 735|#define TOKEN(name) { return SQL_##name; } ------------------ 4041| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4042| 649|case 160: ------------------ | Branch (4042:1): [True: 649, False: 4.46M] ------------------ 4043| 649|YY_RULE_SETUP ------------------ | | 3147| 649| YY_USER_ACTION | | ------------------ | | | | 61| 649| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 649| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 649| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 649| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 649| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 649| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.89k, False: 649] | | | | ------------------ | | | | 64| 3.89k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.89k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.89k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.89k| } else { \ | | | | 70| 3.89k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.89k| } \ | | | | 72| 3.89k| } | | ------------------ ------------------ 4044| 649|#line 220 "flex_lexer.l" 4045| 649|TOKEN(VALUES) ------------------ | | 2887| 649|#define TOKEN(name) { return SQL_##name; } ------------------ 4046| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4047| 600|case 161: ------------------ | Branch (4047:1): [True: 600, False: 4.46M] ------------------ 4048| 600|YY_RULE_SETUP ------------------ | | 3147| 600| YY_USER_ACTION | | ------------------ | | | | 61| 600| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 600| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 600| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 600| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 600| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 600| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.20k, False: 600] | | | | ------------------ | | | | 64| 4.20k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.20k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.20k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.20k] | | | | ------------------ | | | | 67| 0| 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.20k| } else { \ | | | | 70| 4.20k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.20k| } \ | | | | 72| 4.20k| } | | ------------------ ------------------ 4049| 600|#line 221 "flex_lexer.l" 4050| 600|TOKEN(VARCHAR) ------------------ | | 2887| 600|#define TOKEN(name) { return SQL_##name; } ------------------ 4051| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4052| 3.30k|case 162: ------------------ | Branch (4052:1): [True: 3.30k, False: 4.45M] ------------------ 4053| 3.30k|YY_RULE_SETUP ------------------ | | 3147| 3.30k| YY_USER_ACTION | | ------------------ | | | | 61| 3.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # 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: 13.2k, False: 3.30k] | | | | ------------------ | | | | 64| 13.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.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| 13.2k| } else { \ | | | | 70| 13.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.2k| } \ | | | | 72| 13.2k| } | | ------------------ ------------------ 4054| 3.30k|#line 222 "flex_lexer.l" 4055| 3.30k|TOKEN(VIEW) ------------------ | | 2887| 3.30k|#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.46M] ------------------ 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.70k|case 164: ------------------ | Branch (4062:1): [True: 3.70k, False: 4.45M] ------------------ 4063| 3.70k|YY_RULE_SETUP ------------------ | | 3147| 3.70k| YY_USER_ACTION | | ------------------ | | | | 61| 3.70k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.70k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.8k, False: 3.70k] | | | | ------------------ | | | | 64| 14.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.8k| } else { \ | | | | 70| 14.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.8k| } \ | | | | 72| 14.8k| } | | ------------------ ------------------ 4064| 3.70k|#line 224 "flex_lexer.l" 4065| 3.70k|TOKEN(WHEN) ------------------ | | 2887| 3.70k|#define TOKEN(name) { return SQL_##name; } ------------------ 4066| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4067| 3.30k|case 165: ------------------ | Branch (4067:1): [True: 3.30k, False: 4.45M] ------------------ 4068| 3.30k|YY_RULE_SETUP ------------------ | | 3147| 3.30k| YY_USER_ACTION | | ------------------ | | | | 61| 3.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 19.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 19.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 16.5k, False: 3.30k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4069| 3.30k|#line 225 "flex_lexer.l" 4070| 3.30k|TOKEN(WHERE) ------------------ | | 2887| 3.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 4071| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4072| 1.69k|case 166: ------------------ | Branch (4072:1): [True: 1.69k, False: 4.46M] ------------------ 4073| 1.69k|YY_RULE_SETUP ------------------ | | 3147| 1.69k| YY_USER_ACTION | | ------------------ | | | | 61| 1.69k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.69k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.48k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.78k, False: 1.69k] | | | | ------------------ | | | | 64| 6.78k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.78k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.78k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.78k| } else { \ | | | | 70| 6.78k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.78k| } \ | | | | 72| 6.78k| } | | ------------------ ------------------ 4074| 1.69k|#line 226 "flex_lexer.l" 4075| 1.69k|TOKEN(WITH) ------------------ | | 2887| 1.69k|#define TOKEN(name) { return SQL_##name; } ------------------ 4076| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4077| 363|case 167: ------------------ | Branch (4077:1): [True: 363, False: 4.46M] ------------------ 4078| 363|YY_RULE_SETUP ------------------ | | 3147| 363| YY_USER_ACTION | | ------------------ | | | | 61| 363| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 363| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 363| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 363| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 363| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 363| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.81k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.45k, False: 363] | | | | ------------------ | | | | 64| 1.45k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.45k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.45k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.45k] | | | | ------------------ | | | | 67| 0| 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.45k| } else { \ | | | | 70| 1.45k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.45k| } \ | | | | 72| 1.45k| } | | ------------------ ------------------ 4079| 363|#line 227 "flex_lexer.l" 4080| 363|TOKEN(YEAR) ------------------ | | 2887| 363|#define TOKEN(name) { return SQL_##name; } ------------------ 4081| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4082| 366|case 168: ------------------ | Branch (4082:1): [True: 366, False: 4.46M] ------------------ 4083| 366|YY_RULE_SETUP ------------------ | | 3147| 366| YY_USER_ACTION | | ------------------ | | | | 61| 366| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 366| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 366| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 366| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 366| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 366| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.19k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.83k, False: 366] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4084| 366|#line 228 "flex_lexer.l" 4085| 366|TOKEN(YEARS) ------------------ | | 2887| 366|#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.46M] ------------------ 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.46M] ------------------ 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| 886|case 171: ------------------ | Branch (4100:1): [True: 886, False: 4.46M] ------------------ 4101| 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| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.77k, False: 886] | | | | ------------------ | | | | 64| 1.77k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.77k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.77k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.77k] | | | | ------------------ | | | | 67| 0| 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.77k| } else { \ | | | | 70| 1.77k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.77k| } \ | | | | 72| 1.77k| } | | ------------------ ------------------ 4102| 886|#line 234 "flex_lexer.l" 4103| 886|TOKEN(EQUALS) ------------------ | | 2887| 886|#define TOKEN(name) { return SQL_##name; } ------------------ 4104| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4105| 1.03k|case 172: ------------------ | Branch (4105:1): [True: 1.03k, False: 4.46M] ------------------ 4106| 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| 3.09k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.06k, False: 1.03k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4107| 1.03k|#line 235 "flex_lexer.l" 4108| 1.03k|TOKEN(NOTEQUALS) ------------------ | | 2887| 1.03k|#define TOKEN(name) { return SQL_##name; } ------------------ 4109| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4110| 331|case 173: ------------------ | Branch (4110:1): [True: 331, False: 4.46M] ------------------ 4111| 331|YY_RULE_SETUP ------------------ | | 3147| 331| YY_USER_ACTION | | ------------------ | | | | 61| 331| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 331| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 331| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 331| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 331| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 331| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 993| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 993|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 662, False: 331] | | | | ------------------ | | | | 64| 662| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 662| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 662| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 662|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 662] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 662| } else { \ | | | | 70| 662| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 662| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 662| } \ | | | | 72| 662| } | | ------------------ ------------------ 4112| 331|#line 236 "flex_lexer.l" 4113| 331|TOKEN(NOTEQUALS) ------------------ | | 2887| 331|#define TOKEN(name) { return SQL_##name; } ------------------ 4114| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4115| 507|case 174: ------------------ | Branch (4115:1): [True: 507, False: 4.46M] ------------------ 4116| 507|YY_RULE_SETUP ------------------ | | 3147| 507| YY_USER_ACTION | | ------------------ | | | | 61| 507| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 507| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 507| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 507| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 507| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 507| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.01k, False: 507] | | | | ------------------ | | | | 64| 1.01k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.01k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.01k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.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| 1.01k| } else { \ | | | | 70| 1.01k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.01k| } \ | | | | 72| 1.01k| } | | ------------------ ------------------ 4117| 507|#line 237 "flex_lexer.l" 4118| 507|TOKEN(LESSEQ) ------------------ | | 2887| 507|#define TOKEN(name) { return SQL_##name; } ------------------ 4119| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4120| 667|case 175: ------------------ | Branch (4120:1): [True: 667, False: 4.46M] ------------------ 4121| 667|YY_RULE_SETUP ------------------ | | 3147| 667| YY_USER_ACTION | | ------------------ | | | | 61| 667| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 667| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 667| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 667| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 667| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 667| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.33k, False: 667] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4122| 667|#line 238 "flex_lexer.l" 4123| 667|TOKEN(GREATEREQ) ------------------ | | 2887| 667|#define TOKEN(name) { return SQL_##name; } ------------------ 4124| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4125| 1.88k|case 176: ------------------ | Branch (4125:1): [True: 1.88k, False: 4.46M] ------------------ 4126| 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| 5.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.77k, False: 1.88k] | | | | ------------------ | | | | 64| 3.77k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.77k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.77k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.77k] | | | | ------------------ | | | | 67| 0| 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.77k| } else { \ | | | | 70| 3.77k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.77k| } \ | | | | 72| 3.77k| } | | ------------------ ------------------ 4127| 1.88k|#line 239 "flex_lexer.l" 4128| 1.88k|TOKEN(CONCAT) ------------------ | | 2887| 1.88k|#define TOKEN(name) { return SQL_##name; } ------------------ 4129| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4130| 2.74M|case 177: ------------------ | Branch (4130:1): [True: 2.74M, False: 1.71M] ------------------ 4131| 2.74M|YY_RULE_SETUP ------------------ | | 3147| 2.74M| YY_USER_ACTION | | ------------------ | | | | 61| 2.74M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.74M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.48M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.48M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.74M, False: 2.74M] | | | | ------------------ | | | | 64| 2.74M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.74M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.74M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.74M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.74M] | | | | ------------------ | | | | 67| 0| 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.74M| } else { \ | | | | 70| 2.74M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.74M| } \ | | | | 72| 2.74M| } | | ------------------ ------------------ 4132| 2.74M|#line 241 "flex_lexer.l" 4133| 2.74M|{ return yytext[0]; } ------------------ | | 122| 2.74M|#define yytext yyg->yytext_r ------------------ 4134| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4135| 309|case 178: ------------------ | Branch (4135:1): [True: 309, False: 4.46M] ------------------ 4136| 309|#line 244 "flex_lexer.l" 4137| 1.55k|case 179: ------------------ | Branch (4137:1): [True: 1.24k, False: 4.46M] ------------------ 4138| 1.55k|YY_RULE_SETUP ------------------ | | 3147| 1.55k| YY_USER_ACTION | | ------------------ | | | | 61| 1.55k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.55k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.55k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.56k, False: 1.55k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4139| 1.55k|#line 244 "flex_lexer.l" 4140| 1.55k|{ 4141| 1.55k| yylval->fval = atof(yytext); ------------------ | | 2964| 1.55k| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 122| 1.55k|#define yytext yyg->yytext_r ------------------ 4142| 1.55k| return SQL_FLOATVAL; 4143| 309|} 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| 508|case 180: ------------------ | Branch (4150:1): [True: 508, False: 4.46M] ------------------ 4151| 508|YY_RULE_SETUP ------------------ | | 3147| 508| YY_USER_ACTION | | ------------------ | | | | 61| 508| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 508| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 508| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 508| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 508| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 508| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.1k, False: 508] | | | | ------------------ | | | | 64| 10.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.1k| } else { \ | | | | 70| 10.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.1k| } \ | | | | 72| 10.1k| } | | ------------------ ------------------ 4152| 508|#line 254 "flex_lexer.l" 4153| 508|{ 4154| 508| yylval->ival = LLONG_MIN; ------------------ | | 2964| 508| # define yylval yyg->yylval_r ------------------ 4155| 508| return SQL_INTVAL; 4156| 309|} 4157| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4158| 26.6k|case 181: ------------------ | Branch (4158:1): [True: 26.6k, False: 4.43M] ------------------ 4159| 26.6k|YY_RULE_SETUP ------------------ | | 3147| 26.6k| YY_USER_ACTION | | ------------------ | | | | 61| 26.6k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 26.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 26.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 26.6k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 26.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 26.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 60.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 60.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 33.9k, False: 26.6k] | | | | ------------------ | | | | 64| 33.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 33.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 33.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 33.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 33.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 33.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 33.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| 33.9k| } else { \ | | | | 70| 33.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 33.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 33.9k| } \ | | | | 72| 33.9k| } | | ------------------ ------------------ 4160| 26.6k|#line 259 "flex_lexer.l" 4161| 26.6k|{ 4162| 26.6k| errno = 0; 4163| 26.6k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 2964| 26.6k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 122| 26.6k|#define yytext yyg->yytext_r ------------------ 4164| 26.6k| if (errno) { ------------------ | Branch (4164:7): [True: 5, False: 26.6k] ------------------ 4165| 5| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4166| 0| return 0; 4167| 5| } 4168| 26.6k| return SQL_INTVAL; 4169| 26.6k|} 4170| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4171| 1.38k|case 182: ------------------ | Branch (4171:1): [True: 1.38k, False: 4.46M] ------------------ 4172| 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| 7.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.21k, False: 1.38k] | | | | ------------------ | | | | 64| 6.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.21k| } else { \ | | | | 70| 6.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.21k| } \ | | | | 72| 6.21k| } | | ------------------ ------------------ 4173| 1.38k|#line 269 "flex_lexer.l" 4174| 1.38k|{ 4175| | // Crop the leading and trailing quote char 4176| 1.38k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 2964| 1.38k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.38k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.38k|#define yytext yyg->yytext_r ------------------ 4177| 1.38k| return SQL_IDENTIFIER; 4178| 26.6k|} 4179| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4180| 643k|case 183: ------------------ | Branch (4180:1): [True: 643k, False: 3.81M] ------------------ 4181| 643k|YY_RULE_SETUP ------------------ | | 3147| 643k| YY_USER_ACTION | | ------------------ | | | | 61| 643k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 643k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 643k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 643k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 643k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 643k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.41M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.41M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.76M, False: 643k] | | | | ------------------ | | | | 64| 5.76M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.76M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.76M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.76M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.76M] | | | | ------------------ | | | | 67| 0| 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.76M| } else { \ | | | | 70| 5.76M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.76M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.76M| } \ | | | | 72| 5.76M| } | | ------------------ ------------------ 4182| 643k|#line 275 "flex_lexer.l" 4183| 643k|{ 4184| 643k| yylval->sval = strdup(yytext); ------------------ | | 2964| 643k| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 122| 643k|#define yytext yyg->yytext_r ------------------ 4185| 643k| return SQL_IDENTIFIER; 4186| 26.6k|} 4187| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4188| 27.5k|case 184: ------------------ | Branch (4188:1): [True: 27.5k, False: 4.43M] ------------------ 4189| 27.5k|YY_RULE_SETUP ------------------ | | 3147| 27.5k| YY_USER_ACTION | | ------------------ | | | | 61| 27.5k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 27.5k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 55.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 55.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 27.5k, False: 27.5k] | | | | ------------------ | | | | 64| 27.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 27.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 27.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 27.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 27.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| 27.5k| } else { \ | | | | 70| 27.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 27.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 27.5k| } \ | | | | 72| 27.5k| } | | ------------------ ------------------ 4190| 27.5k|#line 280 "flex_lexer.l" 4191| 27.5k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 131| 27.5k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 2907| 27.5k|#define singlequotedstring 1 ------------------ 4192| 27.5k| YY_BREAK ------------------ | | 3143| 27.5k|#define YY_BREAK /*LINTED*/break; ------------------ 4193| 1.58k|case 185: ------------------ | Branch (4193:1): [True: 1.58k, False: 4.46M] ------------------ 4194| 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| 4.75k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.17k, False: 1.58k] | | | | ------------------ | | | | 64| 3.17k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.17k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.17k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.17k| } else { \ | | | | 70| 3.17k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.17k| } \ | | | | 72| 3.17k| } | | ------------------ ------------------ 4195| 1.58k|#line 281 "flex_lexer.l" 4196| 1.58k|{ strbuf << '\''; } 4197| 1.58k| YY_BREAK ------------------ | | 3143| 1.58k|#define YY_BREAK /*LINTED*/break; ------------------ 4198| 15.1k|case 186: ------------------ | Branch (4198:1): [True: 15.1k, False: 4.44M] ------------------ 4199| |/* rule 186 can match eol */ 4200| 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| 3.26M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.26M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.25M, False: 15.1k] | | | | ------------------ | | | | 64| 3.25M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.25M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.25M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.25M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.25M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.25M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 6.47k, False: 3.24M] | | | | ------------------ | | | | 67| 6.47k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 6.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.47k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 6.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.24M| } else { \ | | | | 70| 3.24M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.24M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.24M| } \ | | | | 72| 3.25M| } | | ------------------ ------------------ 4201| 15.1k|#line 282 "flex_lexer.l" 4202| 15.1k|{ strbuf << yytext; } ------------------ | | 122| 15.1k|#define yytext yyg->yytext_r ------------------ 4203| 15.1k| YY_BREAK ------------------ | | 3143| 15.1k|#define YY_BREAK /*LINTED*/break; ------------------ 4204| 27.4k|case 187: ------------------ | Branch (4204:1): [True: 27.4k, False: 4.43M] ------------------ 4205| 27.4k|YY_RULE_SETUP ------------------ | | 3147| 27.4k| YY_USER_ACTION | | ------------------ | | | | 61| 27.4k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 27.4k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 54.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 54.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 27.4k, False: 27.4k] | | | | ------------------ | | | | 64| 27.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 27.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 27.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 27.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 27.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| 27.4k| } else { \ | | | | 70| 27.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 27.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 27.4k| } \ | | | | 72| 27.4k| } | | ------------------ ------------------ 4206| 27.4k|#line 283 "flex_lexer.l" 4207| 27.4k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 131| 27.4k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 2964| 27.4k| # 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.46M] ------------------ 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| 149|case 188: ------------------ | Branch (4213:1): [True: 149, False: 4.46M] ------------------ 4214| 149|YY_RULE_SETUP ------------------ | | 3147| 149| YY_USER_ACTION | | ------------------ | | | | 61| 149| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 149| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 298| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 298|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 149, False: 149] | | | | ------------------ | | | | 64| 149| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 149| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 149| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 149|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 149] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 149| } else { \ | | | | 70| 149| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 149| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 149| } \ | | | | 72| 149| } | | ------------------ ------------------ 4215| 149|#line 286 "flex_lexer.l" 4216| 149|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 122| 149|#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.46M] ------------------ 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.86k|case YY_STATE_EOF(INITIAL): ------------------ | | 141| 2.86k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.86k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4224:1): [True: 2.86k, False: 4.45M] ------------------ 4225| 2.92k|case YY_STATE_EOF(COMMENT): ------------------ | | 141| 2.92k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 2.92k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4225:1): [True: 63, False: 4.46M] ------------------ 4226| 2.92k| yyterminate(); ------------------ | | 3106| 2.92k|#define yyterminate() return YY_NULL | | ------------------ | | | | 101| 2.92k|#define YY_NULL 0 | | ------------------ ------------------ 4227| | 4228| 7.65k| case YY_END_OF_BUFFER: ------------------ | | 351| 7.65k|#define YY_END_OF_BUFFER 190 ------------------ | Branch (4228:2): [True: 7.65k, False: 4.45M] ------------------ 4229| 7.65k| { 4230| | /* Amount of text matched not including the EOB char. */ 4231| 7.65k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 333| 7.65k|#define yytext_ptr yytext_r ------------------ 4232| | 4233| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4234| 7.65k| *yy_cp = yyg->yy_hold_char; 4235| 7.65k| YY_RESTORE_YY_MORE_OFFSET 4236| | 4237| 7.65k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 276| 7.65k|#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.65k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4237:8): [True: 4.62k, False: 3.03k] ------------------ 4238| 4.62k| { 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.62k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 4.62k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4249| 4.62k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 276| 4.62k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 118| 4.62k|#define yyin yyg->yyin_r ------------------ 4250| 4.62k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 276| 4.62k|#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.62k|#define YY_BUFFER_NORMAL 1 ------------------ 4251| 4.62k| } 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.65k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 276| 7.65k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4260:8): [True: 0, False: 7.65k] ------------------ 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.65k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4297:17): [True: 7.65k, False: 0] ------------------ 4298| 7.65k| { 4299| 3.02k| case EOB_ACT_END_OF_FILE: ------------------ | | 176| 3.02k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4299:4): [True: 3.02k, False: 4.62k] ------------------ 4300| 3.02k| { 4301| 3.02k| yyg->yy_did_buffer_switch_on_eof = 0; 4302| | 4303| 3.02k| if ( hsql_wrap(yyscanner ) ) ------------------ | | 326| 3.02k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | ------------------ | | | Branch (326:30): [True: 3.02k, Folded] | | ------------------ ------------------ 4304| 3.02k| { 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.02k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 3.02k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 3.02k|#define YY_MORE_ADJ 0 ------------------ 4315| | 4316| 3.02k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 141| 3.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.02k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ 4317| 3.02k| goto do_action; 4318| 3.02k| } 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.02k| } 4327| | 4328| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 175| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4328:4): [True: 0, False: 7.65k] ------------------ 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.62k| case EOB_ACT_LAST_MATCH: ------------------ | | 177| 4.62k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4338:4): [True: 4.62k, False: 3.02k] ------------------ 4339| 4.62k| yyg->yy_c_buf_p = 4340| 4.62k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 276| 4.62k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4341| | 4342| 4.62k| yy_current_state = yy_get_previous_state( yyscanner ); 4343| | 4344| 4.62k| yy_cp = yyg->yy_c_buf_p; 4345| 4.62k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 4.62k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 4.62k|#define YY_MORE_ADJ 0 ------------------ 4346| 4.62k| goto yy_find_action; 4347| 7.65k| } 4348| 0| break; 4349| 7.65k| } 4350| | 4351| 0| default: ------------------ | Branch (4351:2): [True: 0, False: 4.46M] ------------------ 4352| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4353| 4.46M| "fatal flex scanner internal error--no action found" ); 4354| 4.46M| } /* end of action switch */ 4355| 4.46M| } /* end of scanning one token */ 4356| 3.96M| } /* end of user's declarations */ 4357| 3.96M|} /* end of hsql_lex */ _Z22hsql__switch_to_bufferP15yy_buffer_statePv: 4662| 5.29k|{ 4663| 5.29k| 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.29k| hsql_ensure_buffer_stack (yyscanner); 4671| 5.29k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 269| 5.29k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.29k, False: 0] | | ------------------ | | 270| 5.29k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.29k| : NULL) ------------------ | Branch (4671:7): [True: 0, False: 5.29k] ------------------ 4672| 0| return; 4673| | 4674| 5.29k| if ( YY_CURRENT_BUFFER ) ------------------ | | 269| 5.29k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 5.29k] | | | Branch (269:29): [True: 5.29k, False: 0] | | ------------------ | | 270| 5.29k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.29k| : 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.29k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 276| 5.29k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4683| 5.29k| 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.29k| yyg->yy_did_buffer_switch_on_eof = 1; 4691| 5.29k|} _Z19hsql__delete_bufferP15yy_buffer_statePv: 4737| 5.29k|{ 4738| 5.29k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4739| | 4740| 5.29k| if ( ! b ) ------------------ | Branch (4740:7): [True: 0, False: 5.29k] ------------------ 4741| 0| return; 4742| | 4743| 5.29k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 269| 5.29k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 5.29k, False: 0] | | ------------------ | | 270| 5.29k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.29k| : NULL) ------------------ | Branch (4743:7): [True: 5.29k, False: 0] ------------------ 4744| 5.29k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 276| 5.29k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4745| | 4746| 5.29k| if ( b->yy_is_our_buffer ) ------------------ | Branch (4746:7): [True: 5.29k, False: 0] ------------------ 4747| 5.29k| hsql_free((void *) b->yy_ch_buf ,yyscanner ); 4748| | 4749| 5.29k| hsql_free((void *) b ,yyscanner ); 4750| 5.29k|} _Z17hsql__scan_bufferPcmPv: 4917| 5.29k|{ 4918| 5.29k| YY_BUFFER_STATE b; 4919| | 4920| 5.29k| if ( size < 2 || ------------------ | Branch (4920:7): [True: 0, False: 5.29k] ------------------ 4921| 5.29k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 146| 10.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4921:7): [True: 0, False: 5.29k] ------------------ 4922| 5.29k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 146| 5.29k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4922:7): [True: 0, False: 5.29k] ------------------ 4923| | /* They forgot to leave room for the EOB's. */ 4924| 0| return NULL; 4925| | 4926| 5.29k| b = (YY_BUFFER_STATE) hsql_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 4927| 5.29k| if ( ! b ) ------------------ | Branch (4927:7): [True: 0, False: 5.29k] ------------------ 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.29k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 4931| 5.29k| b->yy_buf_pos = b->yy_ch_buf = base; 4932| 5.29k| b->yy_is_our_buffer = 0; 4933| 5.29k| b->yy_input_file = NULL; 4934| 5.29k| b->yy_n_chars = b->yy_buf_size; 4935| 5.29k| b->yy_is_interactive = 0; 4936| 5.29k| b->yy_at_bol = 1; 4937| 5.29k| b->yy_fill_buffer = 0; 4938| 5.29k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 246| 5.29k|#define YY_BUFFER_NEW 0 ------------------ 4939| | 4940| 5.29k| hsql__switch_to_buffer(b ,yyscanner ); 4941| | 4942| 5.29k| return b; 4943| 5.29k|} _Z17hsql__scan_stringPKcPv: 4954| 5.29k|{ 4955| | 4956| 5.29k| return hsql__scan_bytes(yystr,(int) strlen(yystr) ,yyscanner); 4957| 5.29k|} _Z16hsql__scan_bytesPKciPv: 4967| 5.29k|{ 4968| 5.29k| YY_BUFFER_STATE b; 4969| 5.29k| char *buf; 4970| 5.29k| yy_size_t n; 4971| 5.29k| int i; 4972| | 4973| | /* Get memory for full buffer, including space for trailing EOB's. */ 4974| 5.29k| n = (yy_size_t) (_yybytes_len + 2); 4975| 5.29k| buf = (char *) hsql_alloc(n ,yyscanner ); 4976| 5.29k| if ( ! buf ) ------------------ | Branch (4976:7): [True: 0, False: 5.29k] ------------------ 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| 23.0M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (4979:15): [True: 23.0M, False: 5.29k] ------------------ 4980| 23.0M| buf[i] = yybytes[i]; 4981| | 4982| 5.29k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 5.29k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4983| | 4984| 5.29k| b = hsql__scan_buffer(buf,n ,yyscanner); 4985| 5.29k| if ( ! b ) ------------------ | Branch (4985:7): [True: 0, False: 5.29k] ------------------ 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.29k| b->yy_is_our_buffer = 1; 4992| | 4993| 5.29k| return b; 4994| 5.29k|} _Z13hsql_lex_initPPv: 5204| 5.29k|{ 5205| 5.29k| if (ptr_yy_globals == NULL){ ------------------ | Branch (5205:9): [True: 0, False: 5.29k] ------------------ 5206| 0| errno = EINVAL; 5207| 0| return 1; 5208| 0| } 5209| | 5210| 5.29k| *ptr_yy_globals = (yyscan_t) hsql_alloc ( sizeof( struct yyguts_t ), NULL ); 5211| | 5212| 5.29k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (5212:9): [True: 0, False: 5.29k] ------------------ 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.29k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 5219| | 5220| 5.29k| return yy_init_globals ( *ptr_yy_globals ); 5221| 5.29k|} _Z16hsql_lex_destroyPv: 5294| 5.29k|{ 5295| 5.29k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5296| | 5297| | /* Pop the buffer stack, destroying each element. */ 5298| 5.29k| while(YY_CURRENT_BUFFER){ ------------------ | | 269| 5.29k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 5.29k] | | | Branch (269:29): [True: 5.29k, False: 0] | | ------------------ | | 270| 5.29k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 5.29k| : 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.29k| hsql_free(yyg->yy_buffer_stack ,yyscanner); 5306| 5.29k| yyg->yy_buffer_stack = NULL; 5307| | 5308| | /* Destroy the start condition stack. */ 5309| 5.29k| hsql_free(yyg->yy_start_stack ,yyscanner ); 5310| 5.29k| 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.29k| yy_init_globals( yyscanner); 5315| | 5316| | /* Destroy the main struct (reentrant only). */ 5317| 5.29k| hsql_free ( yyscanner , yyscanner ); 5318| | yyscanner = NULL; 5319| 5.29k| return 0; 5320| 5.29k|} _Z10hsql_allocmPv: 5350| 21.1k|{ 5351| 21.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5352| 21.1k| (void)yyg; 5353| 21.1k| return malloc(size); 5354| 21.1k|} _Z9hsql_freePvS_: 5372| 26.4k|{ 5373| 26.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5374| 26.4k| (void)yyg; 5375| 26.4k| free( (char *) ptr ); /* see hsql_realloc() for (char *) cast */ 5376| 26.4k|} flex_lexer.cpp:_ZL18yy_get_next_bufferPv: 4367| 7.65k|{ 4368| 7.65k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4369| 7.65k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 276| 7.65k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4370| 7.65k| char *source = yyg->yytext_ptr; ------------------ | | 333| 7.65k|#define yytext_ptr yytext_r ------------------ 4371| 7.65k| yy_size_t number_to_move, i; 4372| 7.65k| int ret_val; 4373| | 4374| 7.65k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 276| 7.65k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4374:7): [True: 0, False: 7.65k] ------------------ 4375| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4376| 7.65k| "fatal flex scanner internal error--end of buffer missed" ); 4377| | 4378| 7.65k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 276| 7.65k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4378:7): [True: 7.65k, False: 0] ------------------ 4379| 7.65k| { /* Don't try to fill the buffer, so this is an EOF. */ 4380| 7.65k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 333| 7.65k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 2868| 7.65k|#define YY_MORE_ADJ 0 ------------------ | Branch (4380:8): [True: 3.02k, False: 4.62k] ------------------ 4381| 3.02k| { 4382| | /* We matched a single character, the EOB, so 4383| | * treat this as a final EOF. 4384| | */ 4385| 3.02k| return EOB_ACT_END_OF_FILE; ------------------ | | 176| 3.02k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4386| 3.02k| } 4387| | 4388| 4.62k| else 4389| 4.62k| { 4390| | /* We matched some text prior to the EOB, first 4391| | * process it. 4392| | */ 4393| 4.62k| return EOB_ACT_LAST_MATCH; ------------------ | | 177| 4.62k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4394| 4.62k| } 4395| 7.65k| } 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.62k|{ 4503| 4.62k| yy_state_type yy_current_state; 4504| 4.62k| char *yy_cp; 4505| 4.62k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4506| | 4507| 4.62k| yy_current_state = yyg->yy_start; 4508| | 4509| 6.51M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 333| 4.62k|#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.62k|#define YY_MORE_ADJ 0 ------------------ | Branch (4509:47): [True: 6.51M, False: 4.62k] ------------------ 4510| 6.51M| { 4511| 6.51M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 108| 6.51M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ | Branch (4511:19): [True: 6.51M, False: 0] ------------------ 4512| 6.51M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4512:8): [True: 3.29M, False: 3.21M] ------------------ 4513| 3.29M| { 4514| 3.29M| yyg->yy_last_accepting_state = yy_current_state; 4515| 3.29M| yyg->yy_last_accepting_cpos = yy_cp; 4516| 3.29M| } 4517| 13.5M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4517:11): [True: 7.02M, False: 6.51M] ------------------ 4518| 7.02M| { 4519| 7.02M| yy_current_state = (int) yy_def[yy_current_state]; 4520| 7.02M| if ( yy_current_state >= 1368 ) ------------------ | Branch (4520:9): [True: 6.50M, False: 526k] ------------------ 4521| 6.50M| yy_c = yy_meta[(unsigned int) yy_c]; 4522| 7.02M| } 4523| 6.51M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 4524| 6.51M| } 4525| | 4526| 4.62k| return yy_current_state; 4527| 4.62k|} flex_lexer.cpp:_ZL23hsql__load_buffer_statePv: 4694| 10.5k|{ 4695| 10.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4696| 10.5k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 10.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4697| 10.5k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 333| 10.5k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 276| 10.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4698| 10.5k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 118| 10.5k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 276| 10.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4699| 10.5k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 4700| 10.5k|} flex_lexer.cpp:_ZL24hsql_ensure_buffer_stackPv: 4867| 5.29k|{ 4868| 5.29k| int num_to_alloc; 4869| 5.29k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4870| | 4871| 5.29k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (4871:6): [True: 5.29k, 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.29k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 4878| 5.29k| yyg->yy_buffer_stack = (struct yy_buffer_state**)hsql_alloc 4879| 5.29k| (num_to_alloc * sizeof(struct yy_buffer_state*) 4880| 5.29k| , yyscanner); 4881| 5.29k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4881:8): [True: 0, False: 5.29k] ------------------ 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.29k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 4885| | 4886| 5.29k| yyg->yy_buffer_stack_max = num_to_alloc; 4887| 5.29k| yyg->yy_buffer_stack_top = 0; 4888| 5.29k| return; 4889| 5.29k| } 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| 10.5k|{ 5261| 10.5k| 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| 10.5k| yyg->yy_buffer_stack = NULL; 5267| 10.5k| yyg->yy_buffer_stack_top = 0; 5268| 10.5k| yyg->yy_buffer_stack_max = 0; 5269| 10.5k| yyg->yy_c_buf_p = NULL; 5270| 10.5k| yyg->yy_init = 0; 5271| 10.5k| yyg->yy_start = 0; 5272| | 5273| 10.5k| yyg->yy_start_stack_ptr = 0; 5274| 10.5k| yyg->yy_start_stack_depth = 0; 5275| 10.5k| yyg->yy_start_stack = NULL; 5276| | 5277| |/* Defined in main.c */ 5278| |#ifdef YY_STDINIT 5279| | yyin = stdin; 5280| | yyout = stdout; 5281| |#else 5282| 10.5k| yyin = NULL; ------------------ | | 118| 10.5k|#define yyin yyg->yyin_r ------------------ 5283| 10.5k| yyout = NULL; ------------------ | | 119| 10.5k|#define yyout yyg->yyout_r ------------------ 5284| 10.5k|#endif 5285| | 5286| | /* For future reference: Set errno on error, since we are called by 5287| | * hsql_lex_init() 5288| | */ 5289| 10.5k| return 0; 5290| 10.5k|} _ZN4hsql15TableConstraintC2ENS_14ConstraintTypeEPNSt3__16vectorIPcNS2_9allocatorIS4_EEEE: 29| 1.66k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 31| 1.66k|TableConstraint::~TableConstraint() { 32| 1.92k| for (auto* column : *columnNames) { ------------------ | Branch (32:21): [True: 1.92k, False: 1.66k] ------------------ 33| 1.92k| free(column); 34| 1.92k| } 35| 1.66k| delete columnNames; 36| 1.66k|} _ZN4hsql17ColumnConstraintsC2Ev: 59| 19.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| 19.2k| : column_constraints(column_constraints), name(name), type(type), nullable(true), references(references) {} _ZN4hsql16ColumnDefinitionD2Ev: 66| 19.2k|ColumnDefinition::~ColumnDefinition() { 67| 19.2k| free(name); 68| 19.2k| delete column_constraints; 69| 19.2k| if (references) { ------------------ | Branch (69:7): [True: 19.2k, False: 0] ------------------ 70| 19.2k| for (auto* ref : *references) { ------------------ | Branch (70:20): [True: 0, False: 19.2k] ------------------ 71| 0| delete ref; 72| 0| } 73| 19.2k| } 74| 19.2k| delete references; 75| 19.2k|} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 77| 19.2k|bool ColumnDefinition::trySetNullableExplicit() { 78| 19.2k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (78:7): [True: 1.77k, False: 17.5k] | Branch (78:7): [True: 2.50k, False: 16.7k] | Branch (78:61): [True: 732, False: 16.7k] ------------------ 79| 2.50k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (79:9): [True: 1.42k, False: 1.07k] ------------------ 80| 1.42k| return false; 81| 1.42k| } 82| 1.07k| nullable = false; 83| 1.07k| } 84| | 85| 17.8k| return true; 86| 19.2k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 90| 6.56k| : SQLStatement(kStmtCreate), 91| 6.56k| type(type), 92| 6.56k| ifNotExists(false), 93| 6.56k| filePath(nullptr), 94| 6.56k| schema(nullptr), 95| 6.56k| tableName(nullptr), 96| 6.56k| indexName(nullptr), 97| 6.56k| indexColumns(nullptr), 98| 6.56k| columns(nullptr), 99| 6.56k| tableConstraints(nullptr), 100| 6.56k| viewColumns(nullptr), 101| 6.56k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 103| 6.56k|CreateStatement::~CreateStatement() { 104| 6.56k| free(filePath); 105| 6.56k| free(schema); 106| 6.56k| free(tableName); 107| 6.56k| free(indexName); 108| 6.56k| delete select; 109| | 110| 6.56k| if (columns) { ------------------ | Branch (110:7): [True: 3.98k, False: 2.58k] ------------------ 111| 4.69k| for (auto* def : *columns) { ------------------ | Branch (111:20): [True: 4.69k, False: 3.98k] ------------------ 112| 4.69k| delete def; 113| 4.69k| } 114| 3.98k| delete columns; 115| 3.98k| } 116| | 117| 6.56k| if (tableConstraints) { ------------------ | Branch (117:7): [True: 3.98k, False: 2.58k] ------------------ 118| 3.98k| for (auto* def : *tableConstraints) { ------------------ | Branch (118:20): [True: 1.44k, False: 3.98k] ------------------ 119| 1.44k| delete def; 120| 1.44k| } 121| 3.98k| delete tableConstraints; 122| 3.98k| } 123| | 124| 6.56k| if (indexColumns) { ------------------ | Branch (124:7): [True: 683, False: 5.88k] ------------------ 125| 9.14k| for (char* column : *indexColumns) { ------------------ | Branch (125:23): [True: 9.14k, False: 683] ------------------ 126| 9.14k| free(column); 127| 9.14k| } 128| 683| delete indexColumns; 129| 683| } 130| | 131| 6.56k| if (viewColumns) { ------------------ | Branch (131:7): [True: 786, False: 5.78k] ------------------ 132| 977| for (char* column : *viewColumns) { ------------------ | Branch (132:23): [True: 977, False: 786] ------------------ 133| 977| free(column); 134| 977| } 135| 786| delete viewColumns; 136| 786| } 137| 6.56k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 139| 3.98k|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 140| 3.98k| columns = new std::vector(); 141| 3.98k| tableConstraints = new std::vector(); 142| | 143| 6.13k| for (auto tableElem : *tableElements) { ------------------ | Branch (143:23): [True: 6.13k, False: 3.98k] ------------------ 144| 6.13k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (144:15): [True: 4.69k, False: 1.44k] ------------------ 145| 4.69k| columns->emplace_back(colDef); 146| 4.69k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (146:22): [True: 1.44k, False: 0] ------------------ 147| 1.44k| tableConstraints->emplace_back(tableConstraint); 148| 1.44k| } 149| 6.13k| } 150| 3.98k|} _ZN4hsql12TableElementD2Ev: 18| 20.9k| virtual ~TableElement() = default; _ZN4hsql10FrameBoundC2ElNS_14FrameBoundTypeEb: 12| 9.63k| : offset{offset}, type{type}, unbounded{unbounded} {} _ZN4hsql16FrameDescriptionC2ENS_9FrameTypeEPNS_10FrameBoundES3_: 15| 4.81k| : type{type}, start{start}, end{end} {} _ZN4hsql16FrameDescriptionD2Ev: 17| 4.81k|FrameDescription::~FrameDescription() { 18| 4.81k| delete start; 19| 4.81k| delete end; 20| 4.81k|} _ZN4hsql17WindowDescriptionC2EPNSt3__16vectorIPNS_4ExprENS1_9allocatorIS4_EEEEPNS2_IPNS_16OrderDescriptionENS5_ISA_EEEEPNS_16FrameDescriptionE: 24| 4.75k| : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {} _ZN4hsql17WindowDescriptionD2Ev: 26| 4.75k|WindowDescription::~WindowDescription() { 27| 4.75k| if (partitionList) { ------------------ | Branch (27:7): [True: 667, False: 4.08k] ------------------ 28| 1.27k| for (Expr* e : *partitionList) { ------------------ | Branch (28:18): [True: 1.27k, False: 667] ------------------ 29| 1.27k| delete e; 30| 1.27k| } 31| 667| delete partitionList; 32| 667| } 33| | 34| 4.75k| if (orderList) { ------------------ | Branch (34:7): [True: 872, False: 3.88k] ------------------ 35| 1.48k| for (OrderDescription* orderDescription : *orderList) { ------------------ | Branch (35:45): [True: 1.48k, False: 872] ------------------ 36| 1.48k| delete orderDescription; 37| 1.48k| } 38| 872| delete orderList; 39| 872| } 40| | 41| 4.75k| delete frameDescription; 42| 4.75k|} _ZN4hsql4ExprC2ENS_8ExprTypeE: 45| 2.50M| : type(type), 46| 2.50M| expr(nullptr), 47| 2.50M| expr2(nullptr), 48| 2.50M| exprList(nullptr), 49| 2.50M| select(nullptr), 50| 2.50M| name(nullptr), 51| 2.50M| table(nullptr), 52| 2.50M| schema(nullptr), 53| 2.50M| alias(nullptr), 54| 2.50M| fval(0), 55| 2.50M| ival(0), 56| 2.50M| ival2(0), 57| 2.50M| datetimeField(kDatetimeNone), 58| 2.50M| columnType(DataType::UNKNOWN, 0), 59| 2.50M| isBoolLiteral(false), 60| 2.50M| opType(kOpNone), 61| 2.50M| distinct(false), 62| 2.50M| windowDescription(nullptr) {} _ZN4hsql4ExprD2Ev: 64| 2.50M|Expr::~Expr() { 65| 2.50M| delete expr; 66| 2.50M| delete expr2; 67| 2.50M| delete select; 68| 2.50M| delete windowDescription; 69| | 70| 2.50M| free(name); 71| 2.50M| free(table); 72| 2.50M| free(schema); 73| 2.50M| free(alias); 74| | 75| 2.50M| if (exprList) { ------------------ | Branch (75:7): [True: 10.7k, False: 2.49M] ------------------ 76| 11.0k| for (Expr* e : *exprList) { ------------------ | Branch (76:18): [True: 11.0k, False: 10.7k] ------------------ 77| 11.0k| delete e; 78| 11.0k| } 79| 10.7k| delete exprList; 80| 10.7k| } 81| 2.50M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 83| 2.20k|Expr* Expr::make(ExprType type) { 84| 2.20k| Expr* e = new Expr(type); 85| 2.20k| return e; 86| 2.20k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 88| 11.2k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 89| 11.2k| Expr* e = new Expr(kExprOperator); 90| 11.2k| e->opType = op; 91| 11.2k| e->expr = expr; 92| 11.2k| e->expr2 = nullptr; 93| 11.2k| return e; 94| 11.2k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 96| 995k|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 97| 995k| Expr* e = new Expr(kExprOperator); 98| 995k| e->opType = op; 99| 995k| e->expr = expr1; 100| 995k| e->expr2 = expr2; 101| 995k| return e; 102| 995k|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 104| 491|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 105| 491| Expr* e = new Expr(kExprOperator); 106| 491| e->expr = expr; 107| 491| e->opType = kOpBetween; 108| 491| e->exprList = new std::vector(); 109| 491| e->exprList->push_back(left); 110| 491| e->exprList->push_back(right); 111| 491| return e; 112| 491|} _ZN4hsql4Expr12makeCaseListEPS0_: 114| 1.85k|Expr* Expr::makeCaseList(Expr* caseListElement) { 115| 1.85k| 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.85k| e->opType = kOpNone; 119| 1.85k| e->exprList = new std::vector(); 120| 1.85k| e->exprList->push_back(caseListElement); 121| 1.85k| return e; 122| 1.85k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 124| 3.62k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 125| 3.62k| Expr* e = new Expr(kExprOperator); 126| 3.62k| e->opType = kOpCaseListElement; 127| 3.62k| e->expr = when; 128| 3.62k| e->expr2 = then; 129| 3.62k| return e; 130| 3.62k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 132| 1.77k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 133| 1.77k| caseList->exprList->push_back(caseListElement); 134| 1.77k| return caseList; 135| 1.77k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 137| 1.64k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 138| 1.64k| Expr* e = new Expr(kExprOperator); 139| 1.64k| e->opType = kOpCase; 140| 1.64k| e->expr = expr; 141| 1.64k| e->expr2 = elseExpr; 142| 1.64k| e->exprList = caseList->exprList; 143| 1.64k| caseList->exprList = nullptr; 144| 1.64k| delete caseList; 145| 1.64k| return e; 146| 1.64k|} _ZN4hsql4Expr11makeLiteralEl: 148| 14.1k|Expr* Expr::makeLiteral(int64_t val) { 149| 14.1k| Expr* e = new Expr(kExprLiteralInt); 150| 14.1k| e->ival = val; 151| 14.1k| return e; 152| 14.1k|} _ZN4hsql4Expr11makeLiteralEd: 154| 1.53k|Expr* Expr::makeLiteral(double value) { 155| 1.53k| Expr* e = new Expr(kExprLiteralFloat); 156| 1.53k| e->fval = value; 157| 1.53k| return e; 158| 1.53k|} _ZN4hsql4Expr11makeLiteralEPc: 160| 5.08k|Expr* Expr::makeLiteral(char* string) { 161| 5.08k| Expr* e = new Expr(kExprLiteralString); 162| 5.08k| e->name = string; 163| 5.08k| return e; 164| 5.08k|} _ZN4hsql4Expr11makeLiteralEb: 166| 996|Expr* Expr::makeLiteral(bool val) { 167| 996| Expr* e = new Expr(kExprLiteralInt); 168| 996| e->ival = (int)val; 169| 996| e->isBoolLiteral = true; 170| 996| return e; 171| 996|} _ZN4hsql4Expr15makeNullLiteralEv: 173| 1.84k|Expr* Expr::makeNullLiteral() { 174| 1.84k| Expr* e = new Expr(kExprLiteralNull); 175| 1.84k| return e; 176| 1.84k|} _ZN4hsql4Expr15makeDateLiteralEPc: 178| 196|Expr* Expr::makeDateLiteral(char* string) { 179| 196| Expr* e = new Expr(kExprLiteralDate); 180| 196| e->name = string; 181| 196| return e; 182| 196|} _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| 298k|Expr* Expr::makeColumnRef(char* name) { 192| 298k| Expr* e = new Expr(kExprColumnRef); 193| 298k| e->name = name; 194| 298k| return e; 195| 298k|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 197| 1.67k|Expr* Expr::makeColumnRef(char* table, char* name) { 198| 1.67k| Expr* e = new Expr(kExprColumnRef); 199| 1.67k| e->name = name; 200| 1.67k| e->table = table; 201| 1.67k| return e; 202| 1.67k|} _ZN4hsql4Expr8makeStarEv: 204| 913k|Expr* Expr::makeStar(void) { 205| 913k| Expr* e = new Expr(kExprStar); 206| 913k| return e; 207| 913k|} _ZN4hsql4Expr8makeStarEPc: 209| 397|Expr* Expr::makeStar(char* table) { 210| 397| Expr* e = new Expr(kExprStar); 211| 397| e->table = table; 212| 397| return e; 213| 397|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 215| 6.59k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct, WindowDescription* window) { 216| 6.59k| Expr* e = new Expr(kExprFunctionRef); 217| 6.59k| e->name = func_name; 218| 6.59k| e->exprList = exprList; 219| 6.59k| e->distinct = distinct; 220| 6.59k| e->windowDescription = window; 221| 6.59k| return e; 222| 6.59k|} _ZN4hsql4Expr15makeFunctionRefEPcS1_PNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 224| 410|Expr* Expr::makeFunctionRef(char* func_name, char* schema, std::vector* exprList, bool distinct, WindowDescription* window) { 225| 410| Expr* e = new Expr(kExprFunctionRef); 226| 410| e->name = func_name; 227| 410| e->schema = schema; 228| 410| e->exprList = exprList; 229| 410| e->distinct = distinct; 230| 410| e->windowDescription = window; 231| 410| return e; 232| 410|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 234| 507|Expr* Expr::makeArray(std::vector* exprList) { 235| 507| Expr* e = new Expr(kExprArray); 236| 507| e->exprList = exprList; 237| 507| return e; 238| 507|} _ZN4hsql4Expr14makeArrayIndexEPS0_l: 240| 194|Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) { 241| 194| Expr* e = new Expr(kExprArrayIndex); 242| 194| e->expr = expr; 243| 194| e->ival = index; 244| 194| return e; 245| 194|} _ZN4hsql4Expr13makeParameterEi: 247| 223k|Expr* Expr::makeParameter(int id) { 248| 223k| Expr* e = new Expr(kExprParameter); 249| 223k| e->ival = id; 250| 223k| return e; 251| 223k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 253| 1.08k|Expr* Expr::makeSelect(SelectStatement* select) { 254| 1.08k| Expr* e = new Expr(kExprSelect); 255| 1.08k| e->select = select; 256| 1.08k| return e; 257| 1.08k|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 259| 632|Expr* Expr::makeExists(SelectStatement* select) { 260| 632| Expr* e = new Expr(kExprOperator); 261| 632| e->opType = kOpExists; 262| 632| e->select = select; 263| 632| return e; 264| 632|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 266| 602|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 267| 602| Expr* e = new Expr(kExprOperator); 268| 602| e->opType = kOpIn; 269| 602| e->expr = expr; 270| 602| e->exprList = exprList; 271| | 272| 602| return e; 273| 602|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 275| 471|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 276| 471| Expr* e = new Expr(kExprOperator); 277| 471| e->opType = kOpIn; 278| 471| e->expr = expr; 279| 471| e->select = select; 280| | 281| 471| return e; 282| 471|} _ZN4hsql4Expr11makeExtractENS_13DatetimeFieldEPS0_: 284| 581|Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { 285| 581| Expr* e = new Expr(kExprExtract); 286| 581| e->datetimeField = datetimeField; 287| 581| e->expr = expr; 288| 581| return e; 289| 581|} _ZN4hsql4Expr8makeCastEPS0_NS_10ColumnTypeE: 291| 435|Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { 292| 435| Expr* e = new Expr(kExprCast); 293| 435| e->columnType = columnType; 294| 435| e->expr = expr; 295| 435| return e; 296| 435|} _ZN4hsql6substrEPKcii: 316| 1.38k|char* substr(const char* source, int from, int to) { 317| 1.38k| int len = to - from; 318| 1.38k| char* copy = (char*)malloc(len + 1); 319| 1.38k| ; 320| 1.38k| strncpy(copy, source + from, len); 321| 1.38k| copy[len] = '\0'; 322| 1.38k| return copy; 323| 1.38k|} _ZN4hsql16PrepareStatementC2Ev: 6| 1.24k|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 1.24k|PrepareStatement::~PrepareStatement() { 9| 1.24k| free(name); 10| 1.24k| free(query); 11| 1.24k|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 89.6k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 89.3k|SQLStatement::~SQLStatement() { 10| 89.3k| if (hints) { ------------------ | Branch (10:7): [True: 676, False: 88.6k] ------------------ 11| 1.34k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 1.34k, False: 676] ------------------ 12| 1.34k| delete hint; 13| 1.34k| } 14| 676| } 15| 89.3k| delete hints; 16| 89.3k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 11| 2.52M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 77| 1.75k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 79| 1.75k|DeleteStatement::~DeleteStatement() { 80| 1.75k| free(schema); 81| 1.75k| free(tableName); 82| 1.75k| delete expr; 83| 1.75k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 87| 3.74k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 89| 3.74k|DropStatement::~DropStatement() { 90| 3.74k| free(schema); 91| 3.74k| free(name); 92| 3.74k| free(indexName); 93| 3.74k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 117| 9.30k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 119| 9.30k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 122| 3.62k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 124| 3.62k|ExecuteStatement::~ExecuteStatement() { 125| 3.62k| free(name); 126| | 127| 3.62k| if (parameters) { ------------------ | Branch (127:7): [True: 217, False: 3.41k] ------------------ 128| 660| for (Expr* param : *parameters) { ------------------ | Branch (128:22): [True: 660, False: 217] ------------------ 129| 660| delete param; 130| 660| } 131| 217| delete parameters; 132| 217| } 133| 3.62k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 137| 6.33k| : SQLStatement(kStmtExport), 138| 6.33k| type(type), 139| 6.33k| filePath(nullptr), 140| 6.33k| schema(nullptr), 141| 6.33k| tableName(nullptr), 142| 6.33k| select(nullptr), 143| 6.33k| encoding(nullptr), 144| 6.33k| csv_options(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 146| 6.33k|ExportStatement::~ExportStatement() { 147| 6.33k| free(filePath); 148| 6.33k| free(schema); 149| 6.33k| free(tableName); 150| 6.33k| delete select; 151| 6.33k| free(encoding); 152| 6.33k| delete csv_options; 153| 6.33k|} _ZN4hsql10CsvOptionsC2Ev: 155| 1.84k|CsvOptions::CsvOptions() : delimiter(nullptr), null(nullptr), quote(nullptr) {} _ZN4hsql10CsvOptionsD2Ev: 156| 1.84k|CsvOptions::~CsvOptions() { 157| 1.84k| free(delimiter); 158| 1.84k| free(null); 159| 1.84k| free(quote); 160| 1.84k|} _ZN4hsql10CsvOptions17accept_csv_optionEPNSt3__14pairINS_13CsvOptionTypeEPcEE: 162| 2.10k|bool CsvOptions::accept_csv_option(std::pair* option) { 163| 2.10k| switch (option->first) { ------------------ | Branch (163:11): [True: 2.10k, False: 0] ------------------ 164| 436| case CsvOptionType::Delimiter: ------------------ | Branch (164:5): [True: 436, False: 1.67k] ------------------ 165| 436| if (delimiter != nullptr) { ------------------ | Branch (165:11): [True: 1, False: 435] ------------------ 166| 1| return false; 167| 1| } 168| 435| delimiter = option->second; 169| 435| break; 170| 1.06k| case CsvOptionType::Null: ------------------ | Branch (170:5): [True: 1.06k, False: 1.04k] ------------------ 171| 1.06k| if (null != nullptr) { ------------------ | Branch (171:11): [True: 3, False: 1.05k] ------------------ 172| 3| return false; 173| 3| } 174| 1.05k| null = option->second; 175| 1.05k| break; 176| 612| case CsvOptionType::Quote: ------------------ | Branch (176:5): [True: 612, False: 1.49k] ------------------ 177| 612| if (quote != nullptr) { ------------------ | Branch (177:11): [True: 6, False: 606] ------------------ 178| 6| return false; 179| 6| } 180| 606| quote = option->second; 181| 606| break; 182| 2.10k| } 183| | 184| 2.09k| return true; 185| 2.10k|} _ZN4hsql19ImportExportOptionsC2Ev: 187| 12.5k|ImportExportOptions::ImportExportOptions() : format(kImportAuto), encoding(nullptr), csv_options(nullptr) {} _ZN4hsql19ImportExportOptionsD2Ev: 189| 12.5k|ImportExportOptions::~ImportExportOptions() { 190| 12.5k| free(encoding); 191| 12.5k| delete csv_options; 192| 12.5k|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 196| 6.17k| : SQLStatement(kStmtImport), 197| 6.17k| type(type), 198| 6.17k| filePath(nullptr), 199| 6.17k| schema(nullptr), 200| 6.17k| tableName(nullptr), 201| 6.17k| whereClause(nullptr), 202| 6.17k| encoding(nullptr), 203| 6.17k| csv_options(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 205| 6.17k|ImportStatement::~ImportStatement() { 206| 6.17k| free(filePath); 207| 6.17k| free(schema); 208| 6.17k| free(tableName); 209| 6.17k| delete whereClause; 210| 6.17k| free(encoding); 211| 6.17k| delete csv_options; 212| 6.17k|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 216| 3.32k| : SQLStatement(kStmtInsert), 217| 3.32k| type(type), 218| 3.32k| schema(nullptr), 219| 3.32k| tableName(nullptr), 220| 3.32k| columns(nullptr), 221| 3.32k| values(nullptr), 222| 3.32k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 224| 3.32k|InsertStatement::~InsertStatement() { 225| 3.32k| free(schema); 226| 3.32k| free(tableName); 227| 3.32k| delete select; 228| | 229| 3.32k| if (columns) { ------------------ | Branch (229:7): [True: 208, False: 3.12k] ------------------ 230| 402| for (char* column : *columns) { ------------------ | Branch (230:23): [True: 402, False: 208] ------------------ 231| 402| free(column); 232| 402| } 233| 208| delete columns; 234| 208| } 235| | 236| 3.32k| if (values) { ------------------ | Branch (236:7): [True: 637, False: 2.69k] ------------------ 237| 1.05k| for (Expr* expr : *values) { ------------------ | Branch (237:21): [True: 1.05k, False: 637] ------------------ 238| 1.05k| delete expr; 239| 1.05k| } 240| 637| delete values; 241| 637| } 242| 3.32k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 245| 6.42k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 247| 6.42k|ShowStatement::~ShowStatement() { 248| 6.42k| free(schema); 249| 6.42k| free(name); 250| 6.42k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprENS_12NullOrderingE: 256| 8.26k| : type(type), expr(expr), null_ordering(null_ordering) {} _ZN4hsql16OrderDescriptionD2Ev: 258| 8.26k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 261| 8.47k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 263| 8.47k|LimitDescription::~LimitDescription() { 264| 8.47k| delete limit; 265| 8.47k| delete offset; 266| 8.47k|} _ZN4hsql18GroupByDescriptionC2Ev: 269| 3.04k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 271| 3.04k|GroupByDescription::~GroupByDescription() { 272| 3.04k| delete having; 273| | 274| 3.04k| if (columns) { ------------------ | Branch (274:7): [True: 3.04k, False: 0] ------------------ 275| 23.5k| for (Expr* expr : *columns) { ------------------ | Branch (275:21): [True: 23.5k, False: 3.04k] ------------------ 276| 23.5k| delete expr; 277| 23.5k| } 278| 3.04k| delete columns; 279| 3.04k| } 280| 3.04k|} _ZN4hsql15WithDescriptionD2Ev: 282| 1.42k|WithDescription::~WithDescription() { 283| 1.42k| free(alias); 284| 1.42k| delete select; 285| 1.42k|} _ZN4hsql15SelectStatementC2Ev: 289| 38.9k| : SQLStatement(kStmtSelect), 290| 38.9k| fromTable(nullptr), 291| 38.9k| selectDistinct(false), 292| 38.9k| selectList(nullptr), 293| 38.9k| whereClause(nullptr), 294| 38.9k| groupBy(nullptr), 295| 38.9k| setOperations(nullptr), 296| 38.9k| order(nullptr), 297| 38.9k| withDescriptions(nullptr), 298| 38.9k| limit(nullptr), 299| 38.9k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 301| 38.6k|SelectStatement::~SelectStatement() { 302| 38.6k| delete fromTable; 303| 38.6k| delete whereClause; 304| 38.6k| delete groupBy; 305| 38.6k| delete limit; 306| | 307| | // Delete each element in the select list. 308| 38.6k| if (selectList) { ------------------ | Branch (308:7): [True: 38.6k, False: 0] ------------------ 309| 293k| for (Expr* expr : *selectList) { ------------------ | Branch (309:21): [True: 293k, False: 38.6k] ------------------ 310| 293k| delete expr; 311| 293k| } 312| 38.6k| delete selectList; 313| 38.6k| } 314| | 315| 38.6k| if (order) { ------------------ | Branch (315:7): [True: 977, False: 37.6k] ------------------ 316| 2.92k| for (OrderDescription* desc : *order) { ------------------ | Branch (316:33): [True: 2.92k, False: 977] ------------------ 317| 2.92k| delete desc; 318| 2.92k| } 319| 977| delete order; 320| 977| } 321| | 322| 38.6k| if (withDescriptions) { ------------------ | Branch (322:7): [True: 782, False: 37.8k] ------------------ 323| 1.42k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (323:32): [True: 1.42k, False: 782] ------------------ 324| 1.42k| delete desc; 325| 1.42k| } 326| 782| delete withDescriptions; 327| 782| } 328| | 329| 38.6k| if (setOperations) { ------------------ | Branch (329:7): [True: 5.46k, False: 33.1k] ------------------ 330| 5.75k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (330:37): [True: 5.75k, False: 5.46k] ------------------ 331| 5.75k| delete setOperation; 332| 5.75k| } 333| 5.46k| delete setOperations; 334| 5.46k| } 335| | 336| 38.6k| if (lockings) { ------------------ | Branch (336:7): [True: 401, False: 38.2k] ------------------ 337| 3.35k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (337:39): [True: 3.35k, False: 401] ------------------ 338| 3.35k| if (lockingClause->tables) { ------------------ | Branch (338:11): [True: 204, False: 3.15k] ------------------ 339| 398| for (char* dtable : *lockingClause->tables) { ------------------ | Branch (339:27): [True: 398, False: 204] ------------------ 340| 398| free(dtable); 341| 398| } 342| 204| delete lockingClause->tables; 343| 204| } 344| 3.35k| delete lockingClause; 345| 3.35k| } 346| 401| delete lockings; 347| 401| } 348| 38.6k|} _ZN4hsql15UpdateStatementC2Ev: 351| 2.18k|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 353| 2.18k|UpdateStatement::~UpdateStatement() { 354| 2.18k| delete table; 355| 2.18k| delete where; 356| | 357| 2.18k| if (updates) { ------------------ | Branch (357:7): [True: 2.18k, False: 0] ------------------ 358| 3.25k| for (UpdateClause* update : *updates) { ------------------ | Branch (358:31): [True: 3.25k, False: 2.18k] ------------------ 359| 3.25k| free(update->column); 360| 3.25k| delete update->value; 361| 3.25k| delete update; 362| 3.25k| } 363| 2.18k| delete updates; 364| 2.18k| } 365| 2.18k|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 368| 21.8k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 370| 21.8k|Alias::~Alias() { 371| 21.8k| free(name); 372| 21.8k| if (columns) { ------------------ | Branch (372:7): [True: 187, False: 21.6k] ------------------ 373| 828| for (char* column : *columns) { ------------------ | Branch (373:23): [True: 828, False: 187] ------------------ 374| 828| free(column); 375| 828| } 376| 187| delete columns; 377| 187| } 378| 21.8k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 382| 339k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 384| 339k|TableRef::~TableRef() { 385| 339k| free(schema); 386| 339k| free(name); 387| | 388| 339k| delete select; 389| 339k| delete join; 390| 339k| delete alias; 391| | 392| 339k| if (list) { ------------------ | Branch (392:7): [True: 1.67k, False: 337k] ------------------ 393| 109k| for (TableRef* table : *list) { ------------------ | Branch (393:26): [True: 109k, False: 1.67k] ------------------ 394| 109k| delete table; 395| 109k| } 396| 1.67k| delete list; 397| 1.67k| } 398| 339k|} _ZN4hsql14JoinDefinitionC2Ev: 411| 110k| : left(nullptr), right(nullptr), condition(nullptr), namedColumns(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 413| 110k|JoinDefinition::~JoinDefinition() { 414| 110k| delete left; 415| 110k| delete right; 416| 110k| delete condition; 417| | 418| 110k| if (namedColumns) { ------------------ | Branch (418:7): [True: 720, False: 109k] ------------------ 419| 914| for (auto* column : *namedColumns) { ------------------ | Branch (419:23): [True: 914, False: 720] ------------------ 420| 914| free(column); 421| 914| } 422| 720| delete namedColumns; 423| 720| } 424| 110k|} _ZN4hsql12SetOperationC2Ev: 426| 6.85k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 428| 6.85k|SetOperation::~SetOperation() { 429| 6.85k| delete nestedSelectStatement; 430| 6.85k| delete resultLimit; 431| | 432| 6.85k| if (resultOrder) { ------------------ | Branch (432:7): [True: 648, False: 6.20k] ------------------ 433| 1.66k| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (433:33): [True: 1.66k, False: 648] ------------------ 434| 1.66k| delete desc; 435| 1.66k| } 436| 648| delete resultOrder; 437| 648| } 438| 6.85k|}