LLVMFuzzerTestOneInput: 21| 6.07k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 22| 6.07k| std::string input(reinterpret_cast(data), size); 23| 6.07k| SQLParserResult res; 24| 6.07k| SQLParser::parse(input, &res); 25| 6.07k| return 0; 26| 6.07k|} _ZN4hsql9SQLParser5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15SQLParserResultE: 13| 6.07k|bool SQLParser::parse(const std::string& sql, SQLParserResult* result) { 14| 6.07k| yyscan_t scanner; 15| 6.07k| YY_BUFFER_STATE state; 16| | 17| 6.07k| if (hsql_lex_init(&scanner)) { ------------------ | Branch (17:7): [True: 0, False: 6.07k] ------------------ 18| | // Couldn't initialize the lexer. 19| 0| fprintf(stderr, "SQLParser: Error when initializing lexer!\n"); 20| 0| return false; 21| 0| } 22| 6.07k| const char* text = sql.c_str(); 23| 6.07k| state = hsql__scan_string(text, scanner); 24| | 25| | // Parse the tokens. 26| | // If parsing fails, the result will contain an error object. 27| 6.07k| int ret = hsql_parse(result, scanner); 28| 6.07k| bool success = (ret == 0); 29| 6.07k| result->setIsValid(success); 30| | 31| 6.07k| hsql__delete_buffer(state, scanner); 32| 6.07k| hsql_lex_destroy(scanner); 33| | 34| 6.07k| return true; 35| 6.07k|} _ZN4hsql15SQLParserResultC2Ev: 7| 6.07k|SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) {} _ZN4hsql15SQLParserResultD2Ev: 24| 6.07k|SQLParserResult::~SQLParserResult() { reset(); } _ZN4hsql15SQLParserResult12addStatementEPNS_12SQLStatementE: 26| 24.0k|void SQLParserResult::addStatement(SQLStatement* stmt) { statements_.push_back(stmt); } _ZNK4hsql15SQLParserResult8errorMsgEv: 36| 2.36k|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 11.8k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.78k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.78k| errorMsg_ = errorMsg; 46| 5.78k| errorLine_ = errorLine; 47| 5.78k| errorColumn_ = errorColumn; 48| 5.78k|} _ZN4hsql15SQLParserResult5resetEv: 60| 6.07k|void SQLParserResult::reset() { 61| 24.0k| for (SQLStatement* statement : statements_) { ------------------ | Branch (61:32): [True: 24.0k, False: 6.07k] ------------------ 62| 24.0k| delete statement; 63| 24.0k| } 64| 6.07k| statements_.clear(); 65| | 66| 6.07k| isValid_ = false; 67| | 68| 6.07k| free(errorMsg_); 69| 6.07k| errorMsg_ = nullptr; 70| 6.07k| errorLine_ = -1; 71| 6.07k| errorColumn_ = -1; 72| 6.07k|} _ZN4hsql15SQLParserResult12addParameterEPNS_4ExprE: 75| 137k|void SQLParserResult::addParameter(Expr* parameter) { 76| 137k| parameters_.push_back(parameter); 77| 137k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 137k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 951M| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 97| 5.78k| int yyerror(YYLTYPE * llocp, SQLParserResult * result, yyscan_t scanner, const char* msg) { 98| 5.78k| result->setIsValid(false); 99| 5.78k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 100| 5.78k| return 0; 101| 5.78k| } _Z10hsql_parsePN4hsql15SQLParserResultEPv: 2886| 6.07k|{ 2887| |/* The lookahead symbol. */ 2888| 6.07k|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| 6.07k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 564| 6.07k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2895| 6.07k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 11| 6.07k|#define YYSTYPE HSQL_STYPE ------------------ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 564| 6.07k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2896| | 2897| |/* Location data for the lookahead symbol. */ 2898| 6.07k|static YYLTYPE yyloc_default 2899| |# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL 2900| | = { 1, 1, 1, 1 } 2901| |# endif 2902| 6.07k|; 2903| 6.07k|YYLTYPE yylloc = yyloc_default; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2904| | 2905| | /* Number of syntax errors so far. */ 2906| 6.07k| int yynerrs; 2907| | 2908| 6.07k| int yystate; 2909| | /* Number of tokens to shift before error messages enabled. */ 2910| 6.07k| 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| 6.07k| yytype_int16 yyssa[YYINITDEPTH]; 2922| 6.07k| yytype_int16 *yyss; 2923| 6.07k| yytype_int16 *yyssp; 2924| | 2925| | /* The semantic value stack. */ 2926| 6.07k| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 11| 6.07k|#define YYSTYPE HSQL_STYPE ------------------ 2927| 6.07k| YYSTYPE *yyvs; ------------------ | | 11| 6.07k|#define YYSTYPE HSQL_STYPE ------------------ 2928| 6.07k| YYSTYPE *yyvsp; ------------------ | | 11| 6.07k|#define YYSTYPE HSQL_STYPE ------------------ 2929| | 2930| | /* The location stack. */ 2931| 6.07k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2932| 6.07k| YYLTYPE *yyls; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2933| 6.07k| YYLTYPE *yylsp; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2934| | 2935| | /* The locations where the error started and ended. */ 2936| 6.07k| YYLTYPE yyerror_range[3]; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2937| | 2938| 6.07k| YYSIZE_T yystacksize; ------------------ | | 496| 6.07k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2939| | 2940| 6.07k| int yyn; 2941| 6.07k| int yyresult; 2942| | /* Lookahead token as an internal (translated) token number. */ 2943| 6.07k| int yytoken = 0; 2944| | /* The variables used to return semantic value and location from the 2945| | action routines. */ 2946| 6.07k| YYSTYPE yyval; ------------------ | | 11| 6.07k|#define YYSTYPE HSQL_STYPE ------------------ 2947| 6.07k| YYLTYPE yyloc; ------------------ | | 12| 6.07k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 6.07k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2948| | 2949| 6.07k|#if YYERROR_VERBOSE 2950| | /* Buffer for error messages, and its allocated size. */ 2951| 6.07k| char yymsgbuf[128]; 2952| 6.07k| char *yymsg = yymsgbuf; 2953| 6.07k| YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 496| 6.07k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 2954| 6.07k|#endif 2955| | 2956| 6.07k|#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| 6.07k| int yylen = 0; 2961| | 2962| 6.07k| yyssp = yyss = yyssa; 2963| 6.07k| yyvsp = yyvs = yyvsa; 2964| 6.07k| yylsp = yyls = yylsa; 2965| 6.07k| yystacksize = YYINITDEPTH; ------------------ | | 1688| 6.07k|# define YYINITDEPTH 200 ------------------ 2966| | 2967| 6.07k| YYDPRINTF ((stderr, "Starting parse\n")); 2968| | 2969| 6.07k| yystate = 0; 2970| 6.07k| yyerrstatus = 0; 2971| 6.07k| yynerrs = 0; ------------------ | | 69| 6.07k|#define yynerrs hsql_nerrs ------------------ 2972| 6.07k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 1453| 6.07k|#define YYEMPTY (-2) ------------------ 2973| | 2974| |/* User initialization code. */ 2975| 6.07k|#line 81 "bison_parser.y" /* yacc.c:1429 */ 2976| 6.07k|{ 2977| | // Initialize 2978| 6.07k| yylloc.first_column = 0; 2979| 6.07k| yylloc.last_column = 0; 2980| 6.07k| yylloc.first_line = 0; 2981| 6.07k| yylloc.last_line = 0; 2982| 6.07k| yylloc.total_column = 0; 2983| 6.07k| yylloc.string_length = 0; 2984| 6.07k|} 2985| | 2986| 6.07k|#line 2987 "bison_parser.cpp" /* yacc.c:1429 */ 2987| 6.07k| yylsp[0] = yylloc; 2988| 6.07k| goto yysetstate; 2989| | 2990| |/*------------------------------------------------------------. 2991| || yynewstate -- Push a new state, which is found in yystate. | 2992| |`------------------------------------------------------------*/ 2993| 23.1M| 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| 23.1M| yyssp++; 2997| | 2998| 23.1M| yysetstate: 2999| 23.1M| *yyssp = yystate; 3000| | 3001| 23.1M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3001:7): [True: 11, False: 23.1M] ------------------ 3002| 11| { 3003| | /* Get the current used size of the three stacks, in elements. */ 3004| 11| YYSIZE_T yysize = yyssp - yyss + 1; ------------------ | | 496| 11|# 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| 11|# ifndef YYSTACK_RELOCATE 3031| 11| 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| 23.1M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 3068| | 3069| 23.1M| if (yystate == YYFINAL) ------------------ | | 706| 23.1M|#define YYFINAL 69 ------------------ | Branch (3069:7): [True: 1.74k, False: 23.1M] ------------------ 3070| 1.74k| YYACCEPT; ------------------ | | 1456| 1.74k|#define YYACCEPT goto yyacceptlab ------------------ 3071| | 3072| 23.1M| goto yybackup; 3073| | 3074| |/*-----------. 3075| || yybackup. | 3076| |`-----------*/ 3077| 23.1M|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| 23.1M| yyn = yypact[yystate]; 3084| 23.1M| if (yypact_value_is_default (yyn)) ------------------ | | 923| 23.1M| (!!((Yystate) == (-529))) | | ------------------ | | | Branch (923:3): [True: 11.0M, False: 12.0M] | | ------------------ ------------------ 3085| 11.0M| 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| 12.0M| if (yychar == YYEMPTY) ------------------ | | 1453| 12.0M|#define YYEMPTY (-2) ------------------ | Branch (3090:7): [True: 5.77M, False: 6.31M] ------------------ 3091| 5.77M| { 3092| 5.77M| YYDPRINTF ((stderr, "Reading a token: ")); 3093| 5.77M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 66| 5.77M|#define yylex hsql_lex ------------------ 3094| 5.77M| } 3095| | 3096| 12.0M| if (yychar <= YYEOF) ------------------ | | 1454| 12.0M|#define YYEOF 0 ------------------ | Branch (3096:7): [True: 30.1k, False: 12.0M] ------------------ 3097| 30.1k| { 3098| 30.1k| yychar = yytoken = YYEOF; ------------------ | | 1454| 30.1k|#define YYEOF 0 ------------------ 3099| 30.1k| YYDPRINTF ((stderr, "Now at end of input.\n")); 3100| 30.1k| } 3101| 12.0M| else 3102| 12.0M| { 3103| 12.0M| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 12.0M| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 12.0M|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 12.0M, False: 0] | | ------------------ ------------------ 3104| 12.0M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3105| 12.0M| } 3106| | 3107| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3108| | detect an error, take that action. */ 3109| 12.0M| yyn += yytoken; 3110| 12.0M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 708| 12.0M|#define YYLAST 856 ------------------ | Branch (3110:7): [True: 6.22k, False: 12.0M] | Branch (3110:18): [True: 5.58k, False: 12.0M] | Branch (3110:34): [True: 5.85M, False: 6.21M] ------------------ 3111| 5.86M| goto yydefault; 3112| 6.21M| yyn = yytable[yyn]; 3113| 6.21M| if (yyn <= 0) ------------------ | Branch (3113:7): [True: 451k, False: 5.76M] ------------------ 3114| 451k| { 3115| 451k| if (yytable_value_is_error (yyn)) ------------------ | | 928| 451k| (!!((Yytable_value) == (-355))) | | ------------------ | | | Branch (928:3): [True: 20, False: 451k] | | ------------------ ------------------ 3116| 20| goto yyerrlab; 3117| 451k| yyn = -yyn; 3118| 451k| goto yyreduce; 3119| 451k| } 3120| | 3121| | /* Count tokens shifted since error; after three, turn off error 3122| | status. */ 3123| 5.76M| if (yyerrstatus) ------------------ | Branch (3123:7): [True: 0, False: 5.76M] ------------------ 3124| 0| yyerrstatus--; 3125| | 3126| | /* Shift the lookahead token. */ 3127| 5.76M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3128| | 3129| | /* Discard the shifted token. */ 3130| 5.76M| yychar = YYEMPTY; ------------------ | | 1453| 5.76M|#define YYEMPTY (-2) ------------------ 3131| | 3132| 5.76M| yystate = yyn; 3133| 5.76M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3134| 5.76M| *++yyvsp = yylval; 3135| 5.76M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3136| 5.76M| *++yylsp = yylloc; 3137| 5.76M| goto yynewstate; 3138| | 3139| | 3140| |/*-----------------------------------------------------------. 3141| || yydefault -- do the default action for the current state. | 3142| |`-----------------------------------------------------------*/ 3143| 16.9M|yydefault: 3144| 16.9M| yyn = yydefact[yystate]; 3145| 16.9M| if (yyn == 0) ------------------ | Branch (3145:7): [True: 3.56k, False: 16.9M] ------------------ 3146| 3.56k| goto yyerrlab; 3147| 16.9M| goto yyreduce; 3148| | 3149| | 3150| |/*-----------------------------. 3151| || yyreduce -- Do a reduction. | 3152| |`-----------------------------*/ 3153| 17.3M|yyreduce: 3154| | /* yyn is the number of a rule to reduce with. */ 3155| 17.3M| 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| 17.3M| yyval = yyvsp[1-yylen]; 3166| | 3167| | /* Default location. */ 3168| 17.3M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1491| 17.3M| do \ | | 1492| 17.3M| if (N) \ | | ------------------ | | | Branch (1492:11): [True: 15.0M, False: 2.28M] | | ------------------ | | 1493| 17.3M| { \ | | 1494| 15.0M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1509| 15.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1495| 15.0M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1509| 15.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1496| 15.0M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1509| 15.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1497| 15.0M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1509| 15.0M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1498| 15.0M| } \ | | 1499| 17.3M| else \ | | 1500| 17.3M| { \ | | 1501| 2.28M| (Current).first_line = (Current).last_line = \ | | 1502| 2.28M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1509| 2.28M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1503| 2.28M| (Current).first_column = (Current).last_column = \ | | 1504| 2.28M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1509| 2.28M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1505| 2.28M| } \ | | 1506| 17.3M| while (0) | | ------------------ | | | Branch (1506:12): [Folded, False: 17.3M] | | ------------------ ------------------ 3169| 17.3M| YY_REDUCE_PRINT (yyn); 3170| 17.3M| switch (yyn) 3171| 17.3M| { 3172| 1.98k| case 2: ------------------ | Branch (3172:9): [True: 1.98k, False: 17.3M] ------------------ 3173| 1.98k|#line 343 "bison_parser.y" /* yacc.c:1646 */ 3174| 1.98k| { 3175| 24.0k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3175:27): [True: 24.0k, False: 1.98k] ------------------ 3176| | // Transfers ownership of the statement. 3177| 24.0k| result->addStatement(stmt); 3178| 24.0k| } 3179| | 3180| 1.98k| unsigned param_id = 0; 3181| 137k| for (void* param : yyloc.param_list) { ------------------ | Branch (3181:20): [True: 137k, False: 1.98k] ------------------ 3182| 137k| if (param) { ------------------ | Branch (3182:9): [True: 137k, False: 0] ------------------ 3183| 137k| Expr* expr = (Expr*)param; 3184| 137k| expr->ival = param_id; 3185| 137k| result->addParameter(expr); 3186| 137k| ++param_id; 3187| 137k| } 3188| 137k| } 3189| 1.98k| delete (yyvsp[-1].stmt_vec); 3190| 1.98k| } 3191| 1.98k|#line 3192 "bison_parser.cpp" /* yacc.c:1646 */ 3192| 1.98k| break; 3193| | 3194| 2.50k| case 3: ------------------ | Branch (3194:3): [True: 2.50k, False: 17.3M] ------------------ 3195| 2.50k|#line 362 "bison_parser.y" /* yacc.c:1646 */ 3196| 2.50k| { 3197| 2.50k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3198| 2.50k| yylloc.string_length = 0; 3199| 2.50k| (yyval.stmt_vec) = new std::vector(); 3200| 2.50k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3201| 2.50k|} 3202| 2.50k|#line 3203 "bison_parser.cpp" /* yacc.c:1646 */ 3203| 2.50k| break; 3204| | 3205| 64.6k| case 4: ------------------ | Branch (3205:3): [True: 64.6k, False: 17.3M] ------------------ 3206| 64.6k|#line 368 "bison_parser.y" /* yacc.c:1646 */ 3207| 64.6k| { 3208| 64.6k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3209| 64.6k| yylloc.string_length = 0; 3210| 64.6k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3211| 64.6k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3212| 64.6k|} 3213| 64.6k|#line 3214 "bison_parser.cpp" /* yacc.c:1646 */ 3214| 64.6k| break; 3215| | 3216| 1.18k| case 5: ------------------ | Branch (3216:3): [True: 1.18k, False: 17.3M] ------------------ 3217| 1.18k|#line 375 "bison_parser.y" /* yacc.c:1646 */ 3218| 1.18k| { 3219| 1.18k| (yyval.statement) = (yyvsp[-1].prep_stmt); 3220| 1.18k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3221| 1.18k|} 3222| 1.18k|#line 3223 "bison_parser.cpp" /* yacc.c:1646 */ 3223| 1.18k| break; 3224| | 3225| 51.2k| case 6: ------------------ | Branch (3225:3): [True: 51.2k, False: 17.3M] ------------------ 3226| 51.2k|#line 379 "bison_parser.y" /* yacc.c:1646 */ 3227| 51.2k| { 3228| 51.2k| (yyval.statement) = (yyvsp[-1].statement); 3229| 51.2k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3230| 51.2k|} 3231| 51.2k|#line 3232 "bison_parser.cpp" /* yacc.c:1646 */ 3232| 51.2k| break; 3233| | 3234| 4.98k| case 7: ------------------ | Branch (3234:3): [True: 4.98k, False: 17.3M] ------------------ 3235| 4.98k|#line 383 "bison_parser.y" /* yacc.c:1646 */ 3236| 4.98k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3237| 4.98k|#line 3238 "bison_parser.cpp" /* yacc.c:1646 */ 3238| 4.98k| break; 3239| | 3240| 3.77k| case 8: ------------------ | Branch (3240:3): [True: 3.77k, False: 17.3M] ------------------ 3241| 3.77k|#line 384 "bison_parser.y" /* yacc.c:1646 */ 3242| 3.77k| { (yyval.statement) = (yyvsp[0].import_stmt); } 3243| 3.77k|#line 3244 "bison_parser.cpp" /* yacc.c:1646 */ 3244| 3.77k| break; 3245| | 3246| 5.95k| case 9: ------------------ | Branch (3246:3): [True: 5.95k, False: 17.3M] ------------------ 3247| 5.95k|#line 385 "bison_parser.y" /* yacc.c:1646 */ 3248| 5.95k| { (yyval.statement) = (yyvsp[0].export_stmt); } 3249| 5.95k|#line 3250 "bison_parser.cpp" /* yacc.c:1646 */ 3250| 5.95k| break; 3251| | 3252| 22.8k| case 10: ------------------ | Branch (3252:3): [True: 22.8k, False: 17.3M] ------------------ 3253| 22.8k|#line 387 "bison_parser.y" /* yacc.c:1646 */ 3254| 22.8k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3255| 22.8k|#line 3256 "bison_parser.cpp" /* yacc.c:1646 */ 3256| 22.8k| break; 3257| | 3258| 4.49k| case 11: ------------------ | Branch (3258:3): [True: 4.49k, False: 17.3M] ------------------ 3259| 4.49k|#line 388 "bison_parser.y" /* yacc.c:1646 */ 3260| 4.49k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3261| 4.49k|#line 3262 "bison_parser.cpp" /* yacc.c:1646 */ 3262| 4.49k| break; 3263| | 3264| 1.87k| case 12: ------------------ | Branch (3264:3): [True: 1.87k, False: 17.3M] ------------------ 3265| 1.87k|#line 389 "bison_parser.y" /* yacc.c:1646 */ 3266| 1.87k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3267| 1.87k|#line 3268 "bison_parser.cpp" /* yacc.c:1646 */ 3268| 1.87k| break; 3269| | 3270| 1.69k| case 13: ------------------ | Branch (3270:3): [True: 1.69k, False: 17.3M] ------------------ 3271| 1.69k|#line 390 "bison_parser.y" /* yacc.c:1646 */ 3272| 1.69k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3273| 1.69k|#line 3274 "bison_parser.cpp" /* yacc.c:1646 */ 3274| 1.69k| break; 3275| | 3276| 671| case 14: ------------------ | Branch (3276:3): [True: 671, False: 17.3M] ------------------ 3277| 671|#line 391 "bison_parser.y" /* yacc.c:1646 */ 3278| 671| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3279| 671|#line 3280 "bison_parser.cpp" /* yacc.c:1646 */ 3280| 671| break; 3281| | 3282| 1.49k| case 15: ------------------ | Branch (3282:3): [True: 1.49k, False: 17.3M] ------------------ 3283| 1.49k|#line 392 "bison_parser.y" /* yacc.c:1646 */ 3284| 1.49k| { (yyval.statement) = (yyvsp[0].update_stmt); } 3285| 1.49k|#line 3286 "bison_parser.cpp" /* yacc.c:1646 */ 3286| 1.49k| break; 3287| | 3288| 4.58k| case 16: ------------------ | Branch (3288:3): [True: 4.58k, False: 17.3M] ------------------ 3289| 4.58k|#line 393 "bison_parser.y" /* yacc.c:1646 */ 3290| 4.58k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3291| 4.58k|#line 3292 "bison_parser.cpp" /* yacc.c:1646 */ 3292| 4.58k| break; 3293| | 3294| 0| case 17: ------------------ | Branch (3294:3): [True: 0, False: 17.3M] ------------------ 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.45k| case 18: ------------------ | Branch (3300:3): [True: 3.45k, False: 17.3M] ------------------ 3301| 3.45k|#line 395 "bison_parser.y" /* yacc.c:1646 */ 3302| 3.45k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3303| 3.45k|#line 3304 "bison_parser.cpp" /* yacc.c:1646 */ 3304| 3.45k| break; 3305| | 3306| 10.2k| case 19: ------------------ | Branch (3306:3): [True: 10.2k, False: 17.3M] ------------------ 3307| 10.2k|#line 396 "bison_parser.y" /* yacc.c:1646 */ 3308| 10.2k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3309| 10.2k|#line 3310 "bison_parser.cpp" /* yacc.c:1646 */ 3310| 10.2k| break; 3311| | 3312| 694| case 20: ------------------ | Branch (3312:3): [True: 694, False: 17.3M] ------------------ 3313| 694|#line 402 "bison_parser.y" /* yacc.c:1646 */ 3314| 694| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3315| 694|#line 3316 "bison_parser.cpp" /* yacc.c:1646 */ 3316| 694| break; 3317| | 3318| 51.7k| case 21: ------------------ | Branch (3318:3): [True: 51.7k, False: 17.3M] ------------------ 3319| 51.7k|#line 403 "bison_parser.y" /* yacc.c:1646 */ 3320| 51.7k| { (yyval.expr_vec) = nullptr; } 3321| 51.7k|#line 3322 "bison_parser.cpp" /* yacc.c:1646 */ 3322| 51.7k| break; 3323| | 3324| 732| case 22: ------------------ | Branch (3324:3): [True: 732, False: 17.3M] ------------------ 3325| 732|#line 405 "bison_parser.y" /* yacc.c:1646 */ 3326| 732| { 3327| 732| (yyval.expr_vec) = new std::vector(); 3328| 732| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3329| 732|} 3330| 732|#line 3331 "bison_parser.cpp" /* yacc.c:1646 */ 3331| 732| break; 3332| | 3333| 1.56k| case 23: ------------------ | Branch (3333:3): [True: 1.56k, False: 17.3M] ------------------ 3334| 1.56k|#line 409 "bison_parser.y" /* yacc.c:1646 */ 3335| 1.56k| { 3336| 1.56k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3337| 1.56k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3338| 1.56k|} 3339| 1.56k|#line 3340 "bison_parser.cpp" /* yacc.c:1646 */ 3340| 1.56k| break; 3341| | 3342| 1.96k| case 24: ------------------ | Branch (3342:3): [True: 1.96k, False: 17.3M] ------------------ 3343| 1.96k|#line 414 "bison_parser.y" /* yacc.c:1646 */ 3344| 1.96k| { 3345| 1.96k| (yyval.expr) = Expr::make(kExprHint); 3346| 1.96k| (yyval.expr)->name = (yyvsp[0].sval); 3347| 1.96k|} 3348| 1.96k|#line 3349 "bison_parser.cpp" /* yacc.c:1646 */ 3349| 1.96k| break; 3350| | 3351| 328| case 25: ------------------ | Branch (3351:3): [True: 328, False: 17.3M] ------------------ 3352| 328|#line 418 "bison_parser.y" /* yacc.c:1646 */ 3353| 328| { 3354| 328| (yyval.expr) = Expr::make(kExprHint); 3355| 328| (yyval.expr)->name = (yyvsp[-3].sval); 3356| 328| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3357| 328|} 3358| 328|#line 3359 "bison_parser.cpp" /* yacc.c:1646 */ 3359| 328| break; 3360| | 3361| 6.46k| case 26: ------------------ | Branch (3361:3): [True: 6.46k, False: 17.3M] ------------------ 3362| 6.46k|#line 428 "bison_parser.y" /* yacc.c:1646 */ 3363| 6.46k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3364| 6.46k|#line 3365 "bison_parser.cpp" /* yacc.c:1646 */ 3365| 6.46k| break; 3366| | 3367| 2.99k| case 27: ------------------ | Branch (3367:3): [True: 2.99k, False: 17.3M] ------------------ 3368| 2.99k|#line 429 "bison_parser.y" /* yacc.c:1646 */ 3369| 2.99k| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3370| 2.99k|#line 3371 "bison_parser.cpp" /* yacc.c:1646 */ 3371| 2.99k| break; 3372| | 3373| 760| case 28: ------------------ | Branch (3373:3): [True: 760, False: 17.3M] ------------------ 3374| 760|#line 430 "bison_parser.y" /* yacc.c:1646 */ 3375| 760| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3376| 760|#line 3377 "bison_parser.cpp" /* yacc.c:1646 */ 3377| 760| break; 3378| | 3379| 1.18k| case 31: ------------------ | Branch (3379:3): [True: 1.18k, False: 17.3M] ------------------ 3380| 1.18k|#line 438 "bison_parser.y" /* yacc.c:1646 */ 3381| 1.18k| { 3382| 1.18k| (yyval.prep_stmt) = new PrepareStatement(); 3383| 1.18k| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3384| 1.18k| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3385| 1.18k|} 3386| 1.18k|#line 3387 "bison_parser.cpp" /* yacc.c:1646 */ 3387| 1.18k| break; 3388| | 3389| 2.99k| case 33: ------------------ | Branch (3389:3): [True: 2.99k, False: 17.3M] ------------------ 3390| 2.99k|#line 446 "bison_parser.y" /* yacc.c:1646 */ 3391| 2.99k| { 3392| 2.99k| (yyval.exec_stmt) = new ExecuteStatement(); 3393| 2.99k| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3394| 2.99k|} 3395| 2.99k|#line 3396 "bison_parser.cpp" /* yacc.c:1646 */ 3396| 2.99k| break; 3397| | 3398| 460| case 34: ------------------ | Branch (3398:3): [True: 460, False: 17.3M] ------------------ 3399| 460|#line 450 "bison_parser.y" /* yacc.c:1646 */ 3400| 460| { 3401| 460| (yyval.exec_stmt) = new ExecuteStatement(); 3402| 460| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3403| 460| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3404| 460|} 3405| 460|#line 3406 "bison_parser.cpp" /* yacc.c:1646 */ 3406| 460| break; 3407| | 3408| 0| case 35: ------------------ | Branch (3408:3): [True: 0, False: 17.3M] ------------------ 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| 3.77k| case 36: ------------------ | Branch (3419:3): [True: 3.77k, False: 17.3M] ------------------ 3420| 3.77k|#line 468 "bison_parser.y" /* yacc.c:1646 */ 3421| 3.77k| { 3422| 3.77k| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_export_option_t)->format); 3423| 3.77k| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3424| 3.77k| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3425| 3.77k| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3426| 3.77k| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3427| 3.77k| if ((yyvsp[-1].import_export_option_t)->encoding) { ------------------ | Branch (3427:7): [True: 194, False: 3.58k] ------------------ 3428| 194| (yyval.import_stmt)->encoding = (yyvsp[-1].import_export_option_t)->encoding; 3429| 194| (yyvsp[-1].import_export_option_t)->encoding = nullptr; 3430| 194| } 3431| 3.77k| if ((yyvsp[-1].import_export_option_t)->csv_options) { ------------------ | Branch (3431:7): [True: 66, False: 3.71k] ------------------ 3432| 66| (yyval.import_stmt)->csv_options = (yyvsp[-1].import_export_option_t)->csv_options; 3433| 66| (yyvsp[-1].import_export_option_t)->csv_options = nullptr; 3434| 66| } 3435| 3.77k| delete (yyvsp[-1].import_export_option_t); 3436| 3.77k|} 3437| 3.77k|#line 3438 "bison_parser.cpp" /* yacc.c:1646 */ 3438| 3.77k| break; 3439| | 3440| 1.81k| case 37: ------------------ | Branch (3440:3): [True: 1.81k, False: 17.3M] ------------------ 3441| 1.81k|#line 485 "bison_parser.y" /* yacc.c:1646 */ 3442| 1.81k| { 3443| 1.81k| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3443:7): [True: 912, False: 901] ------------------ 3444| 912| (yyval.import_type_t) = kImportCSV; 3445| 912| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3445:14): [True: 68, False: 833] ------------------ 3446| 68| (yyval.import_type_t) = kImportTbl; 3447| 833| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3447:14): [True: 194, False: 639] | Branch (3447:60): [True: 521, False: 118] ------------------ 3448| 715| (yyval.import_type_t) = kImportBinary; 3449| 715| } else { 3450| 118| free((yyvsp[0].sval)); 3451| 118| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 67| 118|#define yyerror hsql_error ------------------ 3452| 118| YYERROR; ------------------ | | 1458| 118|#define YYERROR goto yyerrorlab ------------------ 3453| 118| } 3454| 1.69k| free((yyvsp[0].sval)); 3455| 1.69k|} 3456| 0|#line 3457 "bison_parser.cpp" /* yacc.c:1646 */ 3457| 0| break; 3458| | 3459| 9.95k| case 38: ------------------ | Branch (3459:3): [True: 9.95k, False: 17.3M] ------------------ 3460| 9.95k|#line 500 "bison_parser.y" /* yacc.c:1646 */ 3461| 9.95k| { (yyval.sval) = (yyvsp[0].sval); } 3462| 9.95k|#line 3463 "bison_parser.cpp" /* yacc.c:1646 */ 3463| 9.95k| break; 3464| | 3465| 194| case 39: ------------------ | Branch (3465:3): [True: 194, False: 17.3M] ------------------ 3466| 194|#line 502 "bison_parser.y" /* yacc.c:1646 */ 3467| 194| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3468| 194|#line 3469 "bison_parser.cpp" /* yacc.c:1646 */ 3469| 194| break; 3470| | 3471| 3.45k| case 40: ------------------ | Branch (3471:3): [True: 3.45k, False: 17.3M] ------------------ 3472| 3.45k|#line 503 "bison_parser.y" /* yacc.c:1646 */ 3473| 3.45k| { (yyval.import_export_option_t) = (yyvsp[-1].import_export_option_t); } 3474| 3.45k|#line 3475 "bison_parser.cpp" /* yacc.c:1646 */ 3475| 3.45k| break; 3476| | 3477| 6.07k| case 41: ------------------ | Branch (3477:3): [True: 6.07k, False: 17.3M] ------------------ 3478| 6.07k|#line 504 "bison_parser.y" /* yacc.c:1646 */ 3479| 6.07k| { (yyval.import_export_option_t) = new ImportExportOptions{}; } 3480| 6.07k|#line 3481 "bison_parser.cpp" /* yacc.c:1646 */ 3481| 6.07k| break; 3482| | 3483| 432| case 42: ------------------ | Branch (3483:3): [True: 432, False: 17.3M] ------------------ 3484| 432|#line 506 "bison_parser.y" /* yacc.c:1646 */ 3485| 432| { 3486| 432| if ((yyvsp[-3].import_export_option_t)->format != kImportAuto) { ------------------ | Branch (3486:7): [True: 9, False: 423] ------------------ 3487| 9| delete (yyvsp[-3].import_export_option_t); 3488| 9| yyerror(&yyloc, result, scanner, "File type must only be provided once."); ------------------ | | 67| 9|#define yyerror hsql_error ------------------ 3489| 9| YYERROR; ------------------ | | 1458| 9|#define YYERROR goto yyerrorlab ------------------ 3490| 9| } 3491| 423| 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: 227, False: 196] | Branch (3491:58): [True: 1, False: 226] | 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| 422| (yyvsp[-3].import_export_option_t)->format = (yyvsp[0].import_type_t); 3497| 422| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3498| 422|} 3499| 0|#line 3500 "bison_parser.cpp" /* yacc.c:1646 */ 3500| 0| break; 3501| | 3502| 1.25k| case 43: ------------------ | Branch (3502:3): [True: 1.25k, False: 17.3M] ------------------ 3503| 1.25k|#line 520 "bison_parser.y" /* yacc.c:1646 */ 3504| 1.25k| { 3505| 1.25k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3506| 1.25k| (yyval.import_export_option_t)->format = (yyvsp[0].import_type_t); 3507| 1.25k|} 3508| 1.25k|#line 3509 "bison_parser.cpp" /* yacc.c:1646 */ 3509| 1.25k| break; 3510| | 3511| 67| case 44: ------------------ | Branch (3511:3): [True: 67, False: 17.3M] ------------------ 3512| 67|#line 524 "bison_parser.y" /* yacc.c:1646 */ 3513| 67| { 3514| 67| if ((yyvsp[-3].import_export_option_t)->encoding) { ------------------ | Branch (3514:7): [True: 1, False: 66] ------------------ 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| 66| (yyvsp[-3].import_export_option_t)->encoding = (yyvsp[0].sval); 3521| 66| (yyval.import_export_option_t) = (yyvsp[-3].import_export_option_t); 3522| 66|} 3523| 0|#line 3524 "bison_parser.cpp" /* yacc.c:1646 */ 3524| 0| break; 3525| | 3526| 1.19k| case 45: ------------------ | Branch (3526:3): [True: 1.19k, False: 17.3M] ------------------ 3527| 1.19k|#line 534 "bison_parser.y" /* yacc.c:1646 */ 3528| 1.19k| { 3529| 1.19k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3530| 1.19k| (yyval.import_export_option_t)->encoding = (yyvsp[0].sval); 3531| 1.19k|} 3532| 1.19k|#line 3533 "bison_parser.cpp" /* yacc.c:1646 */ 3533| 1.19k| break; 3534| | 3535| 825| case 46: ------------------ | Branch (3535:3): [True: 825, False: 17.3M] ------------------ 3536| 825|#line 538 "bison_parser.y" /* yacc.c:1646 */ 3537| 825| { 3538| 825| if ((yyvsp[-2].import_export_option_t)->format != kImportAuto && (yyvsp[-2].import_export_option_t)->format != kImportCSV) { ------------------ | Branch (3538:7): [True: 472, False: 353] | Branch (3538:68): [True: 1, False: 471] ------------------ 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| 824| if ((yyvsp[-2].import_export_option_t)->csv_options == nullptr) { ------------------ | Branch (3546:7): [True: 468, False: 356] ------------------ 3547| 468| (yyvsp[-2].import_export_option_t)->csv_options = new CsvOptions{}; 3548| 468| } 3549| | 3550| 824| if (!(yyvsp[-2].import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t))) { ------------------ | Branch (3550:7): [True: 13, False: 811] ------------------ 3551| 13| free((yyvsp[0].csv_option_t)->second); 3552| 13| delete (yyvsp[0].csv_option_t); 3553| 13| delete (yyvsp[-2].import_export_option_t); 3554| 13| yyerror(&yyloc, result, scanner, "CSV options (DELIMITER, NULL, QUOTE) cannot be provided more than once."); ------------------ | | 67| 13|#define yyerror hsql_error ------------------ 3555| 13| YYERROR; ------------------ | | 1458| 13|#define YYERROR goto yyerrorlab ------------------ 3556| 13| } 3557| | 3558| 811| delete (yyvsp[0].csv_option_t); 3559| 811| (yyval.import_export_option_t) = (yyvsp[-2].import_export_option_t); 3560| 811|} 3561| 0|#line 3562 "bison_parser.cpp" /* yacc.c:1646 */ 3562| 0| break; 3563| | 3564| 1.28k| case 47: ------------------ | Branch (3564:3): [True: 1.28k, False: 17.3M] ------------------ 3565| 1.28k|#line 562 "bison_parser.y" /* yacc.c:1646 */ 3566| 1.28k| { 3567| 1.28k| (yyval.import_export_option_t) = new ImportExportOptions{}; 3568| 1.28k| (yyval.import_export_option_t)->csv_options = new CsvOptions{}; 3569| 1.28k| (yyval.import_export_option_t)->csv_options->accept_csv_option((yyvsp[0].csv_option_t)); 3570| | 3571| 1.28k| delete (yyvsp[0].csv_option_t); 3572| 1.28k|} 3573| 1.28k|#line 3574 "bison_parser.cpp" /* yacc.c:1646 */ 3574| 1.28k| break; 3575| | 3576| 1.27k| case 48: ------------------ | Branch (3576:3): [True: 1.27k, False: 17.3M] ------------------ 3577| 1.27k|#line 570 "bison_parser.y" /* yacc.c:1646 */ 3578| 1.27k| { 3579| 1.27k| if (strcasecmp((yyvsp[-1].sval), "DELIMITER") == 0) { ------------------ | Branch (3579:7): [True: 256, False: 1.01k] ------------------ 3580| 256| (yyval.csv_option_t) = new std::pair(CsvOptionType::Delimiter, (yyvsp[0].sval)); 3581| 1.01k| } else if (strcasecmp((yyvsp[-1].sval), "QUOTE") == 0) { ------------------ | Branch (3581:14): [True: 892, False: 122] ------------------ 3582| 892| (yyval.csv_option_t) = new std::pair(CsvOptionType::Quote, (yyvsp[0].sval)); 3583| 892| } else { 3584| 122| free((yyvsp[-1].sval)); 3585| 122| free((yyvsp[0].sval)); 3586| 122| yyerror(&yyloc, result, scanner, "Unknown CSV option."); ------------------ | | 67| 122|#define yyerror hsql_error ------------------ 3587| 122| YYERROR; ------------------ | | 1458| 122|#define YYERROR goto yyerrorlab ------------------ 3588| 122| } 3589| 1.14k| free((yyvsp[-1].sval)); 3590| 1.14k|} 3591| 0|#line 3592 "bison_parser.cpp" /* yacc.c:1646 */ 3592| 0| break; 3593| | 3594| 964| case 49: ------------------ | Branch (3594:3): [True: 964, False: 17.3M] ------------------ 3595| 964|#line 583 "bison_parser.y" /* yacc.c:1646 */ 3596| 964| { (yyval.csv_option_t) = new std::pair(CsvOptionType::Null, (yyvsp[0].sval)); } 3597| 964|#line 3598 "bison_parser.cpp" /* yacc.c:1646 */ 3598| 964| break; 3599| | 3600| 4.88k| case 50: ------------------ | Branch (3600:3): [True: 4.88k, False: 17.3M] ------------------ 3601| 4.88k|#line 590 "bison_parser.y" /* yacc.c:1646 */ 3602| 4.88k| { 3603| 4.88k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3604| 4.88k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3605| 4.88k| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3606| 4.88k| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3607| 4.88k| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3607:7): [True: 851, False: 4.03k] ------------------ 3608| 851| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3609| 851| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3610| 851| } 3611| 4.88k| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3611:7): [True: 1.44k, False: 3.43k] ------------------ 3612| 1.44k| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3613| 1.44k| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3614| 1.44k| } 3615| 4.88k| delete (yyvsp[0].import_export_option_t); 3616| 4.88k|} 3617| 4.88k|#line 3618 "bison_parser.cpp" /* yacc.c:1646 */ 3618| 4.88k| break; 3619| | 3620| 1.06k| case 51: ------------------ | Branch (3620:3): [True: 1.06k, False: 17.3M] ------------------ 3621| 1.06k|#line 605 "bison_parser.y" /* yacc.c:1646 */ 3622| 1.06k| { 3623| 1.06k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_export_option_t)->format); 3624| 1.06k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3625| 1.06k| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3626| 1.06k| if ((yyvsp[0].import_export_option_t)->encoding) { ------------------ | Branch (3626:7): [True: 194, False: 873] ------------------ 3627| 194| (yyval.export_stmt)->encoding = (yyvsp[0].import_export_option_t)->encoding; 3628| 194| (yyvsp[0].import_export_option_t)->encoding = nullptr; 3629| 194| } 3630| 1.06k| if ((yyvsp[0].import_export_option_t)->csv_options) { ------------------ | Branch (3630:7): [True: 194, False: 873] ------------------ 3631| 194| (yyval.export_stmt)->csv_options = (yyvsp[0].import_export_option_t)->csv_options; 3632| 194| (yyvsp[0].import_export_option_t)->csv_options = nullptr; 3633| 194| } 3634| 1.06k| delete (yyvsp[0].import_export_option_t); 3635| 1.06k|} 3636| 1.06k|#line 3637 "bison_parser.cpp" /* yacc.c:1646 */ 3637| 1.06k| break; 3638| | 3639| 1.39k| case 52: ------------------ | Branch (3639:3): [True: 1.39k, False: 17.3M] ------------------ 3640| 1.39k|#line 625 "bison_parser.y" /* yacc.c:1646 */ 3641| 1.39k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3642| 1.39k|#line 3643 "bison_parser.cpp" /* yacc.c:1646 */ 3643| 1.39k| break; 3644| | 3645| 1.28k| case 53: ------------------ | Branch (3645:3): [True: 1.28k, False: 17.3M] ------------------ 3646| 1.28k|#line 626 "bison_parser.y" /* yacc.c:1646 */ 3647| 1.28k| { 3648| 1.28k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3649| 1.28k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3650| 1.28k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3651| 1.28k|} 3652| 1.28k|#line 3653 "bison_parser.cpp" /* yacc.c:1646 */ 3653| 1.28k| break; 3654| | 3655| 2.31k| case 54: ------------------ | Branch (3655:3): [True: 2.31k, False: 17.3M] ------------------ 3656| 2.31k|#line 631 "bison_parser.y" /* yacc.c:1646 */ 3657| 2.31k| { 3658| 2.31k| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3659| 2.31k| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3660| 2.31k| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3661| 2.31k|} 3662| 2.31k|#line 3663 "bison_parser.cpp" /* yacc.c:1646 */ 3663| 2.31k| break; 3664| | 3665| 0| case 55: ------------------ | Branch (3665:3): [True: 0, False: 17.3M] ------------------ 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| 2.36k| case 56: ------------------ | Branch (3683:3): [True: 2.36k, False: 17.3M] ------------------ 3684| 2.36k|#line 655 "bison_parser.y" /* yacc.c:1646 */ 3685| 2.36k| { 3686| 2.36k| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3687| 2.36k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3688| 2.36k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3689| 2.36k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3690| 2.36k| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3691| 2.36k| delete (yyvsp[-1].table_element_vec); 3692| 2.36k| if (result->errorMsg()) { ------------------ | Branch (3692:7): [True: 1, False: 2.36k] ------------------ 3693| 1| delete (yyval.create_stmt); 3694| 1| YYERROR; ------------------ | | 1458| 1|#define YYERROR goto yyerrorlab ------------------ 3695| 1| } 3696| 2.36k|} 3697| 2.36k|#line 3698 "bison_parser.cpp" /* yacc.c:1646 */ 3698| 2.36k| break; 3699| | 3700| 2.36k| case 57: ------------------ | Branch (3700:3): [True: 317, False: 17.3M] ------------------ 3701| 317|#line 667 "bison_parser.y" /* yacc.c:1646 */ 3702| 317| { 3703| 317| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3704| 317| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3705| 317| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3706| 317| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3707| 317| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3708| 317|} 3709| 317|#line 3710 "bison_parser.cpp" /* yacc.c:1646 */ 3710| 317| break; 3711| | 3712| 794| case 58: ------------------ | Branch (3712:3): [True: 794, False: 17.3M] ------------------ 3713| 794|#line 674 "bison_parser.y" /* yacc.c:1646 */ 3714| 794| { 3715| 794| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3716| 794| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3717| 794| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3718| 794| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3719| 794| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3720| 794|} 3721| 794|#line 3722 "bison_parser.cpp" /* yacc.c:1646 */ 3722| 794| break; 3723| | 3724| 1.02k| case 59: ------------------ | Branch (3724:3): [True: 1.02k, False: 17.3M] ------------------ 3725| 1.02k|#line 681 "bison_parser.y" /* yacc.c:1646 */ 3726| 1.02k| { 3727| 1.02k| (yyval.create_stmt) = new CreateStatement(kCreateView); 3728| 1.02k| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3729| 1.02k| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3730| 1.02k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3731| 1.02k| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3732| 1.02k| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3733| 1.02k|} 3734| 1.02k|#line 3735 "bison_parser.cpp" /* yacc.c:1646 */ 3735| 1.02k| break; 3736| | 3737| 365| case 60: ------------------ | Branch (3737:3): [True: 365, False: 17.3M] ------------------ 3738| 365|#line 690 "bison_parser.y" /* yacc.c:1646 */ 3739| 365| { (yyval.bval) = true; } 3740| 365|#line 3741 "bison_parser.cpp" /* yacc.c:1646 */ 3741| 365| break; 3742| | 3743| 4.79k| case 61: ------------------ | Branch (3743:3): [True: 4.79k, False: 17.3M] ------------------ 3744| 4.79k|#line 691 "bison_parser.y" /* yacc.c:1646 */ 3745| 4.79k| { (yyval.bval) = false; } 3746| 4.79k|#line 3747 "bison_parser.cpp" /* yacc.c:1646 */ 3747| 4.79k| break; 3748| | 3749| 2.96k| case 62: ------------------ | Branch (3749:3): [True: 2.96k, False: 17.3M] ------------------ 3750| 2.96k|#line 693 "bison_parser.y" /* yacc.c:1646 */ 3751| 2.96k| { 3752| 2.96k| (yyval.table_element_vec) = new std::vector(); 3753| 2.96k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3754| 2.96k|} 3755| 2.96k|#line 3756 "bison_parser.cpp" /* yacc.c:1646 */ 3756| 2.96k| break; 3757| | 3758| 34.3k| case 63: ------------------ | Branch (3758:3): [True: 34.3k, False: 17.3M] ------------------ 3759| 34.3k|#line 697 "bison_parser.y" /* yacc.c:1646 */ 3760| 34.3k| { 3761| 34.3k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3762| 34.3k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3763| 34.3k|} 3764| 34.3k|#line 3765 "bison_parser.cpp" /* yacc.c:1646 */ 3765| 34.3k| break; 3766| | 3767| 35.5k| case 64: ------------------ | Branch (3767:3): [True: 35.5k, False: 17.3M] ------------------ 3768| 35.5k|#line 702 "bison_parser.y" /* yacc.c:1646 */ 3769| 35.5k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3770| 35.5k|#line 3771 "bison_parser.cpp" /* yacc.c:1646 */ 3771| 35.5k| break; 3772| | 3773| 1.77k| case 65: ------------------ | Branch (3773:3): [True: 1.77k, False: 17.3M] ------------------ 3774| 1.77k|#line 703 "bison_parser.y" /* yacc.c:1646 */ 3775| 1.77k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3776| 1.77k|#line 3777 "bison_parser.cpp" /* yacc.c:1646 */ 3777| 1.77k| break; 3778| | 3779| 35.5k| case 66: ------------------ | Branch (3779:3): [True: 35.5k, False: 17.3M] ------------------ 3780| 35.5k|#line 705 "bison_parser.y" /* yacc.c:1646 */ 3781| 35.5k| { 3782| 35.5k| (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| 35.5k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3783:7): [True: 1.46k, False: 34.0k] ------------------ 3784| 1.46k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 67| 1.46k|#define yyerror hsql_error ------------------ 3785| 1.46k| } 3786| 35.5k| delete (yyvsp[0].column_constraints_t); 3787| 35.5k|} 3788| 35.5k|#line 3789 "bison_parser.cpp" /* yacc.c:1646 */ 3789| 35.5k| break; 3790| | 3791| 565| case 67: ------------------ | Branch (3791:3): [True: 565, False: 17.3M] ------------------ 3792| 565|#line 713 "bison_parser.y" /* yacc.c:1646 */ 3793| 565| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3794| 565|#line 3795 "bison_parser.cpp" /* yacc.c:1646 */ 3795| 565| break; 3796| | 3797| 630| case 68: ------------------ | Branch (3797:3): [True: 630, False: 17.3M] ------------------ 3798| 630|#line 714 "bison_parser.y" /* yacc.c:1646 */ 3799| 630| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3800| 630|#line 3801 "bison_parser.cpp" /* yacc.c:1646 */ 3801| 630| break; 3802| | 3803| 528| case 69: ------------------ | Branch (3803:3): [True: 528, False: 17.3M] ------------------ 3804| 528|#line 715 "bison_parser.y" /* yacc.c:1646 */ 3805| 528| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3806| 528|#line 3807 "bison_parser.cpp" /* yacc.c:1646 */ 3807| 528| break; 3808| | 3809| 0| case 70: ------------------ | Branch (3809:3): [True: 0, False: 17.3M] ------------------ 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| 1.69k| case 71: ------------------ | Branch (3815:3): [True: 1.69k, False: 17.3M] ------------------ 3816| 1.69k|#line 717 "bison_parser.y" /* yacc.c:1646 */ 3817| 1.69k| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3818| 1.69k|#line 3819 "bison_parser.cpp" /* yacc.c:1646 */ 3819| 1.69k| break; 3820| | 3821| 552| case 72: ------------------ | Branch (3821:3): [True: 552, False: 17.3M] ------------------ 3822| 552|#line 718 "bison_parser.y" /* yacc.c:1646 */ 3823| 552| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3824| 552|#line 3825 "bison_parser.cpp" /* yacc.c:1646 */ 3825| 552| break; 3826| | 3827| 1.13k| case 73: ------------------ | Branch (3827:3): [True: 1.13k, False: 17.3M] ------------------ 3828| 1.13k|#line 719 "bison_parser.y" /* yacc.c:1646 */ 3829| 1.13k| { 3830| 1.13k| (yyval.column_type_t) = ColumnType{DataType::DECIMAL, 0, (yyvsp[0].ival_pair)->first, (yyvsp[0].ival_pair)->second}; 3831| 1.13k| delete (yyvsp[0].ival_pair); 3832| 1.13k|} 3833| 1.13k|#line 3834 "bison_parser.cpp" /* yacc.c:1646 */ 3834| 1.13k| break; 3835| | 3836| 6.99k| case 74: ------------------ | Branch (3836:3): [True: 6.99k, False: 17.3M] ------------------ 3837| 6.99k|#line 723 "bison_parser.y" /* yacc.c:1646 */ 3838| 6.99k| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3839| 6.99k|#line 3840 "bison_parser.cpp" /* yacc.c:1646 */ 3840| 6.99k| break; 3841| | 3842| 700| case 75: ------------------ | Branch (3842:3): [True: 700, False: 17.3M] ------------------ 3843| 700|#line 724 "bison_parser.y" /* yacc.c:1646 */ 3844| 700| { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } 3845| 700|#line 3846 "bison_parser.cpp" /* yacc.c:1646 */ 3846| 700| break; 3847| | 3848| 7.78k| case 76: ------------------ | Branch (3848:3): [True: 7.78k, False: 17.3M] ------------------ 3849| 7.78k|#line 725 "bison_parser.y" /* yacc.c:1646 */ 3850| 7.78k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3851| 7.78k|#line 3852 "bison_parser.cpp" /* yacc.c:1646 */ 3852| 7.78k| break; 3853| | 3854| 642| case 77: ------------------ | Branch (3854:3): [True: 642, False: 17.3M] ------------------ 3855| 642|#line 726 "bison_parser.y" /* yacc.c:1646 */ 3856| 642| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3857| 642|#line 3858 "bison_parser.cpp" /* yacc.c:1646 */ 3858| 642| break; 3859| | 3860| 521| case 78: ------------------ | Branch (3860:3): [True: 521, False: 17.3M] ------------------ 3861| 521|#line 727 "bison_parser.y" /* yacc.c:1646 */ 3862| 521| { (yyval.column_type_t) = ColumnType{DataType::LONG}; } 3863| 521|#line 3864 "bison_parser.cpp" /* yacc.c:1646 */ 3864| 521| break; 3865| | 3866| 2.92k| case 79: ------------------ | Branch (3866:3): [True: 2.92k, False: 17.3M] ------------------ 3867| 2.92k|#line 728 "bison_parser.y" /* yacc.c:1646 */ 3868| 2.92k| { (yyval.column_type_t) = ColumnType{DataType::REAL}; } 3869| 2.92k|#line 3870 "bison_parser.cpp" /* yacc.c:1646 */ 3870| 2.92k| break; 3871| | 3872| 553| case 80: ------------------ | Branch (3872:3): [True: 553, False: 17.3M] ------------------ 3873| 553|#line 729 "bison_parser.y" /* yacc.c:1646 */ 3874| 553| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3875| 553|#line 3876 "bison_parser.cpp" /* yacc.c:1646 */ 3876| 553| break; 3877| | 3878| 514| case 81: ------------------ | Branch (3878:3): [True: 514, False: 17.3M] ------------------ 3879| 514|#line 730 "bison_parser.y" /* yacc.c:1646 */ 3880| 514| { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } 3881| 514|#line 3882 "bison_parser.cpp" /* yacc.c:1646 */ 3882| 514| break; 3883| | 3884| 812| case 82: ------------------ | Branch (3884:3): [True: 812, False: 17.3M] ------------------ 3885| 812|#line 731 "bison_parser.y" /* yacc.c:1646 */ 3886| 812| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3887| 812|#line 3888 "bison_parser.cpp" /* yacc.c:1646 */ 3888| 812| break; 3889| | 3890| 8.95k| case 83: ------------------ | Branch (3890:3): [True: 8.95k, False: 17.3M] ------------------ 3891| 8.95k|#line 732 "bison_parser.y" /* yacc.c:1646 */ 3892| 8.95k| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3893| 8.95k|#line 3894 "bison_parser.cpp" /* yacc.c:1646 */ 3894| 8.95k| break; 3895| | 3896| 632| case 84: ------------------ | Branch (3896:3): [True: 632, False: 17.3M] ------------------ 3897| 632|#line 733 "bison_parser.y" /* yacc.c:1646 */ 3898| 632| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3899| 632|#line 3900 "bison_parser.cpp" /* yacc.c:1646 */ 3900| 632| break; 3901| | 3902| 194| case 85: ------------------ | Branch (3902:3): [True: 194, False: 17.3M] ------------------ 3903| 194|#line 735 "bison_parser.y" /* yacc.c:1646 */ 3904| 194| { (yyval.ival) = (yyvsp[-1].ival); } 3905| 194|#line 3906 "bison_parser.cpp" /* yacc.c:1646 */ 3906| 194| break; 3907| | 3908| 618| case 86: ------------------ | Branch (3908:3): [True: 618, False: 17.3M] ------------------ 3909| 618|#line 736 "bison_parser.y" /* yacc.c:1646 */ 3910| 618| { (yyval.ival) = 0; } 3911| 618|#line 3912 "bison_parser.cpp" /* yacc.c:1646 */ 3912| 618| break; 3913| | 3914| 197| case 87: ------------------ | Branch (3914:3): [True: 197, False: 17.3M] ------------------ 3915| 197|#line 738 "bison_parser.y" /* yacc.c:1646 */ 3916| 197| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3917| 197|#line 3918 "bison_parser.cpp" /* yacc.c:1646 */ 3918| 197| break; 3919| | 3920| 231| case 88: ------------------ | Branch (3920:3): [True: 231, False: 17.3M] ------------------ 3921| 231|#line 739 "bison_parser.y" /* yacc.c:1646 */ 3922| 231| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3923| 231|#line 3924 "bison_parser.cpp" /* yacc.c:1646 */ 3924| 231| break; 3925| | 3926| 704| case 89: ------------------ | Branch (3926:3): [True: 704, False: 17.3M] ------------------ 3927| 704|#line 740 "bison_parser.y" /* yacc.c:1646 */ 3928| 704| { (yyval.ival_pair) = new std::pair{0, 0}; } 3929| 704|#line 3930 "bison_parser.cpp" /* yacc.c:1646 */ 3930| 704| break; 3931| | 3932| 2.79k| case 90: ------------------ | Branch (3932:3): [True: 2.79k, False: 17.3M] ------------------ 3933| 2.79k|#line 742 "bison_parser.y" /* yacc.c:1646 */ 3934| 2.79k| { (yyval.column_constraints_t) = (yyvsp[0].column_constraints_t); } 3935| 2.79k|#line 3936 "bison_parser.cpp" /* yacc.c:1646 */ 3936| 2.79k| break; 3937| | 3938| 32.7k| case 91: ------------------ | Branch (3938:3): [True: 32.7k, False: 17.3M] ------------------ 3939| 32.7k|#line 743 "bison_parser.y" /* yacc.c:1646 */ 3940| 32.7k| { (yyval.column_constraints_t) = new ColumnConstraints(); } 3941| 32.7k|#line 3942 "bison_parser.cpp" /* yacc.c:1646 */ 3942| 32.7k| break; 3943| | 3944| 2.81k| case 92: ------------------ | Branch (3944:3): [True: 2.81k, False: 17.3M] ------------------ 3945| 2.81k|#line 745 "bison_parser.y" /* yacc.c:1646 */ 3946| 2.81k| { 3947| 2.81k| (yyval.column_constraints_t) = new ColumnConstraints(); 3948| 2.81k| (yyval.column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3949| 2.81k|} 3950| 2.81k|#line 3951 "bison_parser.cpp" /* yacc.c:1646 */ 3951| 2.81k| break; 3952| | 3953| 5.33k| case 93: ------------------ | Branch (3953:3): [True: 5.33k, False: 17.3M] ------------------ 3954| 5.33k|#line 749 "bison_parser.y" /* yacc.c:1646 */ 3955| 5.33k| { 3956| 5.33k| (yyvsp[-1].column_constraints_t)->constraints->insert((yyvsp[0].column_constraint_t)); 3957| 5.33k| (yyval.column_constraints_t) = (yyvsp[-1].column_constraints_t); 3958| 5.33k|} 3959| 5.33k|#line 3960 "bison_parser.cpp" /* yacc.c:1646 */ 3960| 5.33k| break; 3961| | 3962| 0| case 94: ------------------ | Branch (3962:3): [True: 0, False: 17.3M] ------------------ 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: 17.3M] ------------------ 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.80k| case 96: ------------------ | Branch (3984:3): [True: 1.80k, False: 17.3M] ------------------ 3985| 1.80k|#line 766 "bison_parser.y" /* yacc.c:1646 */ 3986| 1.80k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3987| 1.80k|#line 3988 "bison_parser.cpp" /* yacc.c:1646 */ 3988| 1.80k| break; 3989| | 3990| 1.88k| case 97: ------------------ | Branch (3990:3): [True: 1.88k, False: 17.3M] ------------------ 3991| 1.88k|#line 767 "bison_parser.y" /* yacc.c:1646 */ 3992| 1.88k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3993| 1.88k|#line 3994 "bison_parser.cpp" /* yacc.c:1646 */ 3994| 1.88k| break; 3995| | 3996| 2.71k| case 98: ------------------ | Branch (3996:3): [True: 2.71k, False: 17.3M] ------------------ 3997| 2.71k|#line 768 "bison_parser.y" /* yacc.c:1646 */ 3998| 2.71k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3999| 2.71k|#line 4000 "bison_parser.cpp" /* yacc.c:1646 */ 4000| 2.71k| break; 4001| | 4002| 1.75k| case 99: ------------------ | Branch (4002:3): [True: 1.75k, False: 17.3M] ------------------ 4003| 1.75k|#line 769 "bison_parser.y" /* yacc.c:1646 */ 4004| 1.75k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 4005| 1.75k|#line 4006 "bison_parser.cpp" /* yacc.c:1646 */ 4006| 1.75k| break; 4007| | 4008| 195| case 100: ------------------ | Branch (4008:3): [True: 195, False: 17.3M] ------------------ 4009| 195|#line 771 "bison_parser.y" /* yacc.c:1646 */ 4010| 195| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 4011| 195|#line 4012 "bison_parser.cpp" /* yacc.c:1646 */ 4012| 195| break; 4013| | 4014| 1.57k| case 101: ------------------ | Branch (4014:3): [True: 1.57k, False: 17.3M] ------------------ 4015| 1.57k|#line 772 "bison_parser.y" /* yacc.c:1646 */ 4016| 1.57k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 4017| 1.57k|#line 4018 "bison_parser.cpp" /* yacc.c:1646 */ 4018| 1.57k| break; 4019| | 4020| 0| case 102: ------------------ | Branch (4020:3): [True: 0, False: 17.3M] ------------------ 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: 17.3M] ------------------ 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| 713| case 104: ------------------ | Branch (4032:3): [True: 713, False: 17.3M] ------------------ 4033| 713|#line 783 "bison_parser.y" /* yacc.c:1646 */ 4034| 713| { 4035| 713| (yyval.drop_stmt) = new DropStatement(kDropTable); 4036| 713| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4037| 713| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4038| 713| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4039| 713|} 4040| 713|#line 4041 "bison_parser.cpp" /* yacc.c:1646 */ 4041| 713| break; 4042| | 4043| 2.09k| case 105: ------------------ | Branch (4043:3): [True: 2.09k, False: 17.3M] ------------------ 4044| 2.09k|#line 789 "bison_parser.y" /* yacc.c:1646 */ 4045| 2.09k| { 4046| 2.09k| (yyval.drop_stmt) = new DropStatement(kDropView); 4047| 2.09k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4048| 2.09k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 4049| 2.09k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 4050| 2.09k|} 4051| 2.09k|#line 4052 "bison_parser.cpp" /* yacc.c:1646 */ 4052| 2.09k| break; 4053| | 4054| 862| case 106: ------------------ | Branch (4054:3): [True: 862, False: 17.3M] ------------------ 4055| 862|#line 795 "bison_parser.y" /* yacc.c:1646 */ 4056| 862| { 4057| 862| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 4058| 862| (yyval.drop_stmt)->ifExists = false; 4059| 862| (yyval.drop_stmt)->name = (yyvsp[0].sval); 4060| 862|} 4061| 862|#line 4062 "bison_parser.cpp" /* yacc.c:1646 */ 4062| 862| break; 4063| | 4064| 911| case 107: ------------------ | Branch (4064:3): [True: 911, False: 17.3M] ------------------ 4065| 911|#line 801 "bison_parser.y" /* yacc.c:1646 */ 4066| 911| { 4067| 911| (yyval.drop_stmt) = new DropStatement(kDropIndex); 4068| 911| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 4069| 911| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 4070| 911|} 4071| 911|#line 4072 "bison_parser.cpp" /* yacc.c:1646 */ 4072| 911| break; 4073| | 4074| 392| case 108: ------------------ | Branch (4074:3): [True: 392, False: 17.3M] ------------------ 4075| 392|#line 807 "bison_parser.y" /* yacc.c:1646 */ 4076| 392| { (yyval.bval) = true; } 4077| 392|#line 4078 "bison_parser.cpp" /* yacc.c:1646 */ 4078| 392| break; 4079| | 4080| 3.36k| case 109: ------------------ | Branch (4080:3): [True: 3.36k, False: 17.3M] ------------------ 4081| 3.36k|#line 808 "bison_parser.y" /* yacc.c:1646 */ 4082| 3.36k| { (yyval.bval) = false; } 4083| 3.36k|#line 4084 "bison_parser.cpp" /* yacc.c:1646 */ 4084| 3.36k| break; 4085| | 4086| 0| case 110: ------------------ | Branch (4086:3): [True: 0, False: 17.3M] ------------------ 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: 17.3M] ------------------ 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: 17.3M] ------------------ 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.69k| case 113: ------------------ | Branch (4111:3): [True: 1.69k, False: 17.3M] ------------------ 4112| 1.69k|#line 833 "bison_parser.y" /* yacc.c:1646 */ 4113| 1.69k| { 4114| 1.69k| (yyval.delete_stmt) = new DeleteStatement(); 4115| 1.69k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 4116| 1.69k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 4117| 1.69k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 4118| 1.69k|} 4119| 1.69k|#line 4120 "bison_parser.cpp" /* yacc.c:1646 */ 4120| 1.69k| break; 4121| | 4122| 671| case 114: ------------------ | Branch (4122:3): [True: 671, False: 17.3M] ------------------ 4123| 671|#line 840 "bison_parser.y" /* yacc.c:1646 */ 4124| 671| { 4125| 671| (yyval.delete_stmt) = new DeleteStatement(); 4126| 671| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 4127| 671| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 4128| 671|} 4129| 671|#line 4130 "bison_parser.cpp" /* yacc.c:1646 */ 4130| 671| break; 4131| | 4132| 841| case 115: ------------------ | Branch (4132:3): [True: 841, False: 17.3M] ------------------ 4133| 841|#line 851 "bison_parser.y" /* yacc.c:1646 */ 4134| 841| { 4135| 841| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 4136| 841| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 4137| 841| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 4138| 841| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 4139| 841| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 4140| 841|} 4141| 841|#line 4142 "bison_parser.cpp" /* yacc.c:1646 */ 4142| 841| break; 4143| | 4144| 1.02k| case 116: ------------------ | Branch (4144:3): [True: 1.02k, False: 17.3M] ------------------ 4145| 1.02k|#line 858 "bison_parser.y" /* yacc.c:1646 */ 4146| 1.02k| { 4147| 1.02k| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 4148| 1.02k| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 4149| 1.02k| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 4150| 1.02k| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 4151| 1.02k| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 4152| 1.02k|} 4153| 1.02k|#line 4154 "bison_parser.cpp" /* yacc.c:1646 */ 4154| 1.02k| break; 4155| | 4156| 624| case 117: ------------------ | Branch (4156:3): [True: 624, False: 17.3M] ------------------ 4157| 624|#line 866 "bison_parser.y" /* yacc.c:1646 */ 4158| 624| { (yyval.str_vec) = (yyvsp[-1].str_vec); } 4159| 624|#line 4160 "bison_parser.cpp" /* yacc.c:1646 */ 4160| 624| break; 4161| | 4162| 2.30k| case 118: ------------------ | Branch (4162:3): [True: 2.30k, False: 17.3M] ------------------ 4163| 2.30k|#line 867 "bison_parser.y" /* yacc.c:1646 */ 4164| 2.30k| { (yyval.str_vec) = nullptr; } 4165| 2.30k|#line 4166 "bison_parser.cpp" /* yacc.c:1646 */ 4166| 2.30k| break; 4167| | 4168| 1.49k| case 119: ------------------ | Branch (4168:3): [True: 1.49k, False: 17.3M] ------------------ 4169| 1.49k|#line 874 "bison_parser.y" /* yacc.c:1646 */ 4170| 1.49k| { 4171| 1.49k| (yyval.update_stmt) = new UpdateStatement(); 4172| 1.49k| (yyval.update_stmt)->table = (yyvsp[-3].table); 4173| 1.49k| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4174| 1.49k| (yyval.update_stmt)->where = (yyvsp[0].expr); 4175| 1.49k|} 4176| 1.49k|#line 4177 "bison_parser.cpp" /* yacc.c:1646 */ 4177| 1.49k| break; 4178| | 4179| 1.51k| case 120: ------------------ | Branch (4179:3): [True: 1.51k, False: 17.3M] ------------------ 4180| 1.51k|#line 881 "bison_parser.y" /* yacc.c:1646 */ 4181| 1.51k| { 4182| 1.51k| (yyval.update_vec) = new std::vector(); 4183| 1.51k| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4184| 1.51k|} 4185| 1.51k|#line 4186 "bison_parser.cpp" /* yacc.c:1646 */ 4186| 1.51k| break; 4187| | 4188| 1.49k| case 121: ------------------ | Branch (4188:3): [True: 1.49k, False: 17.3M] ------------------ 4189| 1.49k|#line 885 "bison_parser.y" /* yacc.c:1646 */ 4190| 1.49k| { 4191| 1.49k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4192| 1.49k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4193| 1.49k|} 4194| 1.49k|#line 4195 "bison_parser.cpp" /* yacc.c:1646 */ 4195| 1.49k| break; 4196| | 4197| 3.00k| case 122: ------------------ | Branch (4197:3): [True: 3.00k, False: 17.3M] ------------------ 4198| 3.00k|#line 890 "bison_parser.y" /* yacc.c:1646 */ 4199| 3.00k| { 4200| 3.00k| (yyval.update_t) = new UpdateClause(); 4201| 3.00k| (yyval.update_t)->column = (yyvsp[-2].sval); 4202| 3.00k| (yyval.update_t)->value = (yyvsp[0].expr); 4203| 3.00k|} 4204| 3.00k|#line 4205 "bison_parser.cpp" /* yacc.c:1646 */ 4205| 3.00k| break; 4206| | 4207| 869| case 123: ------------------ | Branch (4207:3): [True: 869, False: 17.3M] ------------------ 4208| 869|#line 900 "bison_parser.y" /* yacc.c:1646 */ 4209| 869| { 4210| 869| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4211| 869| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4212| 869|} 4213| 869|#line 4214 "bison_parser.cpp" /* yacc.c:1646 */ 4214| 869| break; 4215| | 4216| 22.8k| case 124: ------------------ | Branch (4216:3): [True: 22.8k, False: 17.3M] ------------------ 4217| 22.8k|#line 904 "bison_parser.y" /* yacc.c:1646 */ 4218| 22.8k| { 4219| 22.8k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4220| 22.8k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4221| 22.8k|} 4222| 22.8k|#line 4223 "bison_parser.cpp" /* yacc.c:1646 */ 4223| 22.8k| break; 4224| | 4225| 1.29k| case 125: ------------------ | Branch (4225:3): [True: 1.29k, False: 17.3M] ------------------ 4226| 1.29k|#line 908 "bison_parser.y" /* yacc.c:1646 */ 4227| 1.29k| { 4228| 1.29k| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4229| 1.29k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4229:7): [True: 1.05k, False: 233] ------------------ 4230| 1.05k| (yyval.select_stmt)->setOperations = new std::vector(); 4231| 1.05k| } 4232| 1.29k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4233| 1.29k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4234| 1.29k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4235| 1.29k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4236| 1.29k| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4237| 1.29k|} 4238| 1.29k|#line 4239 "bison_parser.cpp" /* yacc.c:1646 */ 4239| 1.29k| break; 4240| | 4241| 2.43k| case 128: ------------------ | Branch (4241:3): [True: 2.43k, False: 17.3M] ------------------ 4242| 2.43k|#line 922 "bison_parser.y" /* yacc.c:1646 */ 4243| 2.43k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4244| 2.43k|#line 4245 "bison_parser.cpp" /* yacc.c:1646 */ 4245| 2.43k| break; 4246| | 4247| 1.61k| case 129: ------------------ | Branch (4247:3): [True: 1.61k, False: 17.3M] ------------------ 4248| 1.61k|#line 923 "bison_parser.y" /* yacc.c:1646 */ 4249| 1.61k| { 4250| 1.61k| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4251| 1.61k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4251:7): [True: 1.61k, False: 0] ------------------ 4252| 1.61k| (yyval.select_stmt)->setOperations = new std::vector(); 4253| 1.61k| } 4254| 1.61k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4255| 1.61k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4256| 1.61k|} 4257| 1.61k|#line 4258 "bison_parser.cpp" /* yacc.c:1646 */ 4258| 1.61k| break; 4259| | 4260| 5.86k| case 130: ------------------ | Branch (4260:3): [True: 5.86k, False: 17.3M] ------------------ 4261| 5.86k|#line 932 "bison_parser.y" /* yacc.c:1646 */ 4262| 5.86k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4263| 5.86k|#line 4264 "bison_parser.cpp" /* yacc.c:1646 */ 4264| 5.86k| break; 4265| | 4266| 194| case 131: ------------------ | Branch (4266:3): [True: 194, False: 17.3M] ------------------ 4267| 194|#line 933 "bison_parser.y" /* yacc.c:1646 */ 4268| 194| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4269| 194|#line 4270 "bison_parser.cpp" /* yacc.c:1646 */ 4270| 194| break; 4271| | 4272| 30.6k| case 132: ------------------ | Branch (4272:3): [True: 30.6k, False: 17.3M] ------------------ 4273| 30.6k|#line 935 "bison_parser.y" /* yacc.c:1646 */ 4274| 30.6k| { 4275| 30.6k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4276| 30.6k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4277| | 4278| | // Limit could have been set by TOP. 4279| 30.6k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4279:7): [True: 4.07k, False: 26.5k] ------------------ 4280| 4.07k| delete (yyval.select_stmt)->limit; 4281| 4.07k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4282| 4.07k| } 4283| | 4284| 30.6k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4284:7): [True: 449, False: 30.2k] ------------------ 4285| 449| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4286| 449| } 4287| 30.6k|} 4288| 30.6k|#line 4289 "bison_parser.cpp" /* yacc.c:1646 */ 4289| 30.6k| break; 4290| | 4291| 1.14k| case 133: ------------------ | Branch (4291:3): [True: 1.14k, False: 17.3M] ------------------ 4292| 1.14k|#line 949 "bison_parser.y" /* yacc.c:1646 */ 4293| 1.14k| { 4294| 1.14k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4295| 1.14k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4295:7): [True: 1.14k, False: 0] ------------------ 4296| 1.14k| (yyval.select_stmt)->setOperations = new std::vector(); 4297| 1.14k| } 4298| 1.14k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4299| 1.14k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4300| 1.14k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4301| 1.14k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4302| 1.14k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4303| 1.14k|} 4304| 1.14k|#line 4305 "bison_parser.cpp" /* yacc.c:1646 */ 4305| 1.14k| break; 4306| | 4307| 5.14k| case 134: ------------------ | Branch (4307:3): [True: 5.14k, False: 17.3M] ------------------ 4308| 5.14k|#line 961 "bison_parser.y" /* yacc.c:1646 */ 4309| 5.14k| { 4310| 5.14k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4311| 5.14k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4312| 5.14k|} 4313| 5.14k|#line 4314 "bison_parser.cpp" /* yacc.c:1646 */ 4314| 5.14k| break; 4315| | 4316| 3.09k| case 135: ------------------ | Branch (4316:3): [True: 3.09k, False: 17.3M] ------------------ 4317| 3.09k|#line 966 "bison_parser.y" /* yacc.c:1646 */ 4318| 3.09k| { 4319| 3.09k| (yyval.set_operator_t) = new SetOperation(); 4320| 3.09k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4321| 3.09k|} 4322| 3.09k|#line 4323 "bison_parser.cpp" /* yacc.c:1646 */ 4323| 3.09k| break; 4324| | 4325| 607| case 136: ------------------ | Branch (4325:3): [True: 607, False: 17.3M] ------------------ 4326| 607|#line 970 "bison_parser.y" /* yacc.c:1646 */ 4327| 607| { 4328| 607| (yyval.set_operator_t) = new SetOperation(); 4329| 607| (yyval.set_operator_t)->setType = SetType::kSetIntersect; 4330| 607|} 4331| 607|#line 4332 "bison_parser.cpp" /* yacc.c:1646 */ 4332| 607| break; 4333| | 4334| 1.44k| case 137: ------------------ | Branch (4334:3): [True: 1.44k, False: 17.3M] ------------------ 4335| 1.44k|#line 974 "bison_parser.y" /* yacc.c:1646 */ 4336| 1.44k| { 4337| 1.44k| (yyval.set_operator_t) = new SetOperation(); 4338| 1.44k| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4339| 1.44k|} 4340| 1.44k|#line 4341 "bison_parser.cpp" /* yacc.c:1646 */ 4341| 1.44k| break; 4342| | 4343| 139| case 138: ------------------ | Branch (4343:3): [True: 139, False: 17.3M] ------------------ 4344| 139|#line 979 "bison_parser.y" /* yacc.c:1646 */ 4345| 139| { (yyval.bval) = true; } 4346| 139|#line 4347 "bison_parser.cpp" /* yacc.c:1646 */ 4347| 139| break; 4348| | 4349| 5.00k| case 139: ------------------ | Branch (4349:3): [True: 5.00k, False: 17.3M] ------------------ 4350| 5.00k|#line 980 "bison_parser.y" /* yacc.c:1646 */ 4351| 5.00k| { (yyval.bval) = false; } 4352| 5.00k|#line 4353 "bison_parser.cpp" /* yacc.c:1646 */ 4353| 5.00k| break; 4354| | 4355| 37.6k| case 140: ------------------ | Branch (4355:3): [True: 37.6k, False: 17.3M] ------------------ 4356| 37.6k|#line 982 "bison_parser.y" /* yacc.c:1646 */ 4357| 37.6k| { 4358| 37.6k| (yyval.select_stmt) = new SelectStatement(); 4359| 37.6k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4360| 37.6k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4361| 37.6k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4362| 37.6k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4363| 37.6k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4364| 37.6k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4365| 37.6k|} 4366| 37.6k|#line 4367 "bison_parser.cpp" /* yacc.c:1646 */ 4367| 37.6k| break; 4368| | 4369| 559| case 141: ------------------ | Branch (4369:3): [True: 559, False: 17.3M] ------------------ 4370| 559|#line 992 "bison_parser.y" /* yacc.c:1646 */ 4371| 559| { (yyval.bval) = true; } 4372| 559|#line 4373 "bison_parser.cpp" /* yacc.c:1646 */ 4373| 559| break; 4374| | 4375| 44.4k| case 142: ------------------ | Branch (4375:3): [True: 44.4k, False: 17.3M] ------------------ 4376| 44.4k|#line 993 "bison_parser.y" /* yacc.c:1646 */ 4377| 44.4k| { (yyval.bval) = false; } 4378| 44.4k|#line 4379 "bison_parser.cpp" /* yacc.c:1646 */ 4379| 44.4k| break; 4380| | 4381| 4.09k| case 144: ------------------ | Branch (4381:3): [True: 4.09k, False: 17.3M] ------------------ 4382| 4.09k|#line 997 "bison_parser.y" /* yacc.c:1646 */ 4383| 4.09k| { (yyval.table) = (yyvsp[0].table); } 4384| 4.09k|#line 4385 "bison_parser.cpp" /* yacc.c:1646 */ 4385| 4.09k| break; 4386| | 4387| 33.7k| case 145: ------------------ | Branch (4387:3): [True: 33.7k, False: 17.3M] ------------------ 4388| 33.7k|#line 998 "bison_parser.y" /* yacc.c:1646 */ 4389| 33.7k| { (yyval.table) = nullptr; } 4390| 33.7k|#line 4391 "bison_parser.cpp" /* yacc.c:1646 */ 4391| 33.7k| break; 4392| | 4393| 4.09k| case 146: ------------------ | Branch (4393:3): [True: 4.09k, False: 17.3M] ------------------ 4394| 4.09k|#line 1000 "bison_parser.y" /* yacc.c:1646 */ 4395| 4.09k| { (yyval.table) = (yyvsp[0].table); } 4396| 4.09k|#line 4397 "bison_parser.cpp" /* yacc.c:1646 */ 4397| 4.09k| break; 4398| | 4399| 2.08k| case 147: ------------------ | Branch (4399:3): [True: 2.08k, False: 17.3M] ------------------ 4400| 2.08k|#line 1002 "bison_parser.y" /* yacc.c:1646 */ 4401| 2.08k| { (yyval.expr) = (yyvsp[0].expr); } 4402| 2.08k|#line 4403 "bison_parser.cpp" /* yacc.c:1646 */ 4403| 2.08k| break; 4404| | 4405| 42.6k| case 148: ------------------ | Branch (4405:3): [True: 42.6k, False: 17.3M] ------------------ 4406| 42.6k|#line 1003 "bison_parser.y" /* yacc.c:1646 */ 4407| 42.6k| { (yyval.expr) = nullptr; } 4408| 42.6k|#line 4409 "bison_parser.cpp" /* yacc.c:1646 */ 4409| 42.6k| break; 4410| | 4411| 3.29k| case 149: ------------------ | Branch (4411:3): [True: 3.29k, False: 17.3M] ------------------ 4412| 3.29k|#line 1005 "bison_parser.y" /* yacc.c:1646 */ 4413| 3.29k| { 4414| 3.29k| (yyval.group_t) = new GroupByDescription(); 4415| 3.29k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4416| 3.29k| (yyval.group_t)->having = (yyvsp[0].expr); 4417| 3.29k|} 4418| 3.29k|#line 4419 "bison_parser.cpp" /* yacc.c:1646 */ 4419| 3.29k| break; 4420| | 4421| 34.3k| case 150: ------------------ | Branch (4421:3): [True: 34.3k, False: 17.3M] ------------------ 4422| 34.3k|#line 1010 "bison_parser.y" /* yacc.c:1646 */ 4423| 34.3k| { (yyval.group_t) = nullptr; } 4424| 34.3k|#line 4425 "bison_parser.cpp" /* yacc.c:1646 */ 4425| 34.3k| break; 4426| | 4427| 845| case 151: ------------------ | Branch (4427:3): [True: 845, False: 17.3M] ------------------ 4428| 845|#line 1012 "bison_parser.y" /* yacc.c:1646 */ 4429| 845| { (yyval.expr) = (yyvsp[0].expr); } 4430| 845|#line 4431 "bison_parser.cpp" /* yacc.c:1646 */ 4431| 845| break; 4432| | 4433| 2.44k| case 152: ------------------ | Branch (4433:3): [True: 2.44k, False: 17.3M] ------------------ 4434| 2.44k|#line 1013 "bison_parser.y" /* yacc.c:1646 */ 4435| 2.44k| { (yyval.expr) = nullptr; } 4436| 2.44k|#line 4437 "bison_parser.cpp" /* yacc.c:1646 */ 4437| 2.44k| break; 4438| | 4439| 2.16k| case 153: ------------------ | Branch (4439:3): [True: 2.16k, False: 17.3M] ------------------ 4440| 2.16k|#line 1015 "bison_parser.y" /* yacc.c:1646 */ 4441| 2.16k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4442| 2.16k|#line 4443 "bison_parser.cpp" /* yacc.c:1646 */ 4443| 2.16k| break; 4444| | 4445| 36.9k| case 154: ------------------ | Branch (4445:3): [True: 36.9k, False: 17.3M] ------------------ 4446| 36.9k|#line 1016 "bison_parser.y" /* yacc.c:1646 */ 4447| 36.9k| { (yyval.order_vec) = nullptr; } 4448| 36.9k|#line 4449 "bison_parser.cpp" /* yacc.c:1646 */ 4449| 36.9k| break; 4450| | 4451| 2.28k| case 155: ------------------ | Branch (4451:3): [True: 2.28k, False: 17.3M] ------------------ 4452| 2.28k|#line 1018 "bison_parser.y" /* yacc.c:1646 */ 4453| 2.28k| { 4454| 2.28k| (yyval.order_vec) = new std::vector(); 4455| 2.28k| (yyval.order_vec)->push_back((yyvsp[0].order)); 4456| 2.28k|} 4457| 2.28k|#line 4458 "bison_parser.cpp" /* yacc.c:1646 */ 4458| 2.28k| break; 4459| | 4460| 325k| case 156: ------------------ | Branch (4460:3): [True: 325k, False: 17.0M] ------------------ 4461| 325k|#line 1022 "bison_parser.y" /* yacc.c:1646 */ 4462| 325k| { 4463| 325k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4464| 325k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4465| 325k|} 4466| 325k|#line 4467 "bison_parser.cpp" /* yacc.c:1646 */ 4467| 325k| break; 4468| | 4469| 327k| case 157: ------------------ | Branch (4469:3): [True: 327k, False: 17.0M] ------------------ 4470| 327k|#line 1027 "bison_parser.y" /* yacc.c:1646 */ 4471| 327k| { (yyval.order) = new OrderDescription((yyvsp[-1].order_type), (yyvsp[-2].expr), (yyvsp[0].null_ordering_t)); } 4472| 327k|#line 4473 "bison_parser.cpp" /* yacc.c:1646 */ 4473| 327k| break; 4474| | 4475| 608| case 158: ------------------ | Branch (4475:3): [True: 608, False: 17.3M] ------------------ 4476| 608|#line 1029 "bison_parser.y" /* yacc.c:1646 */ 4477| 608| { (yyval.order_type) = kOrderAsc; } 4478| 608|#line 4479 "bison_parser.cpp" /* yacc.c:1646 */ 4479| 608| break; 4480| | 4481| 537| case 159: ------------------ | Branch (4481:3): [True: 537, False: 17.3M] ------------------ 4482| 537|#line 1030 "bison_parser.y" /* yacc.c:1646 */ 4483| 537| { (yyval.order_type) = kOrderDesc; } 4484| 537|#line 4485 "bison_parser.cpp" /* yacc.c:1646 */ 4485| 537| break; 4486| | 4487| 326k| case 160: ------------------ | Branch (4487:3): [True: 326k, False: 17.0M] ------------------ 4488| 326k|#line 1031 "bison_parser.y" /* yacc.c:1646 */ 4489| 326k| { (yyval.order_type) = kOrderAsc; } 4490| 326k|#line 4491 "bison_parser.cpp" /* yacc.c:1646 */ 4491| 326k| break; 4492| | 4493| 327k| case 161: ------------------ | Branch (4493:3): [True: 327k, False: 17.0M] ------------------ 4494| 327k|#line 1033 "bison_parser.y" /* yacc.c:1646 */ 4495| 327k| { (yyval.null_ordering_t) = NullOrdering::Undefined; } 4496| 327k|#line 4497 "bison_parser.cpp" /* yacc.c:1646 */ 4497| 327k| break; 4498| | 4499| 398| case 162: ------------------ | Branch (4499:3): [True: 398, False: 17.3M] ------------------ 4500| 398|#line 1034 "bison_parser.y" /* yacc.c:1646 */ 4501| 398| { 4502| 398| auto null_ordering = NullOrdering::Undefined; 4503| 398| if (strcasecmp((yyvsp[-1].sval), "nulls") == 0) { ------------------ | Branch (4503:7): [True: 339, False: 59] ------------------ 4504| 339| if (strcasecmp((yyvsp[0].sval), "first") == 0) { ------------------ | Branch (4504:9): [True: 194, False: 145] ------------------ 4505| 194| null_ordering = NullOrdering::First; 4506| 194| } else if (strcasecmp((yyvsp[0].sval), "last") == 0) { ------------------ | Branch (4506:16): [True: 66, False: 79] ------------------ 4507| 66| null_ordering = NullOrdering::Last; 4508| 66| } 4509| 339| } 4510| 398| free((yyvsp[-1].sval)); 4511| 398| free((yyvsp[0].sval)); 4512| | 4513| 398| if (null_ordering == NullOrdering::Undefined) { ------------------ | Branch (4513:7): [True: 138, False: 260] ------------------ 4514| 138| yyerror(&yyloc, result, scanner, "Expected NULLS FIRST or NULLS LAST ordering."); ------------------ | | 67| 138|#define yyerror hsql_error ------------------ 4515| 138| YYERROR; ------------------ | | 1458| 138|#define YYERROR goto yyerrorlab ------------------ 4516| 138| } 4517| | 4518| 260| (yyval.null_ordering_t) = null_ordering; 4519| 260|} 4520| 0|#line 4521 "bison_parser.cpp" /* yacc.c:1646 */ 4521| 0| break; 4522| | 4523| 1.73k| case 163: ------------------ | Branch (4523:3): [True: 1.73k, False: 17.3M] ------------------ 4524| 1.73k|#line 1056 "bison_parser.y" /* yacc.c:1646 */ 4525| 1.73k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4526| 1.73k|#line 4527 "bison_parser.cpp" /* yacc.c:1646 */ 4527| 1.73k| break; 4528| | 4529| 38.2k| case 164: ------------------ | Branch (4529:3): [True: 38.2k, False: 17.3M] ------------------ 4530| 38.2k|#line 1057 "bison_parser.y" /* yacc.c:1646 */ 4531| 38.2k| { (yyval.limit) = nullptr; } 4532| 38.2k|#line 4533 "bison_parser.cpp" /* yacc.c:1646 */ 4533| 38.2k| break; 4534| | 4535| 1.57k| case 165: ------------------ | Branch (4535:3): [True: 1.57k, False: 17.3M] ------------------ 4536| 1.57k|#line 1059 "bison_parser.y" /* yacc.c:1646 */ 4537| 1.57k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4538| 1.57k|#line 4539 "bison_parser.cpp" /* yacc.c:1646 */ 4539| 1.57k| break; 4540| | 4541| 1.25k| case 166: ------------------ | Branch (4541:3): [True: 1.25k, False: 17.3M] ------------------ 4542| 1.25k|#line 1060 "bison_parser.y" /* yacc.c:1646 */ 4543| 1.25k| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4544| 1.25k|#line 4545 "bison_parser.cpp" /* yacc.c:1646 */ 4545| 1.25k| break; 4546| | 4547| 444| case 167: ------------------ | Branch (4547:3): [True: 444, False: 17.3M] ------------------ 4548| 444|#line 1061 "bison_parser.y" /* yacc.c:1646 */ 4549| 444| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4550| 444|#line 4551 "bison_parser.cpp" /* yacc.c:1646 */ 4551| 444| break; 4552| | 4553| 1.25k| case 168: ------------------ | Branch (4553:3): [True: 1.25k, False: 17.3M] ------------------ 4554| 1.25k|#line 1062 "bison_parser.y" /* yacc.c:1646 */ 4555| 1.25k| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4556| 1.25k|#line 4557 "bison_parser.cpp" /* yacc.c:1646 */ 4557| 1.25k| break; 4558| | 4559| 290| case 169: ------------------ | Branch (4559:3): [True: 290, False: 17.3M] ------------------ 4560| 290|#line 1063 "bison_parser.y" /* yacc.c:1646 */ 4561| 290| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4562| 290|#line 4563 "bison_parser.cpp" /* yacc.c:1646 */ 4563| 290| break; 4564| | 4565| 28.3k| case 170: ------------------ | Branch (4565:3): [True: 28.3k, False: 17.3M] ------------------ 4566| 28.3k|#line 1064 "bison_parser.y" /* yacc.c:1646 */ 4567| 28.3k| { (yyval.limit) = nullptr; } 4568| 28.3k|#line 4569 "bison_parser.cpp" /* yacc.c:1646 */ 4569| 28.3k| break; 4570| | 4571| 47.9k| case 171: ------------------ | Branch (4571:3): [True: 47.9k, False: 17.3M] ------------------ 4572| 47.9k|#line 1069 "bison_parser.y" /* yacc.c:1646 */ 4573| 47.9k| { 4574| 47.9k| (yyval.expr_vec) = new std::vector(); 4575| 47.9k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4576| 47.9k|} 4577| 47.9k|#line 4578 "bison_parser.cpp" /* yacc.c:1646 */ 4578| 47.9k| break; 4579| | 4580| 582k| case 172: ------------------ | Branch (4580:3): [True: 582k, False: 16.8M] ------------------ 4581| 582k|#line 1073 "bison_parser.y" /* yacc.c:1646 */ 4582| 582k| { 4583| 582k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4584| 582k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4585| 582k|} 4586| 582k|#line 4587 "bison_parser.cpp" /* yacc.c:1646 */ 4587| 582k| break; 4588| | 4589| 329| case 173: ------------------ | Branch (4589:3): [True: 329, False: 17.3M] ------------------ 4590| 329|#line 1079 "bison_parser.y" /* yacc.c:1646 */ 4591| 329| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4592| 329|#line 4593 "bison_parser.cpp" /* yacc.c:1646 */ 4593| 329| break; 4594| | 4595| 180| case 174: ------------------ | Branch (4595:3): [True: 180, False: 17.3M] ------------------ 4596| 180|#line 1080 "bison_parser.y" /* yacc.c:1646 */ 4597| 180| { (yyval.expr_vec) = nullptr; } 4598| 180|#line 4599 "bison_parser.cpp" /* yacc.c:1646 */ 4599| 180| break; 4600| | 4601| 1.52k| case 175: ------------------ | Branch (4601:3): [True: 1.52k, False: 17.3M] ------------------ 4602| 1.52k|#line 1082 "bison_parser.y" /* yacc.c:1646 */ 4603| 1.52k| { 4604| 1.52k| (yyval.expr_vec) = new std::vector(); 4605| 1.52k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4606| 1.52k|} 4607| 1.52k|#line 4608 "bison_parser.cpp" /* yacc.c:1646 */ 4608| 1.52k| break; 4609| | 4610| 2.51k| case 176: ------------------ | Branch (4610:3): [True: 2.51k, False: 17.3M] ------------------ 4611| 2.51k|#line 1086 "bison_parser.y" /* yacc.c:1646 */ 4612| 2.51k| { 4613| 2.51k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4614| 2.51k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4615| 2.51k|} 4616| 2.51k|#line 4617 "bison_parser.cpp" /* yacc.c:1646 */ 4617| 2.51k| break; 4618| | 4619| 194| case 178: ------------------ | Branch (4619:3): [True: 194, False: 17.3M] ------------------ 4620| 194|#line 1091 "bison_parser.y" /* yacc.c:1646 */ 4621| 194| { 4622| 194| (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); 4623| 194|} 4624| 194|#line 4625 "bison_parser.cpp" /* yacc.c:1646 */ 4625| 194| break; 4626| | 4627| 3.63k| case 179: ------------------ | Branch (4627:3): [True: 3.63k, False: 17.3M] ------------------ 4628| 3.63k|#line 1095 "bison_parser.y" /* yacc.c:1646 */ 4629| 3.63k| { 4630| 3.63k| if ((yyvsp[0].expr)->type == ExprType::kExprParameter) { ------------------ | Branch (4630:7): [True: 2, False: 3.63k] ------------------ 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.63k| (yyval.expr) = (yyvsp[0].expr); 4636| 3.63k|} 4637| 0|#line 4638 "bison_parser.cpp" /* yacc.c:1646 */ 4638| 0| break; 4639| | 4640| 215| case 180: ------------------ | Branch (4640:3): [True: 215, False: 17.3M] ------------------ 4641| 215|#line 1103 "bison_parser.y" /* yacc.c:1646 */ 4642| 215| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4643| 215|#line 4644 "bison_parser.cpp" /* yacc.c:1646 */ 4644| 215| break; 4645| | 4646| 194| case 181: ------------------ | Branch (4646:3): [True: 194, False: 17.3M] ------------------ 4647| 194|#line 1104 "bison_parser.y" /* yacc.c:1646 */ 4648| 194| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4649| 194|#line 4650 "bison_parser.cpp" /* yacc.c:1646 */ 4650| 194| break; 4651| | 4652| 630k| case 182: ------------------ | Branch (4652:3): [True: 630k, False: 16.7M] ------------------ 4653| 630k|#line 1106 "bison_parser.y" /* yacc.c:1646 */ 4654| 630k| { 4655| 630k| (yyval.expr) = (yyvsp[-1].expr); 4656| 630k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4656:7): [True: 6.32k, False: 624k] ------------------ 4657| 6.32k| (yyval.expr)->alias = (yyvsp[0].alias_t)->name; 4658| 6.32k| (yyvsp[0].alias_t)->name = nullptr; 4659| 6.32k| delete (yyvsp[0].alias_t); 4660| 6.32k| } 4661| 630k|} 4662| 630k|#line 4663 "bison_parser.cpp" /* yacc.c:1646 */ 4663| 630k| break; 4664| | 4665| 956| case 188: ------------------ | Branch (4665:3): [True: 956, False: 17.3M] ------------------ 4666| 956|#line 1117 "bison_parser.y" /* yacc.c:1646 */ 4667| 956| { (yyval.expr) = (yyvsp[-1].expr); } 4668| 956|#line 4669 "bison_parser.cpp" /* yacc.c:1646 */ 4669| 956| break; 4670| | 4671| 445| case 198: ------------------ | Branch (4671:3): [True: 445, False: 17.3M] ------------------ 4672| 445|#line 1119 "bison_parser.y" /* yacc.c:1646 */ 4673| 445| { 4674| 445| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4675| 445|} 4676| 445|#line 4677 "bison_parser.cpp" /* yacc.c:1646 */ 4677| 445| break; 4678| | 4679| 8.55k| case 201: ------------------ | Branch (4679:3): [True: 8.55k, False: 17.3M] ------------------ 4680| 8.55k|#line 1125 "bison_parser.y" /* yacc.c:1646 */ 4681| 8.55k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4682| 8.55k|#line 4683 "bison_parser.cpp" /* yacc.c:1646 */ 4683| 8.55k| break; 4684| | 4685| 828| case 202: ------------------ | Branch (4685:3): [True: 828, False: 17.3M] ------------------ 4686| 828|#line 1126 "bison_parser.y" /* yacc.c:1646 */ 4687| 828| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4688| 828|#line 4689 "bison_parser.cpp" /* yacc.c:1646 */ 4689| 828| break; 4690| | 4691| 765| case 203: ------------------ | Branch (4691:3): [True: 765, False: 17.3M] ------------------ 4692| 765|#line 1127 "bison_parser.y" /* yacc.c:1646 */ 4693| 765| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } 4694| 765|#line 4695 "bison_parser.cpp" /* yacc.c:1646 */ 4695| 765| break; 4696| | 4697| 280| case 204: ------------------ | Branch (4697:3): [True: 280, False: 17.3M] ------------------ 4698| 280|#line 1128 "bison_parser.y" /* yacc.c:1646 */ 4699| 280| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } 4700| 280|#line 4701 "bison_parser.cpp" /* yacc.c:1646 */ 4701| 280| break; 4702| | 4703| 194| case 205: ------------------ | Branch (4703:3): [True: 194, False: 17.3M] ------------------ 4704| 194|#line 1129 "bison_parser.y" /* yacc.c:1646 */ 4705| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } 4706| 194|#line 4707 "bison_parser.cpp" /* yacc.c:1646 */ 4707| 194| break; 4708| | 4709| 17.5k| case 207: ------------------ | Branch (4709:3): [True: 17.5k, False: 17.3M] ------------------ 4710| 17.5k|#line 1131 "bison_parser.y" /* yacc.c:1646 */ 4711| 17.5k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4712| 17.5k|#line 4713 "bison_parser.cpp" /* yacc.c:1646 */ 4713| 17.5k| break; 4714| | 4715| 14.7k| case 208: ------------------ | Branch (4715:3): [True: 14.7k, False: 17.3M] ------------------ 4716| 14.7k|#line 1132 "bison_parser.y" /* yacc.c:1646 */ 4717| 14.7k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4718| 14.7k|#line 4719 "bison_parser.cpp" /* yacc.c:1646 */ 4719| 14.7k| break; 4720| | 4721| 129k| case 209: ------------------ | Branch (4721:3): [True: 129k, False: 17.2M] ------------------ 4722| 129k|#line 1133 "bison_parser.y" /* yacc.c:1646 */ 4723| 129k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4724| 129k|#line 4725 "bison_parser.cpp" /* yacc.c:1646 */ 4725| 129k| break; 4726| | 4727| 845k| case 210: ------------------ | Branch (4727:3): [True: 845k, False: 16.5M] ------------------ 4728| 845k|#line 1134 "bison_parser.y" /* yacc.c:1646 */ 4729| 845k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4730| 845k|#line 4731 "bison_parser.cpp" /* yacc.c:1646 */ 4731| 845k| break; 4732| | 4733| 3.50k| case 211: ------------------ | Branch (4733:3): [True: 3.50k, False: 17.3M] ------------------ 4734| 3.50k|#line 1135 "bison_parser.y" /* yacc.c:1646 */ 4735| 3.50k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4736| 3.50k|#line 4737 "bison_parser.cpp" /* yacc.c:1646 */ 4737| 3.50k| break; 4738| | 4739| 6.34k| case 212: ------------------ | Branch (4739:3): [True: 6.34k, False: 17.3M] ------------------ 4740| 6.34k|#line 1136 "bison_parser.y" /* yacc.c:1646 */ 4741| 6.34k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4742| 6.34k|#line 4743 "bison_parser.cpp" /* yacc.c:1646 */ 4743| 6.34k| break; 4744| | 4745| 496| case 213: ------------------ | Branch (4745:3): [True: 496, False: 17.3M] ------------------ 4746| 496|#line 1137 "bison_parser.y" /* yacc.c:1646 */ 4747| 496| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4748| 496|#line 4749 "bison_parser.cpp" /* yacc.c:1646 */ 4749| 496| break; 4750| | 4751| 194| case 214: ------------------ | Branch (4751:3): [True: 194, False: 17.3M] ------------------ 4752| 194|#line 1138 "bison_parser.y" /* yacc.c:1646 */ 4753| 194| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4754| 194|#line 4755 "bison_parser.cpp" /* yacc.c:1646 */ 4755| 194| break; 4756| | 4757| 680| case 215: ------------------ | Branch (4757:3): [True: 680, False: 17.3M] ------------------ 4758| 680|#line 1139 "bison_parser.y" /* yacc.c:1646 */ 4759| 680| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4760| 680|#line 4761 "bison_parser.cpp" /* yacc.c:1646 */ 4761| 680| break; 4762| | 4763| 4.10k| case 216: ------------------ | Branch (4763:3): [True: 4.10k, False: 17.3M] ------------------ 4764| 4.10k|#line 1140 "bison_parser.y" /* yacc.c:1646 */ 4765| 4.10k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4766| 4.10k|#line 4767 "bison_parser.cpp" /* yacc.c:1646 */ 4767| 4.10k| break; 4768| | 4769| 818| case 217: ------------------ | Branch (4769:3): [True: 818, False: 17.3M] ------------------ 4770| 818|#line 1142 "bison_parser.y" /* yacc.c:1646 */ 4771| 818| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4772| 818|#line 4773 "bison_parser.cpp" /* yacc.c:1646 */ 4773| 818| break; 4774| | 4775| 558| case 218: ------------------ | Branch (4775:3): [True: 558, False: 17.3M] ------------------ 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| 398| case 219: ------------------ | Branch (4781:3): [True: 398, False: 17.3M] ------------------ 4782| 398|#line 1145 "bison_parser.y" /* yacc.c:1646 */ 4783| 398| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4784| 398|#line 4785 "bison_parser.cpp" /* yacc.c:1646 */ 4785| 398| break; 4786| | 4787| 195| case 220: ------------------ | Branch (4787:3): [True: 195, False: 17.3M] ------------------ 4788| 195|#line 1146 "bison_parser.y" /* yacc.c:1646 */ 4789| 195| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4790| 195|#line 4791 "bison_parser.cpp" /* yacc.c:1646 */ 4791| 195| break; 4792| | 4793| 230| case 221: ------------------ | Branch (4793:3): [True: 230, False: 17.3M] ------------------ 4794| 230|#line 1147 "bison_parser.y" /* yacc.c:1646 */ 4795| 230| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4796| 230|#line 4797 "bison_parser.cpp" /* yacc.c:1646 */ 4797| 230| break; 4798| | 4799| 194| case 222: ------------------ | Branch (4799:3): [True: 194, False: 17.3M] ------------------ 4800| 194|#line 1148 "bison_parser.y" /* yacc.c:1646 */ 4801| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4802| 194|#line 4803 "bison_parser.cpp" /* yacc.c:1646 */ 4803| 194| break; 4804| | 4805| 289| case 223: ------------------ | Branch (4805:3): [True: 289, False: 17.3M] ------------------ 4806| 289|#line 1152 "bison_parser.y" /* yacc.c:1646 */ 4807| 289| { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } 4808| 289|#line 4809 "bison_parser.cpp" /* yacc.c:1646 */ 4809| 289| break; 4810| | 4811| 205| case 224: ------------------ | Branch (4811:3): [True: 205, False: 17.3M] ------------------ 4812| 205|#line 1153 "bison_parser.y" /* yacc.c:1646 */ 4813| 205| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4814| 205|#line 4815 "bison_parser.cpp" /* yacc.c:1646 */ 4815| 205| break; 4816| | 4817| 598| case 225: ------------------ | Branch (4817:3): [True: 598, False: 17.3M] ------------------ 4818| 598|#line 1154 "bison_parser.y" /* yacc.c:1646 */ 4819| 598| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4820| 598|#line 4821 "bison_parser.cpp" /* yacc.c:1646 */ 4821| 598| break; 4822| | 4823| 447| case 226: ------------------ | Branch (4823:3): [True: 447, False: 17.3M] ------------------ 4824| 447|#line 1155 "bison_parser.y" /* yacc.c:1646 */ 4825| 447| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4826| 447|#line 4827 "bison_parser.cpp" /* yacc.c:1646 */ 4827| 447| break; 4828| | 4829| 1.82k| case 227: ------------------ | Branch (4829:3): [True: 1.82k, False: 17.3M] ------------------ 4830| 1.82k|#line 1157 "bison_parser.y" /* yacc.c:1646 */ 4831| 1.82k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4832| 1.82k|#line 4833 "bison_parser.cpp" /* yacc.c:1646 */ 4833| 1.82k| break; 4834| | 4835| 1.40k| case 228: ------------------ | Branch (4835:3): [True: 1.40k, False: 17.3M] ------------------ 4836| 1.40k|#line 1158 "bison_parser.y" /* yacc.c:1646 */ 4837| 1.40k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4838| 1.40k|#line 4839 "bison_parser.cpp" /* yacc.c:1646 */ 4839| 1.40k| break; 4840| | 4841| 834| case 229: ------------------ | Branch (4841:3): [True: 834, False: 17.3M] ------------------ 4842| 834|#line 1160 "bison_parser.y" /* yacc.c:1646 */ 4843| 834| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4844| 834|#line 4845 "bison_parser.cpp" /* yacc.c:1646 */ 4845| 834| break; 4846| | 4847| 220| case 230: ------------------ | Branch (4847:3): [True: 220, False: 17.3M] ------------------ 4848| 220|#line 1161 "bison_parser.y" /* yacc.c:1646 */ 4849| 220| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4850| 220|#line 4851 "bison_parser.cpp" /* yacc.c:1646 */ 4851| 220| break; 4852| | 4853| 889| case 231: ------------------ | Branch (4853:3): [True: 889, False: 17.3M] ------------------ 4854| 889|#line 1163 "bison_parser.y" /* yacc.c:1646 */ 4855| 889| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4856| 889|#line 4857 "bison_parser.cpp" /* yacc.c:1646 */ 4857| 889| break; 4858| | 4859| 383| case 232: ------------------ | Branch (4859:3): [True: 383, False: 17.3M] ------------------ 4860| 383|#line 1164 "bison_parser.y" /* yacc.c:1646 */ 4861| 383| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4862| 383|#line 4863 "bison_parser.cpp" /* yacc.c:1646 */ 4863| 383| break; 4864| | 4865| 518| case 233: ------------------ | Branch (4865:3): [True: 518, False: 17.3M] ------------------ 4866| 518|#line 1165 "bison_parser.y" /* yacc.c:1646 */ 4867| 518| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4868| 518|#line 4869 "bison_parser.cpp" /* yacc.c:1646 */ 4869| 518| break; 4870| | 4871| 4.69k| case 234: ------------------ | Branch (4871:3): [True: 4.69k, False: 17.3M] ------------------ 4872| 4.69k|#line 1166 "bison_parser.y" /* yacc.c:1646 */ 4873| 4.69k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4874| 4.69k|#line 4875 "bison_parser.cpp" /* yacc.c:1646 */ 4875| 4.69k| break; 4876| | 4877| 6.84k| case 235: ------------------ | Branch (4877:3): [True: 6.84k, False: 17.3M] ------------------ 4878| 6.84k|#line 1167 "bison_parser.y" /* yacc.c:1646 */ 4879| 6.84k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4880| 6.84k|#line 4881 "bison_parser.cpp" /* yacc.c:1646 */ 4881| 6.84k| break; 4882| | 4883| 213| case 236: ------------------ | Branch (4883:3): [True: 213, False: 17.3M] ------------------ 4884| 213|#line 1168 "bison_parser.y" /* yacc.c:1646 */ 4885| 213| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4886| 213|#line 4887 "bison_parser.cpp" /* yacc.c:1646 */ 4887| 213| break; 4888| | 4889| 1.40k| case 237: ------------------ | Branch (4889:3): [True: 1.40k, False: 17.3M] ------------------ 4890| 1.40k|#line 1169 "bison_parser.y" /* yacc.c:1646 */ 4891| 1.40k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4892| 1.40k|#line 4893 "bison_parser.cpp" /* yacc.c:1646 */ 4893| 1.40k| break; 4894| | 4895| 4.04k| case 238: ------------------ | Branch (4895:3): [True: 4.04k, False: 17.3M] ------------------ 4896| 4.04k|#line 1173 "bison_parser.y" /* yacc.c:1646 */ 4897| 4.04k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4898| 4.04k|#line 4899 "bison_parser.cpp" /* yacc.c:1646 */ 4899| 4.04k| break; 4900| | 4901| 3.55k| case 239: ------------------ | Branch (4901:3): [True: 3.55k, False: 17.3M] ------------------ 4902| 3.55k|#line 1174 "bison_parser.y" /* yacc.c:1646 */ 4903| 3.55k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4904| 3.55k|#line 4905 "bison_parser.cpp" /* yacc.c:1646 */ 4905| 3.55k| break; 4906| | 4907| 205| case 240: ------------------ | Branch (4907:3): [True: 205, False: 17.3M] ------------------ 4908| 205|#line 1175 "bison_parser.y" /* yacc.c:1646 */ 4909| 205| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), (yyvsp[-5].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4910| 205|#line 4911 "bison_parser.cpp" /* yacc.c:1646 */ 4911| 205| break; 4912| | 4913| 210| case 241: ------------------ | Branch (4913:3): [True: 210, False: 17.3M] ------------------ 4914| 210|#line 1176 "bison_parser.y" /* yacc.c:1646 */ 4915| 210| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-7].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4916| 210|#line 4917 "bison_parser.cpp" /* yacc.c:1646 */ 4917| 210| break; 4918| | 4919| 5.44k| case 242: ------------------ | Branch (4919:3): [True: 5.44k, False: 17.3M] ------------------ 4920| 5.44k|#line 1180 "bison_parser.y" /* yacc.c:1646 */ 4921| 5.44k| { (yyval.window_description) = new WindowDescription((yyvsp[-3].expr_vec), (yyvsp[-2].order_vec), (yyvsp[-1].frame_description)); } 4922| 5.44k|#line 4923 "bison_parser.cpp" /* yacc.c:1646 */ 4923| 5.44k| break; 4924| | 4925| 2.57k| case 243: ------------------ | Branch (4925:3): [True: 2.57k, False: 17.3M] ------------------ 4926| 2.57k|#line 1181 "bison_parser.y" /* yacc.c:1646 */ 4927| 2.57k| { (yyval.window_description) = nullptr; } 4928| 2.57k|#line 4929 "bison_parser.cpp" /* yacc.c:1646 */ 4929| 2.57k| break; 4930| | 4931| 834| case 244: ------------------ | Branch (4931:3): [True: 834, False: 17.3M] ------------------ 4932| 834|#line 1183 "bison_parser.y" /* yacc.c:1646 */ 4933| 834| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4934| 834|#line 4935 "bison_parser.cpp" /* yacc.c:1646 */ 4935| 834| break; 4936| | 4937| 4.80k| case 245: ------------------ | Branch (4937:3): [True: 4.80k, False: 17.3M] ------------------ 4938| 4.80k|#line 1184 "bison_parser.y" /* yacc.c:1646 */ 4939| 4.80k| { (yyval.expr_vec) = nullptr; } 4940| 4.80k|#line 4941 "bison_parser.cpp" /* yacc.c:1646 */ 4941| 4.80k| break; 4942| | 4943| 3.34k| case 246: ------------------ | Branch (4943:3): [True: 3.34k, False: 17.3M] ------------------ 4944| 3.34k|#line 1189 "bison_parser.y" /* yacc.c:1646 */ 4945| 3.34k| { (yyval.frame_description) = new FrameDescription{(yyvsp[-1].frame_type), (yyvsp[0].frame_bound), new FrameBound{0, kCurrentRow, false}}; } 4946| 3.34k|#line 4947 "bison_parser.cpp" /* yacc.c:1646 */ 4947| 3.34k| break; 4948| | 4949| 194| case 247: ------------------ | Branch (4949:3): [True: 194, False: 17.3M] ------------------ 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: 17.3M] ------------------ 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.15k| case 249: ------------------ | Branch (4963:3): [True: 1.15k, False: 17.3M] ------------------ 4964| 1.15k|#line 1195 "bison_parser.y" /* yacc.c:1646 */ 4965| 1.15k| { (yyval.frame_type) = kRange; } 4966| 1.15k|#line 4967 "bison_parser.cpp" /* yacc.c:1646 */ 4967| 1.15k| break; 4968| | 4969| 1.45k| case 250: ------------------ | Branch (4969:3): [True: 1.45k, False: 17.3M] ------------------ 4970| 1.45k|#line 1196 "bison_parser.y" /* yacc.c:1646 */ 4971| 1.45k| { (yyval.frame_type) = kRows; } 4972| 1.45k|#line 4973 "bison_parser.cpp" /* yacc.c:1646 */ 4973| 1.45k| break; 4974| | 4975| 988| case 251: ------------------ | Branch (4975:3): [True: 988, False: 17.3M] ------------------ 4976| 988|#line 1197 "bison_parser.y" /* yacc.c:1646 */ 4977| 988| { (yyval.frame_type) = kGroups; } 4978| 988|#line 4979 "bison_parser.cpp" /* yacc.c:1646 */ 4979| 988| break; 4980| | 4981| 595| case 252: ------------------ | Branch (4981:3): [True: 595, False: 17.3M] ------------------ 4982| 595|#line 1199 "bison_parser.y" /* yacc.c:1646 */ 4983| 595| { (yyval.frame_bound) = new FrameBound{0, kPreceding, true}; } 4984| 595|#line 4985 "bison_parser.cpp" /* yacc.c:1646 */ 4985| 595| break; 4986| | 4987| 1.09k| case 253: ------------------ | Branch (4987:3): [True: 1.09k, False: 17.3M] ------------------ 4988| 1.09k|#line 1200 "bison_parser.y" /* yacc.c:1646 */ 4989| 1.09k| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kPreceding, false}; } 4990| 1.09k|#line 4991 "bison_parser.cpp" /* yacc.c:1646 */ 4991| 1.09k| break; 4992| | 4993| 242| case 254: ------------------ | Branch (4993:3): [True: 242, False: 17.3M] ------------------ 4994| 242|#line 1201 "bison_parser.y" /* yacc.c:1646 */ 4995| 242| { (yyval.frame_bound) = new FrameBound{0, kFollowing, true}; } 4996| 242|#line 4997 "bison_parser.cpp" /* yacc.c:1646 */ 4997| 242| break; 4998| | 4999| 1.80k| case 255: ------------------ | Branch (4999:3): [True: 1.80k, False: 17.3M] ------------------ 5000| 1.80k|#line 1202 "bison_parser.y" /* yacc.c:1646 */ 5001| 1.80k| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kFollowing, false}; } 5002| 1.80k|#line 5003 "bison_parser.cpp" /* yacc.c:1646 */ 5003| 1.80k| break; 5004| | 5005| 0| case 256: ------------------ | Branch (5005:3): [True: 0, False: 17.3M] ------------------ 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| 532| case 257: ------------------ | Branch (5011:3): [True: 532, False: 17.3M] ------------------ 5012| 532|#line 1205 "bison_parser.y" /* yacc.c:1646 */ 5013| 532| { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } 5014| 532|#line 5015 "bison_parser.cpp" /* yacc.c:1646 */ 5015| 532| break; 5016| | 5017| 365| case 258: ------------------ | Branch (5017:3): [True: 365, False: 17.3M] ------------------ 5018| 365|#line 1207 "bison_parser.y" /* yacc.c:1646 */ 5019| 365| { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } 5020| 365|#line 5021 "bison_parser.cpp" /* yacc.c:1646 */ 5021| 365| break; 5022| | 5023| 792| case 259: ------------------ | Branch (5023:3): [True: 792, False: 17.3M] ------------------ 5024| 792|#line 1209 "bison_parser.y" /* yacc.c:1646 */ 5025| 792| { (yyval.datetime_field) = kDatetimeSecond; } 5026| 792|#line 5027 "bison_parser.cpp" /* yacc.c:1646 */ 5027| 792| break; 5028| | 5029| 817| case 260: ------------------ | Branch (5029:3): [True: 817, False: 17.3M] ------------------ 5030| 817|#line 1210 "bison_parser.y" /* yacc.c:1646 */ 5031| 817| { (yyval.datetime_field) = kDatetimeMinute; } 5032| 817|#line 5033 "bison_parser.cpp" /* yacc.c:1646 */ 5033| 817| break; 5034| | 5035| 1.17k| case 261: ------------------ | Branch (5035:3): [True: 1.17k, False: 17.3M] ------------------ 5036| 1.17k|#line 1211 "bison_parser.y" /* yacc.c:1646 */ 5037| 1.17k| { (yyval.datetime_field) = kDatetimeHour; } 5038| 1.17k|#line 5039 "bison_parser.cpp" /* yacc.c:1646 */ 5039| 1.17k| break; 5040| | 5041| 1.91k| case 262: ------------------ | Branch (5041:3): [True: 1.91k, False: 17.3M] ------------------ 5042| 1.91k|#line 1212 "bison_parser.y" /* yacc.c:1646 */ 5043| 1.91k| { (yyval.datetime_field) = kDatetimeDay; } 5044| 1.91k|#line 5045 "bison_parser.cpp" /* yacc.c:1646 */ 5045| 1.91k| break; 5046| | 5047| 713| case 263: ------------------ | Branch (5047:3): [True: 713, False: 17.3M] ------------------ 5048| 713|#line 1213 "bison_parser.y" /* yacc.c:1646 */ 5049| 713| { (yyval.datetime_field) = kDatetimeMonth; } 5050| 713|#line 5051 "bison_parser.cpp" /* yacc.c:1646 */ 5051| 713| break; 5052| | 5053| 647| case 264: ------------------ | Branch (5053:3): [True: 647, False: 17.3M] ------------------ 5054| 647|#line 1214 "bison_parser.y" /* yacc.c:1646 */ 5055| 647| { (yyval.datetime_field) = kDatetimeYear; } 5056| 647|#line 5057 "bison_parser.cpp" /* yacc.c:1646 */ 5057| 647| break; 5058| | 5059| 863| case 265: ------------------ | Branch (5059:3): [True: 863, False: 17.3M] ------------------ 5060| 863|#line 1216 "bison_parser.y" /* yacc.c:1646 */ 5061| 863| { (yyval.datetime_field) = kDatetimeSecond; } 5062| 863|#line 5063 "bison_parser.cpp" /* yacc.c:1646 */ 5063| 863| break; 5064| | 5065| 686| case 266: ------------------ | Branch (5065:3): [True: 686, False: 17.3M] ------------------ 5066| 686|#line 1217 "bison_parser.y" /* yacc.c:1646 */ 5067| 686| { (yyval.datetime_field) = kDatetimeMinute; } 5068| 686|#line 5069 "bison_parser.cpp" /* yacc.c:1646 */ 5069| 686| break; 5070| | 5071| 726| case 267: ------------------ | Branch (5071:3): [True: 726, False: 17.3M] ------------------ 5072| 726|#line 1218 "bison_parser.y" /* yacc.c:1646 */ 5073| 726| { (yyval.datetime_field) = kDatetimeHour; } 5074| 726|#line 5075 "bison_parser.cpp" /* yacc.c:1646 */ 5075| 726| break; 5076| | 5077| 523| case 268: ------------------ | Branch (5077:3): [True: 523, False: 17.3M] ------------------ 5078| 523|#line 1219 "bison_parser.y" /* yacc.c:1646 */ 5079| 523| { (yyval.datetime_field) = kDatetimeDay; } 5080| 523|#line 5081 "bison_parser.cpp" /* yacc.c:1646 */ 5081| 523| break; 5082| | 5083| 764| case 269: ------------------ | Branch (5083:3): [True: 764, False: 17.3M] ------------------ 5084| 764|#line 1220 "bison_parser.y" /* yacc.c:1646 */ 5085| 764| { (yyval.datetime_field) = kDatetimeMonth; } 5086| 764|#line 5087 "bison_parser.cpp" /* yacc.c:1646 */ 5087| 764| break; 5088| | 5089| 692| case 270: ------------------ | Branch (5089:3): [True: 692, False: 17.3M] ------------------ 5090| 692|#line 1221 "bison_parser.y" /* yacc.c:1646 */ 5091| 692| { (yyval.datetime_field) = kDatetimeYear; } 5092| 692|#line 5093 "bison_parser.cpp" /* yacc.c:1646 */ 5093| 692| break; 5094| | 5095| 529| case 273: ------------------ | Branch (5095:3): [True: 529, False: 17.3M] ------------------ 5096| 529|#line 1225 "bison_parser.y" /* yacc.c:1646 */ 5097| 529| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 5098| 529|#line 5099 "bison_parser.cpp" /* yacc.c:1646 */ 5099| 529| break; 5100| | 5101| 194| case 274: ------------------ | Branch (5101:3): [True: 194, False: 17.3M] ------------------ 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| 494| case 275: ------------------ | Branch (5107:3): [True: 494, False: 17.3M] ------------------ 5108| 494|#line 1229 "bison_parser.y" /* yacc.c:1646 */ 5109| 494| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 5110| 494|#line 5111 "bison_parser.cpp" /* yacc.c:1646 */ 5111| 494| break; 5112| | 5113| 868k| case 276: ------------------ | Branch (5113:3): [True: 868k, False: 16.5M] ------------------ 5114| 868k|#line 1231 "bison_parser.y" /* yacc.c:1646 */ 5115| 868k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 5116| 868k|#line 5117 "bison_parser.cpp" /* yacc.c:1646 */ 5117| 868k| break; 5118| | 5119| 389| case 277: ------------------ | Branch (5119:3): [True: 389, False: 17.3M] ------------------ 5120| 389|#line 1232 "bison_parser.y" /* yacc.c:1646 */ 5121| 389| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 5122| 389|#line 5123 "bison_parser.cpp" /* yacc.c:1646 */ 5123| 389| break; 5124| | 5125| 981k| case 278: ------------------ | Branch (5125:3): [True: 981k, False: 16.4M] ------------------ 5126| 981k|#line 1233 "bison_parser.y" /* yacc.c:1646 */ 5127| 981k| { (yyval.expr) = Expr::makeStar(); } 5128| 981k|#line 5129 "bison_parser.cpp" /* yacc.c:1646 */ 5129| 981k| break; 5130| | 5131| 260| case 279: ------------------ | Branch (5131:3): [True: 260, False: 17.3M] ------------------ 5132| 260|#line 1234 "bison_parser.y" /* yacc.c:1646 */ 5133| 260| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 5134| 260|#line 5135 "bison_parser.cpp" /* yacc.c:1646 */ 5135| 260| break; 5136| | 5137| 2.94k| case 287: ------------------ | Branch (5137:3): [True: 2.94k, False: 17.3M] ------------------ 5138| 2.94k|#line 1238 "bison_parser.y" /* yacc.c:1646 */ 5139| 2.94k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 5140| 2.94k|#line 5141 "bison_parser.cpp" /* yacc.c:1646 */ 5141| 2.94k| break; 5142| | 5143| 511| case 288: ------------------ | Branch (5143:3): [True: 511, False: 17.3M] ------------------ 5144| 511|#line 1240 "bison_parser.y" /* yacc.c:1646 */ 5145| 511| { (yyval.expr) = Expr::makeLiteral(true); } 5146| 511|#line 5147 "bison_parser.cpp" /* yacc.c:1646 */ 5147| 511| break; 5148| | 5149| 923| case 289: ------------------ | Branch (5149:3): [True: 923, False: 17.3M] ------------------ 5150| 923|#line 1241 "bison_parser.y" /* yacc.c:1646 */ 5151| 923| { (yyval.expr) = Expr::makeLiteral(false); } 5152| 923|#line 5153 "bison_parser.cpp" /* yacc.c:1646 */ 5153| 923| break; 5154| | 5155| 538| case 290: ------------------ | Branch (5155:3): [True: 538, False: 17.3M] ------------------ 5156| 538|#line 1243 "bison_parser.y" /* yacc.c:1646 */ 5157| 538| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 5158| 538|#line 5159 "bison_parser.cpp" /* yacc.c:1646 */ 5159| 538| break; 5160| | 5161| 9.71k| case 292: ------------------ | Branch (5161:3): [True: 9.71k, False: 17.3M] ------------------ 5162| 9.71k|#line 1246 "bison_parser.y" /* yacc.c:1646 */ 5163| 9.71k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 5164| 9.71k|#line 5165 "bison_parser.cpp" /* yacc.c:1646 */ 5165| 9.71k| break; 5166| | 5167| 1.01k| case 293: ------------------ | Branch (5167:3): [True: 1.01k, False: 17.3M] ------------------ 5168| 1.01k|#line 1248 "bison_parser.y" /* yacc.c:1646 */ 5169| 1.01k| { (yyval.expr) = Expr::makeNullLiteral(); } 5170| 1.01k|#line 5171 "bison_parser.cpp" /* yacc.c:1646 */ 5171| 1.01k| break; 5172| | 5173| 206| case 294: ------------------ | Branch (5173:3): [True: 206, False: 17.3M] ------------------ 5174| 206|#line 1250 "bison_parser.y" /* yacc.c:1646 */ 5175| 206| { 5176| 206| 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| 206| if (sscanf((yyvsp[0].sval), "%4d-%2d-%2d%n", &day, &month, &year, &chars_parsed) != 3 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5178:7): [True: 3, False: 203] | Branch (5178:92): [True: 7, False: 196] ------------------ 5179| 10| free((yyvsp[0].sval)); 5180| 10| yyerror(&yyloc, result, scanner, "Found incorrect date format. Expected format: YYYY-MM-DD"); ------------------ | | 67| 10|#define yyerror hsql_error ------------------ 5181| 10| YYERROR; ------------------ | | 1458| 10|#define YYERROR goto yyerrorlab ------------------ 5182| 10| } 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| 9.19k| case 295: ------------------ | Branch (5188:3): [True: 9.19k, False: 17.3M] ------------------ 5189| 9.19k|#line 1261 "bison_parser.y" /* yacc.c:1646 */ 5190| 9.19k| { (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].ival), (yyvsp[0].datetime_field)); } 5191| 9.19k|#line 5192 "bison_parser.cpp" /* yacc.c:1646 */ 5192| 9.19k| break; 5193| | 5194| 306| case 296: ------------------ | Branch (5194:3): [True: 306, False: 17.3M] ------------------ 5195| 306|#line 1262 "bison_parser.y" /* yacc.c:1646 */ 5196| 306| { 5197| 306| 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| 306| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (5199:7): [True: 2, False: 304] | Branch (5199:74): [True: 8, False: 296] ------------------ 5200| 10| free((yyvsp[-1].sval)); 5201| 10| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER"); ------------------ | | 67| 10|#define yyerror hsql_error ------------------ 5202| 10| YYERROR; ------------------ | | 1458| 10|#define YYERROR goto yyerrorlab ------------------ 5203| 10| } 5204| 296| free((yyvsp[-1].sval)); 5205| 296| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 5206| 296|} 5207| 0|#line 5208 "bison_parser.cpp" /* yacc.c:1646 */ 5208| 0| break; 5209| | 5210| 4.21k| case 297: ------------------ | Branch (5210:3): [True: 4.21k, False: 17.3M] ------------------ 5211| 4.21k|#line 1273 "bison_parser.y" /* yacc.c:1646 */ 5212| 4.21k| { 5213| 4.21k| int duration{0}, chars_parsed{0}; 5214| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 5215| 4.21k| 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.21k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5217:7): [True: 11, False: 4.20k] | Branch (5217:90): [True: 5, False: 4.19k] ------------------ 5218| 16| free((yyvsp[0].sval)); 5219| 16| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER INTERVAL_QUALIIFIER"); ------------------ | | 67| 16|#define yyerror hsql_error ------------------ 5220| 16| YYERROR; ------------------ | | 1458| 16|#define YYERROR goto yyerrorlab ------------------ 5221| 16| } 5222| 4.19k| free((yyvsp[0].sval)); 5223| | 5224| 4.19k| DatetimeField unit; 5225| 4.19k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (5225:7): [True: 272, False: 3.92k] | Branch (5225:49): [True: 486, False: 3.43k] ------------------ 5226| 758| unit = kDatetimeSecond; 5227| 3.43k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (5227:14): [True: 195, False: 3.24k] | Branch (5227:56): [True: 195, False: 3.04k] ------------------ 5228| 390| unit = kDatetimeMinute; 5229| 3.04k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (5229:14): [True: 204, False: 2.84k] | Branch (5229:54): [True: 527, False: 2.31k] ------------------ 5230| 731| unit = kDatetimeHour; 5231| 2.31k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (5231:14): [True: 560, False: 1.75k] | Branch (5231:53): [True: 554, False: 1.20k] ------------------ 5232| 1.11k| unit = kDatetimeDay; 5233| 1.20k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (5233:14): [True: 199, False: 1.00k] | Branch (5233:55): [True: 239, False: 764] ------------------ 5234| 438| unit = kDatetimeMonth; 5235| 764| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (5235:14): [True: 194, False: 570] | Branch (5235:54): [True: 280, False: 290] ------------------ 5236| 474| unit = kDatetimeYear; 5237| 474| } else { 5238| 290| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 67| 290|#define yyerror hsql_error ------------------ 5239| 290| YYERROR; ------------------ | | 1458| 290|#define YYERROR goto yyerrorlab ------------------ 5240| 290| } 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| 241k| case 298: ------------------ | Branch (5246:3): [True: 241k, False: 17.1M] ------------------ 5247| 241k|#line 1305 "bison_parser.y" /* yacc.c:1646 */ 5248| 241k| { 5249| 241k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 5250| 241k| (yyval.expr)->ival2 = yyloc.param_list.size(); 5251| 241k| yyloc.param_list.push_back((yyval.expr)); 5252| 241k|} 5253| 241k|#line 5254 "bison_parser.cpp" /* yacc.c:1646 */ 5254| 241k| break; 5255| | 5256| 2.00k| case 300: ------------------ | Branch (5256:3): [True: 2.00k, False: 17.3M] ------------------ 5257| 2.00k|#line 1314 "bison_parser.y" /* yacc.c:1646 */ 5258| 2.00k| { 5259| 2.00k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5260| 2.00k| auto tbl = new TableRef(kTableCrossProduct); 5261| 2.00k| tbl->list = (yyvsp[-2].table_vec); 5262| 2.00k| (yyval.table) = tbl; 5263| 2.00k|} 5264| 2.00k|#line 5265 "bison_parser.cpp" /* yacc.c:1646 */ 5265| 2.00k| break; 5266| | 5267| 869| case 304: ------------------ | Branch (5267:3): [True: 869, False: 17.3M] ------------------ 5268| 869|#line 1323 "bison_parser.y" /* yacc.c:1646 */ 5269| 869| { 5270| 869| auto tbl = new TableRef(kTableSelect); 5271| 869| tbl->select = (yyvsp[-2].select_stmt); 5272| 869| tbl->alias = (yyvsp[0].alias_t); 5273| 869| (yyval.table) = tbl; 5274| 869|} 5275| 869|#line 5276 "bison_parser.cpp" /* yacc.c:1646 */ 5276| 869| break; 5277| | 5278| 2.11k| case 305: ------------------ | Branch (5278:3): [True: 2.11k, False: 17.3M] ------------------ 5279| 2.11k|#line 1330 "bison_parser.y" /* yacc.c:1646 */ 5280| 2.11k| { 5281| 2.11k| (yyval.table_vec) = new std::vector(); 5282| 2.11k| (yyval.table_vec)->push_back((yyvsp[0].table)); 5283| 2.11k|} 5284| 2.11k|#line 5285 "bison_parser.cpp" /* yacc.c:1646 */ 5285| 2.11k| break; 5286| | 5287| 341k| case 306: ------------------ | Branch (5287:3): [True: 341k, False: 17.0M] ------------------ 5288| 341k|#line 1334 "bison_parser.y" /* yacc.c:1646 */ 5289| 341k| { 5290| 341k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5291| 341k| (yyval.table_vec) = (yyvsp[-2].table_vec); 5292| 341k|} 5293| 341k|#line 5294 "bison_parser.cpp" /* yacc.c:1646 */ 5294| 341k| break; 5295| | 5296| 460k| case 307: ------------------ | Branch (5296:3): [True: 460k, False: 16.9M] ------------------ 5297| 460k|#line 1339 "bison_parser.y" /* yacc.c:1646 */ 5298| 460k| { 5299| 460k| auto tbl = new TableRef(kTableName); 5300| 460k| tbl->schema = (yyvsp[-1].table_name).schema; 5301| 460k| tbl->name = (yyvsp[-1].table_name).name; 5302| 460k| tbl->alias = (yyvsp[0].alias_t); 5303| 460k| (yyval.table) = tbl; 5304| 460k|} 5305| 460k|#line 5306 "bison_parser.cpp" /* yacc.c:1646 */ 5306| 460k| break; 5307| | 5308| 1.52k| case 308: ------------------ | Branch (5308:3): [True: 1.52k, False: 17.3M] ------------------ 5309| 1.52k|#line 1347 "bison_parser.y" /* yacc.c:1646 */ 5310| 1.52k| { 5311| 1.52k| (yyval.table) = new TableRef(kTableName); 5312| 1.52k| (yyval.table)->schema = (yyvsp[0].table_name).schema; 5313| 1.52k| (yyval.table)->name = (yyvsp[0].table_name).name; 5314| 1.52k|} 5315| 1.52k|#line 5316 "bison_parser.cpp" /* yacc.c:1646 */ 5316| 1.52k| break; 5317| | 5318| 486k| case 309: ------------------ | Branch (5318:3): [True: 486k, False: 16.8M] ------------------ 5319| 486k|#line 1353 "bison_parser.y" /* yacc.c:1646 */ 5320| 486k| { 5321| 486k| (yyval.table_name).schema = nullptr; 5322| 486k| (yyval.table_name).name = (yyvsp[0].sval); 5323| 486k|} 5324| 486k|#line 5325 "bison_parser.cpp" /* yacc.c:1646 */ 5325| 486k| break; 5326| | 5327| 200| case 310: ------------------ | Branch (5327:3): [True: 200, False: 17.3M] ------------------ 5328| 200|#line 1357 "bison_parser.y" /* yacc.c:1646 */ 5329| 200| { 5330| 200| (yyval.table_name).schema = (yyvsp[-2].sval); 5331| 200| (yyval.table_name).name = (yyvsp[0].sval); 5332| 200|} 5333| 200|#line 5334 "bison_parser.cpp" /* yacc.c:1646 */ 5334| 200| break; 5335| | 5336| 202| case 311: ------------------ | Branch (5336:3): [True: 202, False: 17.3M] ------------------ 5337| 202|#line 1362 "bison_parser.y" /* yacc.c:1646 */ 5338| 202| { (yyval.sval) = (yyvsp[0].sval); } 5339| 202|#line 5340 "bison_parser.cpp" /* yacc.c:1646 */ 5340| 202| break; 5341| | 5342| 610| case 312: ------------------ | Branch (5342:3): [True: 610, False: 17.3M] ------------------ 5343| 610|#line 1363 "bison_parser.y" /* yacc.c:1646 */ 5344| 610| { (yyval.sval) = nullptr; } 5345| 610|#line 5346 "bison_parser.cpp" /* yacc.c:1646 */ 5346| 610| break; 5347| | 5348| 311| case 314: ------------------ | Branch (5348:3): [True: 311, False: 17.3M] ------------------ 5349| 311|#line 1365 "bison_parser.y" /* yacc.c:1646 */ 5350| 311| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5351| 311|#line 5352 "bison_parser.cpp" /* yacc.c:1646 */ 5352| 311| break; 5353| | 5354| 448k| case 316: ------------------ | Branch (5354:3): [True: 448k, False: 16.9M] ------------------ 5355| 448k|#line 1367 "bison_parser.y" /* yacc.c:1646 */ 5356| 448k| { (yyval.alias_t) = nullptr; } 5357| 448k|#line 5358 "bison_parser.cpp" /* yacc.c:1646 */ 5358| 448k| break; 5359| | 5360| 282| case 317: ------------------ | Branch (5360:3): [True: 282, False: 17.3M] ------------------ 5361| 282|#line 1369 "bison_parser.y" /* yacc.c:1646 */ 5362| 282| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5363| 282|#line 5364 "bison_parser.cpp" /* yacc.c:1646 */ 5364| 282| break; 5365| | 5366| 18.2k| case 318: ------------------ | Branch (5366:3): [True: 18.2k, False: 17.3M] ------------------ 5367| 18.2k|#line 1370 "bison_parser.y" /* yacc.c:1646 */ 5368| 18.2k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5369| 18.2k|#line 5370 "bison_parser.cpp" /* yacc.c:1646 */ 5370| 18.2k| break; 5371| | 5372| 624k| case 320: ------------------ | Branch (5372:3): [True: 624k, False: 16.7M] ------------------ 5373| 624k|#line 1372 "bison_parser.y" /* yacc.c:1646 */ 5374| 624k| { (yyval.alias_t) = nullptr; } 5375| 624k|#line 5376 "bison_parser.cpp" /* yacc.c:1646 */ 5376| 624k| break; 5377| | 5378| 449| case 321: ------------------ | Branch (5378:3): [True: 449, False: 17.3M] ------------------ 5379| 449|#line 1378 "bison_parser.y" /* yacc.c:1646 */ 5380| 449| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5381| 449|#line 5382 "bison_parser.cpp" /* yacc.c:1646 */ 5382| 449| break; 5383| | 5384| 31.3k| case 322: ------------------ | Branch (5384:3): [True: 31.3k, False: 17.3M] ------------------ 5385| 31.3k|#line 1379 "bison_parser.y" /* yacc.c:1646 */ 5386| 31.3k| { (yyval.locking_clause_vec) = nullptr; } 5387| 31.3k|#line 5388 "bison_parser.cpp" /* yacc.c:1646 */ 5388| 31.3k| break; 5389| | 5390| 476| case 323: ------------------ | Branch (5390:3): [True: 476, False: 17.3M] ------------------ 5391| 476|#line 1381 "bison_parser.y" /* yacc.c:1646 */ 5392| 476| { 5393| 476| (yyval.locking_clause_vec) = new std::vector(); 5394| 476| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5395| 476|} 5396| 476|#line 5397 "bison_parser.cpp" /* yacc.c:1646 */ 5397| 476| break; 5398| | 5399| 4.65k| case 324: ------------------ | Branch (5399:3): [True: 4.65k, False: 17.3M] ------------------ 5400| 4.65k|#line 1385 "bison_parser.y" /* yacc.c:1646 */ 5401| 4.65k| { 5402| 4.65k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5403| 4.65k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5404| 4.65k|} 5405| 4.65k|#line 5406 "bison_parser.cpp" /* yacc.c:1646 */ 5406| 4.65k| break; 5407| | 5408| 4.58k| case 325: ------------------ | Branch (5408:3): [True: 4.58k, False: 17.3M] ------------------ 5409| 4.58k|#line 1390 "bison_parser.y" /* yacc.c:1646 */ 5410| 4.58k| { 5411| 4.58k| (yyval.locking_t) = new LockingClause(); 5412| 4.58k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5413| 4.58k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5414| 4.58k| (yyval.locking_t)->tables = nullptr; 5415| 4.58k|} 5416| 4.58k|#line 5417 "bison_parser.cpp" /* yacc.c:1646 */ 5417| 4.58k| break; 5418| | 5419| 549| case 326: ------------------ | Branch (5419:3): [True: 549, False: 17.3M] ------------------ 5420| 549|#line 1396 "bison_parser.y" /* yacc.c:1646 */ 5421| 549| { 5422| 549| (yyval.locking_t) = new LockingClause(); 5423| 549| (yyval.locking_t)->rowLockMode = (yyvsp[-3].lock_mode_t); 5424| 549| (yyval.locking_t)->tables = (yyvsp[-1].str_vec); 5425| 549| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5426| 549|} 5427| 549|#line 5428 "bison_parser.cpp" /* yacc.c:1646 */ 5428| 549| break; 5429| | 5430| 766| case 327: ------------------ | Branch (5430:3): [True: 766, False: 17.3M] ------------------ 5431| 766|#line 1403 "bison_parser.y" /* yacc.c:1646 */ 5432| 766| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5433| 766|#line 5434 "bison_parser.cpp" /* yacc.c:1646 */ 5434| 766| break; 5435| | 5436| 0| case 328: ------------------ | Branch (5436:3): [True: 0, False: 17.3M] ------------------ 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| 4.16k| case 329: ------------------ | Branch (5442:3): [True: 4.16k, False: 17.3M] ------------------ 5443| 4.16k|#line 1405 "bison_parser.y" /* yacc.c:1646 */ 5444| 4.16k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5445| 4.16k|#line 5446 "bison_parser.cpp" /* yacc.c:1646 */ 5446| 4.16k| break; 5447| | 5448| 216| case 330: ------------------ | Branch (5448:3): [True: 216, False: 17.3M] ------------------ 5449| 216|#line 1406 "bison_parser.y" /* yacc.c:1646 */ 5450| 216| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5451| 216|#line 5452 "bison_parser.cpp" /* yacc.c:1646 */ 5452| 216| break; 5453| | 5454| 0| case 331: ------------------ | Branch (5454:3): [True: 0, False: 17.3M] ------------------ 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| 814| case 332: ------------------ | Branch (5460:3): [True: 814, False: 17.3M] ------------------ 5461| 814|#line 1409 "bison_parser.y" /* yacc.c:1646 */ 5462| 814| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5463| 814|#line 5464 "bison_parser.cpp" /* yacc.c:1646 */ 5464| 814| break; 5465| | 5466| 4.32k| case 333: ------------------ | Branch (5466:3): [True: 4.32k, False: 17.3M] ------------------ 5467| 4.32k|#line 1410 "bison_parser.y" /* yacc.c:1646 */ 5468| 4.32k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5469| 4.32k|#line 5470 "bison_parser.cpp" /* yacc.c:1646 */ 5470| 4.32k| break; 5471| | 5472| 26.3k| case 335: ------------------ | Branch (5472:3): [True: 26.3k, False: 17.3M] ------------------ 5473| 26.3k|#line 1416 "bison_parser.y" /* yacc.c:1646 */ 5474| 26.3k| { (yyval.with_description_vec) = nullptr; } 5475| 26.3k|#line 5476 "bison_parser.cpp" /* yacc.c:1646 */ 5476| 26.3k| break; 5477| | 5478| 1.49k| case 336: ------------------ | Branch (5478:3): [True: 1.49k, False: 17.3M] ------------------ 5479| 1.49k|#line 1418 "bison_parser.y" /* yacc.c:1646 */ 5480| 1.49k| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5481| 1.49k|#line 5482 "bison_parser.cpp" /* yacc.c:1646 */ 5482| 1.49k| break; 5483| | 5484| 1.52k| case 337: ------------------ | Branch (5484:3): [True: 1.52k, False: 17.3M] ------------------ 5485| 1.52k|#line 1420 "bison_parser.y" /* yacc.c:1646 */ 5486| 1.52k| { 5487| 1.52k| (yyval.with_description_vec) = new std::vector(); 5488| 1.52k| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5489| 1.52k|} 5490| 1.52k|#line 5491 "bison_parser.cpp" /* yacc.c:1646 */ 5491| 1.52k| break; 5492| | 5493| 1.00k| case 338: ------------------ | Branch (5493:3): [True: 1.00k, False: 17.3M] ------------------ 5494| 1.00k|#line 1424 "bison_parser.y" /* yacc.c:1646 */ 5495| 1.00k| { 5496| 1.00k| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5497| 1.00k| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5498| 1.00k|} 5499| 1.00k|#line 5500 "bison_parser.cpp" /* yacc.c:1646 */ 5500| 1.00k| break; 5501| | 5502| 2.53k| case 339: ------------------ | Branch (5502:3): [True: 2.53k, False: 17.3M] ------------------ 5503| 2.53k|#line 1429 "bison_parser.y" /* yacc.c:1646 */ 5504| 2.53k| { 5505| 2.53k| (yyval.with_description_t) = new WithDescription(); 5506| 2.53k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5507| 2.53k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5508| 2.53k|} 5509| 2.53k|#line 5510 "bison_parser.cpp" /* yacc.c:1646 */ 5510| 2.53k| break; 5511| | 5512| 1.21k| case 340: ------------------ | Branch (5512:3): [True: 1.21k, False: 17.3M] ------------------ 5513| 1.21k|#line 1439 "bison_parser.y" /* yacc.c:1646 */ 5514| 1.21k| { 5515| 1.21k| (yyval.table) = new TableRef(kTableJoin); 5516| 1.21k| (yyval.table)->join = new JoinDefinition(); 5517| 1.21k| (yyval.table)->join->type = kJoinNatural; 5518| 1.21k| (yyval.table)->join->left = (yyvsp[-3].table); 5519| 1.21k| (yyval.table)->join->right = (yyvsp[0].table); 5520| 1.21k|} 5521| 1.21k|#line 5522 "bison_parser.cpp" /* yacc.c:1646 */ 5522| 1.21k| break; 5523| | 5524| 109k| case 341: ------------------ | Branch (5524:3): [True: 109k, False: 17.2M] ------------------ 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| 747| case 342: ------------------ | Branch (5537:3): [True: 747, False: 17.3M] ------------------ 5538| 747|#line 1454 "bison_parser.y" /* yacc.c:1646 */ 5539| 747| { 5540| 747| (yyval.table) = new TableRef(kTableJoin); 5541| 747| (yyval.table)->join = new JoinDefinition(); 5542| 747| (yyval.table)->join->type = (yyvsp[-6].join_type); 5543| 747| (yyval.table)->join->left = (yyvsp[-7].table); 5544| 747| (yyval.table)->join->right = (yyvsp[-4].table); 5545| 747| (yyval.table)->join->namedColumns = (yyvsp[-1].str_vec); 5546| 747|} 5547| 747|#line 5548 "bison_parser.cpp" /* yacc.c:1646 */ 5548| 747| break; 5549| | 5550| 495| case 343: ------------------ | Branch (5550:3): [True: 495, False: 17.3M] ------------------ 5551| 495|#line 1463 "bison_parser.y" /* yacc.c:1646 */ 5552| 495| { (yyval.join_type) = kJoinInner; } 5553| 495|#line 5554 "bison_parser.cpp" /* yacc.c:1646 */ 5554| 495| break; 5555| | 5556| 577| case 344: ------------------ | Branch (5556:3): [True: 577, False: 17.3M] ------------------ 5557| 577|#line 1464 "bison_parser.y" /* yacc.c:1646 */ 5558| 577| { (yyval.join_type) = kJoinLeft; } 5559| 577|#line 5560 "bison_parser.cpp" /* yacc.c:1646 */ 5560| 577| break; 5561| | 5562| 151| case 345: ------------------ | Branch (5562:3): [True: 151, False: 17.3M] ------------------ 5563| 151|#line 1465 "bison_parser.y" /* yacc.c:1646 */ 5564| 151| { (yyval.join_type) = kJoinLeft; } 5565| 151|#line 5566 "bison_parser.cpp" /* yacc.c:1646 */ 5566| 151| break; 5567| | 5568| 66| case 346: ------------------ | Branch (5568:3): [True: 66, False: 17.3M] ------------------ 5569| 66|#line 1466 "bison_parser.y" /* yacc.c:1646 */ 5570| 66| { (yyval.join_type) = kJoinRight; } 5571| 66|#line 5572 "bison_parser.cpp" /* yacc.c:1646 */ 5572| 66| break; 5573| | 5574| 526| case 347: ------------------ | Branch (5574:3): [True: 526, False: 17.3M] ------------------ 5575| 526|#line 1467 "bison_parser.y" /* yacc.c:1646 */ 5576| 526| { (yyval.join_type) = kJoinRight; } 5577| 526|#line 5578 "bison_parser.cpp" /* yacc.c:1646 */ 5578| 526| break; 5579| | 5580| 66| case 348: ------------------ | Branch (5580:3): [True: 66, False: 17.3M] ------------------ 5581| 66|#line 1468 "bison_parser.y" /* yacc.c:1646 */ 5582| 66| { (yyval.join_type) = kJoinFull; } 5583| 66|#line 5584 "bison_parser.cpp" /* yacc.c:1646 */ 5584| 66| break; 5585| | 5586| 752| case 349: ------------------ | Branch (5586:3): [True: 752, False: 17.3M] ------------------ 5587| 752|#line 1469 "bison_parser.y" /* yacc.c:1646 */ 5588| 752| { (yyval.join_type) = kJoinFull; } 5589| 752|#line 5590 "bison_parser.cpp" /* yacc.c:1646 */ 5590| 752| break; 5591| | 5592| 522| case 350: ------------------ | Branch (5592:3): [True: 522, False: 17.3M] ------------------ 5593| 522|#line 1470 "bison_parser.y" /* yacc.c:1646 */ 5594| 522| { (yyval.join_type) = kJoinFull; } 5595| 522|#line 5596 "bison_parser.cpp" /* yacc.c:1646 */ 5596| 522| break; 5597| | 5598| 489| case 351: ------------------ | Branch (5598:3): [True: 489, False: 17.3M] ------------------ 5599| 489|#line 1471 "bison_parser.y" /* yacc.c:1646 */ 5600| 489| { (yyval.join_type) = kJoinCross; } 5601| 489|#line 5602 "bison_parser.cpp" /* yacc.c:1646 */ 5602| 489| break; 5603| | 5604| 108k| case 352: ------------------ | Branch (5604:3): [True: 108k, False: 17.2M] ------------------ 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.83k| case 356: ------------------ | Branch (5610:3): [True: 4.83k, False: 17.3M] ------------------ 5611| 4.83k|#line 1483 "bison_parser.y" /* yacc.c:1646 */ 5612| 4.83k| { 5613| 4.83k| (yyval.str_vec) = new std::vector(); 5614| 4.83k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5615| 4.83k|} 5616| 4.83k|#line 5617 "bison_parser.cpp" /* yacc.c:1646 */ 5617| 4.83k| break; 5618| | 5619| 18.1k| case 357: ------------------ | Branch (5619:3): [True: 18.1k, False: 17.3M] ------------------ 5620| 18.1k|#line 1487 "bison_parser.y" /* yacc.c:1646 */ 5621| 18.1k| { 5622| 18.1k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5623| 18.1k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5624| 18.1k|} 5625| 18.1k|#line 5626 "bison_parser.cpp" /* yacc.c:1646 */ 5626| 18.1k| break; 5627| | 5628| | 5629| 0|#line 5630 "bison_parser.cpp" /* yacc.c:1646 */ 5630| 7.91M| default: break; ------------------ | Branch (5630:7): [True: 7.91M, False: 9.46M] ------------------ 5631| 17.3M| } 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| 17.3M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 5644| | 5645| 17.3M| YYPOPSTACK (yylen); ------------------ | | 2956| 17.3M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5646| 17.3M| yylen = 0; 5647| 17.3M| YY_STACK_PRINT (yyss, yyssp); 5648| | 5649| 17.3M| *++yyvsp = yyval; 5650| 17.3M| *++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| 17.3M| yyn = yyr1[yyn]; 5657| | 5658| 17.3M| yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; ------------------ | | 711| 17.3M|#define YYNTOKENS 199 ------------------ 5659| 17.3M| if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) ------------------ | | 708| 25.9M|#define YYLAST 856 ------------------ | Branch (5659:7): [True: 8.53M, False: 8.85M] | Branch (5659:23): [True: 8.49M, False: 36.0k] | Branch (5659:44): [True: 4.09M, False: 4.40M] ------------------ 5660| 4.09M| yystate = yytable[yystate]; 5661| 13.2M| else 5662| 13.2M| yystate = yydefgoto[yyn - YYNTOKENS]; ------------------ | | 711| 13.2M|#define YYNTOKENS 199 ------------------ 5663| | 5664| 17.3M| goto yynewstate; 5665| | 5666| | 5667| |/*--------------------------------------. 5668| || yyerrlab -- here on detecting error. | 5669| |`--------------------------------------*/ 5670| 3.58k|yyerrlab: 5671| | /* Make sure we have latest lookahead translation. See comments at 5672| | user semantic actions for why this is necessary. */ 5673| 3.58k| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 3.58k|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 1453| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 725| 7.16k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.58k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.58k, False: 0] | | ------------------ ------------------ | Branch (5673:13): [True: 0, False: 3.58k] ------------------ 5674| | 5675| | /* If not already recovering from an error, report this error. */ 5676| 3.58k| if (!yyerrstatus) ------------------ | Branch (5676:7): [True: 3.58k, False: 0] ------------------ 5677| 3.58k| { 5678| 3.58k| ++yynerrs; ------------------ | | 69| 3.58k|#define yynerrs hsql_nerrs ------------------ 5679| |#if ! YYERROR_VERBOSE 5680| | yyerror (&yylloc, result, scanner, YY_("syntax error")); 5681| |#else 5682| 3.58k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 5683| 3.58k| yyssp, yytoken) 5684| 3.58k| { 5685| 3.58k| char const *yymsgp = YY_("syntax error"); ------------------ | | 517| 3.58k|# define YY_(Msgid) Msgid ------------------ 5686| 3.58k| int yysyntax_error_status; 5687| 3.58k| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 5682| 3.58k|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 5683| 3.58k| yyssp, yytoken) ------------------ 5688| 3.58k| if (yysyntax_error_status == 0) ------------------ | Branch (5688:13): [True: 3.58k, False: 0] ------------------ 5689| 3.58k| 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.58k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 67| 3.58k|#define yyerror hsql_error ------------------ 5708| 3.58k| if (yysyntax_error_status == 2) ------------------ | Branch (5708:13): [True: 0, False: 3.58k] ------------------ 5709| 0| goto yyexhaustedlab; 5710| 3.58k| } 5711| 3.58k|# undef YYSYNTAX_ERROR 5712| 3.58k|#endif 5713| 3.58k| } 5714| | 5715| 3.58k| yyerror_range[1] = yylloc; 5716| | 5717| 3.58k| if (yyerrstatus == 3) ------------------ | Branch (5717:7): [True: 0, False: 3.58k] ------------------ 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.58k| goto yyerrlab1; 5739| | 5740| | 5741| |/*---------------------------------------------------. 5742| || yyerrorlab -- error raised explicitly by YYERROR. | 5743| |`---------------------------------------------------*/ 5744| 3.58k|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| 732| if (/*CONSTCOND*/ 0) ------------------ | Branch (5749:21): [Folded, False: 732] ------------------ 5750| 0| goto yyerrorlab; 5751| | 5752| 732| yyerror_range[1] = yylsp[1-yylen]; 5753| | /* Do not reclaim the symbols of the rule whose action triggered 5754| | this YYERROR. */ 5755| 732| YYPOPSTACK (yylen); ------------------ | | 2956| 732|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5756| 732| yylen = 0; 5757| 732| YY_STACK_PRINT (yyss, yyssp); 5758| 732| yystate = *yyssp; 5759| 732| goto yyerrlab1; 5760| | 5761| | 5762| |/*-------------------------------------------------------------. 5763| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5764| |`-------------------------------------------------------------*/ 5765| 4.31k|yyerrlab1: 5766| 4.31k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5767| | 5768| 4.31k| for (;;) 5769| 54.6k| { 5770| 54.6k| yyn = yypact[yystate]; 5771| 54.6k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 54.6k| (!!((Yystate) == (-529))) ------------------ | Branch (5771:11): [True: 54.6k, False: 0] ------------------ 5772| 54.6k| { 5773| 54.6k| yyn += YYTERROR; ------------------ | | 1481| 54.6k|#define YYTERROR 1 ------------------ 5774| 54.6k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 708| 103k|#define YYLAST 856 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 1481| 48.3k|#define YYTERROR 1 ------------------ | Branch (5774:15): [True: 48.3k, False: 6.23k] | Branch (5774:27): [True: 48.3k, False: 0] | Branch (5774:44): [True: 0, False: 48.3k] ------------------ 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| 54.6k| } 5781| | 5782| | /* Pop the current state because it cannot handle the error token. */ 5783| 54.6k| if (yyssp == yyss) ------------------ | Branch (5783:11): [True: 4.31k, False: 50.3k] ------------------ 5784| 4.31k| YYABORT; ------------------ | | 1457| 4.31k|#define YYABORT goto yyabortlab ------------------ 5785| | 5786| 50.3k| yyerror_range[1] = *yylsp; 5787| 50.3k| yydestruct ("Error: popping", 5788| 50.3k| yystos[yystate], yyvsp, yylsp, result, scanner); 5789| 50.3k| YYPOPSTACK (1); ------------------ | | 2956| 50.3k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5790| 50.3k| yystate = *yyssp; 5791| 50.3k| YY_STACK_PRINT (yyss, yyssp); 5792| 50.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.74k|yyacceptlab: 5815| 1.74k| yyresult = 0; 5816| 1.74k| goto yyreturn; 5817| | 5818| |/*-----------------------------------. 5819| || yyabortlab -- YYABORT comes here. | 5820| |`-----------------------------------*/ 5821| 4.31k|yyabortlab: 5822| 4.31k| yyresult = 1; 5823| 4.31k| goto yyreturn; 5824| | 5825| 0|#if !defined yyoverflow || YYERROR_VERBOSE 5826| |/*-------------------------------------------------. 5827| || yyexhaustedlab -- memory exhaustion comes here. | 5828| |`-------------------------------------------------*/ 5829| 11|yyexhaustedlab: 5830| 11| yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 67| 11|#define yyerror hsql_error ------------------ yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 517| 11|# define YY_(Msgid) Msgid ------------------ 5831| 11| yyresult = 2; 5832| | /* Fall through. */ 5833| 11|#endif 5834| | 5835| 6.07k|yyreturn: 5836| 6.07k| if (yychar != YYEMPTY) ------------------ | | 1453| 6.07k|#define YYEMPTY (-2) ------------------ | Branch (5836:7): [True: 3.89k, False: 2.17k] ------------------ 5837| 3.89k| { 5838| | /* Make sure we have latest lookahead translation. See comments at 5839| | user semantic actions for why this is necessary. */ 5840| 3.89k| yytoken = YYTRANSLATE (yychar); ------------------ | | 725| 3.89k| ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 722| 3.89k|#define YYMAXUTOK 436 | | ------------------ | | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 721| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (725:4): [True: 3.89k, False: 0] | | ------------------ ------------------ 5841| 3.89k| yydestruct ("Cleanup: discarding lookahead", 5842| 3.89k| yytoken, &yylval, &yylloc, result, scanner); 5843| 3.89k| } 5844| | /* Do not reclaim the symbols of the rule whose action triggered 5845| | this YYABORT or YYACCEPT. */ 5846| 6.07k| YYPOPSTACK (yylen); ------------------ | | 2956| 6.07k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5847| 6.07k| YY_STACK_PRINT (yyss, yyssp); 5848| 11.7k| while (yyssp != yyss) ------------------ | Branch (5848:10): [True: 5.67k, False: 6.07k] ------------------ 5849| 5.67k| { 5850| 5.67k| yydestruct ("Cleanup: popping", 5851| 5.67k| yystos[*yyssp], yyvsp, yylsp, result, scanner); 5852| 5.67k| YYPOPSTACK (1); ------------------ | | 2956| 5.67k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5853| 5.67k| } 5854| 6.07k|#ifndef yyoverflow 5855| 6.07k| if (yyss != yyssa) ------------------ | Branch (5855:7): [True: 0, False: 6.07k] ------------------ 5856| 0| YYSTACK_FREE (yyss); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5857| 6.07k|#endif 5858| 6.07k|#if YYERROR_VERBOSE 5859| 6.07k| if (yymsg != yymsgbuf) ------------------ | Branch (5859:7): [True: 0, False: 6.07k] ------------------ 5860| 0| YYSTACK_FREE (yymsg); ------------------ | | 615| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 634| 0|# define YYFREE free | | ------------------ ------------------ 5861| 6.07k|#endif 5862| 6.07k| return yyresult; 5863| 11|} bison_parser.cpp:_ZL14yysyntax_errorPmPPcPsi: 1800| 3.58k|{ 1801| 3.58k| YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 496| 3.58k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 108| 3.58k|# define YY_NULLPTR nullptr ------------------ 1802| 3.58k| YYSIZE_T yysize = yysize0; ------------------ | | 496| 3.58k|# define YYSIZE_T __SIZE_TYPE__ ------------------ 1803| 3.58k| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1804| | /* Internationalized format string. */ 1805| 3.58k| const char *yyformat = YY_NULLPTR; ------------------ | | 108| 3.58k|# define YY_NULLPTR nullptr ------------------ 1806| | /* Arguments of yyformat. */ 1807| 3.58k| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1808| | /* Number of reported tokens (one for the "unexpected", one per 1809| | "expected"). */ 1810| 3.58k| 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.58k| if (yytoken != YYEMPTY) ------------------ | | 1453| 3.58k|#define YYEMPTY (-2) ------------------ | Branch (1835:7): [True: 3.58k, False: 0] ------------------ 1836| 3.58k| { 1837| 3.58k| int yyn = yypact[*yyssp]; 1838| 3.58k| yyarg[yycount++] = yytname[yytoken]; 1839| 3.58k| if (!yypact_value_is_default (yyn)) ------------------ | | 923| 3.58k| (!!((Yystate) == (-529))) ------------------ | Branch (1839:11): [True: 3.58k, False: 0] ------------------ 1840| 3.58k| { 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.58k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1844:26): [True: 962, False: 2.62k] ------------------ 1845| | /* Stay within bounds of both yycheck and yytname. */ 1846| 3.58k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 708| 3.58k|#define YYLAST 856 ------------------ 1847| 3.58k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.58k|#define YYNTOKENS 199 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 711| 3.48k|#define YYNTOKENS 199 ------------------ | Branch (1847:24): [True: 104, False: 3.48k] ------------------ 1848| 3.58k| int yyx; 1849| | 1850| 608k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1850:32): [True: 605k, False: 3.02k] ------------------ 1851| 605k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 1481| 614k|#define YYTERROR 1 ------------------ | Branch (1851:17): [True: 8.27k, False: 597k] | Branch (1851:46): [True: 8.27k, False: 0] ------------------ 1852| 8.27k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 928| 8.27k| (!!((Yytable_value) == (-355))) ------------------ | Branch (1852:20): [True: 8.17k, False: 96] ------------------ 1853| 8.17k| { 1854| 8.17k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1854:21): [True: 562, False: 7.61k] ------------------ 1855| 562| { 1856| 562| yycount = 1; 1857| 562| yysize = yysize0; 1858| 562| break; 1859| 562| } 1860| 7.61k| yyarg[yycount++] = yytname[yyx]; 1861| 7.61k| { 1862| 7.61k| YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 496| 7.61k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 108| 7.61k|# define YY_NULLPTR nullptr ------------------ 1863| 7.61k| if (! (yysize <= yysize1 ------------------ | Branch (1863:26): [True: 7.61k, False: 0] ------------------ 1864| 7.61k| && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 7.61k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 7.61k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1864:29): [True: 7.61k, False: 0] ------------------ 1865| 0| return 2; 1866| 7.61k| yysize = yysize1; 1867| 7.61k| } 1868| 7.61k| } 1869| 3.58k| } 1870| 3.58k| } 1871| | 1872| 3.58k| switch (yycount) ------------------ | Branch (1872:11): [True: 3.58k, False: 0] ------------------ 1873| 3.58k| { 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.58k] | | ------------------ | | 1876| 0| yyformat = S; \ | | 1877| 0| break ------------------ 1879| 562| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1875| 562| case N: \ | | ------------------ | | | Branch (1875:7): [True: 562, False: 3.02k] | | ------------------ | | 1876| 562| yyformat = S; \ | | 1877| 562| break ------------------ 1880| 1.11k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1875| 1.11k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.11k, False: 2.46k] | | ------------------ | | 1876| 1.11k| yyformat = S; \ | | 1877| 1.11k| break ------------------ 1881| 1.60k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1875| 1.60k| case N: \ | | ------------------ | | | Branch (1875:7): [True: 1.60k, False: 1.98k] | | ------------------ | | 1876| 1.60k| yyformat = S; \ | | 1877| 1.60k| break ------------------ 1882| 158| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1875| 158| case N: \ | | ------------------ | | | Branch (1875:7): [True: 158, False: 3.42k] | | ------------------ | | 1876| 158| yyformat = S; \ | | 1877| 158| break ------------------ 1883| 3.58k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1875| 142| case N: \ | | ------------------ | | | Branch (1875:7): [True: 142, False: 3.44k] | | ------------------ | | 1876| 142| yyformat = S; \ | | 1877| 142| break ------------------ 1884| 3.58k|# undef YYCASE_ 1885| 3.58k| } 1886| | 1887| 3.58k| { 1888| 3.58k| YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 496| 3.58k|# define YYSIZE_T __SIZE_TYPE__ ------------------ YYSIZE_T yysize1 = yysize + yystrlen (yyformat); ------------------ | | 1707| 3.58k|# define yystrlen strlen ------------------ 1889| 3.58k| if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 617| 3.58k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 507| 3.58k|#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) | | ------------------ ------------------ | Branch (1889:12): [True: 3.58k, False: 0] | Branch (1889:33): [True: 3.58k, False: 0] ------------------ 1890| 0| return 2; 1891| 3.58k| yysize = yysize1; 1892| 3.58k| } 1893| | 1894| 3.58k| if (*yymsg_alloc < yysize) ------------------ | Branch (1894:7): [True: 0, False: 3.58k] ------------------ 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.58k| { 1907| 3.58k| char *yyp = *yymsg; 1908| 3.58k| int yyi = 0; 1909| 147k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1909:12): [True: 144k, False: 3.58k] ------------------ 1910| 144k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1910:11): [True: 8.95k, False: 135k] | Branch (1910:26): [True: 8.95k, False: 0] | Branch (1910:48): [True: 8.95k, False: 0] ------------------ 1911| 8.95k| { 1912| 8.95k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1913| 8.95k| yyformat += 2; 1914| 8.95k| } 1915| 135k| else 1916| 135k| { 1917| 135k| yyp++; 1918| 135k| yyformat++; 1919| 135k| } 1920| 3.58k| } 1921| 3.58k| return 0; 1922| 3.58k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1751| 20.1k|{ 1752| 20.1k| if (*yystr == '"') ------------------ | Branch (1752:7): [True: 0, False: 20.1k] ------------------ 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| 20.1k| if (! yyres) ------------------ | Branch (1782:7): [True: 11.1k, False: 8.95k] ------------------ 1783| 11.1k| return yystrlen (yystr); ------------------ | | 1707| 11.1k|# define yystrlen strlen ------------------ 1784| | 1785| 8.95k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1723| 8.95k|# define yystpcpy stpcpy ------------------ 1786| 20.1k|} bison_parser.cpp:_ZL10yydestructPKciP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 1931| 59.8k|{ 1932| 59.8k| YYUSE (yyvaluep); ------------------ | | 550| 59.8k|# define YYUSE(E) ((void) (E)) ------------------ 1933| 59.8k| YYUSE (yylocationp); ------------------ | | 550| 59.8k|# define YYUSE(E) ((void) (E)) ------------------ 1934| 59.8k| YYUSE (result); ------------------ | | 550| 59.8k|# define YYUSE(E) ((void) (E)) ------------------ 1935| 59.8k| YYUSE (scanner); ------------------ | | 550| 59.8k|# define YYUSE(E) ((void) (E)) ------------------ 1936| 59.8k| if (!yymsg) ------------------ | Branch (1936:7): [True: 0, False: 59.8k] ------------------ 1937| 0| yymsg = "Deleting"; 1938| 59.8k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1939| | 1940| 59.8k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1941| 59.8k| switch (yytype) 1942| 59.8k| { 1943| 2.26k| case 3: /* IDENTIFIER */ ------------------ | Branch (1943:11): [True: 2.26k, False: 57.6k] ------------------ 1944| 2.26k|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1945| 2.26k| { free(((*yyvaluep).sval)); } 1946| 2.26k|#line 1947 "bison_parser.cpp" /* yacc.c:1257 */ 1947| 2.26k| break; 1948| | 1949| 14| case 4: /* STRING */ ------------------ | Branch (1949:5): [True: 14, False: 59.8k] ------------------ 1950| 14|#line 194 "bison_parser.y" /* yacc.c:1257 */ 1951| 14| { free(((*yyvaluep).sval)); } 1952| 14|#line 1953 "bison_parser.cpp" /* yacc.c:1257 */ 1953| 14| break; 1954| | 1955| 25| case 5: /* FLOATVAL */ ------------------ | Branch (1955:5): [True: 25, False: 59.8k] ------------------ 1956| 25|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1957| 25| { } 1958| 25|#line 1959 "bison_parser.cpp" /* yacc.c:1257 */ 1959| 25| break; 1960| | 1961| 48| case 6: /* INTVAL */ ------------------ | Branch (1961:5): [True: 48, False: 59.8k] ------------------ 1962| 48|#line 181 "bison_parser.y" /* yacc.c:1257 */ 1963| 48| { } 1964| 48|#line 1965 "bison_parser.cpp" /* yacc.c:1257 */ 1965| 48| break; 1966| | 1967| 522| case 201: /* statement_list */ ------------------ | Branch (1967:5): [True: 522, False: 59.3k] ------------------ 1968| 522|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1969| 522| { 1970| 522| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (1970:7): [True: 522, False: 0] ------------------ 1971| 43.1k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (1971:19): [True: 43.1k, False: 522] ------------------ 1972| 43.1k| delete ptr; 1973| 43.1k| } 1974| 522| } 1975| 522| delete (((*yyvaluep).stmt_vec)); 1976| 522|} 1977| 522|#line 1978 "bison_parser.cpp" /* yacc.c:1257 */ 1978| 522| break; 1979| | 1980| 0| case 202: /* statement */ ------------------ | Branch (1980:5): [True: 0, False: 59.8k] ------------------ 1981| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1982| 0| { delete (((*yyvaluep).statement)); } 1983| 0|#line 1984 "bison_parser.cpp" /* yacc.c:1257 */ 1984| 0| break; 1985| | 1986| 52| case 203: /* preparable_statement */ ------------------ | Branch (1986:5): [True: 52, False: 59.8k] ------------------ 1987| 52|#line 207 "bison_parser.y" /* yacc.c:1257 */ 1988| 52| { delete (((*yyvaluep).statement)); } 1989| 52|#line 1990 "bison_parser.cpp" /* yacc.c:1257 */ 1990| 52| break; 1991| | 1992| 0| case 204: /* opt_hints */ ------------------ | Branch (1992:5): [True: 0, False: 59.8k] ------------------ 1993| 0|#line 195 "bison_parser.y" /* yacc.c:1257 */ 1994| 0| { 1995| 0| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (1995:7): [True: 0, False: 0] ------------------ 1996| 0| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (1996:19): [True: 0, False: 0] ------------------ 1997| 0| delete ptr; 1998| 0| } 1999| 0| } 2000| 0| delete (((*yyvaluep).expr_vec)); 2001| 0|} 2002| 0|#line 2003 "bison_parser.cpp" /* yacc.c:1257 */ 2003| 0| break; 2004| | 2005| 38| case 205: /* hint_list */ ------------------ | Branch (2005:5): [True: 38, False: 59.8k] ------------------ 2006| 38|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2007| 38| { 2008| 38| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2008:7): [True: 38, False: 0] ------------------ 2009| 847| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2009:19): [True: 847, False: 38] ------------------ 2010| 847| delete ptr; 2011| 847| } 2012| 38| } 2013| 38| delete (((*yyvaluep).expr_vec)); 2014| 38|} 2015| 38|#line 2016 "bison_parser.cpp" /* yacc.c:1257 */ 2016| 38| break; 2017| | 2018| 0| case 206: /* hint */ ------------------ | Branch (2018:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 224| case 214: /* file_path */ ------------------ | Branch (2060:5): [True: 224, False: 59.6k] ------------------ 2061| 224|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2062| 224| { free(((*yyvaluep).sval)); } 2063| 224|#line 2064 "bison_parser.cpp" /* yacc.c:1257 */ 2064| 224| break; 2065| | 2066| 1| case 215: /* opt_import_export_options */ ------------------ | Branch (2066:5): [True: 1, False: 59.8k] ------------------ 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| 62| case 216: /* import_export_options */ ------------------ | Branch (2072:5): [True: 62, False: 59.8k] ------------------ 2073| 62|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2074| 62| { delete (((*yyvaluep).import_export_option_t)); } 2075| 62|#line 2076 "bison_parser.cpp" /* yacc.c:1257 */ 2076| 62| break; 2077| | 2078| 0| case 217: /* csv_option */ ------------------ | Branch (2078:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 663| case 221: /* opt_not_exists */ ------------------ | Branch (2105:5): [True: 663, False: 59.2k] ------------------ 2106| 663|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2107| 663| { } 2108| 663|#line 2109 "bison_parser.cpp" /* yacc.c:1257 */ 2109| 663| break; 2110| | 2111| 598| case 222: /* table_elem_commalist */ ------------------ | Branch (2111:5): [True: 598, False: 59.2k] ------------------ 2112| 598|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2113| 598| { 2114| 598| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2114:7): [True: 598, False: 0] ------------------ 2115| 32.3k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2115:19): [True: 32.3k, False: 598] ------------------ 2116| 32.3k| delete ptr; 2117| 32.3k| } 2118| 598| } 2119| 598| delete (((*yyvaluep).table_element_vec)); 2120| 598|} 2121| 598|#line 2122 "bison_parser.cpp" /* yacc.c:1257 */ 2122| 598| break; 2123| | 2124| 0| case 223: /* table_elem */ ------------------ | Branch (2124:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 2131| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2132| 0| { delete (((*yyvaluep).column_t)); } 2133| 0|#line 2134 "bison_parser.cpp" /* yacc.c:1257 */ 2134| 0| break; 2135| | 2136| 15| case 225: /* column_type */ ------------------ | Branch (2136:5): [True: 15, False: 59.8k] ------------------ 2137| 15|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2138| 15| { } 2139| 15|#line 2140 "bison_parser.cpp" /* yacc.c:1257 */ 2140| 15| break; 2141| | 2142| 0| case 226: /* opt_time_precision */ ------------------ | Branch (2142:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 2155| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2156| 0| { delete (((*yyvaluep).column_constraints_t)); } 2157| 0|#line 2158 "bison_parser.cpp" /* yacc.c:1257 */ 2158| 0| break; 2159| | 2160| 13| case 229: /* column_constraints */ ------------------ | Branch (2160:5): [True: 13, False: 59.8k] ------------------ 2161| 13|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2162| 13| { delete (((*yyvaluep).column_constraints_t)); } 2163| 13|#line 2164 "bison_parser.cpp" /* yacc.c:1257 */ 2164| 13| break; 2165| | 2166| 0| case 230: /* column_constraint */ ------------------ | Branch (2166:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 34| case 234: /* opt_exists */ ------------------ | Branch (2190:5): [True: 34, False: 59.8k] ------------------ 2191| 34|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2192| 34| { } 2193| 34|#line 2194 "bison_parser.cpp" /* yacc.c:1257 */ 2194| 34| break; 2195| | 2196| 0| case 235: /* alter_statement */ ------------------ | Branch (2196:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 35| case 241: /* opt_column_list */ ------------------ | Branch (2232:5): [True: 35, False: 59.8k] ------------------ 2233| 35|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2234| 35| { 2235| 35| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2235:7): [True: 15, False: 20] ------------------ 2236| 209| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2236:19): [True: 209, False: 15] ------------------ 2237| 209| free(ptr); 2238| 209| } 2239| 15| } 2240| 35| delete (((*yyvaluep).str_vec)); 2241| 35|} 2242| 35|#line 2243 "bison_parser.cpp" /* yacc.c:1257 */ 2243| 35| break; 2244| | 2245| 0| case 242: /* update_statement */ ------------------ | Branch (2245:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 389| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2255:19): [True: 389, False: 14] ------------------ 2256| 389| delete ptr; 2257| 389| } 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: 59.8k] ------------------ 2265| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2266| 0| { delete (((*yyvaluep).update_t)); } 2267| 0|#line 2268 "bison_parser.cpp" /* yacc.c:1257 */ 2268| 0| break; 2269| | 2270| 4| case 245: /* select_statement */ ------------------ | Branch (2270:5): [True: 4, False: 59.8k] ------------------ 2271| 4|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2272| 4| { delete (((*yyvaluep).select_stmt)); } 2273| 4|#line 2274 "bison_parser.cpp" /* yacc.c:1257 */ 2274| 4| break; 2275| | 2276| 66| case 246: /* select_within_set_operation */ ------------------ | Branch (2276:5): [True: 66, False: 59.8k] ------------------ 2277| 66|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2278| 66| { delete (((*yyvaluep).select_stmt)); } 2279| 66|#line 2280 "bison_parser.cpp" /* yacc.c:1257 */ 2280| 66| break; 2281| | 2282| 0| case 247: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2282:5): [True: 0, False: 59.8k] ------------------ 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| 39| case 248: /* select_with_paren */ ------------------ | Branch (2288:5): [True: 39, False: 59.8k] ------------------ 2289| 39|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2290| 39| { delete (((*yyvaluep).select_stmt)); } 2291| 39|#line 2292 "bison_parser.cpp" /* yacc.c:1257 */ 2292| 39| break; 2293| | 2294| 114| case 249: /* select_no_paren */ ------------------ | Branch (2294:5): [True: 114, False: 59.7k] ------------------ 2295| 114|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2296| 114| { delete (((*yyvaluep).select_stmt)); } 2297| 114|#line 2298 "bison_parser.cpp" /* yacc.c:1257 */ 2298| 114| break; 2299| | 2300| 1.09k| case 250: /* set_operator */ ------------------ | Branch (2300:5): [True: 1.09k, False: 58.7k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 2313| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2314| 0| { } 2315| 0|#line 2316 "bison_parser.cpp" /* yacc.c:1257 */ 2316| 0| break; 2317| | 2318| 1.78k| case 253: /* select_clause */ ------------------ | Branch (2318:5): [True: 1.78k, False: 58.0k] ------------------ 2319| 1.78k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2320| 1.78k| { delete (((*yyvaluep).select_stmt)); } 2321| 1.78k|#line 2322 "bison_parser.cpp" /* yacc.c:1257 */ 2322| 1.78k| break; 2323| | 2324| 3.54k| case 254: /* opt_distinct */ ------------------ | Branch (2324:5): [True: 3.54k, False: 56.3k] ------------------ 2325| 3.54k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2326| 3.54k| { } 2327| 3.54k|#line 2328 "bison_parser.cpp" /* yacc.c:1257 */ 2328| 3.54k| break; 2329| | 2330| 691| case 255: /* select_list */ ------------------ | Branch (2330:5): [True: 691, False: 59.1k] ------------------ 2331| 691|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2332| 691| { 2333| 691| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2333:7): [True: 691, False: 0] ------------------ 2334| 1.06k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2334:19): [True: 1.06k, False: 691] ------------------ 2335| 1.06k| delete ptr; 2336| 1.06k| } 2337| 691| } 2338| 691| delete (((*yyvaluep).expr_vec)); 2339| 691|} 2340| 691|#line 2341 "bison_parser.cpp" /* yacc.c:1257 */ 2341| 691| break; 2342| | 2343| 208| case 256: /* opt_from_clause */ ------------------ | Branch (2343:5): [True: 208, False: 59.6k] ------------------ 2344| 208|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2345| 208| { delete (((*yyvaluep).table)); } 2346| 208|#line 2347 "bison_parser.cpp" /* yacc.c:1257 */ 2347| 208| break; 2348| | 2349| 0| case 257: /* from_clause */ ------------------ | Branch (2349:5): [True: 0, False: 59.8k] ------------------ 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| 122| case 258: /* opt_where */ ------------------ | Branch (2355:5): [True: 122, False: 59.7k] ------------------ 2356| 122|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2357| 122| { delete (((*yyvaluep).expr)); } 2358| 122|#line 2359 "bison_parser.cpp" /* yacc.c:1257 */ 2359| 122| break; 2360| | 2361| 1| case 259: /* opt_group */ ------------------ | Branch (2361:5): [True: 1, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 583| case 261: /* opt_order */ ------------------ | Branch (2373:5): [True: 583, False: 59.2k] ------------------ 2374| 583|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2375| 583| { 2376| 583| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2376:7): [True: 81, False: 502] ------------------ 2377| 317| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2377:19): [True: 317, False: 81] ------------------ 2378| 317| delete ptr; 2379| 317| } 2380| 81| } 2381| 583| delete (((*yyvaluep).order_vec)); 2382| 583|} 2383| 583|#line 2384 "bison_parser.cpp" /* yacc.c:1257 */ 2384| 583| break; 2385| | 2386| 124| case 262: /* order_list */ ------------------ | Branch (2386:5): [True: 124, False: 59.7k] ------------------ 2387| 124|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2388| 124| { 2389| 124| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2389:7): [True: 124, False: 0] ------------------ 2390| 320k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2390:19): [True: 320k, False: 124] ------------------ 2391| 320k| delete ptr; 2392| 320k| } 2393| 124| } 2394| 124| delete (((*yyvaluep).order_vec)); 2395| 124|} 2396| 124|#line 2397 "bison_parser.cpp" /* yacc.c:1257 */ 2397| 124| break; 2398| | 2399| 0| case 263: /* order_desc */ ------------------ | Branch (2399:5): [True: 0, False: 59.8k] ------------------ 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| 147| case 264: /* opt_order_type */ ------------------ | Branch (2405:5): [True: 147, False: 59.7k] ------------------ 2406| 147|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2407| 147| { } 2408| 147|#line 2409 "bison_parser.cpp" /* yacc.c:1257 */ 2409| 147| break; 2410| | 2411| 2| case 265: /* opt_null_ordering */ ------------------ | Branch (2411:5): [True: 2, False: 59.8k] ------------------ 2412| 2|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2413| 2| { } 2414| 2|#line 2415 "bison_parser.cpp" /* yacc.c:1257 */ 2415| 2| break; 2416| | 2417| 2.29k| case 266: /* opt_top */ ------------------ | Branch (2417:5): [True: 2.29k, False: 57.5k] ------------------ 2418| 2.29k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2419| 2.29k| { delete (((*yyvaluep).limit)); } 2420| 2.29k|#line 2421 "bison_parser.cpp" /* yacc.c:1257 */ 2421| 2.29k| break; 2422| | 2423| 48| case 267: /* opt_limit */ ------------------ | Branch (2423:5): [True: 48, False: 59.8k] ------------------ 2424| 48|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2425| 48| { delete (((*yyvaluep).limit)); } 2426| 48|#line 2427 "bison_parser.cpp" /* yacc.c:1257 */ 2427| 48| break; 2428| | 2429| 625| case 268: /* expr_list */ ------------------ | Branch (2429:5): [True: 625, False: 59.2k] ------------------ 2430| 625|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2431| 625| { 2432| 625| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2432:7): [True: 625, False: 0] ------------------ 2433| 120k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2433:19): [True: 120k, False: 625] ------------------ 2434| 120k| delete ptr; 2435| 120k| } 2436| 625| } 2437| 625| delete (((*yyvaluep).expr_vec)); 2438| 625|} 2439| 625|#line 2440 "bison_parser.cpp" /* yacc.c:1257 */ 2440| 625| break; 2441| | 2442| 49| case 269: /* opt_extended_literal_list */ ------------------ | Branch (2442:5): [True: 49, False: 59.8k] ------------------ 2443| 49|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2444| 49| { 2445| 49| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2445:7): [True: 42, False: 7] ------------------ 2446| 917| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2446:19): [True: 917, False: 42] ------------------ 2447| 917| delete ptr; 2448| 917| } 2449| 42| } 2450| 49| delete (((*yyvaluep).expr_vec)); 2451| 49|} 2452| 49|#line 2453 "bison_parser.cpp" /* yacc.c:1257 */ 2453| 49| break; 2454| | 2455| 26| case 270: /* extended_literal_list */ ------------------ | Branch (2455:5): [True: 26, False: 59.8k] ------------------ 2456| 26|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2457| 26| { 2458| 26| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2458:7): [True: 26, False: 0] ------------------ 2459| 806| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2459:19): [True: 806, False: 26] ------------------ 2460| 806| delete ptr; 2461| 806| } 2462| 26| } 2463| 26| delete (((*yyvaluep).expr_vec)); 2464| 26|} 2465| 26|#line 2466 "bison_parser.cpp" /* yacc.c:1257 */ 2466| 26| break; 2467| | 2468| 0| case 271: /* casted_extended_literal */ ------------------ | Branch (2468:5): [True: 0, False: 59.8k] ------------------ 2469| 0|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2470| 0| { delete (((*yyvaluep).expr)); } 2471| 0|#line 2472 "bison_parser.cpp" /* yacc.c:1257 */ 2472| 0| break; 2473| | 2474| 1| case 272: /* extended_literal */ ------------------ | Branch (2474:5): [True: 1, False: 59.8k] ------------------ 2475| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2476| 1| { delete (((*yyvaluep).expr)); } 2477| 1|#line 2478 "bison_parser.cpp" /* yacc.c:1257 */ 2478| 1| break; 2479| | 2480| 0| case 273: /* expr_alias */ ------------------ | Branch (2480:5): [True: 0, False: 59.8k] ------------------ 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| 463| case 274: /* expr */ ------------------ | Branch (2486:5): [True: 463, False: 59.4k] ------------------ 2487| 463|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2488| 463| { delete (((*yyvaluep).expr)); } 2489| 463|#line 2490 "bison_parser.cpp" /* yacc.c:1257 */ 2490| 463| break; 2491| | 2492| 1.60k| case 275: /* operand */ ------------------ | Branch (2492:5): [True: 1.60k, False: 58.2k] ------------------ 2493| 1.60k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2494| 1.60k| { delete (((*yyvaluep).expr)); } 2495| 1.60k|#line 2496 "bison_parser.cpp" /* yacc.c:1257 */ 2496| 1.60k| break; 2497| | 2498| 0| case 276: /* scalar_expr */ ------------------ | Branch (2498:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 284| case 282: /* case_list */ ------------------ | Branch (2534:5): [True: 284, False: 59.5k] ------------------ 2535| 284|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2536| 284| { delete (((*yyvaluep).expr)); } 2537| 284|#line 2538 "bison_parser.cpp" /* yacc.c:1257 */ 2538| 284| break; 2539| | 2540| 0| case 283: /* exists_expr */ ------------------ | Branch (2540:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 198| case 287: /* opt_partition */ ------------------ | Branch (2564:5): [True: 198, False: 59.6k] ------------------ 2565| 198|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2566| 198| { 2567| 198| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2567:7): [True: 50, False: 148] ------------------ 2568| 267| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2568:19): [True: 267, False: 50] ------------------ 2569| 267| delete ptr; 2570| 267| } 2571| 50| } 2572| 198| delete (((*yyvaluep).expr_vec)); 2573| 198|} 2574| 198|#line 2575 "bison_parser.cpp" /* yacc.c:1257 */ 2575| 198| break; 2576| | 2577| 73| case 288: /* opt_frame_clause */ ------------------ | Branch (2577:5): [True: 73, False: 59.8k] ------------------ 2578| 73|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2579| 73| { delete (((*yyvaluep).frame_description)); } 2580| 73|#line 2581 "bison_parser.cpp" /* yacc.c:1257 */ 2581| 73| break; 2582| | 2583| 57| case 289: /* frame_type */ ------------------ | Branch (2583:5): [True: 57, False: 59.8k] ------------------ 2584| 57|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2585| 57| { } 2586| 57|#line 2587 "bison_parser.cpp" /* yacc.c:1257 */ 2587| 57| break; 2588| | 2589| 2| case 290: /* frame_bound */ ------------------ | Branch (2589:5): [True: 2, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 278| case 293: /* datetime_field */ ------------------ | Branch (2607:5): [True: 278, False: 59.5k] ------------------ 2608| 278|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2609| 278| { } 2610| 278|#line 2611 "bison_parser.cpp" /* yacc.c:1257 */ 2611| 278| break; 2612| | 2613| 0| case 294: /* datetime_field_plural */ ------------------ | Branch (2613:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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.34k| case 310: /* table_ref_atomic */ ------------------ | Branch (2709:5): [True: 2.34k, False: 57.5k] ------------------ 2710| 2.34k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2711| 2.34k| { delete (((*yyvaluep).table)); } 2712| 2.34k|#line 2713 "bison_parser.cpp" /* yacc.c:1257 */ 2713| 2.34k| break; 2714| | 2715| 0| case 311: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2715:5): [True: 0, False: 59.8k] ------------------ 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| 102| case 312: /* table_ref_commalist */ ------------------ | Branch (2721:5): [True: 102, False: 59.7k] ------------------ 2722| 102|#line 195 "bison_parser.y" /* yacc.c:1257 */ 2723| 102| { 2724| 102| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2724:7): [True: 102, False: 0] ------------------ 2725| 296k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2725:19): [True: 296k, False: 102] ------------------ 2726| 296k| delete ptr; 2727| 296k| } 2728| 102| } 2729| 102| delete (((*yyvaluep).table_vec)); 2730| 102|} 2731| 102|#line 2732 "bison_parser.cpp" /* yacc.c:1257 */ 2732| 102| break; 2733| | 2734| 0| case 313: /* table_ref_name */ ------------------ | Branch (2734:5): [True: 0, False: 59.8k] ------------------ 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| 32| case 314: /* table_ref_name_no_alias */ ------------------ | Branch (2740:5): [True: 32, False: 59.8k] ------------------ 2741| 32|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2742| 32| { delete (((*yyvaluep).table)); } 2743| 32|#line 2744 "bison_parser.cpp" /* yacc.c:1257 */ 2744| 32| break; 2745| | 2746| 935| case 315: /* table_name */ ------------------ | Branch (2746:5): [True: 935, False: 58.9k] ------------------ 2747| 935|#line 182 "bison_parser.y" /* yacc.c:1257 */ 2748| 935| { 2749| 935| free(((*yyvaluep).table_name).name); 2750| 935| free(((*yyvaluep).table_name).schema); 2751| 935|} 2752| 935|#line 2753 "bison_parser.cpp" /* yacc.c:1257 */ 2753| 935| break; 2754| | 2755| 18| case 316: /* opt_index_name */ ------------------ | Branch (2755:5): [True: 18, False: 59.8k] ------------------ 2756| 18|#line 194 "bison_parser.y" /* yacc.c:1257 */ 2757| 18| { free(((*yyvaluep).sval)); } 2758| 18|#line 2759 "bison_parser.cpp" /* yacc.c:1257 */ 2759| 18| break; 2760| | 2761| 0| case 317: /* table_alias */ ------------------ | Branch (2761:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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: 59.8k] ------------------ 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| 1| case 320: /* opt_alias */ ------------------ | Branch (2779:5): [True: 1, False: 59.8k] ------------------ 2780| 1|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2781| 1| { delete (((*yyvaluep).alias_t)); } 2782| 1|#line 2783 "bison_parser.cpp" /* yacc.c:1257 */ 2783| 1| break; 2784| | 2785| 0| case 321: /* opt_locking_clause */ ------------------ | Branch (2785:5): [True: 0, False: 59.8k] ------------------ 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| 27| case 322: /* opt_locking_clause_list */ ------------------ | Branch (2791:5): [True: 27, False: 59.8k] ------------------ 2792| 27|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2793| 27| { delete (((*yyvaluep).locking_clause_vec)); } 2794| 27|#line 2795 "bison_parser.cpp" /* yacc.c:1257 */ 2795| 27| break; 2796| | 2797| 0| case 323: /* locking_clause */ ------------------ | Branch (2797:5): [True: 0, False: 59.8k] ------------------ 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| 9| case 324: /* row_lock_mode */ ------------------ | Branch (2803:5): [True: 9, False: 59.8k] ------------------ 2804| 9|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2805| 9| { } 2806| 9|#line 2807 "bison_parser.cpp" /* yacc.c:1257 */ 2807| 9| break; 2808| | 2809| 0| case 325: /* opt_row_lock_policy */ ------------------ | Branch (2809:5): [True: 0, False: 59.8k] ------------------ 2810| 0|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2811| 0| { } 2812| 0|#line 2813 "bison_parser.cpp" /* yacc.c:1257 */ 2813| 0| break; 2814| | 2815| 2.82k| case 326: /* opt_with_clause */ ------------------ | Branch (2815:5): [True: 2.82k, False: 57.0k] ------------------ 2816| 2.82k|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2817| 2.82k| { delete (((*yyvaluep).with_description_vec)); } 2818| 2.82k|#line 2819 "bison_parser.cpp" /* yacc.c:1257 */ 2819| 2.82k| break; 2820| | 2821| 0| case 327: /* with_clause */ ------------------ | Branch (2821:5): [True: 0, False: 59.8k] ------------------ 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| 34| case 328: /* with_description_list */ ------------------ | Branch (2827:5): [True: 34, False: 59.8k] ------------------ 2828| 34|#line 207 "bison_parser.y" /* yacc.c:1257 */ 2829| 34| { delete (((*yyvaluep).with_description_vec)); } 2830| 34|#line 2831 "bison_parser.cpp" /* yacc.c:1257 */ 2831| 34| break; 2832| | 2833| 0| case 329: /* with_description */ ------------------ | Branch (2833:5): [True: 0, False: 59.8k] ------------------ 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: 59.8k] ------------------ 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.31k| case 331: /* opt_join_type */ ------------------ | Branch (2845:5): [True: 2.31k, False: 57.5k] ------------------ 2846| 2.31k|#line 181 "bison_parser.y" /* yacc.c:1257 */ 2847| 2.31k| { } 2848| 2.31k|#line 2849 "bison_parser.cpp" /* yacc.c:1257 */ 2849| 2.31k| break; 2850| | 2851| 0| case 332: /* join_condition */ ------------------ | Branch (2851:5): [True: 0, False: 59.8k] ------------------ 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| 33| case 334: /* ident_commalist */ ------------------ | Branch (2857:5): [True: 33, False: 59.8k] ------------------ 2858| 33|#line 186 "bison_parser.y" /* yacc.c:1257 */ 2859| 33| { 2860| 33| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2860:7): [True: 33, False: 0] ------------------ 2861| 15.8k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2861:19): [True: 15.8k, False: 33] ------------------ 2862| 15.8k| free(ptr); 2863| 15.8k| } 2864| 33| } 2865| 33| delete (((*yyvaluep).str_vec)); 2866| 33|} 2867| 33|#line 2868 "bison_parser.cpp" /* yacc.c:1257 */ 2868| 33| break; 2869| | 2870| | 2871| 32.0k| default: ------------------ | Branch (2871:7): [True: 32.0k, False: 27.8k] ------------------ 2872| 32.0k| break; 2873| 59.8k| } 2874| 59.8k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2875| 59.8k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3152| 5.77M|{ 3153| 5.77M| yy_state_type yy_current_state; 3154| 5.77M| char *yy_cp, *yy_bp; 3155| 5.77M| int yy_act; 3156| 5.77M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3157| | 3158| 5.77M| yylval = yylval_param; ------------------ | | 2964| 5.77M| # define yylval yyg->yylval_r ------------------ 3159| | 3160| 5.77M| yylloc = yylloc_param; ------------------ | | 2966| 5.77M| # define yylloc yyg->yylloc_r ------------------ 3161| | 3162| 5.77M| if ( !yyg->yy_init ) ------------------ | Branch (3162:7): [True: 6.07k, False: 5.76M] ------------------ 3163| 6.07k| { 3164| 6.07k| yyg->yy_init = 1; 3165| | 3166| |#ifdef YY_USER_INIT 3167| | YY_USER_INIT; 3168| |#endif 3169| | 3170| 6.07k| if ( ! yyg->yy_start ) ------------------ | Branch (3170:8): [True: 6.07k, False: 0] ------------------ 3171| 6.07k| yyg->yy_start = 1; /* first start state */ 3172| | 3173| 6.07k| if ( ! yyin ) ------------------ | | 118| 6.07k|#define yyin yyg->yyin_r ------------------ | Branch (3173:8): [True: 6.07k, False: 0] ------------------ 3174| 6.07k| yyin = stdin; ------------------ | | 118| 6.07k|#define yyin yyg->yyin_r ------------------ 3175| | 3176| 6.07k| if ( ! yyout ) ------------------ | | 119| 6.07k|#define yyout yyg->yyout_r ------------------ | Branch (3176:8): [True: 6.07k, False: 0] ------------------ 3177| 6.07k| yyout = stdout; ------------------ | | 119| 6.07k|#define yyout yyg->yyout_r ------------------ 3178| | 3179| 6.07k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 269| 6.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 6.07k, False: 0] | | ------------------ | | 270| 6.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 6.07k| : NULL) ------------------ | Branch (3179:8): [True: 0, False: 6.07k] ------------------ 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| 6.07k| hsql__load_buffer_state(yyscanner ); 3186| 6.07k| } 3187| | 3188| 5.77M| { 3189| 5.77M|#line 57 "flex_lexer.l" 3190| | 3191| | 3192| 5.77M|#line 3193 "flex_lexer.cpp" 3193| | 3194| 6.25M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3194:23): [True: 6.25M, Folded] ------------------ 3195| 6.25M| { 3196| 6.25M| yy_cp = yyg->yy_c_buf_p; 3197| | 3198| | /* Support of yytext. */ 3199| 6.25M| *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| 6.25M| yy_bp = yy_cp; 3205| | 3206| 6.25M| yy_current_state = yyg->yy_start; 3207| 6.25M|yy_match: 3208| 6.25M| do 3209| 29.2M| { 3210| 29.2M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 108| 29.2M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ 3211| 29.2M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3211:9): [True: 16.7M, False: 12.5M] ------------------ 3212| 16.7M| { 3213| 16.7M| yyg->yy_last_accepting_state = yy_current_state; 3214| 16.7M| yyg->yy_last_accepting_cpos = yy_cp; 3215| 16.7M| } 3216| 52.6M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3216:12): [True: 23.3M, False: 29.2M] ------------------ 3217| 23.3M| { 3218| 23.3M| yy_current_state = (int) yy_def[yy_current_state]; 3219| 23.3M| if ( yy_current_state >= 1368 ) ------------------ | Branch (3219:10): [True: 17.0M, False: 6.25M] ------------------ 3220| 17.0M| yy_c = yy_meta[(unsigned int) yy_c]; 3221| 23.3M| } 3222| 29.2M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 3223| 29.2M| ++yy_cp; 3224| 29.2M| } 3225| 29.2M| while ( yy_current_state != 1367 ); ------------------ | Branch (3225:11): [True: 23.0M, False: 6.25M] ------------------ 3226| 6.25M| yy_cp = yyg->yy_last_accepting_cpos; 3227| 6.25M| yy_current_state = yyg->yy_last_accepting_state; 3228| | 3229| 6.25M|yy_find_action: 3230| 6.25M| yy_act = yy_accept[yy_current_state]; 3231| | 3232| 6.25M| YY_DO_BEFORE_ACTION; ------------------ | | 344| 6.25M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 333| 6.25M|#define yytext_ptr yytext_r | | ------------------ | | 345| 6.25M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 121| 6.25M|#define yyleng yyg->yyleng_r | | ------------------ | | 346| 6.25M| yyg->yy_hold_char = *yy_cp; \ | | 347| 6.25M| *yy_cp = '\0'; \ | | 348| 6.25M| yyg->yy_c_buf_p = yy_cp; ------------------ 3233| | 3234| 6.26M|do_action: /* This label is used only to access EOF actions. */ 3235| | 3236| 6.26M| switch ( yy_act ) 3237| 6.26M| { /* beginning of action switch */ 3238| 25| case 0: /* must back up */ ------------------ | Branch (3238:4): [True: 25, False: 6.26M] ------------------ 3239| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3240| 25| *yy_cp = yyg->yy_hold_char; 3241| 25| yy_cp = yyg->yy_last_accepting_cpos; 3242| 25| yy_current_state = yyg->yy_last_accepting_state; 3243| 25| goto yy_find_action; 3244| | 3245| 2.58k|case 1: ------------------ | Branch (3245:1): [True: 2.58k, False: 6.25M] ------------------ 3246| 2.58k|YY_RULE_SETUP ------------------ | | 3147| 2.58k| YY_USER_ACTION | | ------------------ | | | | 61| 2.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.17k, False: 2.58k] | | | | ------------------ | | | | 64| 5.17k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.17k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.17k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.17k| } else { \ | | | | 70| 5.17k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.17k| } \ | | | | 72| 5.17k| } | | ------------------ ------------------ 3247| 2.58k|#line 59 "flex_lexer.l" 3248| 2.58k|BEGIN(COMMENT); ------------------ | | 131| 2.58k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 2908| 2.58k|#define COMMENT 2 ------------------ 3249| 2.58k| YY_BREAK ------------------ | | 3143| 2.58k|#define YY_BREAK /*LINTED*/break; ------------------ 3250| 2.37k|case 2: ------------------ | Branch (3250:1): [True: 2.37k, False: 6.25M] ------------------ 3251| 2.37k|YY_RULE_SETUP ------------------ | | 3147| 2.37k| YY_USER_ACTION | | ------------------ | | | | 61| 2.37k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.37k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 134k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 134k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 131k, False: 2.37k] | | | | ------------------ | | | | 64| 131k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 131k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 131k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 131k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 131k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 131k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 131k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 131k| } else { \ | | | | 70| 131k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 131k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 131k| } \ | | | | 72| 131k| } | | ------------------ ------------------ 3252| 2.37k|#line 60 "flex_lexer.l" 3253| 2.37k|/* skipping comment content until a end of line is read */; 3254| 2.37k| YY_BREAK ------------------ | | 3143| 2.37k|#define YY_BREAK /*LINTED*/break; ------------------ 3255| 2.46k|case 3: ------------------ | Branch (3255:1): [True: 2.46k, False: 6.25M] ------------------ 3256| |/* rule 3 can match eol */ 3257| 2.46k|YY_RULE_SETUP ------------------ | | 3147| 2.46k| YY_USER_ACTION | | ------------------ | | | | 61| 2.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.46k, False: 2.46k] | | | | ------------------ | | | | 64| 2.46k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.46k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.46k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 2.46k, False: 0] | | | | ------------------ | | | | 67| 2.46k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.46k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 2.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.46k| } else { \ | | | | 70| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| } \ | | | | 72| 2.46k| } | | ------------------ ------------------ 3258| 2.46k|#line 61 "flex_lexer.l" 3259| 2.46k|BEGIN(INITIAL); ------------------ | | 131| 2.46k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 2906| 2.46k|#define INITIAL 0 ------------------ 3260| 2.46k| YY_BREAK ------------------ | | 3143| 2.46k|#define YY_BREAK /*LINTED*/break; ------------------ 3261| 436k|case 4: ------------------ | Branch (3261:1): [True: 436k, False: 5.82M] ------------------ 3262| |/* rule 4 can match eol */ 3263| 436k|YY_RULE_SETUP ------------------ | | 3147| 436k| YY_USER_ACTION | | ------------------ | | | | 61| 436k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 436k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 436k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 436k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 436k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 436k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 880k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 880k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 444k, False: 436k] | | | | ------------------ | | | | 64| 444k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 444k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 444k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 444k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 444k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 444k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 205k, False: 239k] | | | | ------------------ | | | | 67| 205k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 205k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 205k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 205k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 239k| } else { \ | | | | 70| 239k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 239k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 239k| } \ | | | | 72| 444k| } | | ------------------ ------------------ 3264| 436k|#line 63 "flex_lexer.l" 3265| 436k|/* skip whitespace */; 3266| 436k| YY_BREAK ------------------ | | 3143| 436k|#define YY_BREAK /*LINTED*/break; ------------------ 3267| 3|case 5: ------------------ | Branch (3267:1): [True: 3, False: 6.26M] ------------------ 3268| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9, False: 3] | | | | ------------------ | | | | 64| 9| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 9| } else { \ | | | | 70| 9| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9| } \ | | | | 72| 9| } | | ------------------ ------------------ 3269| 3|#line 65 "flex_lexer.l" 3270| 3|TOKEN(ADD) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3271| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3272| 1|case 6: ------------------ | Branch (3272:1): [True: 1, False: 6.26M] ------------------ 3273| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5, False: 1] | | | | ------------------ | | | | 64| 5| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5| } else { \ | | | | 70| 5| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5| } \ | | | | 72| 5| } | | ------------------ ------------------ 3274| 1|#line 66 "flex_lexer.l" 3275| 1|TOKEN(AFTER) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3276| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3277| 1.69k|case 7: ------------------ | Branch (3277:1): [True: 1.69k, False: 6.25M] ------------------ 3278| 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| 6.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.08k, False: 1.69k] | | | | ------------------ | | | | 64| 5.08k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.08k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.08k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.08k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.08k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.08k| } else { \ | | | | 70| 5.08k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.08k| } \ | | | | 72| 5.08k| } | | ------------------ ------------------ 3279| 1.69k|#line 67 "flex_lexer.l" 3280| 1.69k|TOKEN(ALL) ------------------ | | 2887| 1.69k|#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: 6.26M] ------------------ 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: 6.26M] ------------------ 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.52k|case 10: ------------------ | Branch (3292:1): [True: 1.52k, False: 6.25M] ------------------ 3293| 1.52k|YY_RULE_SETUP ------------------ | | 3147| 1.52k| YY_USER_ACTION | | ------------------ | | | | 61| 1.52k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.52k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.11k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.58k, False: 1.52k] | | | | ------------------ | | | | 64| 4.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.58k| } else { \ | | | | 70| 4.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.58k| } \ | | | | 72| 4.58k| } | | ------------------ ------------------ 3294| 1.52k|#line 70 "flex_lexer.l" 3295| 1.52k|TOKEN(AND) ------------------ | | 2887| 1.52k|#define TOKEN(name) { return SQL_##name; } ------------------ 3296| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3297| 888|case 11: ------------------ | Branch (3297:1): [True: 888, False: 6.26M] ------------------ 3298| 888|YY_RULE_SETUP ------------------ | | 3147| 888| YY_USER_ACTION | | ------------------ | | | | 61| 888| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 888| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 888| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 888| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 888| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 888| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.32k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.44k, False: 888] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3299| 888|#line 71 "flex_lexer.l" 3300| 888|TOKEN(ARRAY) ------------------ | | 2887| 888|#define TOKEN(name) { return SQL_##name; } ------------------ 3301| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3302| 5.09k|case 12: ------------------ | Branch (3302:1): [True: 5.09k, False: 6.25M] ------------------ 3303| 5.09k|YY_RULE_SETUP ------------------ | | 3147| 5.09k| YY_USER_ACTION | | ------------------ | | | | 61| 5.09k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.09k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.1k, False: 5.09k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3304| 5.09k|#line 72 "flex_lexer.l" 3305| 5.09k|TOKEN(AS) ------------------ | | 2887| 5.09k|#define TOKEN(name) { return SQL_##name; } ------------------ 3306| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3307| 619|case 13: ------------------ | Branch (3307:1): [True: 619, False: 6.26M] ------------------ 3308| 619|YY_RULE_SETUP ------------------ | | 3147| 619| YY_USER_ACTION | | ------------------ | | | | 61| 619| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 619| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.47k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.85k, False: 619] | | | | ------------------ | | | | 64| 1.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.85k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.85k| } else { \ | | | | 70| 1.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.85k| } \ | | | | 72| 1.85k| } | | ------------------ ------------------ 3309| 619|#line 73 "flex_lexer.l" 3310| 619|TOKEN(ASC) ------------------ | | 2887| 619|#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: 6.26M] ------------------ 3313| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6, False: 1] | | | | ------------------ | | | | 64| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6| } else { \ | | | | 70| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| } \ | | | | 72| 6| } | | ------------------ ------------------ 3314| 1|#line 74 "flex_lexer.l" 3315| 1|TOKEN(BEFORE) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3316| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3317| 6.46k|case 15: ------------------ | Branch (3317:1): [True: 6.46k, False: 6.25M] ------------------ 3318| 6.46k|YY_RULE_SETUP ------------------ | | 3147| 6.46k| YY_USER_ACTION | | ------------------ | | | | 61| 6.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 38.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 38.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 32.3k, False: 6.46k] | | | | ------------------ | | | | 64| 32.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 32.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 32.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 32.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 32.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 32.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 32.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| 32.3k| } else { \ | | | | 70| 32.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 32.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 32.3k| } \ | | | | 72| 32.3k| } | | ------------------ ------------------ 3319| 6.46k|#line 75 "flex_lexer.l" 3320| 6.46k|TOKEN(BEGIN) ------------------ | | 2887| 6.46k|#define TOKEN(name) { return SQL_##name; } ------------------ 3321| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3322| 890|case 16: ------------------ | Branch (3322:1): [True: 890, False: 6.26M] ------------------ 3323| 890|YY_RULE_SETUP ------------------ | | 3147| 890| YY_USER_ACTION | | ------------------ | | | | 61| 890| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 890| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 890| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 890| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 890| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 890| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.23k, False: 890] | | | | ------------------ | | | | 64| 6.23k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.23k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.23k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.23k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.23k] | | | | ------------------ | | | | 67| 0| 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.23k| } else { \ | | | | 70| 6.23k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.23k| } \ | | | | 72| 6.23k| } | | ------------------ ------------------ 3324| 890|#line 76 "flex_lexer.l" 3325| 890|TOKEN(BETWEEN) ------------------ | | 2887| 890|#define TOKEN(name) { return SQL_##name; } ------------------ 3326| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3327| 572|case 17: ------------------ | Branch (3327:1): [True: 572, False: 6.26M] ------------------ 3328| 572|YY_RULE_SETUP ------------------ | | 3147| 572| YY_USER_ACTION | | ------------------ | | | | 61| 572| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 572| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 572| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.43k, False: 572] | | | | ------------------ | | | | 64| 3.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.43k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.43k| } else { \ | | | | 70| 3.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.43k| } \ | | | | 72| 3.43k| } | | ------------------ ------------------ 3329| 572|#line 77 "flex_lexer.l" 3330| 572|TOKEN(BIGINT) ------------------ | | 2887| 572|#define TOKEN(name) { return SQL_##name; } ------------------ 3331| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3332| 638|case 18: ------------------ | Branch (3332:1): [True: 638, False: 6.26M] ------------------ 3333| 638|YY_RULE_SETUP ------------------ | | 3147| 638| YY_USER_ACTION | | ------------------ | | | | 61| 638| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 638| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 638| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 638| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 638| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 638| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.10k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.46k, False: 638] | | | | ------------------ | | | | 64| 4.46k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.46k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.46k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.46k] | | | | ------------------ | | | | 67| 0| 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.46k| } else { \ | | | | 70| 4.46k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.46k| } \ | | | | 72| 4.46k| } | | ------------------ ------------------ 3334| 638|#line 78 "flex_lexer.l" 3335| 638|TOKEN(BOOLEAN) ------------------ | | 2887| 638|#define TOKEN(name) { return SQL_##name; } ------------------ 3336| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3337| 6.93k|case 19: ------------------ | Branch (3337:1): [True: 6.93k, False: 6.25M] ------------------ 3338| 6.93k|YY_RULE_SETUP ------------------ | | 3147| 6.93k| YY_USER_ACTION | | ------------------ | | | | 61| 6.93k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.93k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.8k, False: 6.93k] | | | | ------------------ | | | | 64| 13.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.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| 13.8k| } else { \ | | | | 70| 13.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.8k| } \ | | | | 72| 13.8k| } | | ------------------ ------------------ 3339| 6.93k|#line 79 "flex_lexer.l" 3340| 6.93k|TOKEN(BY) ------------------ | | 2887| 6.93k|#define TOKEN(name) { return SQL_##name; } ------------------ 3341| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3342| 2|case 20: ------------------ | Branch (3342:1): [True: 2, False: 6.26M] ------------------ 3343| 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| } | | ------------------ ------------------ 3344| 2|#line 80 "flex_lexer.l" 3345| 2|TOKEN(CALL) ------------------ | | 2887| 2|#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: 6.26M] ------------------ 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.34k|case 22: ------------------ | Branch (3352:1): [True: 2.34k, False: 6.25M] ------------------ 3353| 2.34k|YY_RULE_SETUP ------------------ | | 3147| 2.34k| YY_USER_ACTION | | ------------------ | | | | 61| 2.34k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.34k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.38k, False: 2.34k] | | | | ------------------ | | | | 64| 9.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.38k| } else { \ | | | | 70| 9.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.38k| } \ | | | | 72| 9.38k| } | | ------------------ ------------------ 3354| 2.34k|#line 82 "flex_lexer.l" 3355| 2.34k|TOKEN(CASE) ------------------ | | 2887| 2.34k|#define TOKEN(name) { return SQL_##name; } ------------------ 3356| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3357| 775|case 23: ------------------ | Branch (3357:1): [True: 775, False: 6.26M] ------------------ 3358| 775|YY_RULE_SETUP ------------------ | | 3147| 775| YY_USER_ACTION | | ------------------ | | | | 61| 775| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 775| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.87k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.10k, False: 775] | | | | ------------------ | | | | 64| 3.10k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.10k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.10k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.10k| } else { \ | | | | 70| 3.10k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.10k| } \ | | | | 72| 3.10k| } | | ------------------ ------------------ 3359| 775|#line 83 "flex_lexer.l" 3360| 775|TOKEN(CAST) ------------------ | | 2887| 775|#define TOKEN(name) { return SQL_##name; } ------------------ 3361| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3362| 549|case 24: ------------------ | Branch (3362:1): [True: 549, False: 6.26M] ------------------ 3363| 549|YY_RULE_SETUP ------------------ | | 3147| 549| YY_USER_ACTION | | ------------------ | | | | 61| 549| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 549| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 549| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 549| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 549| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 549| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.74k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.19k, False: 549] | | | | ------------------ | | | | 64| 2.19k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.19k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.19k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.19k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.19k| } else { \ | | | | 70| 2.19k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.19k| } \ | | | | 72| 2.19k| } | | ------------------ ------------------ 3364| 549|#line 84 "flex_lexer.l" 3365| 549|TOKEN(CHAR) ------------------ | | 2887| 549|#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: 6.26M] ------------------ 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.31k|case 26: ------------------ | Branch (3372:1): [True: 1.31k, False: 6.26M] ------------------ 3373| 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| 10.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 9.17k, False: 1.31k] | | | | ------------------ | | | | 64| 9.17k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 9.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 9.17k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 9.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 9.17k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 9.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 9.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| 9.17k| } else { \ | | | | 70| 9.17k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 9.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.17k| } \ | | | | 72| 9.17k| } | | ------------------ ------------------ 3374| 1.31k|#line 86 "flex_lexer.l" 3375| 1.31k|TOKEN(COLUMNS) ------------------ | | 2887| 1.31k|#define TOKEN(name) { return SQL_##name; } ------------------ 3376| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3377| 760|case 27: ------------------ | Branch (3377:1): [True: 760, False: 6.26M] ------------------ 3378| 760|YY_RULE_SETUP ------------------ | | 3147| 760| YY_USER_ACTION | | ------------------ | | | | 61| 760| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 760| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 760| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 760| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 760| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 760| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.32k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.56k, False: 760] | | | | ------------------ | | | | 64| 4.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.56k| } else { \ | | | | 70| 4.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.56k| } \ | | | | 72| 4.56k| } | | ------------------ ------------------ 3379| 760|#line 87 "flex_lexer.l" 3380| 760|TOKEN(COMMIT) ------------------ | | 2887| 760|#define TOKEN(name) { return SQL_##name; } ------------------ 3381| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3382| 2|case 28: ------------------ | Branch (3382:1): [True: 2, False: 6.26M] ------------------ 3383| 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| } | | ------------------ ------------------ 3384| 2|#line 88 "flex_lexer.l" 3385| 2|TOKEN(CONTROL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3386| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3387| 9.99k|case 29: ------------------ | Branch (3387:1): [True: 9.99k, False: 6.25M] ------------------ 3388| 9.99k|YY_RULE_SETUP ------------------ | | 3147| 9.99k| YY_USER_ACTION | | ------------------ | | | | 61| 9.99k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 9.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 9.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 9.99k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 9.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 9.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 49.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 49.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 39.9k, False: 9.99k] | | | | ------------------ | | | | 64| 39.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 39.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 39.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 39.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 39.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| 39.9k| } else { \ | | | | 70| 39.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 39.9k| } \ | | | | 72| 39.9k| } | | ------------------ ------------------ 3389| 9.99k|#line 89 "flex_lexer.l" 3390| 9.99k|TOKEN(COPY) ------------------ | | 2887| 9.99k|#define TOKEN(name) { return SQL_##name; } ------------------ 3391| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3392| 5.18k|case 30: ------------------ | Branch (3392:1): [True: 5.18k, False: 6.25M] ------------------ 3393| 5.18k|YY_RULE_SETUP ------------------ | | 3147| 5.18k| YY_USER_ACTION | | ------------------ | | | | 61| 5.18k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.18k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 36.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 36.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 31.1k, False: 5.18k] | | | | ------------------ | | | | 64| 31.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 31.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 31.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 31.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 31.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 31.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 31.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| 31.1k| } else { \ | | | | 70| 31.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 31.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 31.1k| } \ | | | | 72| 31.1k| } | | ------------------ ------------------ 3394| 5.18k|#line 90 "flex_lexer.l" 3395| 5.18k|TOKEN(CREATE) ------------------ | | 2887| 5.18k|#define TOKEN(name) { return SQL_##name; } ------------------ 3396| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3397| 495|case 31: ------------------ | Branch (3397:1): [True: 495, False: 6.26M] ------------------ 3398| 495|YY_RULE_SETUP ------------------ | | 3147| 495| YY_USER_ACTION | | ------------------ | | | | 61| 495| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 495| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 495| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 495| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 495| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 495| # 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.47k, False: 495] | | | | ------------------ | | | | 64| 2.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.47k| } else { \ | | | | 70| 2.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.47k| } \ | | | | 72| 2.47k| } | | ------------------ ------------------ 3399| 495|#line 91 "flex_lexer.l" 3400| 495|TOKEN(CROSS) ------------------ | | 2887| 495|#define TOKEN(name) { return SQL_##name; } ------------------ 3401| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3402| 1.90k|case 32: ------------------ | Branch (3402:1): [True: 1.90k, False: 6.25M] ------------------ 3403| 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| 9.53k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.62k, False: 1.90k] | | | | ------------------ | | | | 64| 7.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.62k| } else { \ | | | | 70| 7.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.62k| } \ | | | | 72| 7.62k| } | | ------------------ ------------------ 3404| 1.90k|#line 92 "flex_lexer.l" 3405| 1.90k|TOKEN(DATE) ------------------ | | 2887| 1.90k|#define TOKEN(name) { return SQL_##name; } ------------------ 3406| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3407| 559|case 33: ------------------ | Branch (3407:1): [True: 559, False: 6.26M] ------------------ 3408| 559|YY_RULE_SETUP ------------------ | | 3147| 559| YY_USER_ACTION | | ------------------ | | | | 61| 559| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 559| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 559| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 559| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 559| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 559| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.47k, False: 559] | | | | ------------------ | | | | 64| 4.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.47k| } else { \ | | | | 70| 4.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.47k| } \ | | | | 72| 4.47k| } | | ------------------ ------------------ 3409| 559|#line 93 "flex_lexer.l" 3410| 559|TOKEN(DATETIME) ------------------ | | 2887| 559|#define TOKEN(name) { return SQL_##name; } ------------------ 3411| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3412| 1.92k|case 34: ------------------ | Branch (3412:1): [True: 1.92k, False: 6.25M] ------------------ 3413| 1.92k|YY_RULE_SETUP ------------------ | | 3147| 1.92k| YY_USER_ACTION | | ------------------ | | | | 61| 1.92k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.92k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.68k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.76k, False: 1.92k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3414| 1.92k|#line 94 "flex_lexer.l" 3415| 1.92k|TOKEN(DAY) ------------------ | | 2887| 1.92k|#define TOKEN(name) { return SQL_##name; } ------------------ 3416| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3417| 530|case 35: ------------------ | Branch (3417:1): [True: 530, False: 6.26M] ------------------ 3418| 530|YY_RULE_SETUP ------------------ | | 3147| 530| YY_USER_ACTION | | ------------------ | | | | 61| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.12k, False: 530] | | | | ------------------ | | | | 64| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.12k| } else { \ | | | | 70| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| } \ | | | | 72| 2.12k| } | | ------------------ ------------------ 3419| 530|#line 95 "flex_lexer.l" 3420| 530|TOKEN(DAYS) ------------------ | | 2887| 530|#define TOKEN(name) { return SQL_##name; } ------------------ 3421| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3422| 891|case 36: ------------------ | Branch (3422:1): [True: 891, False: 6.26M] ------------------ 3423| 891|YY_RULE_SETUP ------------------ | | 3147| 891| YY_USER_ACTION | | ------------------ | | | | 61| 891| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 891| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 891| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 891| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 891| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 891| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.91k, False: 891] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3424| 891|#line 96 "flex_lexer.l" 3425| 891|TOKEN(DEALLOCATE) ------------------ | | 2887| 891|#define TOKEN(name) { return SQL_##name; } ------------------ 3426| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3427| 1.14k|case 37: ------------------ | Branch (3427:1): [True: 1.14k, False: 6.26M] ------------------ 3428| 1.14k|YY_RULE_SETUP ------------------ | | 3147| 1.14k| YY_USER_ACTION | | ------------------ | | | | 61| 1.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.15k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.00k, False: 1.14k] | | | | ------------------ | | | | 64| 8.00k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.00k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.00k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.00k| } else { \ | | | | 70| 8.00k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.00k| } \ | | | | 72| 8.00k| } | | ------------------ ------------------ 3429| 1.14k|#line 97 "flex_lexer.l" 3430| 1.14k|TOKEN(DECIMAL) ------------------ | | 2887| 1.14k|#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: 6.26M] ------------------ 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.71k|case 39: ------------------ | Branch (3437:1): [True: 1.71k, False: 6.25M] ------------------ 3438| 1.71k|YY_RULE_SETUP ------------------ | | 3147| 1.71k| YY_USER_ACTION | | ------------------ | | | | 61| 1.71k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.71k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.3k, False: 1.71k] | | | | ------------------ | | | | 64| 10.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.3k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.3k| } else { \ | | | | 70| 10.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.3k| } \ | | | | 72| 10.3k| } | | ------------------ ------------------ 3439| 1.71k|#line 99 "flex_lexer.l" 3440| 1.71k|TOKEN(DELETE) ------------------ | | 2887| 1.71k|#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: 6.26M] ------------------ 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| 546|case 41: ------------------ | Branch (3447:1): [True: 546, False: 6.26M] ------------------ 3448| 546|YY_RULE_SETUP ------------------ | | 3147| 546| YY_USER_ACTION | | ------------------ | | | | 61| 546| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 546| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 546| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 546| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 546| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 546| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.73k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.18k, False: 546] | | | | ------------------ | | | | 64| 2.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.18k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.18k| } else { \ | | | | 70| 2.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.18k| } \ | | | | 72| 2.18k| } | | ------------------ ------------------ 3449| 546|#line 101 "flex_lexer.l" 3450| 546|TOKEN(DESC) ------------------ | | 2887| 546|#define TOKEN(name) { return SQL_##name; } ------------------ 3451| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3452| 2.32k|case 42: ------------------ | Branch (3452:1): [True: 2.32k, False: 6.25M] ------------------ 3453| 2.32k|YY_RULE_SETUP ------------------ | | 3147| 2.32k| YY_USER_ACTION | | ------------------ | | | | 61| 2.32k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.32k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.6k, False: 2.32k] | | | | ------------------ | | | | 64| 18.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.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| 18.6k| } else { \ | | | | 70| 18.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.6k| } \ | | | | 72| 18.6k| } | | ------------------ ------------------ 3454| 2.32k|#line 102 "flex_lexer.l" 3455| 2.32k|TOKEN(DESCRIBE) ------------------ | | 2887| 2.32k|#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: 6.26M] ------------------ 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| 566|case 44: ------------------ | Branch (3462:1): [True: 566, False: 6.26M] ------------------ 3463| 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| 5.09k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.52k, False: 566] | | | | ------------------ | | | | 64| 4.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.52k| } else { \ | | | | 70| 4.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.52k| } \ | | | | 72| 4.52k| } | | ------------------ ------------------ 3464| 566|#line 104 "flex_lexer.l" 3465| 566|TOKEN(DISTINCT) ------------------ | | 2887| 566|#define TOKEN(name) { return SQL_##name; } ------------------ 3466| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3467| 7.00k|case 45: ------------------ | Branch (3467:1): [True: 7.00k, False: 6.25M] ------------------ 3468| 7.00k|YY_RULE_SETUP ------------------ | | 3147| 7.00k| YY_USER_ACTION | | ------------------ | | | | 61| 7.00k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.00k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 49.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 49.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 42.0k, False: 7.00k] | | | | ------------------ | | | | 64| 42.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 42.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 42.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 42.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 42.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 42.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 42.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| 42.0k| } else { \ | | | | 70| 42.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 42.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 42.0k| } \ | | | | 72| 42.0k| } | | ------------------ ------------------ 3469| 7.00k|#line 105 "flex_lexer.l" 3470| 7.00k|TOKEN(DOUBLE) ------------------ | | 2887| 7.00k|#define TOKEN(name) { return SQL_##name; } ------------------ 3471| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3472| 3.77k|case 46: ------------------ | Branch (3472:1): [True: 3.77k, False: 6.25M] ------------------ 3473| 3.77k|YY_RULE_SETUP ------------------ | | 3147| 3.77k| YY_USER_ACTION | | ------------------ | | | | 61| 3.77k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.77k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.77k| # 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.1k, False: 3.77k] | | | | ------------------ | | | | 64| 15.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15.1k| } else { \ | | | | 70| 15.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.1k| } \ | | | | 72| 15.1k| } | | ------------------ ------------------ 3474| 3.77k|#line 106 "flex_lexer.l" 3475| 3.77k|TOKEN(DROP) ------------------ | | 2887| 3.77k|#define TOKEN(name) { return SQL_##name; } ------------------ 3476| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3477| 843|case 47: ------------------ | Branch (3477:1): [True: 843, False: 6.26M] ------------------ 3478| 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| 4.21k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.37k, False: 843] | | | | ------------------ | | | | 64| 3.37k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.37k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.37k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.37k| } else { \ | | | | 70| 3.37k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.37k| } \ | | | | 72| 3.37k| } | | ------------------ ------------------ 3479| 843|#line 107 "flex_lexer.l" 3480| 843|TOKEN(ELSE) ------------------ | | 2887| 843|#define TOKEN(name) { return SQL_##name; } ------------------ 3481| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3482| 1.27k|case 48: ------------------ | Branch (3482:1): [True: 1.27k, False: 6.26M] ------------------ 3483| 1.27k|YY_RULE_SETUP ------------------ | | 3147| 1.27k| YY_USER_ACTION | | ------------------ | | | | 61| 1.27k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.27k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.27k| # 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.2k, False: 1.27k] | | | | ------------------ | | | | 64| 10.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.2k| } else { \ | | | | 70| 10.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.2k| } \ | | | | 72| 10.2k| } | | ------------------ ------------------ 3484| 1.27k|#line 108 "flex_lexer.l" 3485| 1.27k|TOKEN(ENCODING) ------------------ | | 2887| 1.27k|#define TOKEN(name) { return SQL_##name; } ------------------ 3486| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3487| 1.55k|case 49: ------------------ | Branch (3487:1): [True: 1.55k, False: 6.25M] ------------------ 3488| 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| 6.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.65k, False: 1.55k] | | | | ------------------ | | | | 64| 4.65k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.65k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.65k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.65k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.65k| } else { \ | | | | 70| 4.65k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.65k| } \ | | | | 72| 4.65k| } | | ------------------ ------------------ 3489| 1.55k|#line 109 "flex_lexer.l" 3490| 1.55k|TOKEN(END) ------------------ | | 2887| 1.55k|#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: 6.26M] ------------------ 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| 1.45k|case 51: ------------------ | Branch (3497:1): [True: 1.45k, False: 6.25M] ------------------ 3498| 1.45k|YY_RULE_SETUP ------------------ | | 3147| 1.45k| YY_USER_ACTION | | ------------------ | | | | 61| 1.45k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.45k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 10.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.73k, False: 1.45k] | | | | ------------------ | | | | 64| 8.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.73k| } else { \ | | | | 70| 8.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.73k| } \ | | | | 72| 8.73k| } | | ------------------ ------------------ 3499| 1.45k|#line 111 "flex_lexer.l" 3500| 1.45k|TOKEN(EXCEPT) ------------------ | | 2887| 1.45k|#define TOKEN(name) { return SQL_##name; } ------------------ 3501| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3502| 3.54k|case 52: ------------------ | Branch (3502:1): [True: 3.54k, False: 6.25M] ------------------ 3503| 3.54k|YY_RULE_SETUP ------------------ | | 3147| 3.54k| YY_USER_ACTION | | ------------------ | | | | 61| 3.54k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.54k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 28.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 28.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 24.8k, False: 3.54k] | | | | ------------------ | | | | 64| 24.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 24.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 24.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 24.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 24.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| 24.8k| } else { \ | | | | 70| 24.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 24.8k| } \ | | | | 72| 24.8k| } | | ------------------ ------------------ 3504| 3.54k|#line 112 "flex_lexer.l" 3505| 3.54k|TOKEN(EXECUTE) ------------------ | | 2887| 3.54k|#define TOKEN(name) { return SQL_##name; } ------------------ 3506| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3507| 2.04k|case 53: ------------------ | Branch (3507:1): [True: 2.04k, False: 6.25M] ------------------ 3508| 2.04k|YY_RULE_SETUP ------------------ | | 3147| 2.04k| YY_USER_ACTION | | ------------------ | | | | 61| 2.04k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.04k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.04k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.2k, False: 2.04k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3509| 2.04k|#line 113 "flex_lexer.l" 3510| 2.04k|TOKEN(EXISTS) ------------------ | | 2887| 2.04k|#define TOKEN(name) { return SQL_##name; } ------------------ 3511| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3512| 2|case 54: ------------------ | Branch (3512:1): [True: 2, False: 6.26M] ------------------ 3513| 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| } | | ------------------ ------------------ 3514| 2|#line 114 "flex_lexer.l" 3515| 2|TOKEN(EXPLAIN) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3516| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3517| 838|case 55: ------------------ | Branch (3517:1): [True: 838, False: 6.26M] ------------------ 3518| 838|YY_RULE_SETUP ------------------ | | 3147| 838| YY_USER_ACTION | | ------------------ | | | | 61| 838| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 838| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 838| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 838| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 838| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 838| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.70k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.86k, False: 838] | | | | ------------------ | | | | 64| 5.86k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.86k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.86k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.86k] | | | | ------------------ | | | | 67| 0| 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.86k| } else { \ | | | | 70| 5.86k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.86k| } \ | | | | 72| 5.86k| } | | ------------------ ------------------ 3519| 838|#line 115 "flex_lexer.l" 3520| 838|TOKEN(EXTRACT) ------------------ | | 2887| 838|#define TOKEN(name) { return SQL_##name; } ------------------ 3521| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3522| 924|case 56: ------------------ | Branch (3522:1): [True: 924, False: 6.26M] ------------------ 3523| 924|YY_RULE_SETUP ------------------ | | 3147| 924| YY_USER_ACTION | | ------------------ | | | | 61| 924| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 924| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 924| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 924| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 924| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 924| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.62k, False: 924] | | | | ------------------ | | | | 64| 4.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.62k| } else { \ | | | | 70| 4.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.62k| } \ | | | | 72| 4.62k| } | | ------------------ ------------------ 3524| 924|#line 116 "flex_lexer.l" 3525| 924|TOKEN(FALSE) ------------------ | | 2887| 924|#define TOKEN(name) { return SQL_##name; } ------------------ 3526| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3527| 1|case 57: ------------------ | Branch (3527:1): [True: 1, False: 6.26M] ------------------ 3528| 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| } | | ------------------ ------------------ 3529| 1|#line 117 "flex_lexer.l" 3530| 1|TOKEN(FILE) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3531| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3532| 708|case 58: ------------------ | Branch (3532:1): [True: 708, False: 6.26M] ------------------ 3533| 708|YY_RULE_SETUP ------------------ | | 3147| 708| YY_USER_ACTION | | ------------------ | | | | 61| 708| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 708| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.54k, False: 708] | | | | ------------------ | | | | 64| 3.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.54k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.54k| } else { \ | | | | 70| 3.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.54k| } \ | | | | 72| 3.54k| } | | ------------------ ------------------ 3534| 708|#line 118 "flex_lexer.l" 3535| 708|TOKEN(FLOAT) ------------------ | | 2887| 708|#define TOKEN(name) { return SQL_##name; } ------------------ 3536| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3537| 2.05k|case 59: ------------------ | Branch (3537:1): [True: 2.05k, False: 6.25M] ------------------ 3538| 2.05k|YY_RULE_SETUP ------------------ | | 3147| 2.05k| YY_USER_ACTION | | ------------------ | | | | 61| 2.05k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.05k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 18.5k, False: 2.05k] | | | | ------------------ | | | | 64| 18.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 18.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 18.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 18.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 18.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 18.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 18.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| 18.5k| } else { \ | | | | 70| 18.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 18.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.5k| } \ | | | | 72| 18.5k| } | | ------------------ ------------------ 3539| 2.05k|#line 119 "flex_lexer.l" 3540| 2.05k|TOKEN(FOLLOWING) ------------------ | | 2887| 2.05k|#define TOKEN(name) { return SQL_##name; } ------------------ 3541| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3542| 5.19k|case 60: ------------------ | Branch (3542:1): [True: 5.19k, False: 6.25M] ------------------ 3543| 5.19k|YY_RULE_SETUP ------------------ | | 3147| 5.19k| YY_USER_ACTION | | ------------------ | | | | 61| 5.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.5k, False: 5.19k] | | | | ------------------ | | | | 64| 15.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.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| 15.5k| } else { \ | | | | 70| 15.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.5k| } \ | | | | 72| 15.5k| } | | ------------------ ------------------ 3544| 5.19k|#line 120 "flex_lexer.l" 3545| 5.19k|TOKEN(FOR) ------------------ | | 2887| 5.19k|#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: 6.26M] ------------------ 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.70k|case 62: ------------------ | Branch (3552:1): [True: 1.70k, False: 6.25M] ------------------ 3553| 1.70k|YY_RULE_SETUP ------------------ | | 3147| 1.70k| YY_USER_ACTION | | ------------------ | | | | 61| 1.70k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.70k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.2k, False: 1.70k] | | | | ------------------ | | | | 64| 10.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.2k| } else { \ | | | | 70| 10.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.2k| } \ | | | | 72| 10.2k| } | | ------------------ ------------------ 3554| 1.70k|#line 122 "flex_lexer.l" 3555| 1.70k|TOKEN(FORMAT) ------------------ | | 2887| 1.70k|#define TOKEN(name) { return SQL_##name; } ------------------ 3556| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3557| 12.1k|case 63: ------------------ | Branch (3557:1): [True: 12.1k, False: 6.24M] ------------------ 3558| 12.1k|YY_RULE_SETUP ------------------ | | 3147| 12.1k| YY_USER_ACTION | | ------------------ | | | | 61| 12.1k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 12.1k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 60.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 60.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 48.6k, False: 12.1k] | | | | ------------------ | | | | 64| 48.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 48.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 48.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 48.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 48.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 48.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 48.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| 48.6k| } else { \ | | | | 70| 48.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 48.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 48.6k| } \ | | | | 72| 48.6k| } | | ------------------ ------------------ 3559| 12.1k|#line 123 "flex_lexer.l" 3560| 12.1k|TOKEN(FROM) ------------------ | | 2887| 12.1k|#define TOKEN(name) { return SQL_##name; } ------------------ 3561| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3562| 596|case 64: ------------------ | Branch (3562:1): [True: 596, False: 6.26M] ------------------ 3563| 596|YY_RULE_SETUP ------------------ | | 3147| 596| YY_USER_ACTION | | ------------------ | | | | 61| 596| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 596| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 596| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 596| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 596| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 596| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.38k, False: 596] | | | | ------------------ | | | | 64| 2.38k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.38k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.38k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.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| 2.38k| } else { \ | | | | 70| 2.38k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.38k| } \ | | | | 72| 2.38k| } | | ------------------ ------------------ 3564| 596|#line 124 "flex_lexer.l" 3565| 596|TOKEN(FULL) ------------------ | | 2887| 596|#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: 6.26M] ------------------ 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.42k|case 66: ------------------ | Branch (3572:1): [True: 3.42k, False: 6.25M] ------------------ 3573| 3.42k|YY_RULE_SETUP ------------------ | | 3147| 3.42k| YY_USER_ACTION | | ------------------ | | | | 61| 3.42k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.42k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 20.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 20.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 17.1k, False: 3.42k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3574| 3.42k|#line 126 "flex_lexer.l" 3575| 3.42k|TOKEN(GROUP) ------------------ | | 2887| 3.42k|#define TOKEN(name) { return SQL_##name; } ------------------ 3576| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3577| 999|case 67: ------------------ | Branch (3577:1): [True: 999, False: 6.26M] ------------------ 3578| 999|YY_RULE_SETUP ------------------ | | 3147| 999| YY_USER_ACTION | | ------------------ | | | | 61| 999| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 999| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 999| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 999| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 999| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 999| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.99k, False: 999] | | | | ------------------ | | | | 64| 5.99k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.99k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.99k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.99k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.99k| } else { \ | | | | 70| 5.99k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.99k| } \ | | | | 72| 5.99k| } | | ------------------ ------------------ 3579| 999|#line 127 "flex_lexer.l" 3580| 999|TOKEN(GROUPS) ------------------ | | 2887| 999|#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: 6.26M] ------------------ 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| 859|case 69: ------------------ | Branch (3587:1): [True: 859, False: 6.26M] ------------------ 3588| 859|YY_RULE_SETUP ------------------ | | 3147| 859| YY_USER_ACTION | | ------------------ | | | | 61| 859| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 859| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 859| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 859| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 859| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 859| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.01k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.15k, False: 859] | | | | ------------------ | | | | 64| 5.15k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.15k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.15k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.15k] | | | | ------------------ | | | | 67| 0| 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.15k| } else { \ | | | | 70| 5.15k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.15k| } \ | | | | 72| 5.15k| } | | ------------------ ------------------ 3589| 859|#line 129 "flex_lexer.l" 3590| 859|TOKEN(HAVING) ------------------ | | 2887| 859|#define TOKEN(name) { return SQL_##name; } ------------------ 3591| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3592| 749|case 70: ------------------ | Branch (3592:1): [True: 749, False: 6.26M] ------------------ 3593| 749|YY_RULE_SETUP ------------------ | | 3147| 749| YY_USER_ACTION | | ------------------ | | | | 61| 749| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 749| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 749| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 749| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 749| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 749| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.74k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.99k, False: 749] | | | | ------------------ | | | | 64| 2.99k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.99k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.99k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.99k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.99k| } else { \ | | | | 70| 2.99k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.99k| } \ | | | | 72| 2.99k| } | | ------------------ ------------------ 3594| 749|#line 130 "flex_lexer.l" 3595| 749|TOKEN(HINT) ------------------ | | 2887| 749|#define TOKEN(name) { return SQL_##name; } ------------------ 3596| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3597| 1.17k|case 71: ------------------ | Branch (3597:1): [True: 1.17k, False: 6.26M] ------------------ 3598| 1.17k|YY_RULE_SETUP ------------------ | | 3147| 1.17k| YY_USER_ACTION | | ------------------ | | | | 61| 1.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.88k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.70k, False: 1.17k] | | | | ------------------ | | | | 64| 4.70k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.70k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.70k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.70k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.70k| } else { \ | | | | 70| 4.70k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.70k| } \ | | | | 72| 4.70k| } | | ------------------ ------------------ 3599| 1.17k|#line 131 "flex_lexer.l" 3600| 1.17k|TOKEN(HOUR) ------------------ | | 2887| 1.17k|#define TOKEN(name) { return SQL_##name; } ------------------ 3601| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3602| 733|case 72: ------------------ | Branch (3602:1): [True: 733, False: 6.26M] ------------------ 3603| 733|YY_RULE_SETUP ------------------ | | 3147| 733| YY_USER_ACTION | | ------------------ | | | | 61| 733| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 733| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 733| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.66k, False: 733] | | | | ------------------ | | | | 64| 3.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.66k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.66k| } else { \ | | | | 70| 3.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.66k| } \ | | | | 72| 3.66k| } | | ------------------ ------------------ 3604| 733|#line 132 "flex_lexer.l" 3605| 733|TOKEN(HOURS) ------------------ | | 2887| 733|#define TOKEN(name) { return SQL_##name; } ------------------ 3606| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3607| 772|case 73: ------------------ | Branch (3607:1): [True: 772, False: 6.26M] ------------------ 3608| 772|YY_RULE_SETUP ------------------ | | 3147| 772| YY_USER_ACTION | | ------------------ | | | | 61| 772| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 772| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 772| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.31k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.54k, False: 772] | | | | ------------------ | | | | 64| 1.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.54k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.54k| } else { \ | | | | 70| 1.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.54k| } \ | | | | 72| 1.54k| } | | ------------------ ------------------ 3609| 772|#line 133 "flex_lexer.l" 3610| 772|TOKEN(IF) ------------------ | | 2887| 772|#define TOKEN(name) { return SQL_##name; } ------------------ 3611| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3612| 708|case 74: ------------------ | Branch (3612:1): [True: 708, False: 6.26M] ------------------ 3613| 708|YY_RULE_SETUP ------------------ | | 3147| 708| YY_USER_ACTION | | ------------------ | | | | 61| 708| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 708| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 708| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.54k, False: 708] | | | | ------------------ | | | | 64| 3.54k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.54k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.54k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.54k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.54k| } else { \ | | | | 70| 3.54k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.54k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.54k| } \ | | | | 72| 3.54k| } | | ------------------ ------------------ 3614| 708|#line 134 "flex_lexer.l" 3615| 708|TOKEN(ILIKE) ------------------ | | 2887| 708|#define TOKEN(name) { return SQL_##name; } ------------------ 3616| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3617| 125|case 75: ------------------ | Branch (3617:1): [True: 125, False: 6.26M] ------------------ 3618| 125|YY_RULE_SETUP ------------------ | | 3147| 125| YY_USER_ACTION | | ------------------ | | | | 61| 125| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 125| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 125| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 125| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 125| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 125| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 875| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 875|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 750, False: 125] | | | | ------------------ | | | | 64| 750| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 750| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 750| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 750| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 750| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 750|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 750] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 750| } else { \ | | | | 70| 750| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 750| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 750| } \ | | | | 72| 750| } | | ------------------ ------------------ 3619| 125|#line 135 "flex_lexer.l" 3620| 125|TOKEN(IMPORT) ------------------ | | 2887| 125|#define TOKEN(name) { return SQL_##name; } ------------------ 3621| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3622| 1.25k|case 76: ------------------ | Branch (3622:1): [True: 1.25k, False: 6.26M] ------------------ 3623| 1.25k|YY_RULE_SETUP ------------------ | | 3147| 1.25k| YY_USER_ACTION | | ------------------ | | | | 61| 1.25k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.25k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.25k| # 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: 2.50k, False: 1.25k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3624| 1.25k|#line 136 "flex_lexer.l" 3625| 1.25k|TOKEN(IN) ------------------ | | 2887| 1.25k|#define TOKEN(name) { return SQL_##name; } ------------------ 3626| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3627| 1.74k|case 77: ------------------ | Branch (3627:1): [True: 1.74k, False: 6.25M] ------------------ 3628| 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| 10.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 10.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.71k, False: 1.74k] | | | | ------------------ | | | | 64| 8.71k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.71k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.71k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.71k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.71k| } else { \ | | | | 70| 8.71k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.71k| } \ | | | | 72| 8.71k| } | | ------------------ ------------------ 3629| 1.74k|#line 137 "flex_lexer.l" 3630| 1.74k|TOKEN(INDEX) ------------------ | | 2887| 1.74k|#define TOKEN(name) { return SQL_##name; } ------------------ 3631| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3632| 504|case 78: ------------------ | Branch (3632:1): [True: 504, False: 6.26M] ------------------ 3633| 504|YY_RULE_SETUP ------------------ | | 3147| 504| YY_USER_ACTION | | ------------------ | | | | 61| 504| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 504| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 504| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 504| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 504| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 504| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.52k, False: 504] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3634| 504|#line 138 "flex_lexer.l" 3635| 504|TOKEN(INNER) ------------------ | | 2887| 504|#define TOKEN(name) { return SQL_##name; } ------------------ 3636| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3637| 1.93k|case 79: ------------------ | Branch (3637:1): [True: 1.93k, False: 6.25M] ------------------ 3638| 1.93k|YY_RULE_SETUP ------------------ | | 3147| 1.93k| YY_USER_ACTION | | ------------------ | | | | 61| 1.93k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.93k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.93k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.6k, False: 1.93k] | | | | ------------------ | | | | 64| 11.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.6k| } else { \ | | | | 70| 11.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.6k| } \ | | | | 72| 11.6k| } | | ------------------ ------------------ 3639| 1.93k|#line 139 "flex_lexer.l" 3640| 1.93k|TOKEN(INSERT) ------------------ | | 2887| 1.93k|#define TOKEN(name) { return SQL_##name; } ------------------ 3641| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3642| 7.79k|case 80: ------------------ | Branch (3642:1): [True: 7.79k, False: 6.25M] ------------------ 3643| 7.79k|YY_RULE_SETUP ------------------ | | 3147| 7.79k| YY_USER_ACTION | | ------------------ | | | | 61| 7.79k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 7.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 7.79k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 7.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 31.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 31.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.3k, False: 7.79k] | | | | ------------------ | | | | 64| 23.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.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| 23.3k| } else { \ | | | | 70| 23.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.3k| } \ | | | | 72| 23.3k| } | | ------------------ ------------------ 3644| 7.79k|#line 140 "flex_lexer.l" 3645| 7.79k|TOKEN(INT) ------------------ | | 2887| 7.79k|#define TOKEN(name) { return SQL_##name; } ------------------ 3646| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3647| 653|case 81: ------------------ | Branch (3647:1): [True: 653, False: 6.26M] ------------------ 3648| 653|YY_RULE_SETUP ------------------ | | 3147| 653| YY_USER_ACTION | | ------------------ | | | | 61| 653| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 653| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.57k, False: 653] | | | | ------------------ | | | | 64| 4.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.57k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.57k| } else { \ | | | | 70| 4.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.57k| } \ | | | | 72| 4.57k| } | | ------------------ ------------------ 3649| 653|#line 141 "flex_lexer.l" 3650| 653|TOKEN(INTEGER) ------------------ | | 2887| 653|#define TOKEN(name) { return SQL_##name; } ------------------ 3651| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3652| 614|case 82: ------------------ | Branch (3652:1): [True: 614, False: 6.26M] ------------------ 3653| 614|YY_RULE_SETUP ------------------ | | 3147| 614| YY_USER_ACTION | | ------------------ | | | | 61| 614| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 614| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.14k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.14k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.52k, False: 614] | | | | ------------------ | | | | 64| 5.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.52k| } else { \ | | | | 70| 5.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.52k| } \ | | | | 72| 5.52k| } | | ------------------ ------------------ 3654| 614|#line 142 "flex_lexer.l" 3655| 614|TOKEN(INTERSECT) ------------------ | | 2887| 614|#define TOKEN(name) { return SQL_##name; } ------------------ 3656| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3657| 4.52k|case 83: ------------------ | Branch (3657:1): [True: 4.52k, False: 6.25M] ------------------ 3658| 4.52k|YY_RULE_SETUP ------------------ | | 3147| 4.52k| YY_USER_ACTION | | ------------------ | | | | 61| 4.52k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.52k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 40.7k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 40.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 36.2k, False: 4.52k] | | | | ------------------ | | | | 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.52k|#line 143 "flex_lexer.l" 3660| 4.52k|TOKEN(INTERVAL) ------------------ | | 2887| 4.52k|#define TOKEN(name) { return SQL_##name; } ------------------ 3661| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3662| 1.92k|case 84: ------------------ | Branch (3662:1): [True: 1.92k, False: 6.25M] ------------------ 3663| 1.92k|YY_RULE_SETUP ------------------ | | 3147| 1.92k| YY_USER_ACTION | | ------------------ | | | | 61| 1.92k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.92k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.63k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.63k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.70k, False: 1.92k] | | | | ------------------ | | | | 64| 7.70k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.70k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.70k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.70k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 7.70k| } else { \ | | | | 70| 7.70k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.70k| } \ | | | | 72| 7.70k| } | | ------------------ ------------------ 3664| 1.92k|#line 144 "flex_lexer.l" 3665| 1.92k|TOKEN(INTO) ------------------ | | 2887| 1.92k|#define TOKEN(name) { return SQL_##name; } ------------------ 3666| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3667| 488|case 85: ------------------ | Branch (3667:1): [True: 488, False: 6.26M] ------------------ 3668| 488|YY_RULE_SETUP ------------------ | | 3147| 488| YY_USER_ACTION | | ------------------ | | | | 61| 488| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 488| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 488| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 488| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 488| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 488| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.46k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 976, False: 488] | | | | ------------------ | | | | 64| 976| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 976| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 976| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 976|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 976] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 976| } else { \ | | | | 70| 976| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 976| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 976| } \ | | | | 72| 976| } | | ------------------ ------------------ 3669| 488|#line 145 "flex_lexer.l" 3670| 488|TOKEN(IS) ------------------ | | 2887| 488|#define TOKEN(name) { return SQL_##name; } ------------------ 3671| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3672| 770|case 86: ------------------ | Branch (3672:1): [True: 770, False: 6.26M] ------------------ 3673| 770|YY_RULE_SETUP ------------------ | | 3147| 770| YY_USER_ACTION | | ------------------ | | | | 61| 770| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 770| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 770| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 770| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 770| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 770| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.62k, False: 770] | | | | ------------------ | | | | 64| 4.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.62k| } else { \ | | | | 70| 4.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.62k| } \ | | | | 72| 4.62k| } | | ------------------ ------------------ 3674| 770|#line 146 "flex_lexer.l" 3675| 770|TOKEN(ISNULL) ------------------ | | 2887| 770|#define TOKEN(name) { return SQL_##name; } ------------------ 3676| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3677| 113k|case 87: ------------------ | Branch (3677:1): [True: 113k, False: 6.14M] ------------------ 3678| 113k|YY_RULE_SETUP ------------------ | | 3147| 113k| YY_USER_ACTION | | ------------------ | | | | 61| 113k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 113k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 566k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 566k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 453k, False: 113k] | | | | ------------------ | | | | 64| 453k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 453k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 453k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 453k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 453k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 453k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 453k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 453k| } else { \ | | | | 70| 453k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 453k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 453k| } \ | | | | 72| 453k| } | | ------------------ ------------------ 3679| 113k|#line 147 "flex_lexer.l" 3680| 113k|TOKEN(JOIN) ------------------ | | 2887| 113k|#define TOKEN(name) { return SQL_##name; } ------------------ 3681| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3682| 2.23k|case 88: ------------------ | Branch (3682:1): [True: 2.23k, False: 6.25M] ------------------ 3683| 2.23k|YY_RULE_SETUP ------------------ | | 3147| 2.23k| YY_USER_ACTION | | ------------------ | | | | 61| 2.23k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.23k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.69k, False: 2.23k] | | | | ------------------ | | | | 64| 6.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.69k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.69k| } else { \ | | | | 70| 6.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.69k| } \ | | | | 72| 6.69k| } | | ------------------ ------------------ 3684| 2.23k|#line 148 "flex_lexer.l" 3685| 2.23k|TOKEN(KEY) ------------------ | | 2887| 2.23k|#define TOKEN(name) { return SQL_##name; } ------------------ 3686| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3687| 737|case 89: ------------------ | Branch (3687:1): [True: 737, False: 6.26M] ------------------ 3688| 737|YY_RULE_SETUP ------------------ | | 3147| 737| YY_USER_ACTION | | ------------------ | | | | 61| 737| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 737| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 737| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.68k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.94k, False: 737] | | | | ------------------ | | | | 64| 2.94k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.94k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.94k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.94k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.94k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.94k| } else { \ | | | | 70| 2.94k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.94k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.94k| } \ | | | | 72| 2.94k| } | | ------------------ ------------------ 3689| 737|#line 149 "flex_lexer.l" 3690| 737|TOKEN(LEFT) ------------------ | | 2887| 737|#define TOKEN(name) { return SQL_##name; } ------------------ 3691| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3692| 775|case 90: ------------------ | Branch (3692:1): [True: 775, False: 6.26M] ------------------ 3693| 775|YY_RULE_SETUP ------------------ | | 3147| 775| YY_USER_ACTION | | ------------------ | | | | 61| 775| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 775| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 775| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.87k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.10k, False: 775] | | | | ------------------ | | | | 64| 3.10k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.10k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.10k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.10k| } else { \ | | | | 70| 3.10k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.10k| } \ | | | | 72| 3.10k| } | | ------------------ ------------------ 3694| 775|#line 150 "flex_lexer.l" 3695| 775|TOKEN(LIKE) ------------------ | | 2887| 775|#define TOKEN(name) { return SQL_##name; } ------------------ 3696| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3697| 3.81k|case 91: ------------------ | Branch (3697:1): [True: 3.81k, False: 6.25M] ------------------ 3698| 3.81k|YY_RULE_SETUP ------------------ | | 3147| 3.81k| YY_USER_ACTION | | ------------------ | | | | 61| 3.81k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.81k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 22.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 22.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 19.0k, False: 3.81k] | | | | ------------------ | | | | 64| 19.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 19.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 19.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 19.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 19.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 19.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 19.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| 19.0k| } else { \ | | | | 70| 19.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 19.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 19.0k| } \ | | | | 72| 19.0k| } | | ------------------ ------------------ 3699| 3.81k|#line 151 "flex_lexer.l" 3700| 3.81k|TOKEN(LIMIT) ------------------ | | 2887| 3.81k|#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: 6.26M] ------------------ 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: 6.26M] ------------------ 3708| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10, False: 2] | | | | ------------------ | | | | 64| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10| } else { \ | | | | 70| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| } \ | | | | 72| 10| } | | ------------------ ------------------ 3709| 2|#line 153 "flex_lexer.l" 3710| 2|TOKEN(LOCAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3711| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3712| 2|case 94: ------------------ | Branch (3712:1): [True: 2, False: 6.26M] ------------------ 3713| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12, False: 2] | | | | ------------------ | | | | 64| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 12| } else { \ | | | | 70| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| } \ | | | | 72| 12| } | | ------------------ ------------------ 3714| 2|#line 154 "flex_lexer.l" 3715| 2|TOKEN(LOCKED) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3716| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3717| 530|case 95: ------------------ | Branch (3717:1): [True: 530, False: 6.26M] ------------------ 3718| 530|YY_RULE_SETUP ------------------ | | 3147| 530| YY_USER_ACTION | | ------------------ | | | | 61| 530| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 530| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 530| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.65k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.12k, False: 530] | | | | ------------------ | | | | 64| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.12k| } else { \ | | | | 70| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| } \ | | | | 72| 2.12k| } | | ------------------ ------------------ 3719| 530|#line 155 "flex_lexer.l" 3720| 530|TOKEN(LONG) ------------------ | | 2887| 530|#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: 6.26M] ------------------ 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| 3|case 97: ------------------ | Branch (3727:1): [True: 3, False: 6.26M] ------------------ 3728| 3|YY_RULE_SETUP ------------------ | | 3147| 3| YY_USER_ACTION | | ------------------ | | | | 61| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15, False: 3] | | | | ------------------ | | | | 64| 15| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 15| } else { \ | | | | 70| 15| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15| } \ | | | | 72| 15| } | | ------------------ ------------------ 3729| 3|#line 157 "flex_lexer.l" 3730| 3|TOKEN(MINUS) ------------------ | | 2887| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3731| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3732| 825|case 98: ------------------ | Branch (3732:1): [True: 825, False: 6.26M] ------------------ 3733| 825|YY_RULE_SETUP ------------------ | | 3147| 825| YY_USER_ACTION | | ------------------ | | | | 61| 825| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 825| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 825| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 825| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 825| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 825| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.77k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.95k, False: 825] | | | | ------------------ | | | | 64| 4.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.95k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.95k| } else { \ | | | | 70| 4.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.95k| } \ | | | | 72| 4.95k| } | | ------------------ ------------------ 3734| 825|#line 158 "flex_lexer.l" 3735| 825|TOKEN(MINUTE) ------------------ | | 2887| 825|#define TOKEN(name) { return SQL_##name; } ------------------ 3736| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3737| 695|case 99: ------------------ | Branch (3737:1): [True: 695, False: 6.26M] ------------------ 3738| 695|YY_RULE_SETUP ------------------ | | 3147| 695| YY_USER_ACTION | | ------------------ | | | | 61| 695| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 695| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 695| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.86k, False: 695] | | | | ------------------ | | | | 64| 4.86k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.86k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.86k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.86k] | | | | ------------------ | | | | 67| 0| 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.86k| } else { \ | | | | 70| 4.86k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.86k| } \ | | | | 72| 4.86k| } | | ------------------ ------------------ 3739| 695|#line 159 "flex_lexer.l" 3740| 695|TOKEN(MINUTES) ------------------ | | 2887| 695|#define TOKEN(name) { return SQL_##name; } ------------------ 3741| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3742| 720|case 100: ------------------ | Branch (3742:1): [True: 720, False: 6.26M] ------------------ 3743| 720|YY_RULE_SETUP ------------------ | | 3147| 720| YY_USER_ACTION | | ------------------ | | | | 61| 720| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 720| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 720| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.32k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.60k, False: 720] | | | | ------------------ | | | | 64| 3.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.60k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.60k| } else { \ | | | | 70| 3.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.60k| } \ | | | | 72| 3.60k| } | | ------------------ ------------------ 3744| 720|#line 160 "flex_lexer.l" 3745| 720|TOKEN(MONTH) ------------------ | | 2887| 720|#define TOKEN(name) { return SQL_##name; } ------------------ 3746| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3747| 771|case 101: ------------------ | Branch (3747:1): [True: 771, False: 6.26M] ------------------ 3748| 771|YY_RULE_SETUP ------------------ | | 3147| 771| YY_USER_ACTION | | ------------------ | | | | 61| 771| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 771| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.62k, False: 771] | | | | ------------------ | | | | 64| 4.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.62k| } else { \ | | | | 70| 4.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.62k| } \ | | | | 72| 4.62k| } | | ------------------ ------------------ 3749| 771|#line 161 "flex_lexer.l" 3750| 771|TOKEN(MONTHS) ------------------ | | 2887| 771|#define TOKEN(name) { return SQL_##name; } ------------------ 3751| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3752| 1.24k|case 102: ------------------ | Branch (3752:1): [True: 1.24k, False: 6.26M] ------------------ 3753| 1.24k|YY_RULE_SETUP ------------------ | | 3147| 1.24k| YY_USER_ACTION | | ------------------ | | | | 61| 1.24k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.24k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.98k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.98k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.73k, False: 1.24k] | | | | ------------------ | | | | 64| 8.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.73k| } else { \ | | | | 70| 8.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.73k| } \ | | | | 72| 8.73k| } | | ------------------ ------------------ 3754| 1.24k|#line 162 "flex_lexer.l" 3755| 1.24k|TOKEN(NATURAL) ------------------ | | 2887| 1.24k|#define TOKEN(name) { return SQL_##name; } ------------------ 3756| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3757| 6|case 103: ------------------ | Branch (3757:1): [True: 6, False: 6.26M] ------------------ 3758| 6|YY_RULE_SETUP ------------------ | | 3147| 6| YY_USER_ACTION | | ------------------ | | | | 61| 6| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6| # 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: 12, False: 6] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3759| 6|#line 163 "flex_lexer.l" 3760| 6|TOKEN(NO) ------------------ | | 2887| 6|#define TOKEN(name) { return SQL_##name; } ------------------ 3761| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3762| 4.37k|case 104: ------------------ | Branch (3762:1): [True: 4.37k, False: 6.25M] ------------------ 3763| 4.37k|YY_RULE_SETUP ------------------ | | 3147| 4.37k| YY_USER_ACTION | | ------------------ | | | | 61| 4.37k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.37k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 17.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 17.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.1k, False: 4.37k] | | | | ------------------ | | | | 64| 13.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 13.1k| } else { \ | | | | 70| 13.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.1k| } \ | | | | 72| 13.1k| } | | ------------------ ------------------ 3764| 4.37k|#line 164 "flex_lexer.l" 3765| 4.37k|TOKEN(NOT) ------------------ | | 2887| 4.37k|#define TOKEN(name) { return SQL_##name; } ------------------ 3766| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3767| 827|case 105: ------------------ | Branch (3767:1): [True: 827, False: 6.26M] ------------------ 3768| 827|YY_RULE_SETUP ------------------ | | 3147| 827| YY_USER_ACTION | | ------------------ | | | | 61| 827| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 827| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 827| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.96k, False: 827] | | | | ------------------ | | | | 64| 4.96k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.96k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.96k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.96k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4.96k| } else { \ | | | | 70| 4.96k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.96k| } \ | | | | 72| 4.96k| } | | ------------------ ------------------ 3769| 827|#line 165 "flex_lexer.l" 3770| 827|TOKEN(NOWAIT) ------------------ | | 2887| 827|#define TOKEN(name) { return SQL_##name; } ------------------ 3771| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3772| 6.92k|case 106: ------------------ | Branch (3772:1): [True: 6.92k, False: 6.25M] ------------------ 3773| 6.92k|YY_RULE_SETUP ------------------ | | 3147| 6.92k| YY_USER_ACTION | | ------------------ | | | | 61| 6.92k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.92k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.92k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 34.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 34.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 27.7k, False: 6.92k] | | | | ------------------ | | | | 64| 27.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 27.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 27.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 27.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 27.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 27.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 27.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| 27.7k| } else { \ | | | | 70| 27.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 27.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 27.7k| } \ | | | | 72| 27.7k| } | | ------------------ ------------------ 3774| 6.92k|#line 166 "flex_lexer.l" 3775| 6.92k|TOKEN(NULL) ------------------ | | 2887| 6.92k|#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: 6.26M] ------------------ 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| 565|case 108: ------------------ | Branch (3782:1): [True: 565, False: 6.26M] ------------------ 3783| 565|YY_RULE_SETUP ------------------ | | 3147| 565| YY_USER_ACTION | | ------------------ | | | | 61| 565| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 565| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.13k, False: 565] | | | | ------------------ | | | | 64| 1.13k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.13k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.13k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.13k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.13k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 1.13k| } else { \ | | | | 70| 1.13k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.13k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.13k| } \ | | | | 72| 1.13k| } | | ------------------ ------------------ 3784| 565|#line 168 "flex_lexer.l" 3785| 565|TOKEN(OF) ------------------ | | 2887| 565|#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: 6.26M] ------------------ 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.15k|case 110: ------------------ | Branch (3792:1): [True: 2.15k, False: 6.25M] ------------------ 3793| 2.15k|YY_RULE_SETUP ------------------ | | 3147| 2.15k| YY_USER_ACTION | | ------------------ | | | | 61| 2.15k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.15k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.9k, False: 2.15k] | | | | ------------------ | | | | 64| 12.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.9k| } else { \ | | | | 70| 12.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.9k| } \ | | | | 72| 12.9k| } | | ------------------ ------------------ 3794| 2.15k|#line 170 "flex_lexer.l" 3795| 2.15k|TOKEN(OFFSET) ------------------ | | 2887| 2.15k|#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: 6.15M] ------------------ 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| 632|case 112: ------------------ | Branch (3802:1): [True: 632, False: 6.26M] ------------------ 3803| 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| 1.89k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 1.26k, False: 632] | | | | ------------------ | | | | 64| 1.26k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 1.26k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 1.26k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 1.26k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 1.26k] | | | | ------------------ | | | | 67| 0| 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.26k| } else { \ | | | | 70| 1.26k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 1.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.26k| } \ | | | | 72| 1.26k| } | | ------------------ ------------------ 3804| 632|#line 172 "flex_lexer.l" 3805| 632|TOKEN(OR) ------------------ | | 2887| 632|#define TOKEN(name) { return SQL_##name; } ------------------ 3806| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3807| 2.58k|case 113: ------------------ | Branch (3807:1): [True: 2.58k, False: 6.25M] ------------------ 3808| 2.58k|YY_RULE_SETUP ------------------ | | 3147| 2.58k| YY_USER_ACTION | | ------------------ | | | | 61| 2.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.9k, False: 2.58k] | | | | ------------------ | | | | 64| 12.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.9k| } else { \ | | | | 70| 12.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.9k| } \ | | | | 72| 12.9k| } | | ------------------ ------------------ 3809| 2.58k|#line 173 "flex_lexer.l" 3810| 2.58k|TOKEN(ORDER) ------------------ | | 2887| 2.58k|#define TOKEN(name) { return SQL_##name; } ------------------ 3811| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3812| 1.47k|case 114: ------------------ | Branch (3812:1): [True: 1.47k, False: 6.25M] ------------------ 3813| 1.47k|YY_RULE_SETUP ------------------ | | 3147| 1.47k| YY_USER_ACTION | | ------------------ | | | | 61| 1.47k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.47k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.82k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.35k, False: 1.47k] | | | | ------------------ | | | | 64| 7.35k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.35k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.35k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.35k] | | | | ------------------ | | | | 67| 0| 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.35k| } else { \ | | | | 70| 7.35k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.35k| } \ | | | | 72| 7.35k| } | | ------------------ ------------------ 3814| 1.47k|#line 174 "flex_lexer.l" 3815| 1.47k|TOKEN(OUTER) ------------------ | | 2887| 1.47k|#define TOKEN(name) { return SQL_##name; } ------------------ 3816| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3817| 5.79k|case 115: ------------------ | Branch (3817:1): [True: 5.79k, False: 6.25M] ------------------ 3818| 5.79k|YY_RULE_SETUP ------------------ | | 3147| 5.79k| YY_USER_ACTION | | ------------------ | | | | 61| 5.79k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 5.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 5.79k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.79k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 5.79k| # 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: 23.1k, False: 5.79k] | | | | ------------------ | | | | 64| 23.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.1k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 23.1k| } else { \ | | | | 70| 23.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.1k| } \ | | | | 72| 23.1k| } | | ------------------ ------------------ 3819| 5.79k|#line 175 "flex_lexer.l" 3820| 5.79k|TOKEN(OVER) ------------------ | | 2887| 5.79k|#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: 6.26M] ------------------ 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| 984|case 117: ------------------ | Branch (3827:1): [True: 984, False: 6.26M] ------------------ 3828| 984|YY_RULE_SETUP ------------------ | | 3147| 984| YY_USER_ACTION | | ------------------ | | | | 61| 984| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 984| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 984| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.85k, False: 984] | | | | ------------------ | | | | 64| 8.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.85k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 8.85k| } else { \ | | | | 70| 8.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.85k| } \ | | | | 72| 8.85k| } | | ------------------ ------------------ 3829| 984|#line 177 "flex_lexer.l" 3830| 984|TOKEN(PARTITION) ------------------ | | 2887| 984|#define TOKEN(name) { return SQL_##name; } ------------------ 3831| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3832| 1|case 118: ------------------ | Branch (3832:1): [True: 1, False: 6.26M] ------------------ 3833| 1|YY_RULE_SETUP ------------------ | | 3147| 1| YY_USER_ACTION | | ------------------ | | | | 61| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4, False: 1] | | | | ------------------ | | | | 64| 4| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 4| } else { \ | | | | 70| 4| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4| } \ | | | | 72| 4| } | | ------------------ ------------------ 3834| 1|#line 178 "flex_lexer.l" 3835| 1|TOKEN(PLAN) ------------------ | | 2887| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3836| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3837| 1.69k|case 119: ------------------ | Branch (3837:1): [True: 1.69k, False: 6.25M] ------------------ 3838| 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| 16.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 15.2k, False: 1.69k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3839| 1.69k|#line 179 "flex_lexer.l" 3840| 1.69k|TOKEN(PRECEDING) ------------------ | | 2887| 1.69k|#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: 6.25M] ------------------ 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| 2.02k|case 121: ------------------ | Branch (3847:1): [True: 2.02k, False: 6.25M] ------------------ 3848| 2.02k|YY_RULE_SETUP ------------------ | | 3147| 2.02k| YY_USER_ACTION | | ------------------ | | | | 61| 2.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14.1k, False: 2.02k] | | | | ------------------ | | | | 64| 14.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14.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| 14.1k| } else { \ | | | | 70| 14.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14.1k| } \ | | | | 72| 14.1k| } | | ------------------ ------------------ 3849| 2.02k|#line 181 "flex_lexer.l" 3850| 2.02k|TOKEN(PRIMARY) ------------------ | | 2887| 2.02k|#define TOKEN(name) { return SQL_##name; } ------------------ 3851| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3852| 1.16k|case 122: ------------------ | Branch (3852:1): [True: 1.16k, False: 6.26M] ------------------ 3853| 1.16k|YY_RULE_SETUP ------------------ | | 3147| 1.16k| YY_USER_ACTION | | ------------------ | | | | 61| 1.16k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.16k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.82k, False: 1.16k] | | | | ------------------ | | | | 64| 5.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.82k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.82k| } else { \ | | | | 70| 5.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.82k| } \ | | | | 72| 5.82k| } | | ------------------ ------------------ 3854| 1.16k|#line 182 "flex_lexer.l" 3855| 1.16k|TOKEN(RANGE) ------------------ | | 2887| 1.16k|#define TOKEN(name) { return SQL_##name; } ------------------ 3856| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3857| 2.93k|case 123: ------------------ | Branch (3857:1): [True: 2.93k, False: 6.25M] ------------------ 3858| 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| } | | ------------------ ------------------ 3859| 2.93k|#line 183 "flex_lexer.l" 3860| 2.93k|TOKEN(REAL) ------------------ | | 2887| 2.93k|#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: 6.26M] ------------------ 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: 6.26M] ------------------ 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: 6.26M] ------------------ 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| 601|case 127: ------------------ | Branch (3877:1): [True: 601, False: 6.26M] ------------------ 3878| 601|YY_RULE_SETUP ------------------ | | 3147| 601| YY_USER_ACTION | | ------------------ | | | | 61| 601| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 601| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 601| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.60k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.00k, False: 601] | | | | ------------------ | | | | 64| 3.00k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.00k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.00k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.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| 3.00k| } else { \ | | | | 70| 3.00k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.00k| } \ | | | | 72| 3.00k| } | | ------------------ ------------------ 3879| 601|#line 187 "flex_lexer.l" 3880| 601|TOKEN(RIGHT) ------------------ | | 2887| 601|#define TOKEN(name) { return SQL_##name; } ------------------ 3881| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3882| 2.99k|case 128: ------------------ | Branch (3882:1): [True: 2.99k, False: 6.25M] ------------------ 3883| 2.99k|YY_RULE_SETUP ------------------ | | 3147| 2.99k| YY_USER_ACTION | | ------------------ | | | | 61| 2.99k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.99k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 26.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 26.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 23.9k, False: 2.99k] | | | | ------------------ | | | | 64| 23.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 23.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 23.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 23.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 23.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 23.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 23.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| 23.9k| } else { \ | | | | 70| 23.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 23.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.9k| } \ | | | | 72| 23.9k| } | | ------------------ ------------------ 3884| 2.99k|#line 188 "flex_lexer.l" 3885| 2.99k|TOKEN(ROLLBACK) ------------------ | | 2887| 2.99k|#define TOKEN(name) { return SQL_##name; } ------------------ 3886| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3887| 1.45k|case 129: ------------------ | Branch (3887:1): [True: 1.45k, False: 6.25M] ------------------ 3888| 1.45k|YY_RULE_SETUP ------------------ | | 3147| 1.45k| YY_USER_ACTION | | ------------------ | | | | 61| 1.45k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.45k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.28k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.82k, False: 1.45k] | | | | ------------------ | | | | 64| 5.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.82k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.82k| } else { \ | | | | 70| 5.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.82k| } \ | | | | 72| 5.82k| } | | ------------------ ------------------ 3889| 1.45k|#line 189 "flex_lexer.l" 3890| 1.45k|TOKEN(ROWS) ------------------ | | 2887| 1.45k|#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: 6.26M] ------------------ 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: 6.26M] ------------------ 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| 803|case 132: ------------------ | Branch (3902:1): [True: 803, False: 6.26M] ------------------ 3903| 803|YY_RULE_SETUP ------------------ | | 3147| 803| YY_USER_ACTION | | ------------------ | | | | 61| 803| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 803| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 803| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 803| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 803| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 803| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.62k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.81k, False: 803] | | | | ------------------ | | | | 64| 4.81k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.81k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.81k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.81k] | | | | ------------------ | | | | 67| 0| 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.81k| } else { \ | | | | 70| 4.81k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.81k| } \ | | | | 72| 4.81k| } | | ------------------ ------------------ 3904| 803|#line 192 "flex_lexer.l" 3905| 803|TOKEN(SECOND) ------------------ | | 2887| 803|#define TOKEN(name) { return SQL_##name; } ------------------ 3906| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3907| 870|case 133: ------------------ | Branch (3907:1): [True: 870, False: 6.26M] ------------------ 3908| 870|YY_RULE_SETUP ------------------ | | 3147| 870| YY_USER_ACTION | | ------------------ | | | | 61| 870| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 870| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 870| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 870| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 870| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 870| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.96k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.96k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.09k, False: 870] | | | | ------------------ | | | | 64| 6.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.09k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 6.09k| } else { \ | | | | 70| 6.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.09k| } \ | | | | 72| 6.09k| } | | ------------------ ------------------ 3909| 870|#line 193 "flex_lexer.l" 3910| 870|TOKEN(SECONDS) ------------------ | | 2887| 870|#define TOKEN(name) { return SQL_##name; } ------------------ 3911| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3912| 39.9k|case 134: ------------------ | Branch (3912:1): [True: 39.9k, False: 6.22M] ------------------ 3913| 39.9k|YY_RULE_SETUP ------------------ | | 3147| 39.9k| YY_USER_ACTION | | ------------------ | | | | 61| 39.9k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 39.9k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 39.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 279k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 279k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 239k, False: 39.9k] | | | | ------------------ | | | | 64| 239k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 239k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 239k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 239k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 239k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 239k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 239k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 239k| } else { \ | | | | 70| 239k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 239k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 239k| } \ | | | | 72| 239k| } | | ------------------ ------------------ 3914| 39.9k|#line 194 "flex_lexer.l" 3915| 39.9k|TOKEN(SELECT) ------------------ | | 2887| 39.9k|#define TOKEN(name) { return SQL_##name; } ------------------ 3916| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3917| 1.52k|case 135: ------------------ | Branch (3917:1): [True: 1.52k, False: 6.25M] ------------------ 3918| 1.52k|YY_RULE_SETUP ------------------ | | 3147| 1.52k| YY_USER_ACTION | | ------------------ | | | | 61| 1.52k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.52k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.11k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.11k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.58k, False: 1.52k] | | | | ------------------ | | | | 64| 4.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.58k| } else { \ | | | | 70| 4.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.58k| } \ | | | | 72| 4.58k| } | | ------------------ ------------------ 3919| 1.52k|#line 195 "flex_lexer.l" 3920| 1.52k|TOKEN(SET) ------------------ | | 2887| 1.52k|#define TOKEN(name) { return SQL_##name; } ------------------ 3921| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3922| 4.38k|case 136: ------------------ | Branch (3922:1): [True: 4.38k, False: 6.25M] ------------------ 3923| 4.38k|YY_RULE_SETUP ------------------ | | 3147| 4.38k| YY_USER_ACTION | | ------------------ | | | | 61| 4.38k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.38k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 26.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 26.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 21.9k, False: 4.38k] | | | | ------------------ | | | | 64| 21.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 21.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 21.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 21.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 21.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 21.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 21.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| 21.9k| } else { \ | | | | 70| 21.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 21.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 21.9k| } \ | | | | 72| 21.9k| } | | ------------------ ------------------ 3924| 4.38k|#line 196 "flex_lexer.l" 3925| 4.38k|TOKEN(SHARE) ------------------ | | 2887| 4.38k|#define TOKEN(name) { return SQL_##name; } ------------------ 3926| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3927| 2.71k|case 137: ------------------ | Branch (3927:1): [True: 2.71k, False: 6.25M] ------------------ 3928| 2.71k|YY_RULE_SETUP ------------------ | | 3147| 2.71k| YY_USER_ACTION | | ------------------ | | | | 61| 2.71k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.71k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.71k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.8k, False: 2.71k] | | | | ------------------ | | | | 64| 10.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.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| 10.8k| } else { \ | | | | 70| 10.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.8k| } \ | | | | 72| 10.8k| } | | ------------------ ------------------ 3929| 2.71k|#line 197 "flex_lexer.l" 3930| 2.71k|TOKEN(SHOW) ------------------ | | 2887| 2.71k|#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: 6.26M] ------------------ 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| 558|case 139: ------------------ | Branch (3937:1): [True: 558, False: 6.26M] ------------------ 3938| 558|YY_RULE_SETUP ------------------ | | 3147| 558| YY_USER_ACTION | | ------------------ | | | | 61| 558| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 558| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 558| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.46k, False: 558] | | | | ------------------ | | | | 64| 4.46k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.46k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.46k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.46k] | | | | ------------------ | | | | 67| 0| 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.46k| } else { \ | | | | 70| 4.46k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.46k| } \ | | | | 72| 4.46k| } | | ------------------ ------------------ 3939| 558|#line 199 "flex_lexer.l" 3940| 558|TOKEN(SMALLINT) ------------------ | | 2887| 558|#define TOKEN(name) { return SQL_##name; } ------------------ 3941| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3942| 3|case 140: ------------------ | Branch (3942:1): [True: 3, False: 6.26M] ------------------ 3943| 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| } | | ------------------ ------------------ 3944| 3|#line 200 "flex_lexer.l" 3945| 3|TOKEN(SORTED) ------------------ | | 2887| 3|#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: 6.26M] ------------------ 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| 4.03k|case 142: ------------------ | Branch (3952:1): [True: 4.03k, False: 6.25M] ------------------ 3953| 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.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 24.1k|#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| } | | ------------------ ------------------ 3954| 4.03k|#line 202 "flex_lexer.l" 3955| 4.03k|TOKEN(TABLE) ------------------ | | 2887| 4.03k|#define TOKEN(name) { return SQL_##name; } ------------------ 3956| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3957| 1.40k|case 143: ------------------ | Branch (3957:1): [True: 1.40k, False: 6.25M] ------------------ 3958| 1.40k|YY_RULE_SETUP ------------------ | | 3147| 1.40k| YY_USER_ACTION | | ------------------ | | | | 61| 1.40k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.40k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.83k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.43k, False: 1.40k] | | | | ------------------ | | | | 64| 8.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.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| 8.43k| } else { \ | | | | 70| 8.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.43k| } \ | | | | 72| 8.43k| } | | ------------------ ------------------ 3959| 1.40k|#line 203 "flex_lexer.l" 3960| 1.40k|TOKEN(TABLES) ------------------ | | 2887| 1.40k|#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: 6.26M] ------------------ 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| 524|case 145: ------------------ | Branch (3967:1): [True: 524, False: 6.26M] ------------------ 3968| 524|YY_RULE_SETUP ------------------ | | 3147| 524| YY_USER_ACTION | | ------------------ | | | | 61| 524| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 524| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 524| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.62k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.09k, False: 524] | | | | ------------------ | | | | 64| 2.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.09k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.09k| } else { \ | | | | 70| 2.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.09k| } \ | | | | 72| 2.09k| } | | ------------------ ------------------ 3969| 524|#line 205 "flex_lexer.l" 3970| 524|TOKEN(TEXT) ------------------ | | 2887| 524|#define TOKEN(name) { return SQL_##name; } ------------------ 3971| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3972| 3.25k|case 146: ------------------ | Branch (3972:1): [True: 3.25k, False: 6.25M] ------------------ 3973| 3.25k|YY_RULE_SETUP ------------------ | | 3147| 3.25k| YY_USER_ACTION | | ------------------ | | | | 61| 3.25k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.25k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.0k, False: 3.25k] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3974| 3.25k|#line 206 "flex_lexer.l" 3975| 3.25k|TOKEN(THEN) ------------------ | | 2887| 3.25k|#define TOKEN(name) { return SQL_##name; } ------------------ 3976| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3977| 821|case 147: ------------------ | Branch (3977:1): [True: 821, False: 6.26M] ------------------ 3978| 821|YY_RULE_SETUP ------------------ | | 3147| 821| YY_USER_ACTION | | ------------------ | | | | 61| 821| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 821| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 821| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 821| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 821| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 821| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.10k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.10k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.28k, False: 821] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 3979| 821|#line 207 "flex_lexer.l" 3980| 821|TOKEN(TIME) ------------------ | | 2887| 821|#define TOKEN(name) { return SQL_##name; } ------------------ 3981| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3982| 8.96k|case 148: ------------------ | Branch (3982:1): [True: 8.96k, False: 6.25M] ------------------ 3983| 8.96k|YY_RULE_SETUP ------------------ | | 3147| 8.96k| YY_USER_ACTION | | ------------------ | | | | 61| 8.96k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 8.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 8.96k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 8.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 89.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 89.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 80.6k, False: 8.96k] | | | | ------------------ | | | | 64| 80.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 80.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 80.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 80.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 80.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 80.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 80.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| 80.6k| } else { \ | | | | 70| 80.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 80.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 80.6k| } \ | | | | 72| 80.6k| } | | ------------------ ------------------ 3984| 8.96k|#line 208 "flex_lexer.l" 3985| 8.96k|TOKEN(TIMESTAMP) ------------------ | | 2887| 8.96k|#define TOKEN(name) { return SQL_##name; } ------------------ 3986| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3987| 6.19k|case 149: ------------------ | Branch (3987:1): [True: 6.19k, False: 6.25M] ------------------ 3988| 6.19k|YY_RULE_SETUP ------------------ | | 3147| 6.19k| YY_USER_ACTION | | ------------------ | | | | 61| 6.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 6.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 6.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 6.19k| # 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: 12.3k, False: 6.19k] | | | | ------------------ | | | | 64| 12.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.3k| } else { \ | | | | 70| 12.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.3k| } \ | | | | 72| 12.3k| } | | ------------------ ------------------ 3989| 6.19k|#line 209 "flex_lexer.l" 3990| 6.19k|TOKEN(TO) ------------------ | | 2887| 6.19k|#define TOKEN(name) { return SQL_##name; } ------------------ 3991| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3992| 1.75k|case 150: ------------------ | Branch (3992:1): [True: 1.75k, False: 6.25M] ------------------ 3993| 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| 7.00k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.00k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.25k, False: 1.75k] | | | | ------------------ | | | | 64| 5.25k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.25k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.25k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.25k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.25k| } else { \ | | | | 70| 5.25k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.25k| } \ | | | | 72| 5.25k| } | | ------------------ ------------------ 3994| 1.75k|#line 210 "flex_lexer.l" 3995| 1.75k|TOKEN(TOP) ------------------ | | 2887| 1.75k|#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: 6.26M] ------------------ 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| 513|case 152: ------------------ | Branch (4002:1): [True: 513, False: 6.26M] ------------------ 4003| 513|YY_RULE_SETUP ------------------ | | 3147| 513| YY_USER_ACTION | | ------------------ | | | | 61| 513| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 513| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 513| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 513| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 513| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 513| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.56k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.05k, False: 513] | | | | ------------------ | | | | 64| 2.05k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.05k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.05k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.05k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.05k| } else { \ | | | | 70| 2.05k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.05k| } \ | | | | 72| 2.05k| } | | ------------------ ------------------ 4004| 513|#line 212 "flex_lexer.l" 4005| 513|TOKEN(TRUE) ------------------ | | 2887| 513|#define TOKEN(name) { return SQL_##name; } ------------------ 4006| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4007| 690|case 153: ------------------ | Branch (4007:1): [True: 690, False: 6.26M] ------------------ 4008| 690|YY_RULE_SETUP ------------------ | | 3147| 690| YY_USER_ACTION | | ------------------ | | | | 61| 690| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 690| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 690| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 6.21k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 6.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.52k, False: 690] | | | | ------------------ | | | | 64| 5.52k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.52k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.52k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.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| 5.52k| } else { \ | | | | 70| 5.52k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.52k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.52k| } \ | | | | 72| 5.52k| } | | ------------------ ------------------ 4009| 690|#line 213 "flex_lexer.l" 4010| 690|TOKEN(TRUNCATE) ------------------ | | 2887| 690|#define TOKEN(name) { return SQL_##name; } ------------------ 4011| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4012| 852|case 154: ------------------ | Branch (4012:1): [True: 852, False: 6.26M] ------------------ 4013| 852|YY_RULE_SETUP ------------------ | | 3147| 852| YY_USER_ACTION | | ------------------ | | | | 61| 852| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 852| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 852| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 852| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 852| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 852| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.66k, False: 852] | | | | ------------------ | | | | 64| 7.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.66k| } else { \ | | | | 70| 7.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.66k| } \ | | | | 72| 7.66k| } | | ------------------ ------------------ 4014| 852|#line 214 "flex_lexer.l" 4015| 852|TOKEN(UNBOUNDED) ------------------ | | 2887| 852|#define TOKEN(name) { return SQL_##name; } ------------------ 4016| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4017| 3.10k|case 155: ------------------ | Branch (4017:1): [True: 3.10k, False: 6.25M] ------------------ 4018| 3.10k|YY_RULE_SETUP ------------------ | | 3147| 3.10k| YY_USER_ACTION | | ------------------ | | | | 61| 3.10k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.10k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.10k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.10k| # 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: 15.5k, False: 3.10k] | | | | ------------------ | | | | 64| 15.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 15.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 15.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 15.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 15.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| 15.5k| } else { \ | | | | 70| 15.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 15.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.5k| } \ | | | | 72| 15.5k| } | | ------------------ ------------------ 4019| 3.10k|#line 215 "flex_lexer.l" 4020| 3.10k|TOKEN(UNION) ------------------ | | 2887| 3.10k|#define TOKEN(name) { return SQL_##name; } ------------------ 4021| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4022| 3.46k|case 156: ------------------ | Branch (4022:1): [True: 3.46k, False: 6.25M] ------------------ 4023| 3.46k|YY_RULE_SETUP ------------------ | | 3147| 3.46k| YY_USER_ACTION | | ------------------ | | | | 61| 3.46k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.46k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 24.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 24.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 20.7k, False: 3.46k] | | | | ------------------ | | | | 64| 20.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 20.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 20.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 20.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 20.7k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 20.7k| } else { \ | | | | 70| 20.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 20.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20.7k| } \ | | | | 72| 20.7k| } | | ------------------ ------------------ 4024| 3.46k|#line 216 "flex_lexer.l" 4025| 3.46k|TOKEN(UNIQUE) ------------------ | | 2887| 3.46k|#define TOKEN(name) { return SQL_##name; } ------------------ 4026| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4027| 1|case 157: ------------------ | Branch (4027:1): [True: 1, False: 6.26M] ------------------ 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.30k|case 158: ------------------ | Branch (4032:1): [True: 2.30k, False: 6.25M] ------------------ 4033| 2.30k|YY_RULE_SETUP ------------------ | | 3147| 2.30k| YY_USER_ACTION | | ------------------ | | | | 61| 2.30k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.30k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.30k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 13.8k, False: 2.30k] | | | | ------------------ | | | | 64| 13.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 13.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 13.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 13.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 13.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| 13.8k| } else { \ | | | | 70| 13.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 13.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.8k| } \ | | | | 72| 13.8k| } | | ------------------ ------------------ 4034| 2.30k|#line 218 "flex_lexer.l" 4035| 2.30k|TOKEN(UPDATE) ------------------ | | 2887| 2.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 4036| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4037| 765|case 159: ------------------ | Branch (4037:1): [True: 765, False: 6.26M] ------------------ 4038| 765|YY_RULE_SETUP ------------------ | | 3147| 765| YY_USER_ACTION | | ------------------ | | | | 61| 765| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 765| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 765| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 765| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 765| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 765| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.82k, False: 765] | | | | ------------------ | | | | 64| 3.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.82k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.82k| } else { \ | | | | 70| 3.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.82k| } \ | | | | 72| 3.82k| } | | ------------------ ------------------ 4039| 765|#line 219 "flex_lexer.l" 4040| 765|TOKEN(USING) ------------------ | | 2887| 765|#define TOKEN(name) { return SQL_##name; } ------------------ 4041| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4042| 854|case 160: ------------------ | Branch (4042:1): [True: 854, False: 6.26M] ------------------ 4043| 854|YY_RULE_SETUP ------------------ | | 3147| 854| YY_USER_ACTION | | ------------------ | | | | 61| 854| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 854| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 854| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 854| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 854| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 854| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.97k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.97k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.12k, False: 854] | | | | ------------------ | | | | 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| } | | ------------------ ------------------ 4044| 854|#line 220 "flex_lexer.l" 4045| 854|TOKEN(VALUES) ------------------ | | 2887| 854|#define TOKEN(name) { return SQL_##name; } ------------------ 4046| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4047| 655|case 161: ------------------ | Branch (4047:1): [True: 655, False: 6.26M] ------------------ 4048| 655|YY_RULE_SETUP ------------------ | | 3147| 655| YY_USER_ACTION | | ------------------ | | | | 61| 655| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 655| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 655| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 655| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 655| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 655| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 5.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 5.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 4.58k, False: 655] | | | | ------------------ | | | | 64| 4.58k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 4.58k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 4.58k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 4.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 4.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| 4.58k| } else { \ | | | | 70| 4.58k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 4.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.58k| } \ | | | | 72| 4.58k| } | | ------------------ ------------------ 4049| 655|#line 221 "flex_lexer.l" 4050| 655|TOKEN(VARCHAR) ------------------ | | 2887| 655|#define TOKEN(name) { return SQL_##name; } ------------------ 4051| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4052| 3.17k|case 162: ------------------ | Branch (4052:1): [True: 3.17k, False: 6.25M] ------------------ 4053| 3.17k|YY_RULE_SETUP ------------------ | | 3147| 3.17k| YY_USER_ACTION | | ------------------ | | | | 61| 3.17k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.17k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 15.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 15.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 12.6k, False: 3.17k] | | | | ------------------ | | | | 64| 12.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 12.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 12.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 12.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 12.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| 12.6k| } else { \ | | | | 70| 12.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.6k| } \ | | | | 72| 12.6k| } | | ------------------ ------------------ 4054| 3.17k|#line 222 "flex_lexer.l" 4055| 3.17k|TOKEN(VIEW) ------------------ | | 2887| 3.17k|#define TOKEN(name) { return SQL_##name; } ------------------ 4056| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4057| 2|case 163: ------------------ | Branch (4057:1): [True: 2, False: 6.26M] ------------------ 4058| 2|YY_RULE_SETUP ------------------ | | 3147| 2| YY_USER_ACTION | | ------------------ | | | | 61| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 14, False: 2] | | | | ------------------ | | | | 64| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 14] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 14| } else { \ | | | | 70| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| } \ | | | | 72| 14| } | | ------------------ ------------------ 4059| 2|#line 223 "flex_lexer.l" 4060| 2|TOKEN(VIRTUAL) ------------------ | | 2887| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4061| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4062| 3.30k|case 164: ------------------ | Branch (4062:1): [True: 3.30k, False: 6.25M] ------------------ 4063| 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| } | | ------------------ ------------------ 4064| 3.30k|#line 224 "flex_lexer.l" 4065| 3.30k|TOKEN(WHEN) ------------------ | | 2887| 3.30k|#define TOKEN(name) { return SQL_##name; } ------------------ 4066| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4067| 2.18k|case 165: ------------------ | Branch (4067:1): [True: 2.18k, False: 6.25M] ------------------ 4068| 2.18k|YY_RULE_SETUP ------------------ | | 3147| 2.18k| YY_USER_ACTION | | ------------------ | | | | 61| 2.18k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.18k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 13.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 13.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.9k, False: 2.18k] | | | | ------------------ | | | | 64| 10.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.9k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.9k| } else { \ | | | | 70| 10.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.9k| } \ | | | | 72| 10.9k| } | | ------------------ ------------------ 4069| 2.18k|#line 225 "flex_lexer.l" 4070| 2.18k|TOKEN(WHERE) ------------------ | | 2887| 2.18k|#define TOKEN(name) { return SQL_##name; } ------------------ 4071| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4072| 2.50k|case 166: ------------------ | Branch (4072:1): [True: 2.50k, False: 6.25M] ------------------ 4073| 2.50k|YY_RULE_SETUP ------------------ | | 3147| 2.50k| YY_USER_ACTION | | ------------------ | | | | 61| 2.50k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.50k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 10.0k, False: 2.50k] | | | | ------------------ | | | | 64| 10.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 10.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 10.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 10.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 10.0k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 10.0k| } else { \ | | | | 70| 10.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.0k| } \ | | | | 72| 10.0k| } | | ------------------ ------------------ 4074| 2.50k|#line 226 "flex_lexer.l" 4075| 2.50k|TOKEN(WITH) ------------------ | | 2887| 2.50k|#define TOKEN(name) { return SQL_##name; } ------------------ 4076| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4077| 652|case 167: ------------------ | Branch (4077:1): [True: 652, False: 6.26M] ------------------ 4078| 652|YY_RULE_SETUP ------------------ | | 3147| 652| YY_USER_ACTION | | ------------------ | | | | 61| 652| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 652| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 652| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.26k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.26k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.60k, False: 652] | | | | ------------------ | | | | 64| 2.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.60k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.60k| } else { \ | | | | 70| 2.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.60k| } \ | | | | 72| 2.60k| } | | ------------------ ------------------ 4079| 652|#line 227 "flex_lexer.l" 4080| 652|TOKEN(YEAR) ------------------ | | 2887| 652|#define TOKEN(name) { return SQL_##name; } ------------------ 4081| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4082| 696|case 168: ------------------ | Branch (4082:1): [True: 696, False: 6.26M] ------------------ 4083| 696|YY_RULE_SETUP ------------------ | | 3147| 696| YY_USER_ACTION | | ------------------ | | | | 61| 696| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 696| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 696| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.17k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.17k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.48k, False: 696] | | | | ------------------ | | | | 64| 3.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.48k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.48k| } else { \ | | | | 70| 3.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.48k| } \ | | | | 72| 3.48k| } | | ------------------ ------------------ 4084| 696|#line 228 "flex_lexer.l" 4085| 696|TOKEN(YEARS) ------------------ | | 2887| 696|#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: 6.26M] ------------------ 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: 6.26M] ------------------ 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| 455|case 171: ------------------ | Branch (4100:1): [True: 455, False: 6.26M] ------------------ 4101| 455|YY_RULE_SETUP ------------------ | | 3147| 455| YY_USER_ACTION | | ------------------ | | | | 61| 455| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 455| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 455| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 455| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 455| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 455| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 910, False: 455] | | | | ------------------ | | | | 64| 910| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 910| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 910| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 910| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 910| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 910|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 910] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 910| } else { \ | | | | 70| 910| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 910| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 910| } \ | | | | 72| 910| } | | ------------------ ------------------ 4102| 455|#line 234 "flex_lexer.l" 4103| 455|TOKEN(EQUALS) ------------------ | | 2887| 455|#define TOKEN(name) { return SQL_##name; } ------------------ 4104| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4105| 332|case 172: ------------------ | Branch (4105:1): [True: 332, False: 6.26M] ------------------ 4106| 332|YY_RULE_SETUP ------------------ | | 3147| 332| YY_USER_ACTION | | ------------------ | | | | 61| 332| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 332| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 332| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 332| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 332| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 332| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 996| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 996|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 664, False: 332] | | | | ------------------ | | | | 64| 664| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 664| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 664| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 664| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 664| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 664|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 664] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 664| } else { \ | | | | 70| 664| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 664| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 664| } \ | | | | 72| 664| } | | ------------------ ------------------ 4107| 332|#line 235 "flex_lexer.l" 4108| 332|TOKEN(NOTEQUALS) ------------------ | | 2887| 332|#define TOKEN(name) { return SQL_##name; } ------------------ 4109| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4110| 452|case 173: ------------------ | Branch (4110:1): [True: 452, False: 6.26M] ------------------ 4111| 452|YY_RULE_SETUP ------------------ | | 3147| 452| YY_USER_ACTION | | ------------------ | | | | 61| 452| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 452| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 452| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 452| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 452| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 452| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 904, False: 452] | | | | ------------------ | | | | 64| 904| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 904| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 904| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 904| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 904| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 904|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 904] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 904| } else { \ | | | | 70| 904| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 904| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 904| } \ | | | | 72| 904| } | | ------------------ ------------------ 4112| 452|#line 236 "flex_lexer.l" 4113| 452|TOKEN(NOTEQUALS) ------------------ | | 2887| 452|#define TOKEN(name) { return SQL_##name; } ------------------ 4114| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4115| 343|case 174: ------------------ | Branch (4115:1): [True: 343, False: 6.26M] ------------------ 4116| 343|YY_RULE_SETUP ------------------ | | 3147| 343| YY_USER_ACTION | | ------------------ | | | | 61| 343| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 343| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 343| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 343| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 343| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 343| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 1.02k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 1.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 686, False: 343] | | | | ------------------ | | | | 64| 686| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 686| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 686| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 686| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 686| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 686|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 686] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 686| } else { \ | | | | 70| 686| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 686| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 686| } \ | | | | 72| 686| } | | ------------------ ------------------ 4117| 343|#line 237 "flex_lexer.l" 4118| 343|TOKEN(LESSEQ) ------------------ | | 2887| 343|#define TOKEN(name) { return SQL_##name; } ------------------ 4119| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4120| 1.47k|case 175: ------------------ | Branch (4120:1): [True: 1.47k, False: 6.25M] ------------------ 4121| 1.47k|YY_RULE_SETUP ------------------ | | 3147| 1.47k| YY_USER_ACTION | | ------------------ | | | | 61| 1.47k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.47k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 4.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 4.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.95k, False: 1.47k] | | | | ------------------ | | | | 64| 2.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.95k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.95k| } else { \ | | | | 70| 2.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.95k| } \ | | | | 72| 2.95k| } | | ------------------ ------------------ 4122| 1.47k|#line 238 "flex_lexer.l" 4123| 1.47k|TOKEN(GREATEREQ) ------------------ | | 2887| 1.47k|#define TOKEN(name) { return SQL_##name; } ------------------ 4124| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4125| 4.11k|case 176: ------------------ | Branch (4125:1): [True: 4.11k, False: 6.25M] ------------------ 4126| 4.11k|YY_RULE_SETUP ------------------ | | 3147| 4.11k| YY_USER_ACTION | | ------------------ | | | | 61| 4.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 4.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 4.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 4.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 12.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 12.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 8.23k, False: 4.11k] | | | | ------------------ | | | | 64| 8.23k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 8.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 8.23k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 8.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 8.23k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 8.23k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 8.23k] | | | | ------------------ | | | | 67| 0| 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.23k| } else { \ | | | | 70| 8.23k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 8.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.23k| } \ | | | | 72| 8.23k| } | | ------------------ ------------------ 4127| 4.11k|#line 239 "flex_lexer.l" 4128| 4.11k|TOKEN(CONCAT) ------------------ | | 2887| 4.11k|#define TOKEN(name) { return SQL_##name; } ------------------ 4129| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4130| 3.73M|case 177: ------------------ | Branch (4130:1): [True: 3.73M, False: 2.52M] ------------------ 4131| 3.73M|YY_RULE_SETUP ------------------ | | 3147| 3.73M| YY_USER_ACTION | | ------------------ | | | | 61| 3.73M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 3.73M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 7.46M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 7.46M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.73M, False: 3.73M] | | | | ------------------ | | | | 64| 3.73M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.73M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.73M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.73M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 3.73M] | | | | ------------------ | | | | 67| 0| 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.73M| } else { \ | | | | 70| 3.73M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.73M| } \ | | | | 72| 3.73M| } | | ------------------ ------------------ 4132| 3.73M|#line 241 "flex_lexer.l" 4133| 3.73M|{ return yytext[0]; } ------------------ | | 122| 3.73M|#define yytext yyg->yytext_r ------------------ 4134| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4135| 220|case 178: ------------------ | Branch (4135:1): [True: 220, False: 6.26M] ------------------ 4136| 220|#line 244 "flex_lexer.l" 4137| 563|case 179: ------------------ | Branch (4137:1): [True: 343, False: 6.26M] ------------------ 4138| 563|YY_RULE_SETUP ------------------ | | 3147| 563| YY_USER_ACTION | | ------------------ | | | | 61| 563| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 563| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 563| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 563| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 563| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 563| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 2.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 2.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 2.24k, False: 563] | | | | ------------------ | | | | 64| 2.24k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 2.24k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 2.24k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 2.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 2.24k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 2.24k| } else { \ | | | | 70| 2.24k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.24k| } \ | | | | 72| 2.24k| } | | ------------------ ------------------ 4139| 563|#line 244 "flex_lexer.l" 4140| 563|{ 4141| 563| yylval->fval = atof(yytext); ------------------ | | 2964| 563| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 122| 563|#define yytext yyg->yytext_r ------------------ 4142| 563| return SQL_FLOATVAL; 4143| 220|} 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| 550|case 180: ------------------ | Branch (4150:1): [True: 550, False: 6.26M] ------------------ 4151| 550|YY_RULE_SETUP ------------------ | | 3147| 550| YY_USER_ACTION | | ------------------ | | | | 61| 550| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 550| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 550| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 550| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 550| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 550| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 11.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 11.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 11.0k, False: 550] | | | | ------------------ | | | | 64| 11.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 11.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 11.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 11.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 11.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 11.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 11.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| 11.0k| } else { \ | | | | 70| 11.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 11.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 11.0k| } \ | | | | 72| 11.0k| } | | ------------------ ------------------ 4152| 550|#line 254 "flex_lexer.l" 4153| 550|{ 4154| 550| yylval->ival = LLONG_MIN; ------------------ | | 2964| 550| # define yylval yyg->yylval_r ------------------ 4155| 550| return SQL_INTVAL; 4156| 220|} 4157| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4158| 23.2k|case 181: ------------------ | Branch (4158:1): [True: 23.2k, False: 6.23M] ------------------ 4159| 23.2k|YY_RULE_SETUP ------------------ | | 3147| 23.2k| YY_USER_ACTION | | ------------------ | | | | 61| 23.2k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 23.2k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 23.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 56.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 56.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 33.1k, False: 23.2k] | | | | ------------------ | | | | 64| 33.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 33.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 33.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 33.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 33.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 33.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 33.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| 33.1k| } else { \ | | | | 70| 33.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 33.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 33.1k| } \ | | | | 72| 33.1k| } | | ------------------ ------------------ 4160| 23.2k|#line 259 "flex_lexer.l" 4161| 23.2k|{ 4162| 23.2k| errno = 0; 4163| 23.2k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 2964| 23.2k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 122| 23.2k|#define yytext yyg->yytext_r ------------------ 4164| 23.2k| if (errno) { ------------------ | Branch (4164:7): [True: 6, False: 23.2k] ------------------ 4165| 6| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4166| 0| return 0; 4167| 6| } 4168| 23.2k| return SQL_INTVAL; 4169| 23.2k|} 4170| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4171| 1.97k|case 182: ------------------ | Branch (4171:1): [True: 1.97k, False: 6.25M] ------------------ 4172| 1.97k|YY_RULE_SETUP ------------------ | | 3147| 1.97k| YY_USER_ACTION | | ------------------ | | | | 61| 1.97k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.97k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 9.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 9.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 7.20k, False: 1.97k] | | | | ------------------ | | | | 64| 7.20k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 7.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 7.20k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 7.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 7.20k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 7.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 7.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| 7.20k| } else { \ | | | | 70| 7.20k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 7.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.20k| } \ | | | | 72| 7.20k| } | | ------------------ ------------------ 4173| 1.97k|#line 269 "flex_lexer.l" 4174| 1.97k|{ 4175| | // Crop the leading and trailing quote char 4176| 1.97k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 2964| 1.97k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.97k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 122| 1.97k|#define yytext yyg->yytext_r ------------------ 4177| 1.97k| return SQL_IDENTIFIER; 4178| 23.2k|} 4179| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4180| 1.46M|case 183: ------------------ | Branch (4180:1): [True: 1.46M, False: 4.80M] ------------------ 4181| 1.46M|YY_RULE_SETUP ------------------ | | 3147| 1.46M| YY_USER_ACTION | | ------------------ | | | | 61| 1.46M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 1.46M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 1.46M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 1.46M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.20M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.20M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 6.74M, False: 1.46M] | | | | ------------------ | | | | 64| 6.74M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 6.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 6.74M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 6.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 6.74M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 6.74M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 6.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| 6.74M| } else { \ | | | | 70| 6.74M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 6.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.74M| } \ | | | | 72| 6.74M| } | | ------------------ ------------------ 4182| 1.46M|#line 275 "flex_lexer.l" 4183| 1.46M|{ 4184| 1.46M| yylval->sval = strdup(yytext); ------------------ | | 2964| 1.46M| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 122| 1.46M|#define yytext yyg->yytext_r ------------------ 4185| 1.46M| return SQL_IDENTIFIER; 4186| 23.2k|} 4187| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4188| 22.4k|case 184: ------------------ | Branch (4188:1): [True: 22.4k, False: 6.23M] ------------------ 4189| 22.4k|YY_RULE_SETUP ------------------ | | 3147| 22.4k| YY_USER_ACTION | | ------------------ | | | | 61| 22.4k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 22.4k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 44.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 44.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 22.4k, False: 22.4k] | | | | ------------------ | | | | 64| 22.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 22.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 22.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 22.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 22.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| 22.4k| } else { \ | | | | 70| 22.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 22.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 22.4k| } \ | | | | 72| 22.4k| } | | ------------------ ------------------ 4190| 22.4k|#line 280 "flex_lexer.l" 4191| 22.4k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 131| 22.4k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 2907| 22.4k|#define singlequotedstring 1 ------------------ 4192| 22.4k| YY_BREAK ------------------ | | 3143| 22.4k|#define YY_BREAK /*LINTED*/break; ------------------ 4193| 2.84k|case 185: ------------------ | Branch (4193:1): [True: 2.84k, False: 6.25M] ------------------ 4194| 2.84k|YY_RULE_SETUP ------------------ | | 3147| 2.84k| YY_USER_ACTION | | ------------------ | | | | 61| 2.84k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 2.84k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 2.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 8.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 8.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 5.68k, False: 2.84k] | | | | ------------------ | | | | 64| 5.68k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 5.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 5.68k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 5.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 5.68k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 5.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 5.68k] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 5.68k| } else { \ | | | | 70| 5.68k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 5.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.68k| } \ | | | | 72| 5.68k| } | | ------------------ ------------------ 4195| 2.84k|#line 281 "flex_lexer.l" 4196| 2.84k|{ strbuf << '\''; } 4197| 2.84k| YY_BREAK ------------------ | | 3143| 2.84k|#define YY_BREAK /*LINTED*/break; ------------------ 4198| 12.6k|case 186: ------------------ | Branch (4198:1): [True: 12.6k, False: 6.24M] ------------------ 4199| |/* rule 186 can match eol */ 4200| 12.6k|YY_RULE_SETUP ------------------ | | 3147| 12.6k| YY_USER_ACTION | | ------------------ | | | | 61| 12.6k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 12.6k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 12.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 3.34M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 3.34M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 3.33M, False: 12.6k] | | | | ------------------ | | | | 64| 3.33M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 3.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 3.33M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 3.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 3.33M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 3.33M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 3.89k, False: 3.33M] | | | | ------------------ | | | | 67| 3.89k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 3.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.89k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 3.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 3.33M| } else { \ | | | | 70| 3.33M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 3.33M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.33M| } \ | | | | 72| 3.33M| } | | ------------------ ------------------ 4201| 12.6k|#line 282 "flex_lexer.l" 4202| 12.6k|{ strbuf << yytext; } ------------------ | | 122| 12.6k|#define yytext yyg->yytext_r ------------------ 4203| 12.6k| YY_BREAK ------------------ | | 3143| 12.6k|#define YY_BREAK /*LINTED*/break; ------------------ 4204| 22.3k|case 187: ------------------ | Branch (4204:1): [True: 22.3k, False: 6.23M] ------------------ 4205| 22.3k|YY_RULE_SETUP ------------------ | | 3147| 22.3k| YY_USER_ACTION | | ------------------ | | | | 61| 22.3k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 22.3k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 44.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 44.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 22.3k, False: 22.3k] | | | | ------------------ | | | | 64| 22.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 22.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 22.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 22.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 22.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| 22.3k| } else { \ | | | | 70| 22.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 22.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 22.3k| } \ | | | | 72| 22.3k| } | | ------------------ ------------------ 4206| 22.3k|#line 283 "flex_lexer.l" 4207| 22.3k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 131| 22.3k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 2964| 22.3k| # define yylval yyg->yylval_r ------------------ 4208| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4209| 109|case YY_STATE_EOF(singlequotedstring): ------------------ | | 141| 109|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 109|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4209:1): [True: 109, False: 6.26M] ------------------ 4210| 109|#line 284 "flex_lexer.l" 4211| 109|{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } 4212| 0| YY_BREAK ------------------ | | 3143| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4213| 136|case 188: ------------------ | Branch (4213:1): [True: 136, False: 6.26M] ------------------ 4214| 136|YY_RULE_SETUP ------------------ | | 3147| 136| YY_USER_ACTION | | ------------------ | | | | 61| 136| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 62| 136| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 63| 272| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 122| 272|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (63:19): [True: 136, False: 136] | | | | ------------------ | | | | 64| 136| yylloc->total_column++; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 65| 136| yylloc->string_length++; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 66| 136| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 122| 136|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (66:9): [True: 0, False: 136] | | | | ------------------ | | | | 67| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 2966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 69| 136| } else { \ | | | | 70| 136| yylloc->last_column++; \ | | | | ------------------ | | | | | | 2966| 136| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 136| } \ | | | | 72| 136| } | | ------------------ ------------------ 4215| 136|#line 286 "flex_lexer.l" 4216| 136|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 122| 136|#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: 6.26M] ------------------ 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| 3.52k|case YY_STATE_EOF(INITIAL): ------------------ | | 141| 3.52k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.52k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4224:1): [True: 3.52k, False: 6.25M] ------------------ 4225| 3.57k|case YY_STATE_EOF(COMMENT): ------------------ | | 141| 3.57k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.57k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ | Branch (4225:1): [True: 55, False: 6.26M] ------------------ 4226| 3.57k| yyterminate(); ------------------ | | 3106| 3.57k|#define yyterminate() return YY_NULL | | ------------------ | | | | 101| 3.57k|#define YY_NULL 0 | | ------------------ ------------------ 4227| | 4228| 9.24k| case YY_END_OF_BUFFER: ------------------ | | 351| 9.24k|#define YY_END_OF_BUFFER 190 ------------------ | Branch (4228:2): [True: 9.24k, False: 6.25M] ------------------ 4229| 9.24k| { 4230| | /* Amount of text matched not including the EOB char. */ 4231| 9.24k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 333| 9.24k|#define yytext_ptr yytext_r ------------------ 4232| | 4233| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4234| 9.24k| *yy_cp = yyg->yy_hold_char; 4235| 9.24k| YY_RESTORE_YY_MORE_OFFSET 4236| | 4237| 9.24k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 276| 9.24k|#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| 9.24k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4237:8): [True: 5.55k, False: 3.69k] ------------------ 4238| 5.55k| { 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| 5.55k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 5.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4249| 5.55k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 276| 5.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 118| 5.55k|#define yyin yyg->yyin_r ------------------ 4250| 5.55k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 276| 5.55k|#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| 5.55k|#define YY_BUFFER_NORMAL 1 ------------------ 4251| 5.55k| } 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| 9.24k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 276| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4260:8): [True: 0, False: 9.24k] ------------------ 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| 9.24k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4297:17): [True: 9.24k, False: 0] ------------------ 4298| 9.24k| { 4299| 3.68k| case EOB_ACT_END_OF_FILE: ------------------ | | 176| 3.68k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4299:4): [True: 3.68k, False: 5.55k] ------------------ 4300| 3.68k| { 4301| 3.68k| yyg->yy_did_buffer_switch_on_eof = 0; 4302| | 4303| 3.68k| if ( hsql_wrap(yyscanner ) ) ------------------ | | 326| 3.68k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | ------------------ | | | Branch (326:30): [True: 3.68k, Folded] | | ------------------ ------------------ 4304| 3.68k| { 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.68k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 3.68k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 3.68k|#define YY_MORE_ADJ 0 ------------------ 4315| | 4316| 3.68k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 141| 3.68k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 351| 3.68k|#define YY_END_OF_BUFFER 190 | | ------------------ ------------------ 4317| 3.68k| goto do_action; 4318| 3.68k| } 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.68k| } 4327| | 4328| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 175| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4328:4): [True: 0, False: 9.24k] ------------------ 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| 5.55k| case EOB_ACT_LAST_MATCH: ------------------ | | 177| 5.55k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4338:4): [True: 5.55k, False: 3.68k] ------------------ 4339| 5.55k| yyg->yy_c_buf_p = 4340| 5.55k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 276| 5.55k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4341| | 4342| 5.55k| yy_current_state = yy_get_previous_state( yyscanner ); 4343| | 4344| 5.55k| yy_cp = yyg->yy_c_buf_p; 4345| 5.55k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 333| 5.55k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 2868| 5.55k|#define YY_MORE_ADJ 0 ------------------ 4346| 5.55k| goto yy_find_action; 4347| 9.24k| } 4348| 0| break; 4349| 9.24k| } 4350| | 4351| 0| default: ------------------ | Branch (4351:2): [True: 0, False: 6.26M] ------------------ 4352| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4353| 6.26M| "fatal flex scanner internal error--no action found" ); 4354| 6.26M| } /* end of action switch */ 4355| 6.26M| } /* end of scanning one token */ 4356| 5.77M| } /* end of user's declarations */ 4357| 5.77M|} /* end of hsql_lex */ _Z22hsql__switch_to_bufferP15yy_buffer_statePv: 4662| 6.07k|{ 4663| 6.07k| 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| 6.07k| hsql_ensure_buffer_stack (yyscanner); 4671| 6.07k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 269| 6.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 6.07k, False: 0] | | ------------------ | | 270| 6.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 6.07k| : NULL) ------------------ | Branch (4671:7): [True: 0, False: 6.07k] ------------------ 4672| 0| return; 4673| | 4674| 6.07k| if ( YY_CURRENT_BUFFER ) ------------------ | | 269| 6.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 6.07k] | | | Branch (269:29): [True: 6.07k, False: 0] | | ------------------ | | 270| 6.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 6.07k| : 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| 6.07k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 276| 6.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4683| 6.07k| 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| 6.07k| yyg->yy_did_buffer_switch_on_eof = 1; 4691| 6.07k|} _Z19hsql__delete_bufferP15yy_buffer_statePv: 4737| 6.07k|{ 4738| 6.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4739| | 4740| 6.07k| if ( ! b ) ------------------ | Branch (4740:7): [True: 0, False: 6.07k] ------------------ 4741| 0| return; 4742| | 4743| 6.07k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 269| 6.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:29): [True: 6.07k, False: 0] | | ------------------ | | 270| 6.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 6.07k| : NULL) ------------------ | Branch (4743:7): [True: 6.07k, False: 0] ------------------ 4744| 6.07k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 276| 6.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4745| | 4746| 6.07k| if ( b->yy_is_our_buffer ) ------------------ | Branch (4746:7): [True: 6.07k, False: 0] ------------------ 4747| 6.07k| hsql_free((void *) b->yy_ch_buf ,yyscanner ); 4748| | 4749| 6.07k| hsql_free((void *) b ,yyscanner ); 4750| 6.07k|} _Z17hsql__scan_bufferPcmPv: 4917| 6.07k|{ 4918| 6.07k| YY_BUFFER_STATE b; 4919| | 4920| 6.07k| if ( size < 2 || ------------------ | Branch (4920:7): [True: 0, False: 6.07k] ------------------ 4921| 6.07k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 146| 12.1k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4921:7): [True: 0, False: 6.07k] ------------------ 4922| 6.07k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 146| 6.07k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (4922:7): [True: 0, False: 6.07k] ------------------ 4923| | /* They forgot to leave room for the EOB's. */ 4924| 0| return NULL; 4925| | 4926| 6.07k| b = (YY_BUFFER_STATE) hsql_alloc(sizeof( struct yy_buffer_state ) ,yyscanner ); 4927| 6.07k| if ( ! b ) ------------------ | Branch (4927:7): [True: 0, False: 6.07k] ------------------ 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| 6.07k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 4931| 6.07k| b->yy_buf_pos = b->yy_ch_buf = base; 4932| 6.07k| b->yy_is_our_buffer = 0; 4933| 6.07k| b->yy_input_file = NULL; 4934| 6.07k| b->yy_n_chars = b->yy_buf_size; 4935| 6.07k| b->yy_is_interactive = 0; 4936| 6.07k| b->yy_at_bol = 1; 4937| 6.07k| b->yy_fill_buffer = 0; 4938| 6.07k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 246| 6.07k|#define YY_BUFFER_NEW 0 ------------------ 4939| | 4940| 6.07k| hsql__switch_to_buffer(b ,yyscanner ); 4941| | 4942| 6.07k| return b; 4943| 6.07k|} _Z17hsql__scan_stringPKcPv: 4954| 6.07k|{ 4955| | 4956| 6.07k| return hsql__scan_bytes(yystr,(int) strlen(yystr) ,yyscanner); 4957| 6.07k|} _Z16hsql__scan_bytesPKciPv: 4967| 6.07k|{ 4968| 6.07k| YY_BUFFER_STATE b; 4969| 6.07k| char *buf; 4970| 6.07k| yy_size_t n; 4971| 6.07k| int i; 4972| | 4973| | /* Get memory for full buffer, including space for trailing EOB's. */ 4974| 6.07k| n = (yy_size_t) (_yybytes_len + 2); 4975| 6.07k| buf = (char *) hsql_alloc(n ,yyscanner ); 4976| 6.07k| if ( ! buf ) ------------------ | Branch (4976:7): [True: 0, False: 6.07k] ------------------ 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| 26.2M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (4979:15): [True: 26.2M, False: 6.07k] ------------------ 4980| 26.2M| buf[i] = yybytes[i]; 4981| | 4982| 6.07k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 146| 6.07k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4983| | 4984| 6.07k| b = hsql__scan_buffer(buf,n ,yyscanner); 4985| 6.07k| if ( ! b ) ------------------ | Branch (4985:7): [True: 0, False: 6.07k] ------------------ 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| 6.07k| b->yy_is_our_buffer = 1; 4992| | 4993| 6.07k| return b; 4994| 6.07k|} _Z13hsql_lex_initPPv: 5204| 6.07k|{ 5205| 6.07k| if (ptr_yy_globals == NULL){ ------------------ | Branch (5205:9): [True: 0, False: 6.07k] ------------------ 5206| 0| errno = EINVAL; 5207| 0| return 1; 5208| 0| } 5209| | 5210| 6.07k| *ptr_yy_globals = (yyscan_t) hsql_alloc ( sizeof( struct yyguts_t ), NULL ); 5211| | 5212| 6.07k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (5212:9): [True: 0, False: 6.07k] ------------------ 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| 6.07k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 5219| | 5220| 6.07k| return yy_init_globals ( *ptr_yy_globals ); 5221| 6.07k|} _Z16hsql_lex_destroyPv: 5294| 6.07k|{ 5295| 6.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5296| | 5297| | /* Pop the buffer stack, destroying each element. */ 5298| 6.07k| while(YY_CURRENT_BUFFER){ ------------------ | | 269| 6.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (269:27): [True: 0, False: 6.07k] | | | Branch (269:29): [True: 6.07k, False: 0] | | ------------------ | | 270| 6.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 271| 6.07k| : 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| 6.07k| hsql_free(yyg->yy_buffer_stack ,yyscanner); 5306| 6.07k| yyg->yy_buffer_stack = NULL; 5307| | 5308| | /* Destroy the start condition stack. */ 5309| 6.07k| hsql_free(yyg->yy_start_stack ,yyscanner ); 5310| 6.07k| 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| 6.07k| yy_init_globals( yyscanner); 5315| | 5316| | /* Destroy the main struct (reentrant only). */ 5317| 6.07k| hsql_free ( yyscanner , yyscanner ); 5318| | yyscanner = NULL; 5319| 6.07k| return 0; 5320| 6.07k|} _Z10hsql_allocmPv: 5350| 24.2k|{ 5351| 24.2k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5352| 24.2k| (void)yyg; 5353| 24.2k| return malloc(size); 5354| 24.2k|} _Z9hsql_freePvS_: 5372| 30.3k|{ 5373| 30.3k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5374| 30.3k| (void)yyg; 5375| 30.3k| free( (char *) ptr ); /* see hsql_realloc() for (char *) cast */ 5376| 30.3k|} flex_lexer.cpp:_ZL18yy_get_next_bufferPv: 4367| 9.24k|{ 4368| 9.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4369| 9.24k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 276| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4370| 9.24k| char *source = yyg->yytext_ptr; ------------------ | | 333| 9.24k|#define yytext_ptr yytext_r ------------------ 4371| 9.24k| yy_size_t number_to_move, i; 4372| 9.24k| int ret_val; 4373| | 4374| 9.24k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 276| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4374:7): [True: 0, False: 9.24k] ------------------ 4375| 0| YY_FATAL_ERROR( ------------------ | | 3116| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4376| 9.24k| "fatal flex scanner internal error--end of buffer missed" ); 4377| | 4378| 9.24k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 276| 9.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4378:7): [True: 9.24k, False: 0] ------------------ 4379| 9.24k| { /* Don't try to fill the buffer, so this is an EOF. */ 4380| 9.24k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 333| 9.24k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 2868| 9.24k|#define YY_MORE_ADJ 0 ------------------ | Branch (4380:8): [True: 3.68k, False: 5.55k] ------------------ 4381| 3.68k| { 4382| | /* We matched a single character, the EOB, so 4383| | * treat this as a final EOF. 4384| | */ 4385| 3.68k| return EOB_ACT_END_OF_FILE; ------------------ | | 176| 3.68k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4386| 3.68k| } 4387| | 4388| 5.55k| else 4389| 5.55k| { 4390| | /* We matched some text prior to the EOB, first 4391| | * process it. 4392| | */ 4393| 5.55k| return EOB_ACT_LAST_MATCH; ------------------ | | 177| 5.55k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4394| 5.55k| } 4395| 9.24k| } 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| 5.55k|{ 4503| 5.55k| yy_state_type yy_current_state; 4504| 5.55k| char *yy_cp; 4505| 5.55k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4506| | 4507| 5.55k| yy_current_state = yyg->yy_start; 4508| | 4509| 7.42M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 333| 5.55k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 2868| 5.55k|#define YY_MORE_ADJ 0 ------------------ | Branch (4509:47): [True: 7.42M, False: 5.55k] ------------------ 4510| 7.42M| { 4511| 7.42M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 108| 7.42M|#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ------------------ | Branch (4511:19): [True: 7.42M, False: 0] ------------------ 4512| 7.42M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4512:8): [True: 1.06M, False: 6.36M] ------------------ 4513| 1.06M| { 4514| 1.06M| yyg->yy_last_accepting_state = yy_current_state; 4515| 1.06M| yyg->yy_last_accepting_cpos = yy_cp; 4516| 1.06M| } 4517| 14.8M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4517:11): [True: 7.40M, False: 7.42M] ------------------ 4518| 7.40M| { 4519| 7.40M| yy_current_state = (int) yy_def[yy_current_state]; 4520| 7.40M| if ( yy_current_state >= 1368 ) ------------------ | Branch (4520:9): [True: 7.40M, False: 577] ------------------ 4521| 7.40M| yy_c = yy_meta[(unsigned int) yy_c]; 4522| 7.40M| } 4523| 7.42M| yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c]; 4524| 7.42M| } 4525| | 4526| 5.55k| return yy_current_state; 4527| 5.55k|} flex_lexer.cpp:_ZL23hsql__load_buffer_statePv: 4694| 12.1k|{ 4695| 12.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4696| 12.1k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 276| 12.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4697| 12.1k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 333| 12.1k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 276| 12.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4698| 12.1k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 118| 12.1k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 276| 12.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4699| 12.1k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 4700| 12.1k|} flex_lexer.cpp:_ZL24hsql_ensure_buffer_stackPv: 4867| 6.07k|{ 4868| 6.07k| int num_to_alloc; 4869| 6.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4870| | 4871| 6.07k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (4871:6): [True: 6.07k, 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| 6.07k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 4878| 6.07k| yyg->yy_buffer_stack = (struct yy_buffer_state**)hsql_alloc 4879| 6.07k| (num_to_alloc * sizeof(struct yy_buffer_state*) 4880| 6.07k| , yyscanner); 4881| 6.07k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (4881:8): [True: 0, False: 6.07k] ------------------ 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| 6.07k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 4885| | 4886| 6.07k| yyg->yy_buffer_stack_max = num_to_alloc; 4887| 6.07k| yyg->yy_buffer_stack_top = 0; 4888| 6.07k| return; 4889| 6.07k| } 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| 12.1k|{ 5261| 12.1k| 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| 12.1k| yyg->yy_buffer_stack = NULL; 5267| 12.1k| yyg->yy_buffer_stack_top = 0; 5268| 12.1k| yyg->yy_buffer_stack_max = 0; 5269| 12.1k| yyg->yy_c_buf_p = NULL; 5270| 12.1k| yyg->yy_init = 0; 5271| 12.1k| yyg->yy_start = 0; 5272| | 5273| 12.1k| yyg->yy_start_stack_ptr = 0; 5274| 12.1k| yyg->yy_start_stack_depth = 0; 5275| 12.1k| yyg->yy_start_stack = NULL; 5276| | 5277| |/* Defined in main.c */ 5278| |#ifdef YY_STDINIT 5279| | yyin = stdin; 5280| | yyout = stdout; 5281| |#else 5282| 12.1k| yyin = NULL; ------------------ | | 118| 12.1k|#define yyin yyg->yyin_r ------------------ 5283| 12.1k| yyout = NULL; ------------------ | | 119| 12.1k|#define yyout yyg->yyout_r ------------------ 5284| 12.1k|#endif 5285| | 5286| | /* For future reference: Set errno on error, since we are called by 5287| | * hsql_lex_init() 5288| | */ 5289| 12.1k| return 0; 5290| 12.1k|} _ZN4hsql15TableConstraintC2ENS_14ConstraintTypeEPNSt3__16vectorIPcNS2_9allocatorIS4_EEEE: 29| 1.77k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 31| 1.77k|TableConstraint::~TableConstraint() { 32| 1.99k| for (auto* column : *columnNames) { ------------------ | Branch (32:21): [True: 1.99k, False: 1.77k] ------------------ 33| 1.99k| free(column); 34| 1.99k| } 35| 1.77k| delete columnNames; 36| 1.77k|} _ZN4hsql17ColumnConstraintsC2Ev: 59| 35.5k| : 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| 35.5k| : column_constraints(column_constraints), name(name), type(type), nullable(true), references(references) {} _ZN4hsql16ColumnDefinitionD2Ev: 66| 35.5k|ColumnDefinition::~ColumnDefinition() { 67| 35.5k| free(name); 68| 35.5k| delete column_constraints; 69| 35.5k| if (references) { ------------------ | Branch (69:7): [True: 35.5k, False: 0] ------------------ 70| 35.5k| for (auto* ref : *references) { ------------------ | Branch (70:20): [True: 0, False: 35.5k] ------------------ 71| 0| delete ref; 72| 0| } 73| 35.5k| } 74| 35.5k| delete references; 75| 35.5k|} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 77| 35.5k|bool ColumnDefinition::trySetNullableExplicit() { 78| 35.5k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (78:7): [True: 1.69k, False: 33.8k] | Branch (78:7): [True: 2.37k, False: 33.1k] | Branch (78:61): [True: 682, False: 33.1k] ------------------ 79| 2.37k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (79:9): [True: 1.46k, False: 911] ------------------ 80| 1.46k| return false; 81| 1.46k| } 82| 911| nullable = false; 83| 911| } 84| | 85| 34.0k| return true; 86| 35.5k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 90| 4.49k| : SQLStatement(kStmtCreate), 91| 4.49k| type(type), 92| 4.49k| ifNotExists(false), 93| 4.49k| filePath(nullptr), 94| 4.49k| schema(nullptr), 95| 4.49k| tableName(nullptr), 96| 4.49k| indexName(nullptr), 97| 4.49k| indexColumns(nullptr), 98| 4.49k| columns(nullptr), 99| 4.49k| tableConstraints(nullptr), 100| 4.49k| viewColumns(nullptr), 101| 4.49k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 103| 4.49k|CreateStatement::~CreateStatement() { 104| 4.49k| free(filePath); 105| 4.49k| free(schema); 106| 4.49k| free(tableName); 107| 4.49k| free(indexName); 108| 4.49k| delete select; 109| | 110| 4.49k| if (columns) { ------------------ | Branch (110:7): [True: 2.36k, False: 2.13k] ------------------ 111| 3.41k| for (auto* def : *columns) { ------------------ | Branch (111:20): [True: 3.41k, False: 2.36k] ------------------ 112| 3.41k| delete def; 113| 3.41k| } 114| 2.36k| delete columns; 115| 2.36k| } 116| | 117| 4.49k| if (tableConstraints) { ------------------ | Branch (117:7): [True: 2.36k, False: 2.13k] ------------------ 118| 2.36k| for (auto* def : *tableConstraints) { ------------------ | Branch (118:20): [True: 1.50k, False: 2.36k] ------------------ 119| 1.50k| delete def; 120| 1.50k| } 121| 2.36k| delete tableConstraints; 122| 2.36k| } 123| | 124| 4.49k| if (indexColumns) { ------------------ | Branch (124:7): [True: 794, False: 3.70k] ------------------ 125| 988| for (char* column : *indexColumns) { ------------------ | Branch (125:23): [True: 988, False: 794] ------------------ 126| 988| free(column); 127| 988| } 128| 794| delete indexColumns; 129| 794| } 130| | 131| 4.49k| if (viewColumns) { ------------------ | Branch (131:7): [True: 376, False: 4.12k] ------------------ 132| 690| for (char* column : *viewColumns) { ------------------ | Branch (132:23): [True: 690, False: 376] ------------------ 133| 690| free(column); 134| 690| } 135| 376| delete viewColumns; 136| 376| } 137| 4.49k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 139| 2.36k|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 140| 2.36k| columns = new std::vector(); 141| 2.36k| tableConstraints = new std::vector(); 142| | 143| 4.92k| for (auto tableElem : *tableElements) { ------------------ | Branch (143:23): [True: 4.92k, False: 2.36k] ------------------ 144| 4.92k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (144:15): [True: 3.41k, False: 1.50k] ------------------ 145| 3.41k| columns->emplace_back(colDef); 146| 3.41k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (146:22): [True: 1.50k, False: 0] ------------------ 147| 1.50k| tableConstraints->emplace_back(tableConstraint); 148| 1.50k| } 149| 4.92k| } 150| 2.36k|} _ZN4hsql12TableElementD2Ev: 18| 37.3k| virtual ~TableElement() = default; _ZN4hsql10FrameBoundC2ElNS_14FrameBoundTypeEb: 12| 11.0k| : offset{offset}, type{type}, unbounded{unbounded} {} _ZN4hsql16FrameDescriptionC2ENS_9FrameTypeEPNS_10FrameBoundES3_: 15| 5.51k| : type{type}, start{start}, end{end} {} _ZN4hsql16FrameDescriptionD2Ev: 17| 5.51k|FrameDescription::~FrameDescription() { 18| 5.51k| delete start; 19| 5.51k| delete end; 20| 5.51k|} _ZN4hsql17WindowDescriptionC2EPNSt3__16vectorIPNS_4ExprENS1_9allocatorIS4_EEEEPNS2_IPNS_16OrderDescriptionENS5_ISA_EEEEPNS_16FrameDescriptionE: 24| 5.44k| : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {} _ZN4hsql17WindowDescriptionD2Ev: 26| 5.44k|WindowDescription::~WindowDescription() { 27| 5.44k| if (partitionList) { ------------------ | Branch (27:7): [True: 784, False: 4.65k] ------------------ 28| 1.29k| for (Expr* e : *partitionList) { ------------------ | Branch (28:18): [True: 1.29k, False: 784] ------------------ 29| 1.29k| delete e; 30| 1.29k| } 31| 784| delete partitionList; 32| 784| } 33| | 34| 5.44k| if (orderList) { ------------------ | Branch (34:7): [True: 432, False: 5.00k] ------------------ 35| 1.32k| for (OrderDescription* orderDescription : *orderList) { ------------------ | Branch (35:45): [True: 1.32k, False: 432] ------------------ 36| 1.32k| delete orderDescription; 37| 1.32k| } 38| 432| delete orderList; 39| 432| } 40| | 41| 5.44k| delete frameDescription; 42| 5.44k|} _ZN4hsql4ExprC2ENS_8ExprTypeE: 45| 3.19M| : type(type), 46| 3.19M| expr(nullptr), 47| 3.19M| expr2(nullptr), 48| 3.19M| exprList(nullptr), 49| 3.19M| select(nullptr), 50| 3.19M| name(nullptr), 51| 3.19M| table(nullptr), 52| 3.19M| schema(nullptr), 53| 3.19M| alias(nullptr), 54| 3.19M| fval(0), 55| 3.19M| ival(0), 56| 3.19M| ival2(0), 57| 3.19M| datetimeField(kDatetimeNone), 58| 3.19M| columnType(DataType::UNKNOWN, 0), 59| 3.19M| isBoolLiteral(false), 60| 3.19M| opType(kOpNone), 61| 3.19M| distinct(false), 62| 3.19M| windowDescription(nullptr) {} _ZN4hsql4ExprD2Ev: 64| 3.19M|Expr::~Expr() { 65| 3.19M| delete expr; 66| 3.19M| delete expr2; 67| 3.19M| delete select; 68| 3.19M| delete windowDescription; 69| | 70| 3.19M| free(name); 71| 3.19M| free(table); 72| 3.19M| free(schema); 73| 3.19M| free(alias); 74| | 75| 3.19M| if (exprList) { ------------------ | Branch (75:7): [True: 11.7k, False: 3.18M] ------------------ 76| 11.7k| for (Expr* e : *exprList) { ------------------ | Branch (76:18): [True: 11.5k, False: 11.7k] ------------------ 77| 11.5k| delete e; 78| 11.5k| } 79| 11.7k| delete exprList; 80| 11.7k| } 81| 3.19M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 83| 2.29k|Expr* Expr::make(ExprType type) { 84| 2.29k| Expr* e = new Expr(type); 85| 2.29k| return e; 86| 2.29k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 88| 11.8k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 89| 11.8k| Expr* e = new Expr(kExprOperator); 90| 11.8k| e->opType = op; 91| 11.8k| e->expr = expr; 92| 11.8k| e->expr2 = nullptr; 93| 11.8k| return e; 94| 11.8k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 96| 1.03M|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 97| 1.03M| Expr* e = new Expr(kExprOperator); 98| 1.03M| e->opType = op; 99| 1.03M| e->expr = expr1; 100| 1.03M| e->expr2 = expr2; 101| 1.03M| return e; 102| 1.03M|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 104| 494|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 105| 494| Expr* e = new Expr(kExprOperator); 106| 494| e->expr = expr; 107| 494| e->opType = kOpBetween; 108| 494| e->exprList = new std::vector(); 109| 494| e->exprList->push_back(left); 110| 494| e->exprList->push_back(right); 111| 494| return e; 112| 494|} _ZN4hsql4Expr12makeCaseListEPS0_: 114| 1.82k|Expr* Expr::makeCaseList(Expr* caseListElement) { 115| 1.82k| 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.82k| e->opType = kOpNone; 119| 1.82k| e->exprList = new std::vector(); 120| 1.82k| e->exprList->push_back(caseListElement); 121| 1.82k| return e; 122| 1.82k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 124| 3.23k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 125| 3.23k| Expr* e = new Expr(kExprOperator); 126| 3.23k| e->opType = kOpCaseListElement; 127| 3.23k| e->expr = when; 128| 3.23k| e->expr2 = then; 129| 3.23k| return e; 130| 3.23k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 132| 1.40k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 133| 1.40k| caseList->exprList->push_back(caseListElement); 134| 1.40k| return caseList; 135| 1.40k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 137| 1.53k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 138| 1.53k| Expr* e = new Expr(kExprOperator); 139| 1.53k| e->opType = kOpCase; 140| 1.53k| e->expr = expr; 141| 1.53k| e->expr2 = elseExpr; 142| 1.53k| e->exprList = caseList->exprList; 143| 1.53k| caseList->exprList = nullptr; 144| 1.53k| delete caseList; 145| 1.53k| return e; 146| 1.53k|} _ZN4hsql4Expr11makeLiteralEl: 148| 9.71k|Expr* Expr::makeLiteral(int64_t val) { 149| 9.71k| Expr* e = new Expr(kExprLiteralInt); 150| 9.71k| e->ival = val; 151| 9.71k| return e; 152| 9.71k|} _ZN4hsql4Expr11makeLiteralEd: 154| 538|Expr* Expr::makeLiteral(double value) { 155| 538| Expr* e = new Expr(kExprLiteralFloat); 156| 538| e->fval = value; 157| 538| return e; 158| 538|} _ZN4hsql4Expr11makeLiteralEPc: 160| 2.94k|Expr* Expr::makeLiteral(char* string) { 161| 2.94k| Expr* e = new Expr(kExprLiteralString); 162| 2.94k| e->name = string; 163| 2.94k| return e; 164| 2.94k|} _ZN4hsql4Expr11makeLiteralEb: 166| 1.43k|Expr* Expr::makeLiteral(bool val) { 167| 1.43k| Expr* e = new Expr(kExprLiteralInt); 168| 1.43k| e->ival = (int)val; 169| 1.43k| e->isBoolLiteral = true; 170| 1.43k| return e; 171| 1.43k|} _ZN4hsql4Expr15makeNullLiteralEv: 173| 1.01k|Expr* Expr::makeNullLiteral() { 174| 1.01k| Expr* e = new Expr(kExprLiteralNull); 175| 1.01k| return e; 176| 1.01k|} _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| 13.3k|Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) { 185| 13.3k| Expr* e = new Expr(kExprLiteralInterval); 186| 13.3k| e->ival = duration; 187| 13.3k| e->datetimeField = unit; 188| 13.3k| return e; 189| 13.3k|} _ZN4hsql4Expr13makeColumnRefEPc: 191| 868k|Expr* Expr::makeColumnRef(char* name) { 192| 868k| Expr* e = new Expr(kExprColumnRef); 193| 868k| e->name = name; 194| 868k| return e; 195| 868k|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 197| 389|Expr* Expr::makeColumnRef(char* table, char* name) { 198| 389| Expr* e = new Expr(kExprColumnRef); 199| 389| e->name = name; 200| 389| e->table = table; 201| 389| return e; 202| 389|} _ZN4hsql4Expr8makeStarEv: 204| 981k|Expr* Expr::makeStar(void) { 205| 981k| Expr* e = new Expr(kExprStar); 206| 981k| return e; 207| 981k|} _ZN4hsql4Expr8makeStarEPc: 209| 260|Expr* Expr::makeStar(char* table) { 210| 260| Expr* e = new Expr(kExprStar); 211| 260| e->table = table; 212| 260| return e; 213| 260|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 215| 7.60k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct, WindowDescription* window) { 216| 7.60k| Expr* e = new Expr(kExprFunctionRef); 217| 7.60k| e->name = func_name; 218| 7.60k| e->exprList = exprList; 219| 7.60k| e->distinct = distinct; 220| 7.60k| e->windowDescription = window; 221| 7.60k| return e; 222| 7.60k|} _ZN4hsql4Expr15makeFunctionRefEPcS1_PNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 224| 415|Expr* Expr::makeFunctionRef(char* func_name, char* schema, std::vector* exprList, bool distinct, WindowDescription* window) { 225| 415| Expr* e = new Expr(kExprFunctionRef); 226| 415| e->name = func_name; 227| 415| e->schema = schema; 228| 415| e->exprList = exprList; 229| 415| e->distinct = distinct; 230| 415| e->windowDescription = window; 231| 415| return e; 232| 415|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 234| 529|Expr* Expr::makeArray(std::vector* exprList) { 235| 529| Expr* e = new Expr(kExprArray); 236| 529| e->exprList = exprList; 237| 529| return e; 238| 529|} _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| 241k|Expr* Expr::makeParameter(int id) { 248| 241k| Expr* e = new Expr(kExprParameter); 249| 241k| e->ival = id; 250| 241k| return e; 251| 241k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 253| 445|Expr* Expr::makeSelect(SelectStatement* select) { 254| 445| Expr* e = new Expr(kExprSelect); 255| 445| e->select = select; 256| 445| return e; 257| 445|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 259| 1.05k|Expr* Expr::makeExists(SelectStatement* select) { 260| 1.05k| Expr* e = new Expr(kExprOperator); 261| 1.05k| e->opType = kOpExists; 262| 1.05k| e->select = select; 263| 1.05k| return e; 264| 1.05k|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 266| 593|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 267| 593| Expr* e = new Expr(kExprOperator); 268| 593| e->opType = kOpIn; 269| 593| e->expr = expr; 270| 593| e->exprList = exprList; 271| | 272| 593| return e; 273| 593|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 275| 424|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 276| 424| Expr* e = new Expr(kExprOperator); 277| 424| e->opType = kOpIn; 278| 424| e->expr = expr; 279| 424| e->select = select; 280| | 281| 424| return e; 282| 424|} _ZN4hsql4Expr11makeExtractENS_13DatetimeFieldEPS0_: 284| 532|Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { 285| 532| Expr* e = new Expr(kExprExtract); 286| 532| e->datetimeField = datetimeField; 287| 532| e->expr = expr; 288| 532| return e; 289| 532|} _ZN4hsql4Expr8makeCastEPS0_NS_10ColumnTypeE: 291| 559|Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { 292| 559| Expr* e = new Expr(kExprCast); 293| 559| e->columnType = columnType; 294| 559| e->expr = expr; 295| 559| return e; 296| 559|} _ZN4hsql6substrEPKcii: 316| 1.97k|char* substr(const char* source, int from, int to) { 317| 1.97k| int len = to - from; 318| 1.97k| char* copy = (char*)malloc(len + 1); 319| 1.97k| ; 320| 1.97k| strncpy(copy, source + from, len); 321| 1.97k| copy[len] = '\0'; 322| 1.97k| return copy; 323| 1.97k|} _ZN4hsql16PrepareStatementC2Ev: 6| 1.18k|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 1.18k|PrepareStatement::~PrepareStatement() { 9| 1.18k| free(name); 10| 1.18k| free(query); 11| 1.18k|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 82.0k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 81.5k|SQLStatement::~SQLStatement() { 10| 81.5k| if (hints) { ------------------ | Branch (10:7): [True: 694, False: 80.8k] ------------------ 11| 1.44k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 1.44k, False: 694] ------------------ 12| 1.44k| delete hint; 13| 1.44k| } 14| 694| } 15| 81.5k| delete hints; 16| 81.5k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 11| 3.22M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 77| 2.36k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 79| 2.36k|DeleteStatement::~DeleteStatement() { 80| 2.36k| free(schema); 81| 2.36k| free(tableName); 82| 2.36k| delete expr; 83| 2.36k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 87| 4.58k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 89| 4.58k|DropStatement::~DropStatement() { 90| 4.58k| free(schema); 91| 4.58k| free(name); 92| 4.58k| free(indexName); 93| 4.58k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 117| 10.2k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 119| 10.2k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 122| 3.45k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 124| 3.45k|ExecuteStatement::~ExecuteStatement() { 125| 3.45k| free(name); 126| | 127| 3.45k| if (parameters) { ------------------ | Branch (127:7): [True: 287, False: 3.16k] ------------------ 128| 535| for (Expr* param : *parameters) { ------------------ | Branch (128:22): [True: 535, False: 287] ------------------ 129| 535| delete param; 130| 535| } 131| 287| delete parameters; 132| 287| } 133| 3.45k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 137| 5.95k| : SQLStatement(kStmtExport), 138| 5.95k| type(type), 139| 5.95k| filePath(nullptr), 140| 5.95k| schema(nullptr), 141| 5.95k| tableName(nullptr), 142| 5.95k| select(nullptr), 143| 5.95k| encoding(nullptr), 144| 5.95k| csv_options(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 146| 5.95k|ExportStatement::~ExportStatement() { 147| 5.95k| free(filePath); 148| 5.95k| free(schema); 149| 5.95k| free(tableName); 150| 5.95k| delete select; 151| 5.95k| free(encoding); 152| 5.95k| delete csv_options; 153| 5.95k|} _ZN4hsql10CsvOptionsC2Ev: 155| 1.75k|CsvOptions::CsvOptions() : delimiter(nullptr), null(nullptr), quote(nullptr) {} _ZN4hsql10CsvOptionsD2Ev: 156| 1.75k|CsvOptions::~CsvOptions() { 157| 1.75k| free(delimiter); 158| 1.75k| free(null); 159| 1.75k| free(quote); 160| 1.75k|} _ZN4hsql10CsvOptions17accept_csv_optionEPNSt3__14pairINS_13CsvOptionTypeEPcEE: 162| 2.11k|bool CsvOptions::accept_csv_option(std::pair* option) { 163| 2.11k| switch (option->first) { ------------------ | Branch (163:11): [True: 2.11k, False: 0] ------------------ 164| 256| case CsvOptionType::Delimiter: ------------------ | Branch (164:5): [True: 256, False: 1.85k] ------------------ 165| 256| if (delimiter != nullptr) { ------------------ | Branch (165:11): [True: 1, False: 255] ------------------ 166| 1| return false; 167| 1| } 168| 255| delimiter = option->second; 169| 255| break; 170| 963| case CsvOptionType::Null: ------------------ | Branch (170:5): [True: 963, False: 1.14k] ------------------ 171| 963| if (null != nullptr) { ------------------ | Branch (171:11): [True: 3, False: 960] ------------------ 172| 3| return false; 173| 3| } 174| 960| null = option->second; 175| 960| break; 176| 892| case CsvOptionType::Quote: ------------------ | Branch (176:5): [True: 892, False: 1.21k] ------------------ 177| 892| if (quote != nullptr) { ------------------ | Branch (177:11): [True: 9, False: 883] ------------------ 178| 9| return false; 179| 9| } 180| 883| quote = option->second; 181| 883| break; 182| 2.11k| } 183| | 184| 2.09k| return true; 185| 2.11k|} _ZN4hsql19ImportExportOptionsC2Ev: 187| 9.81k|ImportExportOptions::ImportExportOptions() : format(kImportAuto), encoding(nullptr), csv_options(nullptr) {} _ZN4hsql19ImportExportOptionsD2Ev: 189| 9.81k|ImportExportOptions::~ImportExportOptions() { 190| 9.81k| free(encoding); 191| 9.81k| delete csv_options; 192| 9.81k|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 196| 3.77k| : SQLStatement(kStmtImport), 197| 3.77k| type(type), 198| 3.77k| filePath(nullptr), 199| 3.77k| schema(nullptr), 200| 3.77k| tableName(nullptr), 201| 3.77k| whereClause(nullptr), 202| 3.77k| encoding(nullptr), 203| 3.77k| csv_options(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 205| 3.77k|ImportStatement::~ImportStatement() { 206| 3.77k| free(filePath); 207| 3.77k| free(schema); 208| 3.77k| free(tableName); 209| 3.77k| delete whereClause; 210| 3.77k| free(encoding); 211| 3.77k| delete csv_options; 212| 3.77k|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 216| 1.87k| : SQLStatement(kStmtInsert), 217| 1.87k| type(type), 218| 1.87k| schema(nullptr), 219| 1.87k| tableName(nullptr), 220| 1.87k| columns(nullptr), 221| 1.87k| values(nullptr), 222| 1.87k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 224| 1.87k|InsertStatement::~InsertStatement() { 225| 1.87k| free(schema); 226| 1.87k| free(tableName); 227| 1.87k| delete select; 228| | 229| 1.87k| if (columns) { ------------------ | Branch (229:7): [True: 233, False: 1.63k] ------------------ 230| 427| for (char* column : *columns) { ------------------ | Branch (230:23): [True: 427, False: 233] ------------------ 231| 427| free(column); 232| 427| } 233| 233| delete columns; 234| 233| } 235| | 236| 1.87k| if (values) { ------------------ | Branch (236:7): [True: 841, False: 1.02k] ------------------ 237| 1.25k| for (Expr* expr : *values) { ------------------ | Branch (237:21): [True: 1.25k, False: 841] ------------------ 238| 1.25k| delete expr; 239| 1.25k| } 240| 841| delete values; 241| 841| } 242| 1.87k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 245| 4.98k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 247| 4.98k|ShowStatement::~ShowStatement() { 248| 4.98k| free(schema); 249| 4.98k| free(name); 250| 4.98k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprENS_12NullOrderingE: 256| 327k| : type(type), expr(expr), null_ordering(null_ordering) {} _ZN4hsql16OrderDescriptionD2Ev: 258| 327k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 261| 6.54k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 263| 6.54k|LimitDescription::~LimitDescription() { 264| 6.54k| delete limit; 265| 6.54k| delete offset; 266| 6.54k|} _ZN4hsql18GroupByDescriptionC2Ev: 269| 3.29k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 271| 3.29k|GroupByDescription::~GroupByDescription() { 272| 3.29k| delete having; 273| | 274| 3.29k| if (columns) { ------------------ | Branch (274:7): [True: 3.29k, False: 0] ------------------ 275| 4.21k| for (Expr* expr : *columns) { ------------------ | Branch (275:21): [True: 4.21k, False: 3.29k] ------------------ 276| 4.21k| delete expr; 277| 4.21k| } 278| 3.29k| delete columns; 279| 3.29k| } 280| 3.29k|} _ZN4hsql15WithDescriptionD2Ev: 282| 2.01k|WithDescription::~WithDescription() { 283| 2.01k| free(alias); 284| 2.01k| delete select; 285| 2.01k|} _ZN4hsql15SelectStatementC2Ev: 289| 37.6k| : SQLStatement(kStmtSelect), 290| 37.6k| fromTable(nullptr), 291| 37.6k| selectDistinct(false), 292| 37.6k| selectList(nullptr), 293| 37.6k| whereClause(nullptr), 294| 37.6k| groupBy(nullptr), 295| 37.6k| setOperations(nullptr), 296| 37.6k| order(nullptr), 297| 37.6k| withDescriptions(nullptr), 298| 37.6k| limit(nullptr), 299| 37.6k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 301| 37.1k|SelectStatement::~SelectStatement() { 302| 37.1k| delete fromTable; 303| 37.1k| delete whereClause; 304| 37.1k| delete groupBy; 305| 37.1k| delete limit; 306| | 307| | // Delete each element in the select list. 308| 37.1k| if (selectList) { ------------------ | Branch (308:7): [True: 37.1k, False: 0] ------------------ 309| 495k| for (Expr* expr : *selectList) { ------------------ | Branch (309:21): [True: 495k, False: 37.1k] ------------------ 310| 495k| delete expr; 311| 495k| } 312| 37.1k| delete selectList; 313| 37.1k| } 314| | 315| 37.1k| if (order) { ------------------ | Branch (315:7): [True: 902, False: 36.2k] ------------------ 316| 3.43k| for (OrderDescription* desc : *order) { ------------------ | Branch (316:33): [True: 3.43k, False: 902] ------------------ 317| 3.43k| delete desc; 318| 3.43k| } 319| 902| delete order; 320| 902| } 321| | 322| 37.1k| if (withDescriptions) { ------------------ | Branch (322:7): [True: 1.42k, False: 35.7k] ------------------ 323| 2.01k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (323:32): [True: 2.01k, False: 1.42k] ------------------ 324| 2.01k| delete desc; 325| 2.01k| } 326| 1.42k| delete withDescriptions; 327| 1.42k| } 328| | 329| 37.1k| if (setOperations) { ------------------ | Branch (329:7): [True: 3.81k, False: 33.3k] ------------------ 330| 4.04k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (330:37): [True: 4.04k, False: 3.81k] ------------------ 331| 4.04k| delete setOperation; 332| 4.04k| } 333| 3.81k| delete setOperations; 334| 3.81k| } 335| | 336| 37.1k| if (lockings) { ------------------ | Branch (336:7): [True: 449, False: 36.6k] ------------------ 337| 3.23k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (337:39): [True: 3.23k, False: 449] ------------------ 338| 3.23k| if (lockingClause->tables) { ------------------ | Branch (338:11): [True: 333, False: 2.90k] ------------------ 339| 527| for (char* dtable : *lockingClause->tables) { ------------------ | Branch (339:27): [True: 527, False: 333] ------------------ 340| 527| free(dtable); 341| 527| } 342| 333| delete lockingClause->tables; 343| 333| } 344| 3.23k| delete lockingClause; 345| 3.23k| } 346| 449| delete lockings; 347| 449| } 348| 37.1k|} _ZN4hsql15UpdateStatementC2Ev: 351| 1.49k|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 353| 1.49k|UpdateStatement::~UpdateStatement() { 354| 1.49k| delete table; 355| 1.49k| delete where; 356| | 357| 1.49k| if (updates) { ------------------ | Branch (357:7): [True: 1.49k, False: 0] ------------------ 358| 2.61k| for (UpdateClause* update : *updates) { ------------------ | Branch (358:31): [True: 2.61k, False: 1.49k] ------------------ 359| 2.61k| free(update->column); 360| 2.61k| delete update->value; 361| 2.61k| delete update; 362| 2.61k| } 363| 1.49k| delete updates; 364| 1.49k| } 365| 1.49k|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 368| 18.7k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 370| 18.7k|Alias::~Alias() { 371| 18.7k| free(name); 372| 18.7k| if (columns) { ------------------ | Branch (372:7): [True: 311, False: 18.4k] ------------------ 373| 903| for (char* column : *columns) { ------------------ | Branch (373:23): [True: 903, False: 311] ------------------ 374| 903| free(column); 375| 903| } 376| 311| delete columns; 377| 311| } 378| 18.7k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 382| 575k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 384| 575k|TableRef::~TableRef() { 385| 575k| free(schema); 386| 575k| free(name); 387| | 388| 575k| delete select; 389| 575k| delete join; 390| 575k| delete alias; 391| | 392| 575k| if (list) { ------------------ | Branch (392:7): [True: 2.00k, False: 573k] ------------------ 393| 48.9k| for (TableRef* table : *list) { ------------------ | Branch (393:26): [True: 48.9k, False: 2.00k] ------------------ 394| 48.9k| delete table; 395| 48.9k| } 396| 2.00k| delete list; 397| 2.00k| } 398| 575k|} _ZN4hsql14JoinDefinitionC2Ev: 411| 111k| : left(nullptr), right(nullptr), condition(nullptr), namedColumns(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 413| 111k|JoinDefinition::~JoinDefinition() { 414| 111k| delete left; 415| 111k| delete right; 416| 111k| delete condition; 417| | 418| 111k| if (namedColumns) { ------------------ | Branch (418:7): [True: 747, False: 110k] ------------------ 419| 941| for (auto* column : *namedColumns) { ------------------ | Branch (419:23): [True: 941, False: 747] ------------------ 420| 941| free(column); 421| 941| } 422| 747| delete namedColumns; 423| 747| } 424| 111k|} _ZN4hsql12SetOperationC2Ev: 426| 5.14k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 428| 5.14k|SetOperation::~SetOperation() { 429| 5.14k| delete nestedSelectStatement; 430| 5.14k| delete resultLimit; 431| | 432| 5.14k| if (resultOrder) { ------------------ | Branch (432:7): [True: 748, False: 4.39k] ------------------ 433| 2.46k| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (433:33): [True: 2.46k, False: 748] ------------------ 434| 2.46k| delete desc; 435| 2.46k| } 436| 748| delete resultOrder; 437| 748| } 438| 5.14k|}