LLVMFuzzerTestOneInput: 21| 5.22k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 22| 5.22k| std::string input(reinterpret_cast(data), size); 23| 5.22k| SQLParserResult res; 24| 5.22k| SQLParser::parse(input, &res); 25| 5.22k| return 0; 26| 5.22k|} _ZN4hsql9SQLParser5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15SQLParserResultE: 13| 5.22k|bool SQLParser::parse(const std::string& sql, SQLParserResult* result) { 14| 5.22k| yyscan_t scanner; 15| 5.22k| YY_BUFFER_STATE state; 16| | 17| 5.22k| if (hsql_lex_init(&scanner)) { ------------------ | Branch (17:7): [True: 0, False: 5.22k] ------------------ 18| | // Couldn't initialize the lexer. 19| 0| fprintf(stderr, "SQLParser: Error when initializing lexer!\n"); 20| 0| return false; 21| 0| } 22| 5.22k| const char* text = sql.c_str(); 23| 5.22k| state = hsql__scan_string(text, scanner); 24| | 25| | // Parse the tokens. 26| | // If parsing fails, the result will contain an error object. 27| 5.22k| int ret = hsql_parse(result, scanner); 28| 5.22k| bool success = (ret == 0); 29| 5.22k| result->setIsValid(success); 30| | 31| 5.22k| hsql__delete_buffer(state, scanner); 32| 5.22k| hsql_lex_destroy(scanner); 33| | 34| 5.22k| return true; 35| 5.22k|} _ZN4hsql15SQLParserResultC2Ev: 7| 5.22k|SQLParserResult::SQLParserResult() : isValid_(false), errorMsg_(nullptr) {} _ZN4hsql15SQLParserResultD2Ev: 24| 5.22k|SQLParserResult::~SQLParserResult() { reset(); } _ZN4hsql15SQLParserResult12addStatementEPNS_12SQLStatementE: 26| 63.6k|void SQLParserResult::addStatement(SQLStatement* stmt) { statements_.push_back(stmt); } _ZNK4hsql15SQLParserResult8errorMsgEv: 36| 653|const char* SQLParserResult::errorMsg() const { return errorMsg_; } _ZN4hsql15SQLParserResult10setIsValidEb: 42| 10.5k|void SQLParserResult::setIsValid(bool isValid) { isValid_ = isValid; } _ZN4hsql15SQLParserResult15setErrorDetailsEPcii: 44| 5.35k|void SQLParserResult::setErrorDetails(char* errorMsg, int errorLine, int errorColumn) { 45| 5.35k| errorMsg_ = errorMsg; 46| 5.35k| errorLine_ = errorLine; 47| 5.35k| errorColumn_ = errorColumn; 48| 5.35k|} _ZN4hsql15SQLParserResult5resetEv: 60| 5.22k|void SQLParserResult::reset() { 61| 63.6k| for (SQLStatement* statement : statements_) { ------------------ | Branch (61:32): [True: 63.6k, False: 5.22k] ------------------ 62| 63.6k| delete statement; 63| 63.6k| } 64| 5.22k| statements_.clear(); 65| | 66| 5.22k| isValid_ = false; 67| | 68| 5.22k| free(errorMsg_); 69| 5.22k| errorMsg_ = nullptr; 70| 5.22k| errorLine_ = -1; 71| 5.22k| errorColumn_ = -1; 72| 5.22k|} _ZN4hsql15SQLParserResult12addParameterEPNS_4ExprE: 75| 237k|void SQLParserResult::addParameter(Expr* parameter) { 76| 237k| parameters_.push_back(parameter); 77| 237k| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); 78| 237k|} SQLParserResult.cpp:_ZZN4hsql15SQLParserResult12addParameterEPNS_4ExprEENK3$_0clEPKS1_S5_: 77| 1.93G| std::sort(parameters_.begin(), parameters_.end(), [](const Expr* a, const Expr* b) { return a->ival < b->ival; }); _Z10hsql_errorP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPvPKc: 100| 5.35k| int yyerror(YYLTYPE * llocp, SQLParserResult * result, yyscan_t scanner, const char* msg) { 101| 5.35k| result->setIsValid(false); 102| 5.35k| result->setErrorDetails(strdup(msg), llocp->first_line, llocp->first_column); 103| 5.35k| return 0; 104| 5.35k| } _Z10hsql_parsePN4hsql15SQLParserResultEPv: 2965| 5.22k|{ 2966| |/* Lookahead token kind. */ 2967| 5.22k|int yychar; 2968| | 2969| | 2970| |/* The semantic value of the lookahead symbol. */ 2971| |/* Default value used for initialization, for pacifying older GCCs 2972| | or non-GCC compilers. */ 2973| 5.22k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 633| 5.22k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2974| 5.22k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 11| 5.22k|#define YYSTYPE HSQL_STYPE ------------------ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 633| 5.22k|# define YY_INITIAL_VALUE(Value) Value ------------------ 2975| | 2976| |/* Location data for the lookahead symbol. */ 2977| 5.22k|static YYLTYPE yyloc_default 2978| |# if defined HSQL_LTYPE_IS_TRIVIAL && HSQL_LTYPE_IS_TRIVIAL 2979| | = { 1, 1, 1, 1 } 2980| |# endif 2981| 5.22k|; 2982| 5.22k|YYLTYPE yylloc = yyloc_default; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 2983| | 2984| | /* Number of syntax errors so far. */ 2985| 5.22k| int yynerrs = 0; 2986| | 2987| 5.22k| yy_state_fast_t yystate = 0; 2988| | /* Number of tokens to shift before error messages enabled. */ 2989| 5.22k| int yyerrstatus = 0; 2990| | 2991| | /* Refer to the stacks through separate pointers, to allow yyoverflow 2992| | to reallocate them elsewhere. */ 2993| | 2994| | /* Their size. */ 2995| 5.22k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 540| 5.22k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1754| 5.22k|# define YYINITDEPTH 200 ------------------ 2996| | 2997| | /* The state stack: array, bottom, top. */ 2998| 5.22k| yy_state_t yyssa[YYINITDEPTH]; 2999| 5.22k| yy_state_t *yyss = yyssa; 3000| 5.22k| yy_state_t *yyssp = yyss; 3001| | 3002| | /* The semantic value stack: array, bottom, top. */ 3003| 5.22k| YYSTYPE yyvsa[YYINITDEPTH]; ------------------ | | 11| 5.22k|#define YYSTYPE HSQL_STYPE ------------------ 3004| 5.22k| YYSTYPE *yyvs = yyvsa; ------------------ | | 11| 5.22k|#define YYSTYPE HSQL_STYPE ------------------ 3005| 5.22k| YYSTYPE *yyvsp = yyvs; ------------------ | | 11| 5.22k|#define YYSTYPE HSQL_STYPE ------------------ 3006| | 3007| | /* The location stack: array, bottom, top. */ 3008| 5.22k| YYLTYPE yylsa[YYINITDEPTH]; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 3009| 5.22k| YYLTYPE *yyls = yylsa; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 3010| 5.22k| YYLTYPE *yylsp = yyls; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 3011| | 3012| 5.22k| int yyn; 3013| | /* The return value of yyparse. */ 3014| 5.22k| int yyresult; 3015| | /* Lookahead symbol kind. */ 3016| 5.22k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 3017| | /* The variables used to return semantic value and location from the 3018| | action routines. */ 3019| 5.22k| YYSTYPE yyval; ------------------ | | 11| 5.22k|#define YYSTYPE HSQL_STYPE ------------------ 3020| 5.22k| YYLTYPE yyloc; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 3021| | 3022| | /* The locations where the error started and ended. */ 3023| 5.22k| YYLTYPE yyerror_range[3]; ------------------ | | 12| 5.22k|#define YYLTYPE HSQL_LTYPE | | ------------------ | | | | 30| 5.22k|#define HSQL_LTYPE HSQL_CUST_LTYPE | | ------------------ ------------------ 3024| | 3025| | /* Buffer for error messages, and its allocated size. */ 3026| 5.22k| char yymsgbuf[128]; 3027| 5.22k| char *yymsg = yymsgbuf; 3028| 5.22k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 540| 5.22k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 3029| | 3030| 5.22k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 3031| | 3032| | /* The number of symbols on the RHS of the reduced rule. 3033| | Keep to zero when no symbol should be popped. */ 3034| 5.22k| int yylen = 0; 3035| | 3036| 5.22k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1745| 5.22k|# define YYDPRINTF(Args) ((void) 0) ------------------ 3037| | 3038| 5.22k| yychar = SQL_HSQL_EMPTY; /* Cause a token to be read. */ 3039| | 3040| | 3041| |/* User initialization code. */ 3042| 5.22k|#line 75 "bison_parser.y" 3043| 5.22k|{ 3044| | // Initialize 3045| 5.22k| yylloc.first_column = 0; 3046| 5.22k| yylloc.last_column = 0; 3047| 5.22k| yylloc.first_line = 0; 3048| 5.22k| yylloc.last_line = 0; 3049| 5.22k| yylloc.total_column = 0; 3050| 5.22k| yylloc.string_length = 0; 3051| 5.22k|} 3052| | 3053| 5.22k|#line 3054 "bison_parser.cpp" 3054| | 3055| 5.22k| yylsp[0] = yylloc; 3056| 5.22k| goto yysetstate; 3057| | 3058| | 3059| |/*------------------------------------------------------------. 3060| || yynewstate -- push a new state, which is found in yystate. | 3061| |`------------------------------------------------------------*/ 3062| 22.3M|yynewstate: 3063| | /* In all cases, when you get here, the value and location stacks 3064| | have just been pushed. So pushing a state here evens the stacks. */ 3065| 22.3M| yyssp++; 3066| | 3067| | 3068| |/*--------------------------------------------------------------------. 3069| || yysetstate -- set current state (the top of the stack) to yystate. | 3070| |`--------------------------------------------------------------------*/ 3071| 22.3M|yysetstate: 3072| 22.3M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1745| 22.3M|# define YYDPRINTF(Args) ((void) 0) ------------------ 3073| 22.3M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 656| 22.3M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (656:31): [Folded - Ignored] | | | Branch (656:37): [True: 0, False: 0] | | | Branch (656:37): [True: 0, False: 0] | | ------------------ ------------------ 3074| 22.3M| YY_IGNORE_USELESS_CAST_BEGIN 3075| 22.3M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 111| 22.3M|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 3076| 22.3M| YY_IGNORE_USELESS_CAST_END 3077| 22.3M| YY_STACK_PRINT (yyss, yyssp); 3078| | 3079| 22.3M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (3079:7): [True: 14, False: 22.3M] ------------------ 3080| 14|#if !defined yyoverflow && !defined YYSTACK_RELOCATE 3081| 14| YYNOMEM; ------------------ | | 1509| 14|#define YYNOMEM goto yyexhaustedlab ------------------ 3082| |#else 3083| | { 3084| | /* Get the current used size of the three stacks, in elements. */ 3085| | YYPTRDIFF_T yysize = yyssp - yyss + 1; 3086| | 3087| |# if defined yyoverflow 3088| | { 3089| | /* Give user a chance to reallocate the stack. Use copies of 3090| | these so that the &'s don't force the real ones into 3091| | memory. */ 3092| | yy_state_t *yyss1 = yyss; 3093| | YYSTYPE *yyvs1 = yyvs; 3094| | YYLTYPE *yyls1 = yyls; 3095| | 3096| | /* Each stack pointer address is followed by the size of the 3097| | data in use in that stack, in bytes. This used to be a 3098| | conditional around just the two extra args, but that might 3099| | be undefined if yyoverflow is a macro. */ 3100| | yyoverflow (YY_("memory exhausted"), 3101| | &yyss1, yysize * YYSIZEOF (*yyssp), 3102| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 3103| | &yyls1, yysize * YYSIZEOF (*yylsp), 3104| | &yystacksize); 3105| | yyss = yyss1; 3106| | yyvs = yyvs1; 3107| | yyls = yyls1; 3108| | } 3109| |# else /* defined YYSTACK_RELOCATE */ 3110| | /* Extend the stack our own way. */ 3111| | if (YYMAXDEPTH <= yystacksize) 3112| | YYNOMEM; 3113| | yystacksize *= 2; 3114| | if (YYMAXDEPTH < yystacksize) 3115| | yystacksize = YYMAXDEPTH; 3116| | 3117| | { 3118| | yy_state_t *yyss1 = yyss; 3119| | union yyalloc *yyptr = 3120| | YY_CAST (union yyalloc *, 3121| | YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 3122| | if (! yyptr) 3123| | YYNOMEM; 3124| | YYSTACK_RELOCATE (yyss_alloc, yyss); 3125| | YYSTACK_RELOCATE (yyvs_alloc, yyvs); 3126| | YYSTACK_RELOCATE (yyls_alloc, yyls); 3127| |# undef YYSTACK_RELOCATE 3128| | if (yyss1 != yyssa) 3129| | YYSTACK_FREE (yyss1); 3130| | } 3131| |# endif 3132| | 3133| | yyssp = yyss + yysize - 1; 3134| | yyvsp = yyvs + yysize - 1; 3135| | yylsp = yyls + yysize - 1; 3136| | 3137| | YY_IGNORE_USELESS_CAST_BEGIN 3138| | YYDPRINTF ((stderr, "Stack size increased to %ld\n", 3139| | YY_CAST (long, yystacksize))); 3140| | YY_IGNORE_USELESS_CAST_END 3141| | 3142| | if (yyss + yystacksize - 1 <= yyssp) 3143| | YYABORT; 3144| | } 3145| |#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 3146| | 3147| | 3148| 22.3M| if (yystate == YYFINAL) ------------------ | | 789| 22.3M|#define YYFINAL 69 ------------------ | Branch (3148:7): [True: 1.37k, False: 22.3M] ------------------ 3149| 1.37k| YYACCEPT; ------------------ | | 1506| 1.37k|#define YYACCEPT goto yyacceptlab ------------------ 3150| | 3151| 22.3M| goto yybackup; 3152| | 3153| | 3154| |/*-----------. 3155| || yybackup. | 3156| |`-----------*/ 3157| 22.3M|yybackup: 3158| | /* Do appropriate processing given the current state. Read a 3159| | lookahead token if we need one and don't already have one. */ 3160| | 3161| | /* First try to decide what to do without reference to lookahead token. */ 3162| 22.3M| yyn = yypact[yystate]; 3163| 22.3M| if (yypact_value_is_default (yyn)) ------------------ | | 990| 22.3M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 987| 22.3M|#define YYPACT_NINF (-527) | | ------------------ | | | Branch (990:3): [True: 10.8M, False: 11.4M] | | ------------------ ------------------ 3164| 10.8M| goto yydefault; 3165| | 3166| | /* Not known => get a lookahead token if don't already have one. */ 3167| | 3168| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 3169| 11.4M| if (yychar == SQL_HSQL_EMPTY) ------------------ | Branch (3169:7): [True: 7.45M, False: 4.02M] ------------------ 3170| 7.45M| { 3171| 7.45M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1745| 7.45M|# define YYDPRINTF(Args) ((void) 0) ------------------ 3172| 7.45M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 71| 7.45M|#define yylex hsql_lex ------------------ 3173| 7.45M| } 3174| | 3175| 11.4M| if (yychar <= SQL_YYEOF) ------------------ | Branch (3175:7): [True: 26.6k, False: 11.4M] ------------------ 3176| 26.6k| { 3177| 26.6k| yychar = SQL_YYEOF; 3178| 26.6k| yytoken = YYSYMBOL_YYEOF; 3179| 26.6k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1745| 26.6k|# define YYDPRINTF(Args) ((void) 0) ------------------ 3180| 26.6k| } 3181| 11.4M| else if (yychar == SQL_HSQL_error) ------------------ | Branch (3181:12): [True: 0, False: 11.4M] ------------------ 3182| 0| { 3183| | /* The scanner already issued an error message, process directly 3184| | to error recovery. But do not keep the error token as 3185| | lookahead, it is too special and may lead us to an endless 3186| | loop in error recovery. */ 3187| 0| yychar = SQL_HSQL_UNDEF; 3188| 0| yytoken = YYSYMBOL_YYerror; 3189| 0| yyerror_range[1] = yylloc; 3190| 0| goto yyerrlab1; 3191| 0| } 3192| 11.4M| else 3193| 11.4M| { 3194| 11.4M| yytoken = YYTRANSLATE (yychar); ------------------ | | 809| 11.4M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 803| 11.4M|#define YYMAXUTOK 433 | | ------------------ | | | Branch (809:4): [True: 11.4M, False: 0] | | | Branch (809:18): [True: 11.4M, False: 0] | | ------------------ | | 810| 11.4M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 11.4M|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 811| 11.4M| : YYSYMBOL_YYUNDEF) ------------------ 3195| 11.4M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 3196| 11.4M| } 3197| | 3198| | /* If the proper action on seeing token YYTOKEN is to reduce or to 3199| | detect an error, take that action. */ 3200| 11.4M| yyn += yytoken; 3201| 11.4M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 791| 11.4M|#define YYLAST 872 ------------------ | Branch (3201:7): [True: 5.99k, False: 11.4M] | Branch (3201:18): [True: 2.64k, False: 11.4M] | Branch (3201:34): [True: 3.87M, False: 7.59M] ------------------ 3202| 3.88M| goto yydefault; 3203| 7.59M| yyn = yytable[yyn]; 3204| 7.59M| if (yyn <= 0) ------------------ | Branch (3204:7): [True: 144k, False: 7.45M] ------------------ 3205| 144k| { 3206| 144k| if (yytable_value_is_error (yyn)) ------------------ | | 995| 144k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 992| 144k|#define YYTABLE_NINF (-333) | | ------------------ | | | Branch (995:3): [True: 11, False: 144k] | | ------------------ ------------------ 3207| 11| goto yyerrlab; 3208| 144k| yyn = -yyn; 3209| 144k| goto yyreduce; 3210| 144k| } 3211| | 3212| | /* Count tokens shifted since error; after three, turn off error 3213| | status. */ 3214| 7.45M| if (yyerrstatus) ------------------ | Branch (3214:7): [True: 0, False: 7.45M] ------------------ 3215| 0| yyerrstatus--; 3216| | 3217| | /* Shift the lookahead token. */ 3218| 7.45M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 3219| 7.45M| yystate = yyn; 3220| 7.45M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 3221| 7.45M| *++yyvsp = yylval; 3222| 7.45M| YY_IGNORE_MAYBE_UNINITIALIZED_END 3223| 7.45M| *++yylsp = yylloc; 3224| | 3225| | /* Discard the shifted token. */ 3226| 7.45M| yychar = SQL_HSQL_EMPTY; 3227| 7.45M| goto yynewstate; 3228| | 3229| | 3230| |/*-----------------------------------------------------------. 3231| || yydefault -- do the default action for the current state. | 3232| |`-----------------------------------------------------------*/ 3233| 14.7M|yydefault: 3234| 14.7M| yyn = yydefact[yystate]; 3235| 14.7M| if (yyn == 0) ------------------ | Branch (3235:7): [True: 3.36k, False: 14.7M] ------------------ 3236| 3.36k| goto yyerrlab; 3237| 14.7M| goto yyreduce; 3238| | 3239| | 3240| |/*-----------------------------. 3241| || yyreduce -- do a reduction. | 3242| |`-----------------------------*/ 3243| 14.8M|yyreduce: 3244| | /* yyn is the number of a rule to reduce with. */ 3245| 14.8M| yylen = yyr2[yyn]; 3246| | 3247| | /* If YYLEN is nonzero, implement the default value of the action: 3248| | '$$ = $1'. 3249| | 3250| | Otherwise, the following line sets YYVAL to garbage. 3251| | This behavior is undocumented and Bison 3252| | users should not rely upon it. Assigning to YYVAL 3253| | unconditionally makes the parser a bit smaller, and it avoids a 3254| | GCC warning that YYVAL may be used uninitialized. */ 3255| 14.8M| yyval = yyvsp[1-yylen]; 3256| | 3257| | /* Default location. */ 3258| 14.8M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 1541| 14.8M| do \ | | 1542| 14.8M| if (N) \ | | ------------------ | | | Branch (1542:11): [True: 13.6M, False: 1.25M] | | ------------------ | | 1543| 14.8M| { \ | | 1544| 13.6M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1559| 13.6M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1545| 13.6M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1559| 13.6M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1546| 13.6M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1559| 13.6M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1547| 13.6M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1559| 13.6M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1548| 13.6M| } \ | | 1549| 14.8M| else \ | | 1550| 14.8M| { \ | | 1551| 1.25M| (Current).first_line = (Current).last_line = \ | | 1552| 1.25M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1559| 1.25M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1553| 1.25M| (Current).first_column = (Current).last_column = \ | | 1554| 1.25M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1559| 1.25M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1555| 1.25M| } \ | | 1556| 14.8M| while (0) | | ------------------ | | | Branch (1556:12): [Folded - Ignored] | | ------------------ ------------------ 3259| 14.8M| yyerror_range[1] = yyloc; 3260| 14.8M| YY_REDUCE_PRINT (yyn); 3261| 14.8M| switch (yyn) 3262| 14.8M| { 3263| 1.63k| case 2: /* input: statement_list opt_semicolon */ ------------------ | Branch (3263:3): [True: 1.63k, False: 14.8M] ------------------ 3264| 1.63k|#line 322 "bison_parser.y" 3265| 1.63k| { 3266| 63.6k| for (SQLStatement* stmt : *(yyvsp[-1].stmt_vec)) { ------------------ | Branch (3266:27): [True: 63.6k, False: 1.63k] ------------------ 3267| | // Transfers ownership of the statement. 3268| 63.6k| result->addStatement(stmt); 3269| 63.6k| } 3270| | 3271| 1.63k| unsigned param_id = 0; 3272| 237k| for (void* param : yyloc.param_list) { ------------------ | Branch (3272:20): [True: 237k, False: 1.63k] ------------------ 3273| 237k| if (param) { ------------------ | Branch (3273:9): [True: 237k, False: 0] ------------------ 3274| 237k| Expr* expr = (Expr*)param; 3275| 237k| expr->ival = param_id; 3276| 237k| result->addParameter(expr); 3277| 237k| ++param_id; 3278| 237k| } 3279| 237k| } 3280| 1.63k| delete (yyvsp[-1].stmt_vec); 3281| 1.63k| } 3282| 1.63k|#line 3283 "bison_parser.cpp" 3283| 1.63k| break; 3284| | 3285| 2.11k| case 3: /* statement_list: statement */ ------------------ | Branch (3285:3): [True: 2.11k, False: 14.8M] ------------------ 3286| 2.11k|#line 341 "bison_parser.y" 3287| 2.11k| { 3288| 2.11k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3289| 2.11k| yylloc.string_length = 0; 3290| 2.11k| (yyval.stmt_vec) = new std::vector(); 3291| 2.11k| (yyval.stmt_vec)->push_back((yyvsp[0].statement)); 3292| 2.11k|} 3293| 2.11k|#line 3294 "bison_parser.cpp" 3294| 2.11k| break; 3295| | 3296| 95.3k| case 4: /* statement_list: statement_list ';' statement */ ------------------ | Branch (3296:3): [True: 95.3k, False: 14.7M] ------------------ 3297| 95.3k|#line 347 "bison_parser.y" 3298| 95.3k| { 3299| 95.3k| (yyvsp[0].statement)->stringLength = yylloc.string_length; 3300| 95.3k| yylloc.string_length = 0; 3301| 95.3k| (yyvsp[-2].stmt_vec)->push_back((yyvsp[0].statement)); 3302| 95.3k| (yyval.stmt_vec) = (yyvsp[-2].stmt_vec); 3303| 95.3k|} 3304| 95.3k|#line 3305 "bison_parser.cpp" 3305| 95.3k| break; 3306| | 3307| 736| case 5: /* statement: prepare_statement opt_hints */ ------------------ | Branch (3307:3): [True: 736, False: 14.8M] ------------------ 3308| 736|#line 354 "bison_parser.y" 3309| 736| { 3310| 736| (yyval.statement) = (yyvsp[-1].prep_stmt); 3311| 736| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3312| 736|} 3313| 736|#line 3314 "bison_parser.cpp" 3314| 736| break; 3315| | 3316| 91.8k| case 6: /* statement: preparable_statement opt_hints */ ------------------ | Branch (3316:3): [True: 91.8k, False: 14.8M] ------------------ 3317| 91.8k|#line 358 "bison_parser.y" 3318| 91.8k| { 3319| 91.8k| (yyval.statement) = (yyvsp[-1].statement); 3320| 91.8k| (yyval.statement)->hints = (yyvsp[0].expr_vec); 3321| 91.8k|} 3322| 91.8k|#line 3323 "bison_parser.cpp" 3323| 91.8k| break; 3324| | 3325| 2.49k| case 7: /* statement: show_statement */ ------------------ | Branch (3325:3): [True: 2.49k, False: 14.8M] ------------------ 3326| 2.49k|#line 362 "bison_parser.y" 3327| 2.49k| { (yyval.statement) = (yyvsp[0].show_stmt); } 3328| 2.49k|#line 3329 "bison_parser.cpp" 3329| 2.49k| break; 3330| | 3331| 562| case 8: /* statement: import_statement */ ------------------ | Branch (3331:3): [True: 562, False: 14.8M] ------------------ 3332| 562|#line 363 "bison_parser.y" 3333| 562| { (yyval.statement) = (yyvsp[0].import_stmt); } 3334| 562|#line 3335 "bison_parser.cpp" 3335| 562| break; 3336| | 3337| 1.85k| case 9: /* statement: export_statement */ ------------------ | Branch (3337:3): [True: 1.85k, False: 14.8M] ------------------ 3338| 1.85k|#line 364 "bison_parser.y" 3339| 1.85k| { (yyval.statement) = (yyvsp[0].export_stmt); } 3340| 1.85k|#line 3341 "bison_parser.cpp" 3341| 1.85k| break; 3342| | 3343| 12.1k| case 10: /* preparable_statement: select_statement */ ------------------ | Branch (3343:3): [True: 12.1k, False: 14.8M] ------------------ 3344| 12.1k|#line 366 "bison_parser.y" 3345| 12.1k| { (yyval.statement) = (yyvsp[0].select_stmt); } 3346| 12.1k|#line 3347 "bison_parser.cpp" 3347| 12.1k| break; 3348| | 3349| 2.35k| case 11: /* preparable_statement: create_statement */ ------------------ | Branch (3349:3): [True: 2.35k, False: 14.8M] ------------------ 3350| 2.35k|#line 367 "bison_parser.y" 3351| 2.35k| { (yyval.statement) = (yyvsp[0].create_stmt); } 3352| 2.35k|#line 3353 "bison_parser.cpp" 3353| 2.35k| break; 3354| | 3355| 1.57k| case 12: /* preparable_statement: insert_statement */ ------------------ | Branch (3355:3): [True: 1.57k, False: 14.8M] ------------------ 3356| 1.57k|#line 368 "bison_parser.y" 3357| 1.57k| { (yyval.statement) = (yyvsp[0].insert_stmt); } 3358| 1.57k|#line 3359 "bison_parser.cpp" 3359| 1.57k| break; 3360| | 3361| 1.17k| case 13: /* preparable_statement: delete_statement */ ------------------ | Branch (3361:3): [True: 1.17k, False: 14.8M] ------------------ 3362| 1.17k|#line 369 "bison_parser.y" 3363| 1.17k| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3364| 1.17k|#line 3365 "bison_parser.cpp" 3365| 1.17k| break; 3366| | 3367| 687| case 14: /* preparable_statement: truncate_statement */ ------------------ | Branch (3367:3): [True: 687, False: 14.8M] ------------------ 3368| 687|#line 370 "bison_parser.y" 3369| 687| { (yyval.statement) = (yyvsp[0].delete_stmt); } 3370| 687|#line 3371 "bison_parser.cpp" 3371| 687| break; 3372| | 3373| 922| case 15: /* preparable_statement: update_statement */ ------------------ | Branch (3373:3): [True: 922, False: 14.8M] ------------------ 3374| 922|#line 371 "bison_parser.y" 3375| 922| { (yyval.statement) = (yyvsp[0].update_stmt); } 3376| 922|#line 3377 "bison_parser.cpp" 3377| 922| break; 3378| | 3379| 3.19k| case 16: /* preparable_statement: drop_statement */ ------------------ | Branch (3379:3): [True: 3.19k, False: 14.8M] ------------------ 3380| 3.19k|#line 372 "bison_parser.y" 3381| 3.19k| { (yyval.statement) = (yyvsp[0].drop_stmt); } 3382| 3.19k|#line 3383 "bison_parser.cpp" 3383| 3.19k| break; 3384| | 3385| 0| case 17: /* preparable_statement: alter_statement */ ------------------ | Branch (3385:3): [True: 0, False: 14.8M] ------------------ 3386| 0|#line 373 "bison_parser.y" 3387| 0| { (yyval.statement) = (yyvsp[0].alter_stmt); } 3388| 0|#line 3389 "bison_parser.cpp" 3389| 0| break; 3390| | 3391| 2.37k| case 18: /* preparable_statement: execute_statement */ ------------------ | Branch (3391:3): [True: 2.37k, False: 14.8M] ------------------ 3392| 2.37k|#line 374 "bison_parser.y" 3393| 2.37k| { (yyval.statement) = (yyvsp[0].exec_stmt); } 3394| 2.37k|#line 3395 "bison_parser.cpp" 3395| 2.37k| break; 3396| | 3397| 67.4k| case 19: /* preparable_statement: transaction_statement */ ------------------ | Branch (3397:3): [True: 67.4k, False: 14.8M] ------------------ 3398| 67.4k|#line 375 "bison_parser.y" 3399| 67.4k| { (yyval.statement) = (yyvsp[0].transaction_stmt); } 3400| 67.4k|#line 3401 "bison_parser.cpp" 3401| 67.4k| break; 3402| | 3403| 813| case 20: /* opt_hints: WITH HINT '(' hint_list ')' */ ------------------ | Branch (3403:3): [True: 813, False: 14.8M] ------------------ 3404| 813|#line 381 "bison_parser.y" 3405| 813| { (yyval.expr_vec) = (yyvsp[-1].expr_vec); } 3406| 813|#line 3407 "bison_parser.cpp" 3407| 813| break; 3408| | 3409| 91.7k| case 21: /* opt_hints: %empty */ ------------------ | Branch (3409:3): [True: 91.7k, False: 14.8M] ------------------ 3410| 91.7k|#line 382 "bison_parser.y" 3411| 91.7k| { (yyval.expr_vec) = nullptr; } 3412| 91.7k|#line 3413 "bison_parser.cpp" 3413| 91.7k| break; 3414| | 3415| 848| case 22: /* hint_list: hint */ ------------------ | Branch (3415:3): [True: 848, False: 14.8M] ------------------ 3416| 848|#line 384 "bison_parser.y" 3417| 848| { 3418| 848| (yyval.expr_vec) = new std::vector(); 3419| 848| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 3420| 848|} 3421| 848|#line 3422 "bison_parser.cpp" 3422| 848| break; 3423| | 3424| 1.34k| case 23: /* hint_list: hint_list ',' hint */ ------------------ | Branch (3424:3): [True: 1.34k, False: 14.8M] ------------------ 3425| 1.34k|#line 388 "bison_parser.y" 3426| 1.34k| { 3427| 1.34k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 3428| 1.34k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 3429| 1.34k|} 3430| 1.34k|#line 3431 "bison_parser.cpp" 3431| 1.34k| break; 3432| | 3433| 1.90k| case 24: /* hint: IDENTIFIER */ ------------------ | Branch (3433:3): [True: 1.90k, False: 14.8M] ------------------ 3434| 1.90k|#line 393 "bison_parser.y" 3435| 1.90k| { 3436| 1.90k| (yyval.expr) = Expr::make(kExprHint); 3437| 1.90k| (yyval.expr)->name = (yyvsp[0].sval); 3438| 1.90k|} 3439| 1.90k|#line 3440 "bison_parser.cpp" 3440| 1.90k| break; 3441| | 3442| 292| case 25: /* hint: IDENTIFIER '(' literal_list ')' */ ------------------ | Branch (3442:3): [True: 292, False: 14.8M] ------------------ 3443| 292|#line 397 "bison_parser.y" 3444| 292| { 3445| 292| (yyval.expr) = Expr::make(kExprHint); 3446| 292| (yyval.expr)->name = (yyvsp[-3].sval); 3447| 292| (yyval.expr)->exprList = (yyvsp[-1].expr_vec); 3448| 292|} 3449| 292|#line 3450 "bison_parser.cpp" 3450| 292| break; 3451| | 3452| 66.4k| case 26: /* transaction_statement: BEGIN opt_transaction_keyword */ ------------------ | Branch (3452:3): [True: 66.4k, False: 14.8M] ------------------ 3453| 66.4k|#line 407 "bison_parser.y" 3454| 66.4k| { (yyval.transaction_stmt) = new TransactionStatement(kBeginTransaction); } 3455| 66.4k|#line 3456 "bison_parser.cpp" 3456| 66.4k| break; 3457| | 3458| 369| case 27: /* transaction_statement: ROLLBACK opt_transaction_keyword */ ------------------ | Branch (3458:3): [True: 369, False: 14.8M] ------------------ 3459| 369|#line 408 "bison_parser.y" 3460| 369| { (yyval.transaction_stmt) = new TransactionStatement(kRollbackTransaction); } 3461| 369|#line 3462 "bison_parser.cpp" 3462| 369| break; 3463| | 3464| 552| case 28: /* transaction_statement: COMMIT opt_transaction_keyword */ ------------------ | Branch (3464:3): [True: 552, False: 14.8M] ------------------ 3465| 552|#line 409 "bison_parser.y" 3466| 552| { (yyval.transaction_stmt) = new TransactionStatement(kCommitTransaction); } 3467| 552|#line 3468 "bison_parser.cpp" 3468| 552| break; 3469| | 3470| 737| case 31: /* prepare_statement: PREPARE IDENTIFIER FROM prepare_target_query */ ------------------ | Branch (3470:3): [True: 737, False: 14.8M] ------------------ 3471| 737|#line 417 "bison_parser.y" 3472| 737| { 3473| 737| (yyval.prep_stmt) = new PrepareStatement(); 3474| 737| (yyval.prep_stmt)->name = (yyvsp[-2].sval); 3475| 737| (yyval.prep_stmt)->query = (yyvsp[0].sval); 3476| 737|} 3477| 737|#line 3478 "bison_parser.cpp" 3478| 737| break; 3479| | 3480| 1.82k| case 33: /* execute_statement: EXECUTE IDENTIFIER */ ------------------ | Branch (3480:3): [True: 1.82k, False: 14.8M] ------------------ 3481| 1.82k|#line 425 "bison_parser.y" 3482| 1.82k| { 3483| 1.82k| (yyval.exec_stmt) = new ExecuteStatement(); 3484| 1.82k| (yyval.exec_stmt)->name = (yyvsp[0].sval); 3485| 1.82k|} 3486| 1.82k|#line 3487 "bison_parser.cpp" 3487| 1.82k| break; 3488| | 3489| 544| case 34: /* execute_statement: EXECUTE IDENTIFIER '(' opt_literal_list ')' */ ------------------ | Branch (3489:3): [True: 544, False: 14.8M] ------------------ 3490| 544|#line 429 "bison_parser.y" 3491| 544| { 3492| 544| (yyval.exec_stmt) = new ExecuteStatement(); 3493| 544| (yyval.exec_stmt)->name = (yyvsp[-3].sval); 3494| 544| (yyval.exec_stmt)->parameters = (yyvsp[-1].expr_vec); 3495| 544|} 3496| 544|#line 3497 "bison_parser.cpp" 3497| 544| break; 3498| | 3499| 0| case 35: /* import_statement: IMPORT FROM file_type FILE file_path INTO table_name */ ------------------ | Branch (3499:3): [True: 0, False: 14.8M] ------------------ 3500| 0|#line 440 "bison_parser.y" 3501| 0| { 3502| 0| (yyval.import_stmt) = new ImportStatement((yyvsp[-4].import_type_t)); 3503| 0| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3504| 0| (yyval.import_stmt)->schema = (yyvsp[0].table_name).schema; 3505| 0| (yyval.import_stmt)->tableName = (yyvsp[0].table_name).name; 3506| 0|} 3507| 0|#line 3508 "bison_parser.cpp" 3508| 0| break; 3509| | 3510| 562| case 36: /* import_statement: COPY table_name FROM file_path opt_file_type opt_where */ ------------------ | Branch (3510:3): [True: 562, False: 14.8M] ------------------ 3511| 562|#line 446 "bison_parser.y" 3512| 562| { 3513| 562| (yyval.import_stmt) = new ImportStatement((yyvsp[-1].import_type_t)); 3514| 562| (yyval.import_stmt)->filePath = (yyvsp[-2].sval); 3515| 562| (yyval.import_stmt)->schema = (yyvsp[-4].table_name).schema; 3516| 562| (yyval.import_stmt)->tableName = (yyvsp[-4].table_name).name; 3517| 562| (yyval.import_stmt)->whereClause = (yyvsp[0].expr); 3518| 562|} 3519| 562|#line 3520 "bison_parser.cpp" 3520| 562| break; 3521| | 3522| 122| case 37: /* file_type: IDENTIFIER */ ------------------ | Branch (3522:3): [True: 122, False: 14.8M] ------------------ 3523| 122|#line 454 "bison_parser.y" 3524| 122| { 3525| 122| if (strcasecmp((yyvsp[0].sval), "csv") == 0) { ------------------ | Branch (3525:7): [True: 1, False: 121] ------------------ 3526| 1| (yyval.import_type_t) = kImportCSV; 3527| 121| } else if (strcasecmp((yyvsp[0].sval), "tbl") == 0) { ------------------ | Branch (3527:14): [True: 1, False: 120] ------------------ 3528| 1| (yyval.import_type_t) = kImportTbl; 3529| 120| } else if (strcasecmp((yyvsp[0].sval), "binary") == 0 || strcasecmp((yyvsp[0].sval), "bin") == 0) { ------------------ | Branch (3529:14): [True: 1, False: 119] | Branch (3529:60): [True: 1, False: 118] ------------------ 3530| 2| (yyval.import_type_t) = kImportBinary; 3531| 118| } else { 3532| 118| free((yyvsp[0].sval)); 3533| 118| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 72| 118|#define yyerror hsql_error ------------------ 3534| 118| YYERROR; ------------------ | | 1508| 118|#define YYERROR goto yyerrorlab ------------------ 3535| 118| } 3536| 4| free((yyvsp[0].sval)); 3537| 4|} 3538| 0|#line 3539 "bison_parser.cpp" 3539| 0| break; 3540| | 3541| 2.41k| case 38: /* file_path: string_literal */ ------------------ | Branch (3541:3): [True: 2.41k, False: 14.8M] ------------------ 3542| 2.41k|#line 469 "bison_parser.y" 3543| 2.41k| { 3544| 2.41k| (yyval.sval) = strdup((yyvsp[0].expr)->name); 3545| 2.41k| delete (yyvsp[0].expr); 3546| 2.41k|} 3547| 2.41k|#line 3548 "bison_parser.cpp" 3548| 2.41k| break; 3549| | 3550| 0| case 39: /* opt_file_type: WITH FORMAT file_type */ ------------------ | Branch (3550:3): [True: 0, False: 14.8M] ------------------ 3551| 0|#line 474 "bison_parser.y" 3552| 0| { (yyval.import_type_t) = (yyvsp[0].import_type_t); } 3553| 0|#line 3554 "bison_parser.cpp" 3554| 0| break; 3555| | 3556| 2.41k| case 40: /* opt_file_type: %empty */ ------------------ | Branch (3556:3): [True: 2.41k, False: 14.8M] ------------------ 3557| 2.41k|#line 475 "bison_parser.y" 3558| 2.41k| { (yyval.import_type_t) = kImportAuto; } 3559| 2.41k|#line 3560 "bison_parser.cpp" 3560| 2.41k| break; 3561| | 3562| 1.78k| case 41: /* export_statement: COPY table_name TO file_path opt_file_type */ ------------------ | Branch (3562:3): [True: 1.78k, False: 14.8M] ------------------ 3563| 1.78k|#line 481 "bison_parser.y" 3564| 1.78k| { 3565| 1.78k| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_type_t)); 3566| 1.78k| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3567| 1.78k| (yyval.export_stmt)->schema = (yyvsp[-3].table_name).schema; 3568| 1.78k| (yyval.export_stmt)->tableName = (yyvsp[-3].table_name).name; 3569| 1.78k|} 3570| 1.78k|#line 3571 "bison_parser.cpp" 3571| 1.78k| break; 3572| | 3573| 66| case 42: /* export_statement: COPY select_with_paren TO file_path opt_file_type */ ------------------ | Branch (3573:3): [True: 66, False: 14.8M] ------------------ 3574| 66|#line 487 "bison_parser.y" 3575| 66| { 3576| 66| (yyval.export_stmt) = new ExportStatement((yyvsp[0].import_type_t)); 3577| 66| (yyval.export_stmt)->filePath = (yyvsp[-1].sval); 3578| 66| (yyval.export_stmt)->select = (yyvsp[-3].select_stmt); 3579| 66|} 3580| 66|#line 3581 "bison_parser.cpp" 3581| 66| break; 3582| | 3583| 1.10k| case 43: /* show_statement: SHOW TABLES */ ------------------ | Branch (3583:3): [True: 1.10k, False: 14.8M] ------------------ 3584| 1.10k|#line 498 "bison_parser.y" 3585| 1.10k| { (yyval.show_stmt) = new ShowStatement(kShowTables); } 3586| 1.10k|#line 3587 "bison_parser.cpp" 3587| 1.10k| break; 3588| | 3589| 453| case 44: /* show_statement: SHOW COLUMNS table_name */ ------------------ | Branch (3589:3): [True: 453, False: 14.8M] ------------------ 3590| 453|#line 499 "bison_parser.y" 3591| 453| { 3592| 453| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3593| 453| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3594| 453| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3595| 453|} 3596| 453|#line 3597 "bison_parser.cpp" 3597| 453| break; 3598| | 3599| 943| case 45: /* show_statement: DESCRIBE table_name */ ------------------ | Branch (3599:3): [True: 943, False: 14.8M] ------------------ 3600| 943|#line 504 "bison_parser.y" 3601| 943| { 3602| 943| (yyval.show_stmt) = new ShowStatement(kShowColumns); 3603| 943| (yyval.show_stmt)->schema = (yyvsp[0].table_name).schema; 3604| 943| (yyval.show_stmt)->name = (yyvsp[0].table_name).name; 3605| 943|} 3606| 943|#line 3607 "bison_parser.cpp" 3607| 943| break; 3608| | 3609| 0| case 46: /* create_statement: CREATE TABLE opt_not_exists table_name FROM IDENTIFIER FILE file_path */ ------------------ | Branch (3609:3): [True: 0, False: 14.8M] ------------------ 3610| 0|#line 515 "bison_parser.y" 3611| 0| { 3612| 0| (yyval.create_stmt) = new CreateStatement(kCreateTableFromTbl); 3613| 0| (yyval.create_stmt)->ifNotExists = (yyvsp[-5].bval); 3614| 0| (yyval.create_stmt)->schema = (yyvsp[-4].table_name).schema; 3615| 0| (yyval.create_stmt)->tableName = (yyvsp[-4].table_name).name; 3616| 0| if (strcasecmp((yyvsp[-2].sval), "tbl") != 0) { ------------------ | Branch (3616:7): [True: 0, False: 0] ------------------ 3617| 0| free((yyvsp[-2].sval)); 3618| 0| yyerror(&yyloc, result, scanner, "File type is unknown."); ------------------ | | 72| 0|#define yyerror hsql_error ------------------ 3619| 0| YYERROR; ------------------ | | 1508| 0|#define YYERROR goto yyerrorlab ------------------ 3620| 0| } 3621| 0| free((yyvsp[-2].sval)); 3622| 0| (yyval.create_stmt)->filePath = (yyvsp[0].sval); 3623| 0|} 3624| 0|#line 3625 "bison_parser.cpp" 3625| 0| break; 3626| | 3627| 653| case 47: /* create_statement: CREATE TABLE opt_not_exists table_name '(' table_elem_commalist ')' */ ------------------ | Branch (3627:3): [True: 653, False: 14.8M] ------------------ 3628| 653|#line 528 "bison_parser.y" 3629| 653| { 3630| 653| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3631| 653| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3632| 653| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3633| 653| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3634| 653| (yyval.create_stmt)->setColumnDefsAndConstraints((yyvsp[-1].table_element_vec)); 3635| 653| delete (yyvsp[-1].table_element_vec); 3636| 653| if (result->errorMsg()) { ------------------ | Branch (3636:7): [True: 1, False: 652] ------------------ 3637| 1| delete (yyval.create_stmt); 3638| 1| YYERROR; ------------------ | | 1508| 1|#define YYERROR goto yyerrorlab ------------------ 3639| 1| } 3640| 653|} 3641| 652|#line 3642 "bison_parser.cpp" 3642| 652| break; 3643| | 3644| 652| case 48: /* create_statement: CREATE TABLE opt_not_exists table_name AS select_statement */ ------------------ | Branch (3644:3): [True: 194, False: 14.8M] ------------------ 3645| 194|#line 540 "bison_parser.y" 3646| 194| { 3647| 194| (yyval.create_stmt) = new CreateStatement(kCreateTable); 3648| 194| (yyval.create_stmt)->ifNotExists = (yyvsp[-3].bval); 3649| 194| (yyval.create_stmt)->schema = (yyvsp[-2].table_name).schema; 3650| 194| (yyval.create_stmt)->tableName = (yyvsp[-2].table_name).name; 3651| 194| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3652| 194|} 3653| 194|#line 3654 "bison_parser.cpp" 3654| 194| break; 3655| | 3656| 1.21k| case 49: /* create_statement: CREATE INDEX opt_not_exists opt_index_name ON table_name '(' ident_commalist ')' */ ------------------ | Branch (3656:3): [True: 1.21k, False: 14.8M] ------------------ 3657| 1.21k|#line 547 "bison_parser.y" 3658| 1.21k| { 3659| 1.21k| (yyval.create_stmt) = new CreateStatement(kCreateIndex); 3660| 1.21k| (yyval.create_stmt)->indexName = (yyvsp[-5].sval); 3661| 1.21k| (yyval.create_stmt)->ifNotExists = (yyvsp[-6].bval); 3662| 1.21k| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3663| 1.21k| (yyval.create_stmt)->indexColumns = (yyvsp[-1].str_vec); 3664| 1.21k|} 3665| 1.21k|#line 3666 "bison_parser.cpp" 3666| 1.21k| break; 3667| | 3668| 293| case 50: /* create_statement: CREATE VIEW opt_not_exists table_name opt_column_list AS select_statement */ ------------------ | Branch (3668:3): [True: 293, False: 14.8M] ------------------ 3669| 293|#line 554 "bison_parser.y" 3670| 293| { 3671| 293| (yyval.create_stmt) = new CreateStatement(kCreateView); 3672| 293| (yyval.create_stmt)->ifNotExists = (yyvsp[-4].bval); 3673| 293| (yyval.create_stmt)->schema = (yyvsp[-3].table_name).schema; 3674| 293| (yyval.create_stmt)->tableName = (yyvsp[-3].table_name).name; 3675| 293| (yyval.create_stmt)->viewColumns = (yyvsp[-2].str_vec); 3676| 293| (yyval.create_stmt)->select = (yyvsp[0].select_stmt); 3677| 293|} 3678| 293|#line 3679 "bison_parser.cpp" 3679| 293| break; 3680| | 3681| 66| case 51: /* opt_not_exists: IF NOT EXISTS */ ------------------ | Branch (3681:3): [True: 66, False: 14.8M] ------------------ 3682| 66|#line 563 "bison_parser.y" 3683| 66| { (yyval.bval) = true; } 3684| 66|#line 3685 "bison_parser.cpp" 3685| 66| break; 3686| | 3687| 2.91k| case 52: /* opt_not_exists: %empty */ ------------------ | Branch (3687:3): [True: 2.91k, False: 14.8M] ------------------ 3688| 2.91k|#line 564 "bison_parser.y" 3689| 2.91k| { (yyval.bval) = false; } 3690| 2.91k|#line 3691 "bison_parser.cpp" 3691| 2.91k| break; 3692| | 3693| 1.20k| case 53: /* table_elem_commalist: table_elem */ ------------------ | Branch (3693:3): [True: 1.20k, False: 14.8M] ------------------ 3694| 1.20k|#line 566 "bison_parser.y" 3695| 1.20k| { 3696| 1.20k| (yyval.table_element_vec) = new std::vector(); 3697| 1.20k| (yyval.table_element_vec)->push_back((yyvsp[0].table_element_t)); 3698| 1.20k|} 3699| 1.20k|#line 3700 "bison_parser.cpp" 3700| 1.20k| break; 3701| | 3702| 404k| case 54: /* table_elem_commalist: table_elem_commalist ',' table_elem */ ------------------ | Branch (3702:3): [True: 404k, False: 14.4M] ------------------ 3703| 404k|#line 570 "bison_parser.y" 3704| 404k| { 3705| 404k| (yyvsp[-2].table_element_vec)->push_back((yyvsp[0].table_element_t)); 3706| 404k| (yyval.table_element_vec) = (yyvsp[-2].table_element_vec); 3707| 404k|} 3708| 404k|#line 3709 "bison_parser.cpp" 3709| 404k| break; 3710| | 3711| 347k| case 55: /* table_elem: column_def */ ------------------ | Branch (3711:3): [True: 347k, False: 14.5M] ------------------ 3712| 347k|#line 575 "bison_parser.y" 3713| 347k| { (yyval.table_element_t) = (yyvsp[0].column_t); } 3714| 347k|#line 3715 "bison_parser.cpp" 3715| 347k| break; 3716| | 3717| 58.6k| case 56: /* table_elem: table_constraint */ ------------------ | Branch (3717:3): [True: 58.6k, False: 14.8M] ------------------ 3718| 58.6k|#line 576 "bison_parser.y" 3719| 58.6k| { (yyval.table_element_t) = (yyvsp[0].table_constraint_t); } 3720| 58.6k|#line 3721 "bison_parser.cpp" 3721| 58.6k| break; 3722| | 3723| 347k| case 57: /* column_def: IDENTIFIER column_type opt_column_constraints */ ------------------ | Branch (3723:3): [True: 347k, False: 14.5M] ------------------ 3724| 347k|#line 578 "bison_parser.y" 3725| 347k| { 3726| 347k| (yyval.column_t) = new ColumnDefinition((yyvsp[-2].sval), (yyvsp[-1].column_type_t), (yyvsp[0].column_constraint_set)); 3727| 347k| if (!(yyval.column_t)->trySetNullableExplicit()) { ------------------ | Branch (3727:7): [True: 1.50k, False: 345k] ------------------ 3728| 1.50k| yyerror(&yyloc, result, scanner, ("Conflicting nullability constraints for " + std::string{(yyvsp[-2].sval)}).c_str()); ------------------ | | 72| 1.50k|#define yyerror hsql_error ------------------ 3729| 1.50k| } 3730| 347k|} 3731| 347k|#line 3732 "bison_parser.cpp" 3732| 347k| break; 3733| | 3734| 763| case 58: /* column_type: BIGINT */ ------------------ | Branch (3734:3): [True: 763, False: 14.8M] ------------------ 3735| 763|#line 585 "bison_parser.y" 3736| 763| { (yyval.column_type_t) = ColumnType{DataType::BIGINT}; } 3737| 763|#line 3738 "bison_parser.cpp" 3738| 763| break; 3739| | 3740| 670| case 59: /* column_type: BOOLEAN */ ------------------ | Branch (3740:3): [True: 670, False: 14.8M] ------------------ 3741| 670|#line 586 "bison_parser.y" 3742| 670| { (yyval.column_type_t) = ColumnType{DataType::BOOLEAN}; } 3743| 670|#line 3744 "bison_parser.cpp" 3744| 670| break; 3745| | 3746| 378| case 60: /* column_type: CHAR '(' INTVAL ')' */ ------------------ | Branch (3746:3): [True: 378, False: 14.8M] ------------------ 3747| 378|#line 587 "bison_parser.y" 3748| 378| { (yyval.column_type_t) = ColumnType{DataType::CHAR, (yyvsp[-1].ival)}; } 3749| 378|#line 3750 "bison_parser.cpp" 3750| 378| break; 3751| | 3752| 0| case 61: /* column_type: CHARACTER_VARYING '(' INTVAL ')' */ ------------------ | Branch (3752:3): [True: 0, False: 14.8M] ------------------ 3753| 0|#line 588 "bison_parser.y" 3754| 0| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3755| 0|#line 3756 "bison_parser.cpp" 3756| 0| break; 3757| | 3758| 372| case 62: /* column_type: DATE */ ------------------ | Branch (3758:3): [True: 372, False: 14.8M] ------------------ 3759| 372|#line 589 "bison_parser.y" 3760| 372| { (yyval.column_type_t) = ColumnType{DataType::DATE}; } 3761| 372|#line 3762 "bison_parser.cpp" 3762| 372| break; 3763| | 3764| 556| case 63: /* column_type: DATETIME */ ------------------ | Branch (3764:3): [True: 556, False: 14.8M] ------------------ 3765| 556|#line 590 "bison_parser.y" 3766| 556| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3767| 556|#line 3768 "bison_parser.cpp" 3768| 556| break; 3769| | 3770| 1.01k| case 64: /* column_type: DECIMAL opt_decimal_specification */ ------------------ | Branch (3770:3): [True: 1.01k, False: 14.8M] ------------------ 3771| 1.01k|#line 591 "bison_parser.y" 3772| 1.01k| { 3773| 1.01k| (yyval.column_type_t) = ColumnType{DataType::DECIMAL, 0, (yyvsp[0].ival_pair)->first, (yyvsp[0].ival_pair)->second}; 3774| 1.01k| delete (yyvsp[0].ival_pair); 3775| 1.01k|} 3776| 1.01k|#line 3777 "bison_parser.cpp" 3777| 1.01k| break; 3778| | 3779| 806| case 65: /* column_type: DOUBLE */ ------------------ | Branch (3779:3): [True: 806, False: 14.8M] ------------------ 3780| 806|#line 595 "bison_parser.y" 3781| 806| { (yyval.column_type_t) = ColumnType{DataType::DOUBLE}; } 3782| 806|#line 3783 "bison_parser.cpp" 3783| 806| break; 3784| | 3785| 701| case 66: /* column_type: FLOAT */ ------------------ | Branch (3785:3): [True: 701, False: 14.8M] ------------------ 3786| 701|#line 596 "bison_parser.y" 3787| 701| { (yyval.column_type_t) = ColumnType{DataType::FLOAT}; } 3788| 701|#line 3789 "bison_parser.cpp" 3789| 701| break; 3790| | 3791| 268k| case 67: /* column_type: INT */ ------------------ | Branch (3791:3): [True: 268k, False: 14.6M] ------------------ 3792| 268k|#line 597 "bison_parser.y" 3793| 268k| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3794| 268k|#line 3795 "bison_parser.cpp" 3795| 268k| break; 3796| | 3797| 602| case 68: /* column_type: INTEGER */ ------------------ | Branch (3797:3): [True: 602, False: 14.8M] ------------------ 3798| 602|#line 598 "bison_parser.y" 3799| 602| { (yyval.column_type_t) = ColumnType{DataType::INT}; } 3800| 602|#line 3801 "bison_parser.cpp" 3801| 602| break; 3802| | 3803| 560| case 69: /* column_type: LONG */ ------------------ | Branch (3803:3): [True: 560, False: 14.8M] ------------------ 3804| 560|#line 599 "bison_parser.y" 3805| 560| { (yyval.column_type_t) = ColumnType{DataType::LONG}; } 3806| 560|#line 3807 "bison_parser.cpp" 3807| 560| break; 3808| | 3809| 553| case 70: /* column_type: REAL */ ------------------ | Branch (3809:3): [True: 553, False: 14.8M] ------------------ 3810| 553|#line 600 "bison_parser.y" 3811| 553| { (yyval.column_type_t) = ColumnType{DataType::REAL}; } 3812| 553|#line 3813 "bison_parser.cpp" 3813| 553| break; 3814| | 3815| 554| case 71: /* column_type: SMALLINT */ ------------------ | Branch (3815:3): [True: 554, False: 14.8M] ------------------ 3816| 554|#line 601 "bison_parser.y" 3817| 554| { (yyval.column_type_t) = ColumnType{DataType::SMALLINT}; } 3818| 554|#line 3819 "bison_parser.cpp" 3819| 554| break; 3820| | 3821| 332| case 72: /* column_type: TEXT */ ------------------ | Branch (3821:3): [True: 332, False: 14.8M] ------------------ 3822| 332|#line 602 "bison_parser.y" 3823| 332| { (yyval.column_type_t) = ColumnType{DataType::TEXT}; } 3824| 332|#line 3825 "bison_parser.cpp" 3825| 332| break; 3826| | 3827| 44.9k| case 73: /* column_type: TIME opt_time_precision */ ------------------ | Branch (3827:3): [True: 44.9k, False: 14.8M] ------------------ 3828| 44.9k|#line 603 "bison_parser.y" 3829| 44.9k| { (yyval.column_type_t) = ColumnType{DataType::TIME, 0, (yyvsp[0].ival)}; } 3830| 44.9k|#line 3831 "bison_parser.cpp" 3831| 44.9k| break; 3832| | 3833| 25.4k| case 74: /* column_type: TIMESTAMP */ ------------------ | Branch (3833:3): [True: 25.4k, False: 14.8M] ------------------ 3834| 25.4k|#line 604 "bison_parser.y" 3835| 25.4k| { (yyval.column_type_t) = ColumnType{DataType::DATETIME}; } 3836| 25.4k|#line 3837 "bison_parser.cpp" 3837| 25.4k| break; 3838| | 3839| 760| case 75: /* column_type: VARCHAR '(' INTVAL ')' */ ------------------ | Branch (3839:3): [True: 760, False: 14.8M] ------------------ 3840| 760|#line 605 "bison_parser.y" 3841| 760| { (yyval.column_type_t) = ColumnType{DataType::VARCHAR, (yyvsp[-1].ival)}; } 3842| 760|#line 3843 "bison_parser.cpp" 3843| 760| break; 3844| | 3845| 194| case 76: /* opt_time_precision: '(' INTVAL ')' */ ------------------ | Branch (3845:3): [True: 194, False: 14.8M] ------------------ 3846| 194|#line 607 "bison_parser.y" 3847| 194| { (yyval.ival) = (yyvsp[-1].ival); } 3848| 194|#line 3849 "bison_parser.cpp" 3849| 194| break; 3850| | 3851| 44.7k| case 77: /* opt_time_precision: %empty */ ------------------ | Branch (3851:3): [True: 44.7k, False: 14.8M] ------------------ 3852| 44.7k|#line 608 "bison_parser.y" 3853| 44.7k| { (yyval.ival) = 0; } 3854| 44.7k|#line 3855 "bison_parser.cpp" 3855| 44.7k| break; 3856| | 3857| 195| case 78: /* opt_decimal_specification: '(' INTVAL ',' INTVAL ')' */ ------------------ | Branch (3857:3): [True: 195, False: 14.8M] ------------------ 3858| 195|#line 610 "bison_parser.y" 3859| 195| { (yyval.ival_pair) = new std::pair{(yyvsp[-3].ival), (yyvsp[-1].ival)}; } 3860| 195|#line 3861 "bison_parser.cpp" 3861| 195| break; 3862| | 3863| 194| case 79: /* opt_decimal_specification: '(' INTVAL ')' */ ------------------ | Branch (3863:3): [True: 194, False: 14.8M] ------------------ 3864| 194|#line 611 "bison_parser.y" 3865| 194| { (yyval.ival_pair) = new std::pair{(yyvsp[-1].ival), 0}; } 3866| 194|#line 3867 "bison_parser.cpp" 3867| 194| break; 3868| | 3869| 629| case 80: /* opt_decimal_specification: %empty */ ------------------ | Branch (3869:3): [True: 629, False: 14.8M] ------------------ 3870| 629|#line 612 "bison_parser.y" 3871| 629| { (yyval.ival_pair) = new std::pair{0, 0}; } 3872| 629|#line 3873 "bison_parser.cpp" 3873| 629| break; 3874| | 3875| 2.38k| case 81: /* opt_column_constraints: column_constraint_set */ ------------------ | Branch (3875:3): [True: 2.38k, False: 14.8M] ------------------ 3876| 2.38k|#line 614 "bison_parser.y" 3877| 2.38k| { (yyval.column_constraint_set) = (yyvsp[0].column_constraint_set); } 3878| 2.38k|#line 3879 "bison_parser.cpp" 3879| 2.38k| break; 3880| | 3881| 345k| case 82: /* opt_column_constraints: %empty */ ------------------ | Branch (3881:3): [True: 345k, False: 14.5M] ------------------ 3882| 345k|#line 615 "bison_parser.y" 3883| 345k| { (yyval.column_constraint_set) = new std::unordered_set(); } 3884| 345k|#line 3885 "bison_parser.cpp" 3885| 345k| break; 3886| | 3887| 2.39k| case 83: /* column_constraint_set: column_constraint */ ------------------ | Branch (3887:3): [True: 2.39k, False: 14.8M] ------------------ 3888| 2.39k|#line 617 "bison_parser.y" 3889| 2.39k| { 3890| 2.39k| (yyval.column_constraint_set) = new std::unordered_set(); 3891| 2.39k| (yyval.column_constraint_set)->insert((yyvsp[0].column_constraint_t)); 3892| 2.39k|} 3893| 2.39k|#line 3894 "bison_parser.cpp" 3894| 2.39k| break; 3895| | 3896| 4.33k| case 84: /* column_constraint_set: column_constraint_set column_constraint */ ------------------ | Branch (3896:3): [True: 4.33k, False: 14.8M] ------------------ 3897| 4.33k|#line 621 "bison_parser.y" 3898| 4.33k| { 3899| 4.33k| (yyvsp[-1].column_constraint_set)->insert((yyvsp[0].column_constraint_t)); 3900| 4.33k| (yyval.column_constraint_set) = (yyvsp[-1].column_constraint_set); 3901| 4.33k|} 3902| 4.33k|#line 3903 "bison_parser.cpp" 3903| 4.33k| break; 3904| | 3905| 1.61k| case 85: /* column_constraint: PRIMARY KEY */ ------------------ | Branch (3905:3): [True: 1.61k, False: 14.8M] ------------------ 3906| 1.61k|#line 626 "bison_parser.y" 3907| 1.61k| { (yyval.column_constraint_t) = ConstraintType::PrimaryKey; } 3908| 1.61k|#line 3909 "bison_parser.cpp" 3909| 1.61k| break; 3910| | 3911| 1.10k| case 86: /* column_constraint: UNIQUE */ ------------------ | Branch (3911:3): [True: 1.10k, False: 14.8M] ------------------ 3912| 1.10k|#line 627 "bison_parser.y" 3913| 1.10k| { (yyval.column_constraint_t) = ConstraintType::Unique; } 3914| 1.10k|#line 3915 "bison_parser.cpp" 3915| 1.10k| break; 3916| | 3917| 2.58k| case 87: /* column_constraint: NULL */ ------------------ | Branch (3917:3): [True: 2.58k, False: 14.8M] ------------------ 3918| 2.58k|#line 628 "bison_parser.y" 3919| 2.58k| { (yyval.column_constraint_t) = ConstraintType::Null; } 3920| 2.58k|#line 3921 "bison_parser.cpp" 3921| 2.58k| break; 3922| | 3923| 1.42k| case 88: /* column_constraint: NOT NULL */ ------------------ | Branch (3923:3): [True: 1.42k, False: 14.8M] ------------------ 3924| 1.42k|#line 629 "bison_parser.y" 3925| 1.42k| { (yyval.column_constraint_t) = ConstraintType::NotNull; } 3926| 1.42k|#line 3927 "bison_parser.cpp" 3927| 1.42k| break; 3928| | 3929| 195| case 89: /* table_constraint: PRIMARY KEY '(' ident_commalist ')' */ ------------------ | Branch (3929:3): [True: 195, False: 14.8M] ------------------ 3930| 195|#line 631 "bison_parser.y" 3931| 195| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::PrimaryKey, (yyvsp[-1].str_vec)); } 3932| 195|#line 3933 "bison_parser.cpp" 3933| 195| break; 3934| | 3935| 58.4k| case 90: /* table_constraint: UNIQUE '(' ident_commalist ')' */ ------------------ | Branch (3935:3): [True: 58.4k, False: 14.8M] ------------------ 3936| 58.4k|#line 632 "bison_parser.y" 3937| 58.4k| { (yyval.table_constraint_t) = new TableConstraint(ConstraintType::Unique, (yyvsp[-1].str_vec)); } 3938| 58.4k|#line 3939 "bison_parser.cpp" 3939| 58.4k| break; 3940| | 3941| 713| case 91: /* drop_statement: DROP TABLE opt_exists table_name */ ------------------ | Branch (3941:3): [True: 713, False: 14.8M] ------------------ 3942| 713|#line 640 "bison_parser.y" 3943| 713| { 3944| 713| (yyval.drop_stmt) = new DropStatement(kDropTable); 3945| 713| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3946| 713| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 3947| 713| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 3948| 713|} 3949| 713|#line 3950 "bison_parser.cpp" 3950| 713| break; 3951| | 3952| 1.00k| case 92: /* drop_statement: DROP VIEW opt_exists table_name */ ------------------ | Branch (3952:3): [True: 1.00k, False: 14.8M] ------------------ 3953| 1.00k|#line 646 "bison_parser.y" 3954| 1.00k| { 3955| 1.00k| (yyval.drop_stmt) = new DropStatement(kDropView); 3956| 1.00k| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3957| 1.00k| (yyval.drop_stmt)->schema = (yyvsp[0].table_name).schema; 3958| 1.00k| (yyval.drop_stmt)->name = (yyvsp[0].table_name).name; 3959| 1.00k|} 3960| 1.00k|#line 3961 "bison_parser.cpp" 3961| 1.00k| break; 3962| | 3963| 727| case 93: /* drop_statement: DEALLOCATE PREPARE IDENTIFIER */ ------------------ | Branch (3963:3): [True: 727, False: 14.8M] ------------------ 3964| 727|#line 652 "bison_parser.y" 3965| 727| { 3966| 727| (yyval.drop_stmt) = new DropStatement(kDropPreparedStatement); 3967| 727| (yyval.drop_stmt)->ifExists = false; 3968| 727| (yyval.drop_stmt)->name = (yyvsp[0].sval); 3969| 727|} 3970| 727|#line 3971 "bison_parser.cpp" 3971| 727| break; 3972| | 3973| 741| case 94: /* drop_statement: DROP INDEX opt_exists IDENTIFIER */ ------------------ | Branch (3973:3): [True: 741, False: 14.8M] ------------------ 3974| 741|#line 658 "bison_parser.y" 3975| 741| { 3976| 741| (yyval.drop_stmt) = new DropStatement(kDropIndex); 3977| 741| (yyval.drop_stmt)->ifExists = (yyvsp[-1].bval); 3978| 741| (yyval.drop_stmt)->indexName = (yyvsp[0].sval); 3979| 741|} 3980| 741|#line 3981 "bison_parser.cpp" 3981| 741| break; 3982| | 3983| 119| case 95: /* opt_exists: IF EXISTS */ ------------------ | Branch (3983:3): [True: 119, False: 14.8M] ------------------ 3984| 119|#line 664 "bison_parser.y" 3985| 119| { (yyval.bval) = true; } 3986| 119|#line 3987 "bison_parser.cpp" 3987| 119| break; 3988| | 3989| 2.37k| case 96: /* opt_exists: %empty */ ------------------ | Branch (3989:3): [True: 2.37k, False: 14.8M] ------------------ 3990| 2.37k|#line 665 "bison_parser.y" 3991| 2.37k| { (yyval.bval) = false; } 3992| 2.37k|#line 3993 "bison_parser.cpp" 3993| 2.37k| break; 3994| | 3995| 0| case 97: /* alter_statement: ALTER TABLE opt_exists table_name alter_action */ ------------------ | Branch (3995:3): [True: 0, False: 14.8M] ------------------ 3996| 0|#line 672 "bison_parser.y" 3997| 0| { 3998| 0| (yyval.alter_stmt) = new AlterStatement((yyvsp[-1].table_name).name, (yyvsp[0].alter_action_t)); 3999| 0| (yyval.alter_stmt)->ifTableExists = (yyvsp[-2].bval); 4000| 0| (yyval.alter_stmt)->schema = (yyvsp[-1].table_name).schema; 4001| 0|} 4002| 0|#line 4003 "bison_parser.cpp" 4003| 0| break; 4004| | 4005| 0| case 98: /* alter_action: drop_action */ ------------------ | Branch (4005:3): [True: 0, False: 14.8M] ------------------ 4006| 0|#line 678 "bison_parser.y" 4007| 0| { (yyval.alter_action_t) = (yyvsp[0].drop_action_t); } 4008| 0|#line 4009 "bison_parser.cpp" 4009| 0| break; 4010| | 4011| 0| case 99: /* drop_action: DROP COLUMN opt_exists IDENTIFIER */ ------------------ | Branch (4011:3): [True: 0, False: 14.8M] ------------------ 4012| 0|#line 680 "bison_parser.y" 4013| 0| { 4014| 0| (yyval.drop_action_t) = new DropColumnAction((yyvsp[0].sval)); 4015| 0| (yyval.drop_action_t)->ifExists = (yyvsp[-1].bval); 4016| 0|} 4017| 0|#line 4018 "bison_parser.cpp" 4018| 0| break; 4019| | 4020| 1.17k| case 100: /* delete_statement: DELETE FROM table_name opt_where */ ------------------ | Branch (4020:3): [True: 1.17k, False: 14.8M] ------------------ 4021| 1.17k|#line 690 "bison_parser.y" 4022| 1.17k| { 4023| 1.17k| (yyval.delete_stmt) = new DeleteStatement(); 4024| 1.17k| (yyval.delete_stmt)->schema = (yyvsp[-1].table_name).schema; 4025| 1.17k| (yyval.delete_stmt)->tableName = (yyvsp[-1].table_name).name; 4026| 1.17k| (yyval.delete_stmt)->expr = (yyvsp[0].expr); 4027| 1.17k|} 4028| 1.17k|#line 4029 "bison_parser.cpp" 4029| 1.17k| break; 4030| | 4031| 687| case 101: /* truncate_statement: TRUNCATE table_name */ ------------------ | Branch (4031:3): [True: 687, False: 14.8M] ------------------ 4032| 687|#line 697 "bison_parser.y" 4033| 687| { 4034| 687| (yyval.delete_stmt) = new DeleteStatement(); 4035| 687| (yyval.delete_stmt)->schema = (yyvsp[0].table_name).schema; 4036| 687| (yyval.delete_stmt)->tableName = (yyvsp[0].table_name).name; 4037| 687|} 4038| 687|#line 4039 "bison_parser.cpp" 4039| 687| break; 4040| | 4041| 605| case 102: /* insert_statement: INSERT INTO table_name opt_column_list VALUES '(' literal_list ')' */ ------------------ | Branch (4041:3): [True: 605, False: 14.8M] ------------------ 4042| 605|#line 708 "bison_parser.y" 4043| 605| { 4044| 605| (yyval.insert_stmt) = new InsertStatement(kInsertValues); 4045| 605| (yyval.insert_stmt)->schema = (yyvsp[-5].table_name).schema; 4046| 605| (yyval.insert_stmt)->tableName = (yyvsp[-5].table_name).name; 4047| 605| (yyval.insert_stmt)->columns = (yyvsp[-4].str_vec); 4048| 605| (yyval.insert_stmt)->values = (yyvsp[-1].expr_vec); 4049| 605|} 4050| 605|#line 4051 "bison_parser.cpp" 4051| 605| break; 4052| | 4053| 973| case 103: /* insert_statement: INSERT INTO table_name opt_column_list select_no_paren */ ------------------ | Branch (4053:3): [True: 973, False: 14.8M] ------------------ 4054| 973|#line 715 "bison_parser.y" 4055| 973| { 4056| 973| (yyval.insert_stmt) = new InsertStatement(kInsertSelect); 4057| 973| (yyval.insert_stmt)->schema = (yyvsp[-2].table_name).schema; 4058| 973| (yyval.insert_stmt)->tableName = (yyvsp[-2].table_name).name; 4059| 973| (yyval.insert_stmt)->columns = (yyvsp[-1].str_vec); 4060| 973| (yyval.insert_stmt)->select = (yyvsp[0].select_stmt); 4061| 973|} 4062| 973|#line 4063 "bison_parser.cpp" 4063| 973| break; 4064| | 4065| 476| case 104: /* opt_column_list: '(' ident_commalist ')' */ ------------------ | Branch (4065:3): [True: 476, False: 14.8M] ------------------ 4066| 476|#line 723 "bison_parser.y" 4067| 476| { (yyval.str_vec) = (yyvsp[-1].str_vec); } 4068| 476|#line 4069 "bison_parser.cpp" 4069| 476| break; 4070| | 4071| 1.43k| case 105: /* opt_column_list: %empty */ ------------------ | Branch (4071:3): [True: 1.43k, False: 14.8M] ------------------ 4072| 1.43k|#line 724 "bison_parser.y" 4073| 1.43k| { (yyval.str_vec) = nullptr; } 4074| 1.43k|#line 4075 "bison_parser.cpp" 4075| 1.43k| break; 4076| | 4077| 922| case 106: /* update_statement: UPDATE table_ref_name_no_alias SET update_clause_commalist opt_where */ ------------------ | Branch (4077:3): [True: 922, False: 14.8M] ------------------ 4078| 922|#line 731 "bison_parser.y" 4079| 922| { 4080| 922| (yyval.update_stmt) = new UpdateStatement(); 4081| 922| (yyval.update_stmt)->table = (yyvsp[-3].table); 4082| 922| (yyval.update_stmt)->updates = (yyvsp[-1].update_vec); 4083| 922| (yyval.update_stmt)->where = (yyvsp[0].expr); 4084| 922|} 4085| 922|#line 4086 "bison_parser.cpp" 4086| 922| break; 4087| | 4088| 949| case 107: /* update_clause_commalist: update_clause */ ------------------ | Branch (4088:3): [True: 949, False: 14.8M] ------------------ 4089| 949|#line 738 "bison_parser.y" 4090| 949| { 4091| 949| (yyval.update_vec) = new std::vector(); 4092| 949| (yyval.update_vec)->push_back((yyvsp[0].update_t)); 4093| 949|} 4094| 949|#line 4095 "bison_parser.cpp" 4095| 949| break; 4096| | 4097| 210k| case 108: /* update_clause_commalist: update_clause_commalist ',' update_clause */ ------------------ | Branch (4097:3): [True: 210k, False: 14.6M] ------------------ 4098| 210k|#line 742 "bison_parser.y" 4099| 210k| { 4100| 210k| (yyvsp[-2].update_vec)->push_back((yyvsp[0].update_t)); 4101| 210k| (yyval.update_vec) = (yyvsp[-2].update_vec); 4102| 210k|} 4103| 210k|#line 4104 "bison_parser.cpp" 4104| 210k| break; 4105| | 4106| 211k| case 109: /* update_clause: IDENTIFIER '=' expr */ ------------------ | Branch (4106:3): [True: 211k, False: 14.6M] ------------------ 4107| 211k|#line 747 "bison_parser.y" 4108| 211k| { 4109| 211k| (yyval.update_t) = new UpdateClause(); 4110| 211k| (yyval.update_t)->column = (yyvsp[-2].sval); 4111| 211k| (yyval.update_t)->value = (yyvsp[0].expr); 4112| 211k|} 4113| 211k|#line 4114 "bison_parser.cpp" 4114| 211k| break; 4115| | 4116| 75| case 110: /* select_statement: opt_with_clause select_with_paren */ ------------------ | Branch (4116:3): [True: 75, False: 14.8M] ------------------ 4117| 75|#line 757 "bison_parser.y" 4118| 75| { 4119| 75| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4120| 75| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4121| 75|} 4122| 75|#line 4123 "bison_parser.cpp" 4123| 75| break; 4124| | 4125| 12.6k| case 111: /* select_statement: opt_with_clause select_no_paren */ ------------------ | Branch (4125:3): [True: 12.6k, False: 14.8M] ------------------ 4126| 12.6k|#line 761 "bison_parser.y" 4127| 12.6k| { 4128| 12.6k| (yyval.select_stmt) = (yyvsp[0].select_stmt); 4129| 12.6k| (yyval.select_stmt)->withDescriptions = (yyvsp[-1].with_description_vec); 4130| 12.6k|} 4131| 12.6k|#line 4132 "bison_parser.cpp" 4132| 12.6k| break; 4133| | 4134| 613| case 112: /* select_statement: opt_with_clause select_with_paren set_operator select_within_set_operation opt_order opt_limit */ ------------------ | Branch (4134:3): [True: 613, False: 14.8M] ------------------ 4135| 613|#line 765 "bison_parser.y" 4136| 613| { 4137| 613| (yyval.select_stmt) = (yyvsp[-4].select_stmt); 4138| 613| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4138:7): [True: 347, False: 266] ------------------ 4139| 347| (yyval.select_stmt)->setOperations = new std::vector(); 4140| 347| } 4141| 613| (yyval.select_stmt)->setOperations->push_back((yyvsp[-3].set_operator_t)); 4142| 613| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-2].select_stmt); 4143| 613| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-1].order_vec); 4144| 613| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[0].limit); 4145| 613| (yyval.select_stmt)->withDescriptions = (yyvsp[-5].with_description_vec); 4146| 613|} 4147| 613|#line 4148 "bison_parser.cpp" 4148| 613| break; 4149| | 4150| 1.77k| case 115: /* select_within_set_operation_no_parentheses: select_clause */ ------------------ | Branch (4150:3): [True: 1.77k, False: 14.8M] ------------------ 4151| 1.77k|#line 779 "bison_parser.y" 4152| 1.77k| { (yyval.select_stmt) = (yyvsp[0].select_stmt); } 4153| 1.77k|#line 4154 "bison_parser.cpp" 4154| 1.77k| break; 4155| | 4156| 831| case 116: /* select_within_set_operation_no_parentheses: select_clause set_operator select_within_set_operation */ ------------------ | Branch (4156:3): [True: 831, False: 14.8M] ------------------ 4157| 831|#line 780 "bison_parser.y" 4158| 831| { 4159| 831| (yyval.select_stmt) = (yyvsp[-2].select_stmt); 4160| 831| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4160:7): [True: 831, False: 0] ------------------ 4161| 831| (yyval.select_stmt)->setOperations = new std::vector(); 4162| 831| } 4163| 831| (yyval.select_stmt)->setOperations->push_back((yyvsp[-1].set_operator_t)); 4164| 831| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[0].select_stmt); 4165| 831|} 4166| 831|#line 4167 "bison_parser.cpp" 4167| 831| break; 4168| | 4169| 2.68k| case 117: /* select_with_paren: '(' select_no_paren ')' */ ------------------ | Branch (4169:3): [True: 2.68k, False: 14.8M] ------------------ 4170| 2.68k|#line 789 "bison_parser.y" 4171| 2.68k| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4172| 2.68k|#line 4173 "bison_parser.cpp" 4173| 2.68k| break; 4174| | 4175| 66| case 118: /* select_with_paren: '(' select_with_paren ')' */ ------------------ | Branch (4175:3): [True: 66, False: 14.8M] ------------------ 4176| 66|#line 790 "bison_parser.y" 4177| 66| { (yyval.select_stmt) = (yyvsp[-1].select_stmt); } 4178| 66|#line 4179 "bison_parser.cpp" 4179| 66| break; 4180| | 4181| 17.4k| case 119: /* select_no_paren: select_clause opt_order opt_limit opt_locking_clause */ ------------------ | Branch (4181:3): [True: 17.4k, False: 14.8M] ------------------ 4182| 17.4k|#line 792 "bison_parser.y" 4183| 17.4k| { 4184| 17.4k| (yyval.select_stmt) = (yyvsp[-3].select_stmt); 4185| 17.4k| (yyval.select_stmt)->order = (yyvsp[-2].order_vec); 4186| | 4187| | // Limit could have been set by TOP. 4188| 17.4k| if ((yyvsp[-1].limit)) { ------------------ | Branch (4188:7): [True: 2.80k, False: 14.6k] ------------------ 4189| 2.80k| delete (yyval.select_stmt)->limit; 4190| 2.80k| (yyval.select_stmt)->limit = (yyvsp[-1].limit); 4191| 2.80k| } 4192| | 4193| 17.4k| if ((yyvsp[0].locking_clause_vec)) { ------------------ | Branch (4193:7): [True: 450, False: 17.0k] ------------------ 4194| 450| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4195| 450| } 4196| 17.4k|} 4197| 17.4k|#line 4198 "bison_parser.cpp" 4198| 17.4k| break; 4199| | 4200| 1.18k| case 120: /* select_no_paren: select_clause set_operator select_within_set_operation opt_order opt_limit opt_locking_clause */ ------------------ | Branch (4200:3): [True: 1.18k, False: 14.8M] ------------------ 4201| 1.18k|#line 806 "bison_parser.y" 4202| 1.18k| { 4203| 1.18k| (yyval.select_stmt) = (yyvsp[-5].select_stmt); 4204| 1.18k| if ((yyval.select_stmt)->setOperations == nullptr) { ------------------ | Branch (4204:7): [True: 1.18k, False: 0] ------------------ 4205| 1.18k| (yyval.select_stmt)->setOperations = new std::vector(); 4206| 1.18k| } 4207| 1.18k| (yyval.select_stmt)->setOperations->push_back((yyvsp[-4].set_operator_t)); 4208| 1.18k| (yyval.select_stmt)->setOperations->back()->nestedSelectStatement = (yyvsp[-3].select_stmt); 4209| 1.18k| (yyval.select_stmt)->setOperations->back()->resultOrder = (yyvsp[-2].order_vec); 4210| 1.18k| (yyval.select_stmt)->setOperations->back()->resultLimit = (yyvsp[-1].limit); 4211| 1.18k| (yyval.select_stmt)->lockings = (yyvsp[0].locking_clause_vec); 4212| 1.18k|} 4213| 1.18k|#line 4214 "bison_parser.cpp" 4214| 1.18k| break; 4215| | 4216| 3.47k| case 121: /* set_operator: set_type opt_all */ ------------------ | Branch (4216:3): [True: 3.47k, False: 14.8M] ------------------ 4217| 3.47k|#line 818 "bison_parser.y" 4218| 3.47k| { 4219| 3.47k| (yyval.set_operator_t) = (yyvsp[-1].set_operator_t); 4220| 3.47k| (yyval.set_operator_t)->isAll = (yyvsp[0].bval); 4221| 3.47k|} 4222| 3.47k|#line 4223 "bison_parser.cpp" 4223| 3.47k| break; 4224| | 4225| 2.65k| case 122: /* set_type: UNION */ ------------------ | Branch (4225:3): [True: 2.65k, False: 14.8M] ------------------ 4226| 2.65k|#line 823 "bison_parser.y" 4227| 2.65k| { 4228| 2.65k| (yyval.set_operator_t) = new SetOperation(); 4229| 2.65k| (yyval.set_operator_t)->setType = SetType::kSetUnion; 4230| 2.65k|} 4231| 2.65k|#line 4232 "bison_parser.cpp" 4232| 2.65k| break; 4233| | 4234| 612| case 123: /* set_type: INTERSECT */ ------------------ | Branch (4234:3): [True: 612, False: 14.8M] ------------------ 4235| 612|#line 827 "bison_parser.y" 4236| 612| { 4237| 612| (yyval.set_operator_t) = new SetOperation(); 4238| 612| (yyval.set_operator_t)->setType = SetType::kSetIntersect; 4239| 612|} 4240| 612|#line 4241 "bison_parser.cpp" 4241| 612| break; 4242| | 4243| 214| case 124: /* set_type: EXCEPT */ ------------------ | Branch (4243:3): [True: 214, False: 14.8M] ------------------ 4244| 214|#line 831 "bison_parser.y" 4245| 214| { 4246| 214| (yyval.set_operator_t) = new SetOperation(); 4247| 214| (yyval.set_operator_t)->setType = SetType::kSetExcept; 4248| 214|} 4249| 214|#line 4250 "bison_parser.cpp" 4250| 214| break; 4251| | 4252| 94| case 125: /* opt_all: ALL */ ------------------ | Branch (4252:3): [True: 94, False: 14.8M] ------------------ 4253| 94|#line 836 "bison_parser.y" 4254| 94| { (yyval.bval) = true; } 4255| 94|#line 4256 "bison_parser.cpp" 4256| 94| break; 4257| | 4258| 3.38k| case 126: /* opt_all: %empty */ ------------------ | Branch (4258:3): [True: 3.38k, False: 14.8M] ------------------ 4259| 3.38k|#line 837 "bison_parser.y" 4260| 3.38k| { (yyval.bval) = false; } 4261| 3.38k|#line 4262 "bison_parser.cpp" 4262| 3.38k| break; 4263| | 4264| 22.5k| case 127: /* select_clause: SELECT opt_top opt_distinct select_list opt_from_clause opt_where opt_group */ ------------------ | Branch (4264:3): [True: 22.5k, False: 14.8M] ------------------ 4265| 22.5k|#line 839 "bison_parser.y" 4266| 22.5k| { 4267| 22.5k| (yyval.select_stmt) = new SelectStatement(); 4268| 22.5k| (yyval.select_stmt)->limit = (yyvsp[-5].limit); 4269| 22.5k| (yyval.select_stmt)->selectDistinct = (yyvsp[-4].bval); 4270| 22.5k| (yyval.select_stmt)->selectList = (yyvsp[-3].expr_vec); 4271| 22.5k| (yyval.select_stmt)->fromTable = (yyvsp[-2].table); 4272| 22.5k| (yyval.select_stmt)->whereClause = (yyvsp[-1].expr); 4273| 22.5k| (yyval.select_stmt)->groupBy = (yyvsp[0].group_t); 4274| 22.5k|} 4275| 22.5k|#line 4276 "bison_parser.cpp" 4276| 22.5k| break; 4277| | 4278| 709| case 128: /* opt_distinct: DISTINCT */ ------------------ | Branch (4278:3): [True: 709, False: 14.8M] ------------------ 4279| 709|#line 849 "bison_parser.y" 4280| 709| { (yyval.bval) = true; } 4281| 709|#line 4282 "bison_parser.cpp" 4282| 709| break; 4283| | 4284| 27.3k| case 129: /* opt_distinct: %empty */ ------------------ | Branch (4284:3): [True: 27.3k, False: 14.8M] ------------------ 4285| 27.3k|#line 850 "bison_parser.y" 4286| 27.3k| { (yyval.bval) = false; } 4287| 27.3k|#line 4288 "bison_parser.cpp" 4288| 27.3k| break; 4289| | 4290| 965| case 131: /* opt_from_clause: from_clause */ ------------------ | Branch (4290:3): [True: 965, False: 14.8M] ------------------ 4291| 965|#line 854 "bison_parser.y" 4292| 965| { (yyval.table) = (yyvsp[0].table); } 4293| 965|#line 4294 "bison_parser.cpp" 4294| 965| break; 4295| | 4296| 21.7k| case 132: /* opt_from_clause: %empty */ ------------------ | Branch (4296:3): [True: 21.7k, False: 14.8M] ------------------ 4297| 21.7k|#line 855 "bison_parser.y" 4298| 21.7k| { (yyval.table) = nullptr; } 4299| 21.7k|#line 4300 "bison_parser.cpp" 4300| 21.7k| break; 4301| | 4302| 965| case 133: /* from_clause: FROM table_ref */ ------------------ | Branch (4302:3): [True: 965, False: 14.8M] ------------------ 4303| 965|#line 857 "bison_parser.y" 4304| 965| { (yyval.table) = (yyvsp[0].table); } 4305| 965|#line 4306 "bison_parser.cpp" 4306| 965| break; 4307| | 4308| 1.62k| case 134: /* opt_where: WHERE expr */ ------------------ | Branch (4308:3): [True: 1.62k, False: 14.8M] ------------------ 4309| 1.62k|#line 859 "bison_parser.y" 4310| 1.62k| { (yyval.expr) = (yyvsp[0].expr); } 4311| 1.62k|#line 4312 "bison_parser.cpp" 4312| 1.62k| break; 4313| | 4314| 23.7k| case 135: /* opt_where: %empty */ ------------------ | Branch (4314:3): [True: 23.7k, False: 14.8M] ------------------ 4315| 23.7k|#line 860 "bison_parser.y" 4316| 23.7k| { (yyval.expr) = nullptr; } 4317| 23.7k|#line 4318 "bison_parser.cpp" 4318| 23.7k| break; 4319| | 4320| 1.27k| case 136: /* opt_group: GROUP BY expr_list opt_having */ ------------------ | Branch (4320:3): [True: 1.27k, False: 14.8M] ------------------ 4321| 1.27k|#line 862 "bison_parser.y" 4322| 1.27k| { 4323| 1.27k| (yyval.group_t) = new GroupByDescription(); 4324| 1.27k| (yyval.group_t)->columns = (yyvsp[-1].expr_vec); 4325| 1.27k| (yyval.group_t)->having = (yyvsp[0].expr); 4326| 1.27k|} 4327| 1.27k|#line 4328 "bison_parser.cpp" 4328| 1.27k| break; 4329| | 4330| 21.3k| case 137: /* opt_group: %empty */ ------------------ | Branch (4330:3): [True: 21.3k, False: 14.8M] ------------------ 4331| 21.3k|#line 867 "bison_parser.y" 4332| 21.3k| { (yyval.group_t) = nullptr; } 4333| 21.3k|#line 4334 "bison_parser.cpp" 4334| 21.3k| break; 4335| | 4336| 549| case 138: /* opt_having: HAVING expr */ ------------------ | Branch (4336:3): [True: 549, False: 14.8M] ------------------ 4337| 549|#line 869 "bison_parser.y" 4338| 549| { (yyval.expr) = (yyvsp[0].expr); } 4339| 549|#line 4340 "bison_parser.cpp" 4340| 549| break; 4341| | 4342| 728| case 139: /* opt_having: %empty */ ------------------ | Branch (4342:3): [True: 728, False: 14.8M] ------------------ 4343| 728|#line 870 "bison_parser.y" 4344| 728| { (yyval.expr) = nullptr; } 4345| 728|#line 4346 "bison_parser.cpp" 4346| 728| break; 4347| | 4348| 1.81k| case 140: /* opt_order: ORDER BY order_list */ ------------------ | Branch (4348:3): [True: 1.81k, False: 14.8M] ------------------ 4349| 1.81k|#line 872 "bison_parser.y" 4350| 1.81k| { (yyval.order_vec) = (yyvsp[0].order_vec); } 4351| 1.81k|#line 4352 "bison_parser.cpp" 4352| 1.81k| break; 4353| | 4354| 18.6k| case 141: /* opt_order: %empty */ ------------------ | Branch (4354:3): [True: 18.6k, False: 14.8M] ------------------ 4355| 18.6k|#line 873 "bison_parser.y" 4356| 18.6k| { (yyval.order_vec) = nullptr; } 4357| 18.6k|#line 4358 "bison_parser.cpp" 4358| 18.6k| break; 4359| | 4360| 1.94k| case 142: /* order_list: order_desc */ ------------------ | Branch (4360:3): [True: 1.94k, False: 14.8M] ------------------ 4361| 1.94k|#line 875 "bison_parser.y" 4362| 1.94k| { 4363| 1.94k| (yyval.order_vec) = new std::vector(); 4364| 1.94k| (yyval.order_vec)->push_back((yyvsp[0].order)); 4365| 1.94k|} 4366| 1.94k|#line 4367 "bison_parser.cpp" 4367| 1.94k| break; 4368| | 4369| 69.9k| case 143: /* order_list: order_list ',' order_desc */ ------------------ | Branch (4369:3): [True: 69.9k, False: 14.8M] ------------------ 4370| 69.9k|#line 879 "bison_parser.y" 4371| 69.9k| { 4372| 69.9k| (yyvsp[-2].order_vec)->push_back((yyvsp[0].order)); 4373| 69.9k| (yyval.order_vec) = (yyvsp[-2].order_vec); 4374| 69.9k|} 4375| 69.9k|#line 4376 "bison_parser.cpp" 4376| 69.9k| break; 4377| | 4378| 71.8k| case 144: /* order_desc: expr opt_order_type */ ------------------ | Branch (4378:3): [True: 71.8k, False: 14.8M] ------------------ 4379| 71.8k|#line 884 "bison_parser.y" 4380| 71.8k| { (yyval.order) = new OrderDescription((yyvsp[0].order_type), (yyvsp[-1].expr)); } 4381| 71.8k|#line 4382 "bison_parser.cpp" 4382| 71.8k| break; 4383| | 4384| 583| case 145: /* opt_order_type: ASC */ ------------------ | Branch (4384:3): [True: 583, False: 14.8M] ------------------ 4385| 583|#line 886 "bison_parser.y" 4386| 583| { (yyval.order_type) = kOrderAsc; } 4387| 583|#line 4388 "bison_parser.cpp" 4388| 583| break; 4389| | 4390| 511| case 146: /* opt_order_type: DESC */ ------------------ | Branch (4390:3): [True: 511, False: 14.8M] ------------------ 4391| 511|#line 887 "bison_parser.y" 4392| 511| { (yyval.order_type) = kOrderDesc; } 4393| 511|#line 4394 "bison_parser.cpp" 4394| 511| break; 4395| | 4396| 70.7k| case 147: /* opt_order_type: %empty */ ------------------ | Branch (4396:3): [True: 70.7k, False: 14.8M] ------------------ 4397| 70.7k|#line 888 "bison_parser.y" 4398| 70.7k| { (yyval.order_type) = kOrderAsc; } 4399| 70.7k|#line 4400 "bison_parser.cpp" 4400| 70.7k| break; 4401| | 4402| 880| case 148: /* opt_top: TOP int_literal */ ------------------ | Branch (4402:3): [True: 880, False: 14.8M] ------------------ 4403| 880|#line 892 "bison_parser.y" 4404| 880| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4405| 880|#line 4406 "bison_parser.cpp" 4406| 880| break; 4407| | 4408| 23.9k| case 149: /* opt_top: %empty */ ------------------ | Branch (4408:3): [True: 23.9k, False: 14.8M] ------------------ 4409| 23.9k|#line 893 "bison_parser.y" 4410| 23.9k| { (yyval.limit) = nullptr; } 4411| 23.9k|#line 4412 "bison_parser.cpp" 4412| 23.9k| break; 4413| | 4414| 1.87k| case 150: /* opt_limit: LIMIT expr */ ------------------ | Branch (4414:3): [True: 1.87k, False: 14.8M] ------------------ 4415| 1.87k|#line 895 "bison_parser.y" 4416| 1.87k| { (yyval.limit) = new LimitDescription((yyvsp[0].expr), nullptr); } 4417| 1.87k|#line 4418 "bison_parser.cpp" 4418| 1.87k| break; 4419| | 4420| 373| case 151: /* opt_limit: OFFSET expr */ ------------------ | Branch (4420:3): [True: 373, False: 14.8M] ------------------ 4421| 373|#line 896 "bison_parser.y" 4422| 373| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4423| 373|#line 4424 "bison_parser.cpp" 4424| 373| break; 4425| | 4426| 272| case 152: /* opt_limit: LIMIT expr OFFSET expr */ ------------------ | Branch (4426:3): [True: 272, False: 14.8M] ------------------ 4427| 272|#line 897 "bison_parser.y" 4428| 272| { (yyval.limit) = new LimitDescription((yyvsp[-2].expr), (yyvsp[0].expr)); } 4429| 272|#line 4430 "bison_parser.cpp" 4430| 272| break; 4431| | 4432| 561| case 153: /* opt_limit: LIMIT ALL */ ------------------ | Branch (4432:3): [True: 561, False: 14.8M] ------------------ 4433| 561|#line 898 "bison_parser.y" 4434| 561| { (yyval.limit) = new LimitDescription(nullptr, nullptr); } 4435| 561|#line 4436 "bison_parser.cpp" 4436| 561| break; 4437| | 4438| 503| case 154: /* opt_limit: LIMIT ALL OFFSET expr */ ------------------ | Branch (4438:3): [True: 503, False: 14.8M] ------------------ 4439| 503|#line 899 "bison_parser.y" 4440| 503| { (yyval.limit) = new LimitDescription(nullptr, (yyvsp[0].expr)); } 4441| 503|#line 4442 "bison_parser.cpp" 4442| 503| break; 4443| | 4444| 15.7k| case 155: /* opt_limit: %empty */ ------------------ | Branch (4444:3): [True: 15.7k, False: 14.8M] ------------------ 4445| 15.7k|#line 900 "bison_parser.y" 4446| 15.7k| { (yyval.limit) = nullptr; } 4447| 15.7k|#line 4448 "bison_parser.cpp" 4448| 15.7k| break; 4449| | 4450| 28.1k| case 156: /* expr_list: expr_alias */ ------------------ | Branch (4450:3): [True: 28.1k, False: 14.8M] ------------------ 4451| 28.1k|#line 905 "bison_parser.y" 4452| 28.1k| { 4453| 28.1k| (yyval.expr_vec) = new std::vector(); 4454| 28.1k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4455| 28.1k|} 4456| 28.1k|#line 4457 "bison_parser.cpp" 4457| 28.1k| break; 4458| | 4459| 138k| case 157: /* expr_list: expr_list ',' expr_alias */ ------------------ | Branch (4459:3): [True: 138k, False: 14.7M] ------------------ 4460| 138k|#line 909 "bison_parser.y" 4461| 138k| { 4462| 138k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4463| 138k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4464| 138k|} 4465| 138k|#line 4466 "bison_parser.cpp" 4466| 138k| break; 4467| | 4468| 104| case 158: /* opt_literal_list: literal_list */ ------------------ | Branch (4468:3): [True: 104, False: 14.8M] ------------------ 4469| 104|#line 914 "bison_parser.y" 4470| 104| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4471| 104|#line 4472 "bison_parser.cpp" 4472| 104| break; 4473| | 4474| 468| case 159: /* opt_literal_list: %empty */ ------------------ | Branch (4474:3): [True: 468, False: 14.8M] ------------------ 4475| 468|#line 915 "bison_parser.y" 4476| 468| { (yyval.expr_vec) = nullptr; } 4477| 468|#line 4478 "bison_parser.cpp" 4478| 468| break; 4479| | 4480| 1.01k| case 160: /* literal_list: literal */ ------------------ | Branch (4480:3): [True: 1.01k, False: 14.8M] ------------------ 4481| 1.01k|#line 917 "bison_parser.y" 4482| 1.01k| { 4483| 1.01k| (yyval.expr_vec) = new std::vector(); 4484| 1.01k| (yyval.expr_vec)->push_back((yyvsp[0].expr)); 4485| 1.01k|} 4486| 1.01k|#line 4487 "bison_parser.cpp" 4487| 1.01k| break; 4488| | 4489| 1.67k| case 161: /* literal_list: literal_list ',' literal */ ------------------ | Branch (4489:3): [True: 1.67k, False: 14.8M] ------------------ 4490| 1.67k|#line 921 "bison_parser.y" 4491| 1.67k| { 4492| 1.67k| (yyvsp[-2].expr_vec)->push_back((yyvsp[0].expr)); 4493| 1.67k| (yyval.expr_vec) = (yyvsp[-2].expr_vec); 4494| 1.67k|} 4495| 1.67k|#line 4496 "bison_parser.cpp" 4496| 1.67k| break; 4497| | 4498| 166k| case 162: /* expr_alias: expr opt_alias */ ------------------ | Branch (4498:3): [True: 166k, False: 14.7M] ------------------ 4499| 166k|#line 926 "bison_parser.y" 4500| 166k| { 4501| 166k| (yyval.expr) = (yyvsp[-1].expr); 4502| 166k| if ((yyvsp[0].alias_t)) { ------------------ | Branch (4502:7): [True: 2.88k, False: 164k] ------------------ 4503| 2.88k| (yyval.expr)->alias = strdup((yyvsp[0].alias_t)->name); 4504| 2.88k| delete (yyvsp[0].alias_t); 4505| 2.88k| } 4506| 166k|} 4507| 166k|#line 4508 "bison_parser.cpp" 4508| 166k| break; 4509| | 4510| 684| case 168: /* operand: '(' expr ')' */ ------------------ | Branch (4510:3): [True: 684, False: 14.8M] ------------------ 4511| 684|#line 936 "bison_parser.y" 4512| 684| { (yyval.expr) = (yyvsp[-1].expr); } 4513| 684|#line 4514 "bison_parser.cpp" 4514| 684| break; 4515| | 4516| 794| case 178: /* operand: '(' select_no_paren ')' */ ------------------ | Branch (4516:3): [True: 794, False: 14.8M] ------------------ 4517| 794|#line 938 "bison_parser.y" 4518| 794| { 4519| 794| (yyval.expr) = Expr::makeSelect((yyvsp[-1].select_stmt)); 4520| 794|} 4521| 794|#line 4522 "bison_parser.cpp" 4522| 794| break; 4523| | 4524| 7.19k| case 181: /* unary_expr: '-' operand */ ------------------ | Branch (4524:3): [True: 7.19k, False: 14.8M] ------------------ 4525| 7.19k|#line 944 "bison_parser.y" 4526| 7.19k| { (yyval.expr) = Expr::makeOpUnary(kOpUnaryMinus, (yyvsp[0].expr)); } 4527| 7.19k|#line 4528 "bison_parser.cpp" 4528| 7.19k| break; 4529| | 4530| 238| case 182: /* unary_expr: NOT operand */ ------------------ | Branch (4530:3): [True: 238, False: 14.8M] ------------------ 4531| 238|#line 945 "bison_parser.y" 4532| 238| { (yyval.expr) = Expr::makeOpUnary(kOpNot, (yyvsp[0].expr)); } 4533| 238|#line 4534 "bison_parser.cpp" 4534| 238| break; 4535| | 4536| 533| case 183: /* unary_expr: operand ISNULL */ ------------------ | Branch (4536:3): [True: 533, False: 14.8M] ------------------ 4537| 533|#line 946 "bison_parser.y" 4538| 533| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-1].expr)); } 4539| 533|#line 4540 "bison_parser.cpp" 4540| 533| break; 4541| | 4542| 269| case 184: /* unary_expr: operand IS NULL */ ------------------ | Branch (4542:3): [True: 269, False: 14.8M] ------------------ 4543| 269|#line 947 "bison_parser.y" 4544| 269| { (yyval.expr) = Expr::makeOpUnary(kOpIsNull, (yyvsp[-2].expr)); } 4545| 269|#line 4546 "bison_parser.cpp" 4546| 269| break; 4547| | 4548| 194| case 185: /* unary_expr: operand IS NOT NULL */ ------------------ | Branch (4548:3): [True: 194, False: 14.8M] ------------------ 4549| 194|#line 948 "bison_parser.y" 4550| 194| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeOpUnary(kOpIsNull, (yyvsp[-3].expr))); } 4551| 194|#line 4552 "bison_parser.cpp" 4552| 194| break; 4553| | 4554| 12.2k| case 187: /* binary_expr: operand '-' operand */ ------------------ | Branch (4554:3): [True: 12.2k, False: 14.8M] ------------------ 4555| 12.2k|#line 950 "bison_parser.y" 4556| 12.2k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpMinus, (yyvsp[0].expr)); } 4557| 12.2k|#line 4558 "bison_parser.cpp" 4558| 12.2k| break; 4559| | 4560| 102k| case 188: /* binary_expr: operand '+' operand */ ------------------ | Branch (4560:3): [True: 102k, False: 14.7M] ------------------ 4561| 102k|#line 951 "bison_parser.y" 4562| 102k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPlus, (yyvsp[0].expr)); } 4563| 102k|#line 4564 "bison_parser.cpp" 4564| 102k| break; 4565| | 4566| 149k| case 189: /* binary_expr: operand '/' operand */ ------------------ | Branch (4566:3): [True: 149k, False: 14.7M] ------------------ 4567| 149k|#line 952 "bison_parser.y" 4568| 149k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpSlash, (yyvsp[0].expr)); } 4569| 149k|#line 4570 "bison_parser.cpp" 4570| 149k| break; 4571| | 4572| 953k| case 190: /* binary_expr: operand '*' operand */ ------------------ | Branch (4572:3): [True: 953k, False: 13.9M] ------------------ 4573| 953k|#line 953 "bison_parser.y" 4574| 953k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAsterisk, (yyvsp[0].expr)); } 4575| 953k|#line 4576 "bison_parser.cpp" 4576| 953k| break; 4577| | 4578| 1.38k| case 191: /* binary_expr: operand '%' operand */ ------------------ | Branch (4578:3): [True: 1.38k, False: 14.8M] ------------------ 4579| 1.38k|#line 954 "bison_parser.y" 4580| 1.38k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpPercentage, (yyvsp[0].expr)); } 4581| 1.38k|#line 4582 "bison_parser.cpp" 4582| 1.38k| break; 4583| | 4584| 5.88k| case 192: /* binary_expr: operand '^' operand */ ------------------ | Branch (4584:3): [True: 5.88k, False: 14.8M] ------------------ 4585| 5.88k|#line 955 "bison_parser.y" 4586| 5.88k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpCaret, (yyvsp[0].expr)); } 4587| 5.88k|#line 4588 "bison_parser.cpp" 4588| 5.88k| break; 4589| | 4590| 284| case 193: /* binary_expr: operand LIKE operand */ ------------------ | Branch (4590:3): [True: 284, False: 14.8M] ------------------ 4591| 284|#line 956 "bison_parser.y" 4592| 284| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLike, (yyvsp[0].expr)); } 4593| 284|#line 4594 "bison_parser.cpp" 4594| 284| break; 4595| | 4596| 366| case 194: /* binary_expr: operand NOT LIKE operand */ ------------------ | Branch (4596:3): [True: 366, False: 14.8M] ------------------ 4597| 366|#line 957 "bison_parser.y" 4598| 366| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-3].expr), kOpNotLike, (yyvsp[0].expr)); } 4599| 366|#line 4600 "bison_parser.cpp" 4600| 366| break; 4601| | 4602| 657| case 195: /* binary_expr: operand ILIKE operand */ ------------------ | Branch (4602:3): [True: 657, False: 14.8M] ------------------ 4603| 657|#line 958 "bison_parser.y" 4604| 657| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpILike, (yyvsp[0].expr)); } 4605| 657|#line 4606 "bison_parser.cpp" 4606| 657| break; 4607| | 4608| 403| case 196: /* binary_expr: operand CONCAT operand */ ------------------ | Branch (4608:3): [True: 403, False: 14.8M] ------------------ 4609| 403|#line 959 "bison_parser.y" 4610| 403| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpConcat, (yyvsp[0].expr)); } 4611| 403|#line 4612 "bison_parser.cpp" 4612| 403| break; 4613| | 4614| 581| case 197: /* logic_expr: expr AND expr */ ------------------ | Branch (4614:3): [True: 581, False: 14.8M] ------------------ 4615| 581|#line 961 "bison_parser.y" 4616| 581| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpAnd, (yyvsp[0].expr)); } 4617| 581|#line 4618 "bison_parser.cpp" 4618| 581| break; 4619| | 4620| 269| case 198: /* logic_expr: expr OR expr */ ------------------ | Branch (4620:3): [True: 269, False: 14.8M] ------------------ 4621| 269|#line 962 "bison_parser.y" 4622| 269| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpOr, (yyvsp[0].expr)); } 4623| 269|#line 4624 "bison_parser.cpp" 4624| 269| break; 4625| | 4626| 456| case 199: /* in_expr: operand IN '(' expr_list ')' */ ------------------ | Branch (4626:3): [True: 456, False: 14.8M] ------------------ 4627| 456|#line 964 "bison_parser.y" 4628| 456| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].expr_vec)); } 4629| 456|#line 4630 "bison_parser.cpp" 4630| 456| break; 4631| | 4632| 70| case 200: /* in_expr: operand NOT IN '(' expr_list ')' */ ------------------ | Branch (4632:3): [True: 70, False: 14.8M] ------------------ 4633| 70|#line 965 "bison_parser.y" 4634| 70| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].expr_vec))); } 4635| 70|#line 4636 "bison_parser.cpp" 4636| 70| break; 4637| | 4638| 388| case 201: /* in_expr: operand IN '(' select_no_paren ')' */ ------------------ | Branch (4638:3): [True: 388, False: 14.8M] ------------------ 4639| 388|#line 966 "bison_parser.y" 4640| 388| { (yyval.expr) = Expr::makeInOperator((yyvsp[-4].expr), (yyvsp[-1].select_stmt)); } 4641| 388|#line 4642 "bison_parser.cpp" 4642| 388| break; 4643| | 4644| 204| case 202: /* in_expr: operand NOT IN '(' select_no_paren ')' */ ------------------ | Branch (4644:3): [True: 204, False: 14.8M] ------------------ 4645| 204|#line 967 "bison_parser.y" 4646| 204| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeInOperator((yyvsp[-5].expr), (yyvsp[-1].select_stmt))); } 4647| 204|#line 4648 "bison_parser.cpp" 4648| 204| break; 4649| | 4650| 244| case 203: /* case_expr: CASE expr case_list END */ ------------------ | Branch (4650:3): [True: 244, False: 14.8M] ------------------ 4651| 244|#line 971 "bison_parser.y" 4652| 244| { (yyval.expr) = Expr::makeCase((yyvsp[-2].expr), (yyvsp[-1].expr), nullptr); } 4653| 244|#line 4654 "bison_parser.cpp" 4654| 244| break; 4655| | 4656| 378| case 204: /* case_expr: CASE expr case_list ELSE expr END */ ------------------ | Branch (4656:3): [True: 378, False: 14.8M] ------------------ 4657| 378|#line 972 "bison_parser.y" 4658| 378| { (yyval.expr) = Expr::makeCase((yyvsp[-4].expr), (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4659| 378|#line 4660 "bison_parser.cpp" 4660| 378| break; 4661| | 4662| 720| case 205: /* case_expr: CASE case_list END */ ------------------ | Branch (4662:3): [True: 720, False: 14.8M] ------------------ 4663| 720|#line 973 "bison_parser.y" 4664| 720| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-1].expr), nullptr); } 4665| 720|#line 4666 "bison_parser.cpp" 4666| 720| break; 4667| | 4668| 459| case 206: /* case_expr: CASE case_list ELSE expr END */ ------------------ | Branch (4668:3): [True: 459, False: 14.8M] ------------------ 4669| 459|#line 974 "bison_parser.y" 4670| 459| { (yyval.expr) = Expr::makeCase(nullptr, (yyvsp[-3].expr), (yyvsp[-1].expr)); } 4671| 459|#line 4672 "bison_parser.cpp" 4672| 459| break; 4673| | 4674| 2.03k| case 207: /* case_list: WHEN expr THEN expr */ ------------------ | Branch (4674:3): [True: 2.03k, False: 14.8M] ------------------ 4675| 2.03k|#line 976 "bison_parser.y" 4676| 2.03k| { (yyval.expr) = Expr::makeCaseList(Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4677| 2.03k|#line 4678 "bison_parser.cpp" 4678| 2.03k| break; 4679| | 4680| 1.22k| case 208: /* case_list: case_list WHEN expr THEN expr */ ------------------ | Branch (4680:3): [True: 1.22k, False: 14.8M] ------------------ 4681| 1.22k|#line 977 "bison_parser.y" 4682| 1.22k| { (yyval.expr) = Expr::caseListAppend((yyvsp[-4].expr), Expr::makeCaseListElement((yyvsp[-2].expr), (yyvsp[0].expr))); } 4683| 1.22k|#line 4684 "bison_parser.cpp" 4684| 1.22k| break; 4685| | 4686| 550| case 209: /* exists_expr: EXISTS '(' select_no_paren ')' */ ------------------ | Branch (4686:3): [True: 550, False: 14.8M] ------------------ 4687| 550|#line 979 "bison_parser.y" 4688| 550| { (yyval.expr) = Expr::makeExists((yyvsp[-1].select_stmt)); } 4689| 550|#line 4690 "bison_parser.cpp" 4690| 550| break; 4691| | 4692| 296| case 210: /* exists_expr: NOT EXISTS '(' select_no_paren ')' */ ------------------ | Branch (4692:3): [True: 296, False: 14.8M] ------------------ 4693| 296|#line 980 "bison_parser.y" 4694| 296| { (yyval.expr) = Expr::makeOpUnary(kOpNot, Expr::makeExists((yyvsp[-1].select_stmt))); } 4695| 296|#line 4696 "bison_parser.cpp" 4696| 296| break; 4697| | 4698| 2.00k| case 211: /* comp_expr: operand '=' operand */ ------------------ | Branch (4698:3): [True: 2.00k, False: 14.8M] ------------------ 4699| 2.00k|#line 982 "bison_parser.y" 4700| 2.00k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4701| 2.00k|#line 4702 "bison_parser.cpp" 4702| 2.00k| break; 4703| | 4704| 639| case 212: /* comp_expr: operand EQUALS operand */ ------------------ | Branch (4704:3): [True: 639, False: 14.8M] ------------------ 4705| 639|#line 983 "bison_parser.y" 4706| 639| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpEquals, (yyvsp[0].expr)); } 4707| 639|#line 4708 "bison_parser.cpp" 4708| 639| break; 4709| | 4710| 395| case 213: /* comp_expr: operand NOTEQUALS operand */ ------------------ | Branch (4710:3): [True: 395, False: 14.8M] ------------------ 4711| 395|#line 984 "bison_parser.y" 4712| 395| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpNotEquals, (yyvsp[0].expr)); } 4713| 395|#line 4714 "bison_parser.cpp" 4714| 395| break; 4715| | 4716| 838| case 214: /* comp_expr: operand '<' operand */ ------------------ | Branch (4716:3): [True: 838, False: 14.8M] ------------------ 4717| 838|#line 985 "bison_parser.y" 4718| 838| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLess, (yyvsp[0].expr)); } 4719| 838|#line 4720 "bison_parser.cpp" 4720| 838| break; 4721| | 4722| 1.24k| case 215: /* comp_expr: operand '>' operand */ ------------------ | Branch (4722:3): [True: 1.24k, False: 14.8M] ------------------ 4723| 1.24k|#line 986 "bison_parser.y" 4724| 1.24k| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreater, (yyvsp[0].expr)); } 4725| 1.24k|#line 4726 "bison_parser.cpp" 4726| 1.24k| break; 4727| | 4728| 258| case 216: /* comp_expr: operand LESSEQ operand */ ------------------ | Branch (4728:3): [True: 258, False: 14.8M] ------------------ 4729| 258|#line 987 "bison_parser.y" 4730| 258| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpLessEq, (yyvsp[0].expr)); } 4731| 258|#line 4732 "bison_parser.cpp" 4732| 258| break; 4733| | 4734| 392| case 217: /* comp_expr: operand GREATEREQ operand */ ------------------ | Branch (4734:3): [True: 392, False: 14.8M] ------------------ 4735| 392|#line 988 "bison_parser.y" 4736| 392| { (yyval.expr) = Expr::makeOpBinary((yyvsp[-2].expr), kOpGreaterEq, (yyvsp[0].expr)); } 4737| 392|#line 4738 "bison_parser.cpp" 4738| 392| break; 4739| | 4740| 591| case 218: /* function_expr: IDENTIFIER '(' ')' opt_window */ ------------------ | Branch (4740:3): [True: 591, False: 14.8M] ------------------ 4741| 591|#line 992 "bison_parser.y" 4742| 591| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-3].sval), new std::vector(), false, (yyvsp[0].window_description)); } 4743| 591|#line 4744 "bison_parser.cpp" 4744| 591| break; 4745| | 4746| 2.11k| case 219: /* function_expr: IDENTIFIER '(' opt_distinct expr_list ')' opt_window */ ------------------ | Branch (4746:3): [True: 2.11k, False: 14.8M] ------------------ 4747| 2.11k|#line 993 "bison_parser.y" 4748| 2.11k| { (yyval.expr) = Expr::makeFunctionRef((yyvsp[-5].sval), (yyvsp[-2].expr_vec), (yyvsp[-3].bval), (yyvsp[0].window_description)); } 4749| 2.11k|#line 4750 "bison_parser.cpp" 4750| 2.11k| break; 4751| | 4752| 785| case 220: /* opt_window: OVER '(' opt_partition opt_order opt_frame_clause ')' */ ------------------ | Branch (4752:3): [True: 785, False: 14.8M] ------------------ 4753| 785|#line 997 "bison_parser.y" 4754| 785| { (yyval.window_description) = new WindowDescription((yyvsp[-3].expr_vec), (yyvsp[-2].order_vec), (yyvsp[-1].frame_description)); } 4755| 785|#line 4756 "bison_parser.cpp" 4756| 785| break; 4757| | 4758| 1.92k| case 221: /* opt_window: %empty */ ------------------ | Branch (4758:3): [True: 1.92k, False: 14.8M] ------------------ 4759| 1.92k|#line 998 "bison_parser.y" 4760| 1.92k| { (yyval.window_description) = nullptr; } 4761| 1.92k|#line 4762 "bison_parser.cpp" 4762| 1.92k| break; 4763| | 4764| 0| case 222: /* opt_partition: PARTITION BY expr_list */ ------------------ | Branch (4764:3): [True: 0, False: 14.8M] ------------------ 4765| 0|#line 1000 "bison_parser.y" 4766| 0| { (yyval.expr_vec) = (yyvsp[0].expr_vec); } 4767| 0|#line 4768 "bison_parser.cpp" 4768| 0| break; 4769| | 4770| 870| case 223: /* opt_partition: %empty */ ------------------ | Branch (4770:3): [True: 870, False: 14.8M] ------------------ 4771| 870|#line 1001 "bison_parser.y" 4772| 870| { (yyval.expr_vec) = nullptr; } 4773| 870|#line 4774 "bison_parser.cpp" 4774| 870| break; 4775| | 4776| 0| case 224: /* opt_frame_clause: frame_type frame_bound */ ------------------ | Branch (4776:3): [True: 0, False: 14.8M] ------------------ 4777| 0|#line 1006 "bison_parser.y" 4778| 0| { (yyval.frame_description) = new FrameDescription{(yyvsp[-1].frame_type), (yyvsp[0].frame_bound), new FrameBound{0, kCurrentRow, false}}; } 4779| 0|#line 4780 "bison_parser.cpp" 4780| 0| break; 4781| | 4782| 0| case 225: /* opt_frame_clause: frame_type BETWEEN frame_bound AND frame_bound */ ------------------ | Branch (4782:3): [True: 0, False: 14.8M] ------------------ 4783| 0|#line 1007 "bison_parser.y" 4784| 0| { (yyval.frame_description) = new FrameDescription{(yyvsp[-4].frame_type), (yyvsp[-2].frame_bound), (yyvsp[0].frame_bound)}; } 4785| 0|#line 4786 "bison_parser.cpp" 4786| 0| break; 4787| | 4788| 806| case 226: /* opt_frame_clause: %empty */ ------------------ | Branch (4788:3): [True: 806, False: 14.8M] ------------------ 4789| 806|#line 1008 "bison_parser.y" 4790| 806| { 4791| 806| (yyval.frame_description) = new FrameDescription{kRange, new FrameBound{0, kPreceding, true}, new FrameBound{0, kCurrentRow, false}}; 4792| 806|} 4793| 806|#line 4794 "bison_parser.cpp" 4794| 806| break; 4795| | 4796| 2| case 227: /* frame_type: RANGE */ ------------------ | Branch (4796:3): [True: 2, False: 14.8M] ------------------ 4797| 2|#line 1012 "bison_parser.y" 4798| 2| { (yyval.frame_type) = kRange; } 4799| 2|#line 4800 "bison_parser.cpp" 4800| 2| break; 4801| | 4802| 2| case 228: /* frame_type: ROWS */ ------------------ | Branch (4802:3): [True: 2, False: 14.8M] ------------------ 4803| 2|#line 1013 "bison_parser.y" 4804| 2| { (yyval.frame_type) = kRows; } 4805| 2|#line 4806 "bison_parser.cpp" 4806| 2| break; 4807| | 4808| 2| case 229: /* frame_type: GROUPS */ ------------------ | Branch (4808:3): [True: 2, False: 14.8M] ------------------ 4809| 2|#line 1014 "bison_parser.y" 4810| 2| { (yyval.frame_type) = kGroups; } 4811| 2|#line 4812 "bison_parser.cpp" 4812| 2| break; 4813| | 4814| 0| case 230: /* frame_bound: UNBOUNDED PRECEDING */ ------------------ | Branch (4814:3): [True: 0, False: 14.8M] ------------------ 4815| 0|#line 1016 "bison_parser.y" 4816| 0| { (yyval.frame_bound) = new FrameBound{0, kPreceding, true}; } 4817| 0|#line 4818 "bison_parser.cpp" 4818| 0| break; 4819| | 4820| 0| case 231: /* frame_bound: INTVAL PRECEDING */ ------------------ | Branch (4820:3): [True: 0, False: 14.8M] ------------------ 4821| 0|#line 1017 "bison_parser.y" 4822| 0| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kPreceding, false}; } 4823| 0|#line 4824 "bison_parser.cpp" 4824| 0| break; 4825| | 4826| 0| case 232: /* frame_bound: UNBOUNDED FOLLOWING */ ------------------ | Branch (4826:3): [True: 0, False: 14.8M] ------------------ 4827| 0|#line 1018 "bison_parser.y" 4828| 0| { (yyval.frame_bound) = new FrameBound{0, kFollowing, true}; } 4829| 0|#line 4830 "bison_parser.cpp" 4830| 0| break; 4831| | 4832| 0| case 233: /* frame_bound: INTVAL FOLLOWING */ ------------------ | Branch (4832:3): [True: 0, False: 14.8M] ------------------ 4833| 0|#line 1019 "bison_parser.y" 4834| 0| { (yyval.frame_bound) = new FrameBound{(yyvsp[-1].ival), kFollowing, false}; } 4835| 0|#line 4836 "bison_parser.cpp" 4836| 0| break; 4837| | 4838| 0| case 234: /* frame_bound: CURRENT_ROW */ ------------------ | Branch (4838:3): [True: 0, False: 14.8M] ------------------ 4839| 0|#line 1020 "bison_parser.y" 4840| 0| { (yyval.frame_bound) = new FrameBound{0, kCurrentRow, false}; } 4841| 0|#line 4842 "bison_parser.cpp" 4842| 0| break; 4843| | 4844| 274| case 235: /* extract_expr: EXTRACT '(' datetime_field FROM expr ')' */ ------------------ | Branch (4844:3): [True: 274, False: 14.8M] ------------------ 4845| 274|#line 1022 "bison_parser.y" 4846| 274| { (yyval.expr) = Expr::makeExtract((yyvsp[-3].datetime_field), (yyvsp[-1].expr)); } 4847| 274|#line 4848 "bison_parser.cpp" 4848| 274| break; 4849| | 4850| 386| case 236: /* cast_expr: CAST '(' expr AS column_type ')' */ ------------------ | Branch (4850:3): [True: 386, False: 14.8M] ------------------ 4851| 386|#line 1024 "bison_parser.y" 4852| 386| { (yyval.expr) = Expr::makeCast((yyvsp[-3].expr), (yyvsp[-1].column_type_t)); } 4853| 386|#line 4854 "bison_parser.cpp" 4854| 386| break; 4855| | 4856| 765| case 237: /* datetime_field: SECOND */ ------------------ | Branch (4856:3): [True: 765, False: 14.8M] ------------------ 4857| 765|#line 1026 "bison_parser.y" 4858| 765| { (yyval.datetime_field) = kDatetimeSecond; } 4859| 765|#line 4860 "bison_parser.cpp" 4860| 765| break; 4861| | 4862| 570| case 238: /* datetime_field: MINUTE */ ------------------ | Branch (4862:3): [True: 570, False: 14.8M] ------------------ 4863| 570|#line 1027 "bison_parser.y" 4864| 570| { (yyval.datetime_field) = kDatetimeMinute; } 4865| 570|#line 4866 "bison_parser.cpp" 4866| 570| break; 4867| | 4868| 526| case 239: /* datetime_field: HOUR */ ------------------ | Branch (4868:3): [True: 526, False: 14.8M] ------------------ 4869| 526|#line 1028 "bison_parser.y" 4870| 526| { (yyval.datetime_field) = kDatetimeHour; } 4871| 526|#line 4872 "bison_parser.cpp" 4872| 526| break; 4873| | 4874| 1.33k| case 240: /* datetime_field: DAY */ ------------------ | Branch (4874:3): [True: 1.33k, False: 14.8M] ------------------ 4875| 1.33k|#line 1029 "bison_parser.y" 4876| 1.33k| { (yyval.datetime_field) = kDatetimeDay; } 4877| 1.33k|#line 4878 "bison_parser.cpp" 4878| 1.33k| break; 4879| | 4880| 733| case 241: /* datetime_field: MONTH */ ------------------ | Branch (4880:3): [True: 733, False: 14.8M] ------------------ 4881| 733|#line 1030 "bison_parser.y" 4882| 733| { (yyval.datetime_field) = kDatetimeMonth; } 4883| 733|#line 4884 "bison_parser.cpp" 4884| 733| break; 4885| | 4886| 538| case 242: /* datetime_field: YEAR */ ------------------ | Branch (4886:3): [True: 538, False: 14.8M] ------------------ 4887| 538|#line 1031 "bison_parser.y" 4888| 538| { (yyval.datetime_field) = kDatetimeYear; } 4889| 538|#line 4890 "bison_parser.cpp" 4890| 538| break; 4891| | 4892| 624| case 243: /* datetime_field_plural: SECONDS */ ------------------ | Branch (4892:3): [True: 624, False: 14.8M] ------------------ 4893| 624|#line 1033 "bison_parser.y" 4894| 624| { (yyval.datetime_field) = kDatetimeSecond; } 4895| 624|#line 4896 "bison_parser.cpp" 4896| 624| break; 4897| | 4898| 643| case 244: /* datetime_field_plural: MINUTES */ ------------------ | Branch (4898:3): [True: 643, False: 14.8M] ------------------ 4899| 643|#line 1034 "bison_parser.y" 4900| 643| { (yyval.datetime_field) = kDatetimeMinute; } 4901| 643|#line 4902 "bison_parser.cpp" 4902| 643| break; 4903| | 4904| 694| case 245: /* datetime_field_plural: HOURS */ ------------------ | Branch (4904:3): [True: 694, False: 14.8M] ------------------ 4905| 694|#line 1035 "bison_parser.y" 4906| 694| { (yyval.datetime_field) = kDatetimeHour; } 4907| 694|#line 4908 "bison_parser.cpp" 4908| 694| break; 4909| | 4910| 577| case 246: /* datetime_field_plural: DAYS */ ------------------ | Branch (4910:3): [True: 577, False: 14.8M] ------------------ 4911| 577|#line 1036 "bison_parser.y" 4912| 577| { (yyval.datetime_field) = kDatetimeDay; } 4913| 577|#line 4914 "bison_parser.cpp" 4914| 577| break; 4915| | 4916| 798| case 247: /* datetime_field_plural: MONTHS */ ------------------ | Branch (4916:3): [True: 798, False: 14.8M] ------------------ 4917| 798|#line 1037 "bison_parser.y" 4918| 798| { (yyval.datetime_field) = kDatetimeMonth; } 4919| 798|#line 4920 "bison_parser.cpp" 4920| 798| break; 4921| | 4922| 729| case 248: /* datetime_field_plural: YEARS */ ------------------ | Branch (4922:3): [True: 729, False: 14.8M] ------------------ 4923| 729|#line 1038 "bison_parser.y" 4924| 729| { (yyval.datetime_field) = kDatetimeYear; } 4925| 729|#line 4926 "bison_parser.cpp" 4926| 729| break; 4927| | 4928| 480| case 251: /* array_expr: ARRAY '[' expr_list ']' */ ------------------ | Branch (4928:3): [True: 480, False: 14.8M] ------------------ 4929| 480|#line 1042 "bison_parser.y" 4930| 480| { (yyval.expr) = Expr::makeArray((yyvsp[-1].expr_vec)); } 4931| 480|#line 4932 "bison_parser.cpp" 4932| 480| break; 4933| | 4934| 66| case 252: /* array_index: operand '[' int_literal ']' */ ------------------ | Branch (4934:3): [True: 66, False: 14.8M] ------------------ 4935| 66|#line 1044 "bison_parser.y" 4936| 66| { (yyval.expr) = Expr::makeArrayIndex((yyvsp[-3].expr), (yyvsp[-1].expr)->ival); } 4937| 66|#line 4938 "bison_parser.cpp" 4938| 66| break; 4939| | 4940| 305| case 253: /* between_expr: operand BETWEEN operand AND operand */ ------------------ | Branch (4940:3): [True: 305, False: 14.8M] ------------------ 4941| 305|#line 1046 "bison_parser.y" 4942| 305| { (yyval.expr) = Expr::makeBetween((yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); } 4943| 305|#line 4944 "bison_parser.cpp" 4944| 305| break; 4945| | 4946| 387k| case 254: /* column_name: IDENTIFIER */ ------------------ | Branch (4946:3): [True: 387k, False: 14.5M] ------------------ 4947| 387k|#line 1048 "bison_parser.y" 4948| 387k| { (yyval.expr) = Expr::makeColumnRef((yyvsp[0].sval)); } 4949| 387k|#line 4950 "bison_parser.cpp" 4950| 387k| break; 4951| | 4952| 472| case 255: /* column_name: IDENTIFIER '.' IDENTIFIER */ ------------------ | Branch (4952:3): [True: 472, False: 14.8M] ------------------ 4953| 472|#line 1049 "bison_parser.y" 4954| 472| { (yyval.expr) = Expr::makeColumnRef((yyvsp[-2].sval), (yyvsp[0].sval)); } 4955| 472|#line 4956 "bison_parser.cpp" 4956| 472| break; 4957| | 4958| 1.08M| case 256: /* column_name: '*' */ ------------------ | Branch (4958:3): [True: 1.08M, False: 13.8M] ------------------ 4959| 1.08M|#line 1050 "bison_parser.y" 4960| 1.08M| { (yyval.expr) = Expr::makeStar(); } 4961| 1.08M|#line 4962 "bison_parser.cpp" 4962| 1.08M| break; 4963| | 4964| 195| case 257: /* column_name: IDENTIFIER '.' '*' */ ------------------ | Branch (4964:3): [True: 195, False: 14.8M] ------------------ 4965| 195|#line 1051 "bison_parser.y" 4966| 195| { (yyval.expr) = Expr::makeStar((yyvsp[-2].sval)); } 4967| 195|#line 4968 "bison_parser.cpp" 4968| 195| break; 4969| | 4970| 4.78k| case 265: /* string_literal: STRING */ ------------------ | Branch (4970:3): [True: 4.78k, False: 14.8M] ------------------ 4971| 4.78k|#line 1055 "bison_parser.y" 4972| 4.78k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].sval)); } 4973| 4.78k|#line 4974 "bison_parser.cpp" 4974| 4.78k| break; 4975| | 4976| 511| case 266: /* bool_literal: TRUE */ ------------------ | Branch (4976:3): [True: 511, False: 14.8M] ------------------ 4977| 511|#line 1057 "bison_parser.y" 4978| 511| { (yyval.expr) = Expr::makeLiteral(true); } 4979| 511|#line 4980 "bison_parser.cpp" 4980| 511| break; 4981| | 4982| 686| case 267: /* bool_literal: FALSE */ ------------------ | Branch (4982:3): [True: 686, False: 14.8M] ------------------ 4983| 686|#line 1058 "bison_parser.y" 4984| 686| { (yyval.expr) = Expr::makeLiteral(false); } 4985| 686|#line 4986 "bison_parser.cpp" 4986| 686| break; 4987| | 4988| 545| case 268: /* num_literal: FLOATVAL */ ------------------ | Branch (4988:3): [True: 545, False: 14.8M] ------------------ 4989| 545|#line 1060 "bison_parser.y" 4990| 545| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].fval)); } 4991| 545|#line 4992 "bison_parser.cpp" 4992| 545| break; 4993| | 4994| 13.8k| case 270: /* int_literal: INTVAL */ ------------------ | Branch (4994:3): [True: 13.8k, False: 14.8M] ------------------ 4995| 13.8k|#line 1063 "bison_parser.y" 4996| 13.8k| { (yyval.expr) = Expr::makeLiteral((yyvsp[0].ival)); } 4997| 13.8k|#line 4998 "bison_parser.cpp" 4998| 13.8k| break; 4999| | 5000| 258| case 271: /* null_literal: NULL */ ------------------ | Branch (5000:3): [True: 258, False: 14.8M] ------------------ 5001| 258|#line 1065 "bison_parser.y" 5002| 258| { (yyval.expr) = Expr::makeNullLiteral(); } 5003| 258|#line 5004 "bison_parser.cpp" 5004| 258| break; 5005| | 5006| 208| case 272: /* date_literal: DATE STRING */ ------------------ | Branch (5006:3): [True: 208, False: 14.8M] ------------------ 5007| 208|#line 1067 "bison_parser.y" 5008| 208| { 5009| 208| int day{0}, month{0}, year{0}, chars_parsed{0}; 5010| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5011| 208| if (sscanf((yyvsp[0].sval), "%4d-%2d-%2d%n", &day, &month, &year, &chars_parsed) != 3 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5011:7): [True: 5, False: 203] | Branch (5011:92): [True: 9, False: 194] ------------------ 5012| 14| free((yyvsp[0].sval)); 5013| 14| yyerror(&yyloc, result, scanner, "Found incorrect date format. Expected format: YYYY-MM-DD"); ------------------ | | 72| 14|#define yyerror hsql_error ------------------ 5014| 14| YYERROR; ------------------ | | 1508| 14|#define YYERROR goto yyerrorlab ------------------ 5015| 14| } 5016| 194| (yyval.expr) = Expr::makeDateLiteral((yyvsp[0].sval)); 5017| 194|} 5018| 0|#line 5019 "bison_parser.cpp" 5019| 0| break; 5020| | 5021| 7.65k| case 273: /* interval_literal: int_literal duration_field */ ------------------ | Branch (5021:3): [True: 7.65k, False: 14.8M] ------------------ 5022| 7.65k|#line 1078 "bison_parser.y" 5023| 7.65k| { 5024| 7.65k| (yyval.expr) = Expr::makeIntervalLiteral((yyvsp[-1].expr)->ival, (yyvsp[0].datetime_field)); 5025| 7.65k| delete (yyvsp[-1].expr); 5026| 7.65k|} 5027| 7.65k|#line 5028 "bison_parser.cpp" 5028| 7.65k| break; 5029| | 5030| 386| case 274: /* interval_literal: INTERVAL STRING datetime_field */ ------------------ | Branch (5030:3): [True: 386, False: 14.8M] ------------------ 5031| 386|#line 1082 "bison_parser.y" 5032| 386| { 5033| 386| int duration{0}, chars_parsed{0}; 5034| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5035| 386| if (sscanf((yyvsp[-1].sval), "%d%n", &duration, &chars_parsed) != 1 || (yyvsp[-1].sval)[chars_parsed] != 0) { ------------------ | Branch (5035:7): [True: 2, False: 384] | Branch (5035:74): [True: 8, False: 376] ------------------ 5036| 10| free((yyvsp[-1].sval)); 5037| 10| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER"); ------------------ | | 72| 10|#define yyerror hsql_error ------------------ 5038| 10| YYERROR; ------------------ | | 1508| 10|#define YYERROR goto yyerrorlab ------------------ 5039| 10| } 5040| 376| free((yyvsp[-1].sval)); 5041| 376| (yyval.expr) = Expr::makeIntervalLiteral(duration, (yyvsp[0].datetime_field)); 5042| 376|} 5043| 0|#line 5044 "bison_parser.cpp" 5044| 0| break; 5045| | 5046| 2.86k| case 275: /* interval_literal: INTERVAL STRING */ ------------------ | Branch (5046:3): [True: 2.86k, False: 14.8M] ------------------ 5047| 2.86k|#line 1093 "bison_parser.y" 5048| 2.86k| { 5049| 2.86k| int duration{0}, chars_parsed{0}; 5050| | // 'seconds' and 'minutes' are the longest accepted interval qualifiers (7 chars) + null byte 5051| 2.86k| char unit_string[8]; 5052| | // If the whole string is parsed, chars_parsed points to the terminating null byte after the last character 5053| 2.86k| if (sscanf((yyvsp[0].sval), "%d %7s%n", &duration, unit_string, &chars_parsed) != 2 || (yyvsp[0].sval)[chars_parsed] != 0) { ------------------ | Branch (5053:7): [True: 22, False: 2.83k] | Branch (5053:90): [True: 8, False: 2.83k] ------------------ 5054| 30| free((yyvsp[0].sval)); 5055| 30| yyerror(&yyloc, result, scanner, "Found incorrect interval format. Expected format: INTEGER INTERVAL_QUALIIFIER"); ------------------ | | 72| 30|#define yyerror hsql_error ------------------ 5056| 30| YYERROR; ------------------ | | 1508| 30|#define YYERROR goto yyerrorlab ------------------ 5057| 30| } 5058| 2.83k| free((yyvsp[0].sval)); 5059| | 5060| 2.83k| DatetimeField unit; 5061| 2.83k| if (strcasecmp(unit_string, "second") == 0 || strcasecmp(unit_string, "seconds") == 0) { ------------------ | Branch (5061:7): [True: 234, False: 2.59k] | Branch (5061:49): [True: 200, False: 2.39k] ------------------ 5062| 434| unit = kDatetimeSecond; 5063| 2.39k| } else if (strcasecmp(unit_string, "minute") == 0 || strcasecmp(unit_string, "minutes") == 0) { ------------------ | Branch (5063:14): [True: 254, False: 2.14k] | Branch (5063:56): [True: 197, False: 1.94k] ------------------ 5064| 451| unit = kDatetimeMinute; 5065| 1.94k| } else if (strcasecmp(unit_string, "hour") == 0 || strcasecmp(unit_string, "hours") == 0) { ------------------ | Branch (5065:14): [True: 204, False: 1.74k] | Branch (5065:54): [True: 66, False: 1.67k] ------------------ 5066| 270| unit = kDatetimeHour; 5067| 1.67k| } else if (strcasecmp(unit_string, "day") == 0 || strcasecmp(unit_string, "days") == 0) { ------------------ | Branch (5067:14): [True: 412, False: 1.26k] | Branch (5067:53): [True: 195, False: 1.06k] ------------------ 5068| 607| unit = kDatetimeDay; 5069| 1.06k| } else if (strcasecmp(unit_string, "month") == 0 || strcasecmp(unit_string, "months") == 0) { ------------------ | Branch (5069:14): [True: 66, False: 1.00k] | Branch (5069:55): [True: 208, False: 794] ------------------ 5070| 274| unit = kDatetimeMonth; 5071| 794| } else if (strcasecmp(unit_string, "year") == 0 || strcasecmp(unit_string, "years") == 0) { ------------------ | Branch (5071:14): [True: 201, False: 593] | Branch (5071:54): [True: 303, False: 290] ------------------ 5072| 504| unit = kDatetimeYear; 5073| 504| } else { 5074| 290| yyerror(&yyloc, result, scanner, "Interval qualifier is unknown."); ------------------ | | 72| 290|#define yyerror hsql_error ------------------ 5075| 290| YYERROR; ------------------ | | 1508| 290|#define YYERROR goto yyerrorlab ------------------ 5076| 290| } 5077| 2.54k| (yyval.expr) = Expr::makeIntervalLiteral(duration, unit); 5078| 2.54k|} 5079| 0|#line 5080 "bison_parser.cpp" 5080| 0| break; 5081| | 5082| 316k| case 276: /* param_expr: '?' */ ------------------ | Branch (5082:3): [True: 316k, False: 14.5M] ------------------ 5083| 316k|#line 1125 "bison_parser.y" 5084| 316k| { 5085| 316k| (yyval.expr) = Expr::makeParameter(yylloc.total_column); 5086| 316k| (yyval.expr)->ival2 = yyloc.param_list.size(); 5087| 316k| yyloc.param_list.push_back((yyval.expr)); 5088| 316k|} 5089| 316k|#line 5090 "bison_parser.cpp" 5090| 316k| break; 5091| | 5092| 802| case 278: /* table_ref: table_ref_commalist ',' table_ref_atomic */ ------------------ | Branch (5092:3): [True: 802, False: 14.8M] ------------------ 5093| 802|#line 1134 "bison_parser.y" 5094| 802| { 5095| 802| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5096| 802| auto tbl = new TableRef(kTableCrossProduct); 5097| 802| tbl->list = (yyvsp[-2].table_vec); 5098| 802| (yyval.table) = tbl; 5099| 802|} 5100| 802|#line 5101 "bison_parser.cpp" 5101| 802| break; 5102| | 5103| 621| case 282: /* nonjoin_table_ref_atomic: '(' select_statement ')' opt_table_alias */ ------------------ | Branch (5103:3): [True: 621, False: 14.8M] ------------------ 5104| 621|#line 1143 "bison_parser.y" 5105| 621| { 5106| 621| auto tbl = new TableRef(kTableSelect); 5107| 621| tbl->select = (yyvsp[-2].select_stmt); 5108| 621| tbl->alias = (yyvsp[0].alias_t); 5109| 621| (yyval.table) = tbl; 5110| 621|} 5111| 621|#line 5112 "bison_parser.cpp" 5112| 621| break; 5113| | 5114| 911| case 283: /* table_ref_commalist: table_ref_atomic */ ------------------ | Branch (5114:3): [True: 911, False: 14.8M] ------------------ 5115| 911|#line 1150 "bison_parser.y" 5116| 911| { 5117| 911| (yyval.table_vec) = new std::vector(); 5118| 911| (yyval.table_vec)->push_back((yyvsp[0].table)); 5119| 911|} 5120| 911|#line 5121 "bison_parser.cpp" 5121| 911| break; 5122| | 5123| 36.2k| case 284: /* table_ref_commalist: table_ref_commalist ',' table_ref_atomic */ ------------------ | Branch (5123:3): [True: 36.2k, False: 14.8M] ------------------ 5124| 36.2k|#line 1154 "bison_parser.y" 5125| 36.2k| { 5126| 36.2k| (yyvsp[-2].table_vec)->push_back((yyvsp[0].table)); 5127| 36.2k| (yyval.table_vec) = (yyvsp[-2].table_vec); 5128| 36.2k|} 5129| 36.2k|#line 5130 "bison_parser.cpp" 5130| 36.2k| break; 5131| | 5132| 150k| case 285: /* table_ref_name: table_name opt_table_alias */ ------------------ | Branch (5132:3): [True: 150k, False: 14.7M] ------------------ 5133| 150k|#line 1159 "bison_parser.y" 5134| 150k| { 5135| 150k| auto tbl = new TableRef(kTableName); 5136| 150k| tbl->schema = (yyvsp[-1].table_name).schema; 5137| 150k| tbl->name = (yyvsp[-1].table_name).name; 5138| 150k| tbl->alias = (yyvsp[0].alias_t); 5139| 150k| (yyval.table) = tbl; 5140| 150k|} 5141| 150k|#line 5142 "bison_parser.cpp" 5142| 150k| break; 5143| | 5144| 966| case 286: /* table_ref_name_no_alias: table_name */ ------------------ | Branch (5144:3): [True: 966, False: 14.8M] ------------------ 5145| 966|#line 1167 "bison_parser.y" 5146| 966| { 5147| 966| (yyval.table) = new TableRef(kTableName); 5148| 966| (yyval.table)->schema = (yyvsp[0].table_name).schema; 5149| 966| (yyval.table)->name = (yyvsp[0].table_name).name; 5150| 966|} 5151| 966|#line 5152 "bison_parser.cpp" 5152| 966| break; 5153| | 5154| 163k| case 287: /* table_name: IDENTIFIER */ ------------------ | Branch (5154:3): [True: 163k, False: 14.7M] ------------------ 5155| 163k|#line 1173 "bison_parser.y" 5156| 163k| { 5157| 163k| (yyval.table_name).schema = nullptr; 5158| 163k| (yyval.table_name).name = (yyvsp[0].sval); 5159| 163k|} 5160| 163k|#line 5161 "bison_parser.cpp" 5161| 163k| break; 5162| | 5163| 205| case 288: /* table_name: IDENTIFIER '.' IDENTIFIER */ ------------------ | Branch (5163:3): [True: 205, False: 14.8M] ------------------ 5164| 205|#line 1177 "bison_parser.y" 5165| 205| { 5166| 205| (yyval.table_name).schema = (yyvsp[-2].sval); 5167| 205| (yyval.table_name).name = (yyvsp[0].sval); 5168| 205|} 5169| 205|#line 5170 "bison_parser.cpp" 5170| 205| break; 5171| | 5172| 239| case 289: /* opt_index_name: IDENTIFIER */ ------------------ | Branch (5172:3): [True: 239, False: 14.8M] ------------------ 5173| 239|#line 1182 "bison_parser.y" 5174| 239| { (yyval.sval) = (yyvsp[0].sval); } 5175| 239|#line 5176 "bison_parser.cpp" 5176| 239| break; 5177| | 5178| 993| case 290: /* opt_index_name: %empty */ ------------------ | Branch (5178:3): [True: 993, False: 14.8M] ------------------ 5179| 993|#line 1183 "bison_parser.y" 5180| 993| { (yyval.sval) = nullptr; } 5181| 993|#line 5182 "bison_parser.cpp" 5182| 993| break; 5183| | 5184| 317| case 292: /* table_alias: AS IDENTIFIER '(' ident_commalist ')' */ ------------------ | Branch (5184:3): [True: 317, False: 14.8M] ------------------ 5185| 317|#line 1185 "bison_parser.y" 5186| 317| { (yyval.alias_t) = new Alias((yyvsp[-3].sval), (yyvsp[-1].str_vec)); } 5187| 317|#line 5188 "bison_parser.cpp" 5188| 317| break; 5189| | 5190| 146k| case 294: /* opt_table_alias: %empty */ ------------------ | Branch (5190:3): [True: 146k, False: 14.7M] ------------------ 5191| 146k|#line 1187 "bison_parser.y" 5192| 146k| { (yyval.alias_t) = nullptr; } 5193| 146k|#line 5194 "bison_parser.cpp" 5194| 146k| break; 5195| | 5196| 300| case 295: /* alias: AS IDENTIFIER */ ------------------ | Branch (5196:3): [True: 300, False: 14.8M] ------------------ 5197| 300|#line 1189 "bison_parser.y" 5198| 300| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5199| 300|#line 5200 "bison_parser.cpp" 5200| 300| break; 5201| | 5202| 7.31k| case 296: /* alias: IDENTIFIER */ ------------------ | Branch (5202:3): [True: 7.31k, False: 14.8M] ------------------ 5203| 7.31k|#line 1190 "bison_parser.y" 5204| 7.31k| { (yyval.alias_t) = new Alias((yyvsp[0].sval)); } 5205| 7.31k|#line 5206 "bison_parser.cpp" 5206| 7.31k| break; 5207| | 5208| 164k| case 298: /* opt_alias: %empty */ ------------------ | Branch (5208:3): [True: 164k, False: 14.7M] ------------------ 5209| 164k|#line 1192 "bison_parser.y" 5210| 164k| { (yyval.alias_t) = nullptr; } 5211| 164k|#line 5212 "bison_parser.cpp" 5212| 164k| break; 5213| | 5214| 450| case 299: /* opt_locking_clause: opt_locking_clause_list */ ------------------ | Branch (5214:3): [True: 450, False: 14.8M] ------------------ 5215| 450|#line 1198 "bison_parser.y" 5216| 450| { (yyval.locking_clause_vec) = (yyvsp[0].locking_clause_vec); } 5217| 450|#line 5218 "bison_parser.cpp" 5218| 450| break; 5219| | 5220| 18.1k| case 300: /* opt_locking_clause: %empty */ ------------------ | Branch (5220:3): [True: 18.1k, False: 14.8M] ------------------ 5221| 18.1k|#line 1199 "bison_parser.y" 5222| 18.1k| { (yyval.locking_clause_vec) = nullptr; } 5223| 18.1k|#line 5224 "bison_parser.cpp" 5224| 18.1k| break; 5225| | 5226| 476| case 301: /* opt_locking_clause_list: locking_clause */ ------------------ | Branch (5226:3): [True: 476, False: 14.8M] ------------------ 5227| 476|#line 1201 "bison_parser.y" 5228| 476| { 5229| 476| (yyval.locking_clause_vec) = new std::vector(); 5230| 476| (yyval.locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5231| 476|} 5232| 476|#line 5233 "bison_parser.cpp" 5233| 476| break; 5234| | 5235| 7.36k| case 302: /* opt_locking_clause_list: opt_locking_clause_list locking_clause */ ------------------ | Branch (5235:3): [True: 7.36k, False: 14.8M] ------------------ 5236| 7.36k|#line 1205 "bison_parser.y" 5237| 7.36k| { 5238| 7.36k| (yyvsp[-1].locking_clause_vec)->push_back((yyvsp[0].locking_t)); 5239| 7.36k| (yyval.locking_clause_vec) = (yyvsp[-1].locking_clause_vec); 5240| 7.36k|} 5241| 7.36k|#line 5242 "bison_parser.cpp" 5242| 7.36k| break; 5243| | 5244| 7.55k| case 303: /* locking_clause: FOR row_lock_mode opt_row_lock_policy */ ------------------ | Branch (5244:3): [True: 7.55k, False: 14.8M] ------------------ 5245| 7.55k|#line 1210 "bison_parser.y" 5246| 7.55k| { 5247| 7.55k| (yyval.locking_t) = new LockingClause(); 5248| 7.55k| (yyval.locking_t)->rowLockMode = (yyvsp[-1].lock_mode_t); 5249| 7.55k| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5250| 7.55k| (yyval.locking_t)->tables = nullptr; 5251| 7.55k|} 5252| 7.55k|#line 5253 "bison_parser.cpp" 5253| 7.55k| break; 5254| | 5255| 279| case 304: /* locking_clause: FOR row_lock_mode OF ident_commalist opt_row_lock_policy */ ------------------ | Branch (5255:3): [True: 279, False: 14.8M] ------------------ 5256| 279|#line 1216 "bison_parser.y" 5257| 279| { 5258| 279| (yyval.locking_t) = new LockingClause(); 5259| 279| (yyval.locking_t)->rowLockMode = (yyvsp[-3].lock_mode_t); 5260| 279| (yyval.locking_t)->tables = (yyvsp[-1].str_vec); 5261| 279| (yyval.locking_t)->rowLockWaitPolicy = (yyvsp[0].lock_wait_policy_t); 5262| 279|} 5263| 279|#line 5264 "bison_parser.cpp" 5264| 279| break; 5265| | 5266| 773| case 305: /* row_lock_mode: UPDATE */ ------------------ | Branch (5266:3): [True: 773, False: 14.8M] ------------------ 5267| 773|#line 1223 "bison_parser.y" 5268| 773| { (yyval.lock_mode_t) = RowLockMode::ForUpdate; } 5269| 773|#line 5270 "bison_parser.cpp" 5270| 773| break; 5271| | 5272| 0| case 306: /* row_lock_mode: NO KEY UPDATE */ ------------------ | Branch (5272:3): [True: 0, False: 14.8M] ------------------ 5273| 0|#line 1224 "bison_parser.y" 5274| 0| { (yyval.lock_mode_t) = RowLockMode::ForNoKeyUpdate; } 5275| 0|#line 5276 "bison_parser.cpp" 5276| 0| break; 5277| | 5278| 7.01k| case 307: /* row_lock_mode: SHARE */ ------------------ | Branch (5278:3): [True: 7.01k, False: 14.8M] ------------------ 5279| 7.01k|#line 1225 "bison_parser.y" 5280| 7.01k| { (yyval.lock_mode_t) = RowLockMode::ForShare; } 5281| 7.01k|#line 5282 "bison_parser.cpp" 5282| 7.01k| break; 5283| | 5284| 56| case 308: /* row_lock_mode: KEY SHARE */ ------------------ | Branch (5284:3): [True: 56, False: 14.8M] ------------------ 5285| 56|#line 1226 "bison_parser.y" 5286| 56| { (yyval.lock_mode_t) = RowLockMode::ForKeyShare; } 5287| 56|#line 5288 "bison_parser.cpp" 5288| 56| break; 5289| | 5290| 0| case 309: /* opt_row_lock_policy: SKIP LOCKED */ ------------------ | Branch (5290:3): [True: 0, False: 14.8M] ------------------ 5291| 0|#line 1228 "bison_parser.y" 5292| 0| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::SkipLocked; } 5293| 0|#line 5294 "bison_parser.cpp" 5294| 0| break; 5295| | 5296| 573| case 310: /* opt_row_lock_policy: NOWAIT */ ------------------ | Branch (5296:3): [True: 573, False: 14.8M] ------------------ 5297| 573|#line 1229 "bison_parser.y" 5298| 573| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::NoWait; } 5299| 573|#line 5300 "bison_parser.cpp" 5300| 573| break; 5301| | 5302| 7.26k| case 311: /* opt_row_lock_policy: %empty */ ------------------ | Branch (5302:3): [True: 7.26k, False: 14.8M] ------------------ 5303| 7.26k|#line 1230 "bison_parser.y" 5304| 7.26k| { (yyval.lock_wait_policy_t) = RowLockWaitPolicy::None; } 5305| 7.26k|#line 5306 "bison_parser.cpp" 5306| 7.26k| break; 5307| | 5308| 15.5k| case 313: /* opt_with_clause: %empty */ ------------------ | Branch (5308:3): [True: 15.5k, False: 14.8M] ------------------ 5309| 15.5k|#line 1236 "bison_parser.y" 5310| 15.5k| { (yyval.with_description_vec) = nullptr; } 5311| 15.5k|#line 5312 "bison_parser.cpp" 5312| 15.5k| break; 5313| | 5314| 418| case 314: /* with_clause: WITH with_description_list */ ------------------ | Branch (5314:3): [True: 418, False: 14.8M] ------------------ 5315| 418|#line 1238 "bison_parser.y" 5316| 418| { (yyval.with_description_vec) = (yyvsp[0].with_description_vec); } 5317| 418|#line 5318 "bison_parser.cpp" 5318| 418| break; 5319| | 5320| 456| case 315: /* with_description_list: with_description */ ------------------ | Branch (5320:3): [True: 456, False: 14.8M] ------------------ 5321| 456|#line 1240 "bison_parser.y" 5322| 456| { 5323| 456| (yyval.with_description_vec) = new std::vector(); 5324| 456| (yyval.with_description_vec)->push_back((yyvsp[0].with_description_t)); 5325| 456|} 5326| 456|#line 5327 "bison_parser.cpp" 5327| 456| break; 5328| | 5329| 1.37k| case 316: /* with_description_list: with_description_list ',' with_description */ ------------------ | Branch (5329:3): [True: 1.37k, False: 14.8M] ------------------ 5330| 1.37k|#line 1244 "bison_parser.y" 5331| 1.37k| { 5332| 1.37k| (yyvsp[-2].with_description_vec)->push_back((yyvsp[0].with_description_t)); 5333| 1.37k| (yyval.with_description_vec) = (yyvsp[-2].with_description_vec); 5334| 1.37k|} 5335| 1.37k|#line 5336 "bison_parser.cpp" 5336| 1.37k| break; 5337| | 5338| 1.82k| case 317: /* with_description: IDENTIFIER AS select_with_paren */ ------------------ | Branch (5338:3): [True: 1.82k, False: 14.8M] ------------------ 5339| 1.82k|#line 1249 "bison_parser.y" 5340| 1.82k| { 5341| 1.82k| (yyval.with_description_t) = new WithDescription(); 5342| 1.82k| (yyval.with_description_t)->alias = (yyvsp[-2].sval); 5343| 1.82k| (yyval.with_description_t)->select = (yyvsp[0].select_stmt); 5344| 1.82k|} 5345| 1.82k|#line 5346 "bison_parser.cpp" 5346| 1.82k| break; 5347| | 5348| 660| case 318: /* join_clause: table_ref_atomic NATURAL JOIN nonjoin_table_ref_atomic */ ------------------ | Branch (5348:3): [True: 660, False: 14.8M] ------------------ 5349| 660|#line 1259 "bison_parser.y" 5350| 660| { 5351| 660| (yyval.table) = new TableRef(kTableJoin); 5352| 660| (yyval.table)->join = new JoinDefinition(); 5353| 660| (yyval.table)->join->type = kJoinNatural; 5354| 660| (yyval.table)->join->left = (yyvsp[-3].table); 5355| 660| (yyval.table)->join->right = (yyvsp[0].table); 5356| 660|} 5357| 660|#line 5358 "bison_parser.cpp" 5358| 660| break; 5359| | 5360| 108k| case 319: /* join_clause: table_ref_atomic opt_join_type JOIN table_ref_atomic ON join_condition */ ------------------ | Branch (5360:3): [True: 108k, False: 14.7M] ------------------ 5361| 108k|#line 1266 "bison_parser.y" 5362| 108k| { 5363| 108k| (yyval.table) = new TableRef(kTableJoin); 5364| 108k| (yyval.table)->join = new JoinDefinition(); 5365| 108k| (yyval.table)->join->type = (JoinType)(yyvsp[-4].join_type); 5366| 108k| (yyval.table)->join->left = (yyvsp[-5].table); 5367| 108k| (yyval.table)->join->right = (yyvsp[-2].table); 5368| 108k| (yyval.table)->join->condition = (yyvsp[0].expr); 5369| 108k|} 5370| 108k|#line 5371 "bison_parser.cpp" 5371| 108k| break; 5372| | 5373| 1.51k| case 320: /* join_clause: table_ref_atomic opt_join_type JOIN table_ref_atomic USING '(' column_name ')' */ ------------------ | Branch (5373:3): [True: 1.51k, False: 14.8M] ------------------ 5374| 1.51k|#line 1274 "bison_parser.y" 5375| 1.51k| { 5376| 1.51k| (yyval.table) = new TableRef(kTableJoin); 5377| 1.51k| (yyval.table)->join = new JoinDefinition(); 5378| 1.51k| (yyval.table)->join->type = (JoinType)(yyvsp[-6].join_type); 5379| 1.51k| (yyval.table)->join->left = (yyvsp[-7].table); 5380| 1.51k| (yyval.table)->join->right = (yyvsp[-4].table); 5381| 1.51k| auto left_col = Expr::makeColumnRef(strdup((yyvsp[-1].expr)->name)); 5382| 1.51k| if ((yyvsp[-1].expr)->alias) { ------------------ | Branch (5382:7): [True: 0, False: 1.51k] ------------------ 5383| 0| left_col->alias = strdup((yyvsp[-1].expr)->alias); 5384| 0| } 5385| 1.51k| if ((yyvsp[-7].table)->getName()) { ------------------ | Branch (5385:7): [True: 477, False: 1.03k] ------------------ 5386| 477| left_col->table = strdup((yyvsp[-7].table)->getName()); 5387| 477| } 5388| 1.51k| auto right_col = Expr::makeColumnRef(strdup((yyvsp[-1].expr)->name)); 5389| 1.51k| if ((yyvsp[-1].expr)->alias) { ------------------ | Branch (5389:7): [True: 0, False: 1.51k] ------------------ 5390| 0| right_col->alias = strdup((yyvsp[-1].expr)->alias); 5391| 0| } 5392| 1.51k| if ((yyvsp[-4].table)->getName()) { ------------------ | Branch (5392:7): [True: 1.14k, False: 374] ------------------ 5393| 1.14k| right_col->table = strdup((yyvsp[-4].table)->getName()); 5394| 1.14k| } 5395| 1.51k| (yyval.table)->join->condition = Expr::makeOpBinary(left_col, kOpEquals, right_col); 5396| 1.51k| delete (yyvsp[-1].expr); 5397| 1.51k|} 5398| 1.51k|#line 5399 "bison_parser.cpp" 5399| 1.51k| break; 5400| | 5401| 714| case 321: /* opt_join_type: INNER */ ------------------ | Branch (5401:3): [True: 714, False: 14.8M] ------------------ 5402| 714|#line 1298 "bison_parser.y" 5403| 714| { (yyval.join_type) = kJoinInner; } 5404| 714|#line 5405 "bison_parser.cpp" 5405| 714| break; 5406| | 5407| 401| case 322: /* opt_join_type: LEFT OUTER */ ------------------ | Branch (5407:3): [True: 401, False: 14.8M] ------------------ 5408| 401|#line 1299 "bison_parser.y" 5409| 401| { (yyval.join_type) = kJoinLeft; } 5410| 401|#line 5411 "bison_parser.cpp" 5411| 401| break; 5412| | 5413| 549| case 323: /* opt_join_type: LEFT */ ------------------ | Branch (5413:3): [True: 549, False: 14.8M] ------------------ 5414| 549|#line 1300 "bison_parser.y" 5415| 549| { (yyval.join_type) = kJoinLeft; } 5416| 549|#line 5417 "bison_parser.cpp" 5417| 549| break; 5418| | 5419| 66| case 324: /* opt_join_type: RIGHT OUTER */ ------------------ | Branch (5419:3): [True: 66, False: 14.8M] ------------------ 5420| 66|#line 1301 "bison_parser.y" 5421| 66| { (yyval.join_type) = kJoinRight; } 5422| 66|#line 5423 "bison_parser.cpp" 5423| 66| break; 5424| | 5425| 495| case 325: /* opt_join_type: RIGHT */ ------------------ | Branch (5425:3): [True: 495, False: 14.8M] ------------------ 5426| 495|#line 1302 "bison_parser.y" 5427| 495| { (yyval.join_type) = kJoinRight; } 5428| 495|#line 5429 "bison_parser.cpp" 5429| 495| break; 5430| | 5431| 66| case 326: /* opt_join_type: FULL OUTER */ ------------------ | Branch (5431:3): [True: 66, False: 14.8M] ------------------ 5432| 66|#line 1303 "bison_parser.y" 5433| 66| { (yyval.join_type) = kJoinFull; } 5434| 66|#line 5435 "bison_parser.cpp" 5435| 66| break; 5436| | 5437| 518| case 327: /* opt_join_type: OUTER */ ------------------ | Branch (5437:3): [True: 518, False: 14.8M] ------------------ 5438| 518|#line 1304 "bison_parser.y" 5439| 518| { (yyval.join_type) = kJoinFull; } 5440| 518|#line 5441 "bison_parser.cpp" 5441| 518| break; 5442| | 5443| 690| case 328: /* opt_join_type: FULL */ ------------------ | Branch (5443:3): [True: 690, False: 14.8M] ------------------ 5444| 690|#line 1305 "bison_parser.y" 5445| 690| { (yyval.join_type) = kJoinFull; } 5446| 690|#line 5447 "bison_parser.cpp" 5447| 690| break; 5448| | 5449| 538| case 329: /* opt_join_type: CROSS */ ------------------ | Branch (5449:3): [True: 538, False: 14.8M] ------------------ 5450| 538|#line 1306 "bison_parser.y" 5451| 538| { (yyval.join_type) = kJoinCross; } 5452| 538|#line 5453 "bison_parser.cpp" 5453| 538| break; 5454| | 5455| 108k| case 330: /* opt_join_type: %empty */ ------------------ | Branch (5455:3): [True: 108k, False: 14.7M] ------------------ 5456| 108k|#line 1307 "bison_parser.y" 5457| 108k| { (yyval.join_type) = kJoinInner; } 5458| 108k|#line 5459 "bison_parser.cpp" 5459| 108k| break; 5460| | 5461| 60.9k| case 334: /* ident_commalist: IDENTIFIER */ ------------------ | Branch (5461:3): [True: 60.9k, False: 14.8M] ------------------ 5462| 60.9k|#line 1318 "bison_parser.y" 5463| 60.9k| { 5464| 60.9k| (yyval.str_vec) = new std::vector(); 5465| 60.9k| (yyval.str_vec)->push_back((yyvsp[0].sval)); 5466| 60.9k|} 5467| 60.9k|#line 5468 "bison_parser.cpp" 5468| 60.9k| break; 5469| | 5470| 700k| case 335: /* ident_commalist: ident_commalist ',' IDENTIFIER */ ------------------ | Branch (5470:3): [True: 700k, False: 14.1M] ------------------ 5471| 700k|#line 1322 "bison_parser.y" 5472| 700k| { 5473| 700k| (yyvsp[-2].str_vec)->push_back((yyvsp[0].sval)); 5474| 700k| (yyval.str_vec) = (yyvsp[-2].str_vec); 5475| 700k|} 5476| 700k|#line 5477 "bison_parser.cpp" 5477| 700k| break; 5478| | 5479| | 5480| 0|#line 5481 "bison_parser.cpp" 5481| | 5482| 6.41M| default: break; ------------------ | Branch (5482:7): [True: 6.41M, False: 8.48M] ------------------ 5483| 14.8M| } 5484| | /* User semantic actions sometimes alter yychar, and that requires 5485| | that yytoken be updated with the new translation. We take the 5486| | approach of translating immediately before every use of yytoken. 5487| | One alternative is translating here after every semantic action, 5488| | but that translation would be missed if the semantic action invokes 5489| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5490| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5491| | incorrect destructor might then be invoked immediately. In the 5492| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5493| | to an incorrect destructor call or verbose syntax error message 5494| | before the lookahead is translated. */ 5495| 14.8M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 5496| | 5497| 14.8M| YYPOPSTACK (yylen); ------------------ | | 3030| 14.8M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5498| 14.8M| yylen = 0; 5499| | 5500| 14.8M| *++yyvsp = yyval; 5501| 14.8M| *++yylsp = yyloc; 5502| | 5503| | /* Now 'shift' the result of the reduction. Determine what state 5504| | that goes to, based on the state we popped back to and the rule 5505| | number reduced by. */ 5506| 14.8M| { 5507| 14.8M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 794| 14.8M|#define YYNTOKENS 196 ------------------ 5508| 14.8M| const int yyi = yypgoto[yylhs] + *yyssp; 5509| 14.8M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 791| 22.8M|#define YYLAST 872 ------------------ | Branch (5509:16): [True: 7.91M, False: 6.97M] | Branch (5509:28): [True: 7.91M, False: 400] | Branch (5509:45): [True: 3.87M, False: 4.04M] ------------------ 5510| 14.8M| ? yytable[yyi] 5511| 14.8M| : yydefgoto[yylhs]); 5512| 14.8M| } 5513| | 5514| 14.8M| goto yynewstate; 5515| | 5516| | 5517| |/*--------------------------------------. 5518| || yyerrlab -- here on detecting error. | 5519| |`--------------------------------------*/ 5520| 3.37k|yyerrlab: 5521| | /* Make sure we have latest lookahead translation. See comments at 5522| | user semantic actions for why this is necessary. */ 5523| 3.37k| yytoken = yychar == SQL_HSQL_EMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 809| 6.74k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 803| 3.37k|#define YYMAXUTOK 433 | | ------------------ | | | Branch (809:4): [True: 3.37k, False: 0] | | | Branch (809:18): [True: 3.37k, False: 0] | | ------------------ | | 810| 6.74k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 3.37k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 811| 6.74k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (5523:13): [True: 0, False: 3.37k] ------------------ 5524| | /* If not already recovering from an error, report this error. */ 5525| 3.37k| if (!yyerrstatus) ------------------ | Branch (5525:7): [True: 3.37k, False: 0] ------------------ 5526| 3.37k| { 5527| 3.37k| ++yynerrs; ------------------ | | 74| 3.37k|#define yynerrs hsql_nerrs ------------------ 5528| 3.37k| { 5529| 3.37k| yypcontext_t yyctx 5530| 3.37k| = {yyssp, yytoken, &yylloc}; 5531| 3.37k| char const *yymsgp = YY_("syntax error"); ------------------ | | 590| 3.37k|# define YY_(Msgid) Msgid ------------------ 5532| 3.37k| int yysyntax_error_status; 5533| 3.37k| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5534| 3.37k| if (yysyntax_error_status == 0) ------------------ | Branch (5534:13): [True: 3.37k, False: 0] ------------------ 5535| 3.37k| yymsgp = yymsg; 5536| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (5536:18): [True: 0, False: 0] ------------------ 5537| 0| { 5538| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5538:17): [True: 0, False: 0] ------------------ 5539| 0| YYSTACK_FREE (yymsg); ------------------ | | 698| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 717| 0|# define YYFREE free | | ------------------ ------------------ 5540| 0| yymsg = YY_CAST (char *, ------------------ | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 5541| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 5542| 0| if (yymsg) ------------------ | Branch (5542:17): [True: 0, False: 0] ------------------ 5543| 0| { 5544| 0| yysyntax_error_status 5545| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5546| 0| yymsgp = yymsg; 5547| 0| } 5548| 0| else 5549| 0| { 5550| 0| yymsg = yymsgbuf; 5551| 0| yymsg_alloc = sizeof yymsgbuf; 5552| 0| yysyntax_error_status = YYENOMEM; 5553| 0| } 5554| 0| } 5555| 3.37k| yyerror (&yylloc, result, scanner, yymsgp); ------------------ | | 72| 3.37k|#define yyerror hsql_error ------------------ 5556| 3.37k| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (5556:13): [True: 0, False: 3.37k] ------------------ 5557| 0| YYNOMEM; ------------------ | | 1509| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 5558| 3.37k| } 5559| 3.37k| } 5560| | 5561| 3.37k| yyerror_range[1] = yylloc; 5562| 3.37k| if (yyerrstatus == 3) ------------------ | Branch (5562:7): [True: 0, False: 3.37k] ------------------ 5563| 0| { 5564| | /* If just tried and failed to reuse lookahead token after an 5565| | error, discard it. */ 5566| | 5567| 0| if (yychar <= SQL_YYEOF) ------------------ | Branch (5567:11): [True: 0, False: 0] ------------------ 5568| 0| { 5569| | /* Return failure if at end of input. */ 5570| 0| if (yychar == SQL_YYEOF) ------------------ | Branch (5570:15): [True: 0, False: 0] ------------------ 5571| 0| YYABORT; ------------------ | | 1507| 0|#define YYABORT goto yyabortlab ------------------ 5572| 0| } 5573| 0| else 5574| 0| { 5575| 0| yydestruct ("Error: discarding", 5576| 0| yytoken, &yylval, &yylloc, result, scanner); 5577| 0| yychar = SQL_HSQL_EMPTY; 5578| 0| } 5579| 0| } 5580| | 5581| | /* Else will try to reuse lookahead token after shifting the error 5582| | token. */ 5583| 3.37k| goto yyerrlab1; 5584| | 5585| | 5586| |/*---------------------------------------------------. 5587| || yyerrorlab -- error raised explicitly by YYERROR. | 5588| |`---------------------------------------------------*/ 5589| 3.37k|yyerrorlab: 5590| | /* Pacify compilers when the user code never invokes YYERROR and the 5591| | label yyerrorlab therefore never appears in user code. */ 5592| 463| if (0) ------------------ | Branch (5592:7): [Folded - Ignored] ------------------ 5593| 0| YYERROR; ------------------ | | 1508| 0|#define YYERROR goto yyerrorlab ------------------ 5594| 463| ++yynerrs; ------------------ | | 74| 463|#define yynerrs hsql_nerrs ------------------ 5595| | 5596| | /* Do not reclaim the symbols of the rule whose action triggered 5597| | this YYERROR. */ 5598| 463| YYPOPSTACK (yylen); ------------------ | | 3030| 463|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5599| 463| yylen = 0; 5600| 463| YY_STACK_PRINT (yyss, yyssp); 5601| 463| yystate = *yyssp; 5602| 463| goto yyerrlab1; 5603| | 5604| | 5605| |/*-------------------------------------------------------------. 5606| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5607| |`-------------------------------------------------------------*/ 5608| 3.83k|yyerrlab1: 5609| 3.83k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5610| | 5611| | /* Pop stack until we find a state that shifts the error token. */ 5612| 3.83k| for (;;) 5613| 47.1k| { 5614| 47.1k| yyn = yypact[yystate]; 5615| 47.1k| if (!yypact_value_is_default (yyn)) ------------------ | | 990| 47.1k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 987| 47.1k|#define YYPACT_NINF (-527) | | ------------------ ------------------ | Branch (5615:11): [True: 47.1k, False: 0] ------------------ 5616| 47.1k| { 5617| 47.1k| yyn += YYSYMBOL_YYerror; 5618| 47.1k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 791| 88.7k|#define YYLAST 872 ------------------ | Branch (5618:15): [True: 41.5k, False: 5.51k] | Branch (5618:27): [True: 41.5k, False: 0] | Branch (5618:44): [True: 0, False: 41.5k] ------------------ 5619| 0| { 5620| 0| yyn = yytable[yyn]; 5621| 0| if (0 < yyn) ------------------ | Branch (5621:19): [True: 0, False: 0] ------------------ 5622| 0| break; 5623| 0| } 5624| 47.1k| } 5625| | 5626| | /* Pop the current state because it cannot handle the error token. */ 5627| 47.1k| if (yyssp == yyss) ------------------ | Branch (5627:11): [True: 3.83k, False: 43.2k] ------------------ 5628| 3.83k| YYABORT; ------------------ | | 1507| 3.83k|#define YYABORT goto yyabortlab ------------------ 5629| | 5630| 43.2k| yyerror_range[1] = *yylsp; 5631| 43.2k| yydestruct ("Error: popping", 5632| 43.2k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp, result, scanner); ------------------ | | 905| 43.2k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 111| 43.2k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 5633| 43.2k| YYPOPSTACK (1); ------------------ | | 3030| 43.2k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5634| 43.2k| yystate = *yyssp; 5635| 43.2k| YY_STACK_PRINT (yyss, yyssp); 5636| 43.2k| } 5637| | 5638| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5639| 0| *++yyvsp = yylval; 5640| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 5641| | 5642| 0| yyerror_range[2] = yylloc; 5643| 0| ++yylsp; 5644| 0| YYLLOC_DEFAULT (*yylsp, yyerror_range, 2); ------------------ | | 1541| 0| do \ | | 1542| 0| if (N) \ | | ------------------ | | | Branch (1542:11): [Folded - Ignored] | | ------------------ | | 1543| 0| { \ | | 1544| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1545| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1546| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1547| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1548| 0| } \ | | 1549| 0| else \ | | 1550| 0| { \ | | 1551| 0| (Current).first_line = (Current).last_line = \ | | 1552| 0| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1553| 0| (Current).first_column = (Current).last_column = \ | | 1554| 0| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 1559| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 1555| 0| } \ | | 1556| 0| while (0) | | ------------------ | | | Branch (1556:12): [Folded - Ignored] | | ------------------ ------------------ 5645| | 5646| | /* Shift the error token. */ 5647| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 5648| | 5649| 0| yystate = yyn; 5650| 0| goto yynewstate; 5651| | 5652| | 5653| |/*-------------------------------------. 5654| || yyacceptlab -- YYACCEPT comes here. | 5655| |`-------------------------------------*/ 5656| 1.37k|yyacceptlab: 5657| 1.37k| yyresult = 0; 5658| 1.37k| goto yyreturnlab; 5659| | 5660| | 5661| |/*-----------------------------------. 5662| || yyabortlab -- YYABORT comes here. | 5663| |`-----------------------------------*/ 5664| 3.83k|yyabortlab: 5665| 3.83k| yyresult = 1; 5666| 3.83k| goto yyreturnlab; 5667| | 5668| | 5669| |/*-----------------------------------------------------------. 5670| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 5671| |`-----------------------------------------------------------*/ 5672| 14|yyexhaustedlab: 5673| 14| yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 72| 14|#define yyerror hsql_error ------------------ yyerror (&yylloc, result, scanner, YY_("memory exhausted")); ------------------ | | 590| 14|# define YY_(Msgid) Msgid ------------------ 5674| 14| yyresult = 2; 5675| 14| goto yyreturnlab; 5676| | 5677| | 5678| |/*----------------------------------------------------------. 5679| || yyreturnlab -- parsing is finished, clean up and return. | 5680| |`----------------------------------------------------------*/ 5681| 5.22k|yyreturnlab: 5682| 5.22k| if (yychar != SQL_HSQL_EMPTY) ------------------ | Branch (5682:7): [True: 3.70k, False: 1.52k] ------------------ 5683| 3.70k| { 5684| | /* Make sure we have latest lookahead translation. See comments at 5685| | user semantic actions for why this is necessary. */ 5686| 3.70k| yytoken = YYTRANSLATE (yychar); ------------------ | | 809| 3.70k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 803| 3.70k|#define YYMAXUTOK 433 | | ------------------ | | | Branch (809:4): [True: 3.70k, False: 0] | | | Branch (809:18): [True: 3.70k, False: 0] | | ------------------ | | 810| 3.70k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 111| 3.70k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ | | 811| 3.70k| : YYSYMBOL_YYUNDEF) ------------------ 5687| 3.70k| yydestruct ("Cleanup: discarding lookahead", 5688| 3.70k| yytoken, &yylval, &yylloc, result, scanner); 5689| 3.70k| } 5690| | /* Do not reclaim the symbols of the rule whose action triggered 5691| | this YYABORT or YYACCEPT. */ 5692| 5.22k| YYPOPSTACK (yylen); ------------------ | | 3030| 5.22k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5693| 5.22k| YY_STACK_PRINT (yyss, yyssp); 5694| 10.7k| while (yyssp != yyss) ------------------ | Branch (5694:10): [True: 5.53k, False: 5.22k] ------------------ 5695| 5.53k| { 5696| 5.53k| yydestruct ("Cleanup: popping", 5697| 5.53k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp, result, scanner); ------------------ | | 905| 5.53k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 111| 5.53k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 5698| 5.53k| YYPOPSTACK (1); ------------------ | | 3030| 5.53k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 5699| 5.53k| } 5700| 5.22k|#ifndef yyoverflow 5701| 5.22k| if (yyss != yyssa) ------------------ | Branch (5701:7): [True: 0, False: 5.22k] ------------------ 5702| 0| YYSTACK_FREE (yyss); ------------------ | | 698| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 717| 0|# define YYFREE free | | ------------------ ------------------ 5703| 5.22k|#endif 5704| 5.22k| if (yymsg != yymsgbuf) ------------------ | Branch (5704:7): [True: 0, False: 5.22k] ------------------ 5705| 0| YYSTACK_FREE (yymsg); ------------------ | | 698| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 717| 0|# define YYFREE free | | ------------------ ------------------ 5706| 5.22k| return yyresult; 5707| 3.83k|} bison_parser.cpp:_ZL14yysyntax_errorPlPPcPK12yypcontext_t: 1963| 3.37k|{ 1964| 3.37k| enum { YYARGS_MAX = 5 }; 1965| | /* Internationalized format string. */ 1966| 3.37k| const char *yyformat = YY_NULLPTR; ------------------ | | 121| 3.37k|# define YY_NULLPTR nullptr ------------------ 1967| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1968| | one per "expected"). */ 1969| 3.37k| yysymbol_kind_t yyarg[YYARGS_MAX]; 1970| | /* Cumulated lengths of YYARG. */ 1971| 3.37k| YYPTRDIFF_T yysize = 0; ------------------ | | 540| 3.37k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1972| | 1973| | /* Actual size of YYARG. */ 1974| 3.37k| int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); 1975| 3.37k| if (yycount == YYENOMEM) ------------------ | Branch (1975:7): [True: 0, False: 3.37k] ------------------ 1976| 0| return YYENOMEM; 1977| | 1978| 3.37k| switch (yycount) 1979| 3.37k| { 1980| 0|#define YYCASE_(N, S) \ 1981| 0| case N: \ 1982| 0| yyformat = S; \ 1983| 0| break 1984| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1984:5): [True: 0, False: 3.37k] ------------------ 1985| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1981| 0| case N: \ | | ------------------ | | | Branch (1981:7): [True: 0, False: 3.37k] | | ------------------ | | 1982| 0| yyformat = S; \ | | 1983| 0| break ------------------ 1986| 586| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1981| 586| case N: \ | | ------------------ | | | Branch (1981:7): [True: 586, False: 2.78k] | | ------------------ | | 1982| 586| yyformat = S; \ | | 1983| 586| break ------------------ 1987| 999| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1981| 999| case N: \ | | ------------------ | | | Branch (1981:7): [True: 999, False: 2.37k] | | ------------------ | | 1982| 999| yyformat = S; \ | | 1983| 999| break ------------------ 1988| 1.49k| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1981| 1.49k| case N: \ | | ------------------ | | | Branch (1981:7): [True: 1.49k, False: 1.87k] | | ------------------ | | 1982| 1.49k| yyformat = S; \ | | 1983| 1.49k| break ------------------ 1989| 248| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1981| 248| case N: \ | | ------------------ | | | Branch (1981:7): [True: 248, False: 3.12k] | | ------------------ | | 1982| 248| yyformat = S; \ | | 1983| 248| break ------------------ 1990| 3.37k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1981| 43| case N: \ | | ------------------ | | | Branch (1981:7): [True: 43, False: 3.33k] | | ------------------ | | 1982| 43| yyformat = S; \ | | 1983| 43| break ------------------ 1991| 3.37k|#undef YYCASE_ 1992| 3.37k| } 1993| | 1994| | /* Compute error message size. Don't count the "%s"s, but reserve 1995| | room for the terminator. */ 1996| 3.37k| yysize = yystrlen (yyformat) - 2 * yycount + 1; ------------------ | | 1822| 3.37k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 111| 3.37k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 1997| 3.37k| { 1998| 3.37k| int yyi; 1999| 11.6k| for (yyi = 0; yyi < yycount; ++yyi) ------------------ | Branch (1999:19): [True: 8.28k, False: 3.37k] ------------------ 2000| 8.28k| { 2001| 8.28k| YYPTRDIFF_T yysize1 ------------------ | | 540| 8.28k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 2002| 8.28k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); ------------------ | | 121| 8.28k|# define YY_NULLPTR nullptr ------------------ 2003| 8.28k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 700| 8.28k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 568| 8.28k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 16.5k|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2003:13): [True: 8.28k, False: 0] | Branch (2003:34): [True: 8.28k, False: 0] ------------------ 2004| 8.28k| yysize = yysize1; 2005| 0| else 2006| 0| return YYENOMEM; 2007| 8.28k| } 2008| 3.37k| } 2009| | 2010| 3.37k| if (*yymsg_alloc < yysize) ------------------ | Branch (2010:7): [True: 0, False: 3.37k] ------------------ 2011| 0| { 2012| 0| *yymsg_alloc = 2 * yysize; 2013| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (2013:14): [True: 0, False: 0] ------------------ 2014| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 700| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 568| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (2014:17): [True: 0, False: 0] ------------------ 2015| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 700| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 568| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 111| 0|# define YY_CAST(Type, Val) static_cast (Val) | | | | | | ------------------ | | | | | | | Branch (111:50): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2016| 0| return -1; 2017| 0| } 2018| | 2019| | /* Avoid sprintf, as that infringes on the user's name space. 2020| | Don't have undefined behavior even if the translation 2021| | produced a string with the wrong number of "%s"s. */ 2022| 3.37k| { 2023| 3.37k| char *yyp = *yymsg; 2024| 3.37k| int yyi = 0; 2025| 137k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (2025:12): [True: 134k, False: 3.37k] ------------------ 2026| 134k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (2026:11): [True: 8.28k, False: 126k] | Branch (2026:26): [True: 8.28k, False: 0] | Branch (2026:48): [True: 8.28k, False: 0] ------------------ 2027| 8.28k| { 2028| 8.28k| yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); 2029| 8.28k| yyformat += 2; 2030| 8.28k| } 2031| 126k| else 2032| 126k| { 2033| 126k| ++yyp; 2034| 126k| ++yyformat; 2035| 126k| } 2036| 3.37k| } 2037| 3.37k| return 0; 2038| 3.37k|} bison_parser.cpp:_ZL25yy_syntax_error_argumentsPK12yypcontext_tP15yysymbol_kind_ti: 1910| 3.37k|{ 1911| | /* Actual size of YYARG. */ 1912| 3.37k| int yycount = 0; 1913| | /* There are many possibilities here to consider: 1914| | - If this state is a consistent state with a default action, then 1915| | the only way this function was invoked is if the default action 1916| | is an error action. In that case, don't check for expected 1917| | tokens because there are none. 1918| | - The only way there can be no lookahead present (in yychar) is if 1919| | this state is a consistent state with a default action. Thus, 1920| | detecting the absence of a lookahead is sufficient to determine 1921| | that there is no unexpected or expected token to report. In that 1922| | case, just report a simple "syntax error". 1923| | - Don't assume there isn't a lookahead just because this state is a 1924| | consistent state with a default action. There might have been a 1925| | previous inconsistent state, consistent state with a non-default 1926| | action, or user semantic action that manipulated yychar. 1927| | - Of course, the expected token list depends on states to have 1928| | correct lookahead information, and it depends on the parser not 1929| | to perform extra reductions after fetching a lookahead from the 1930| | scanner and before detecting a syntax error. Thus, state merging 1931| | (from LALR or IELR) and default reductions corrupt the expected 1932| | token list. However, the list is correct for canonical LR with 1933| | one exception: it will still contain any token that will not be 1934| | accepted due to an error action in a later state. 1935| | */ 1936| 3.37k| if (yyctx->yytoken != YYSYMBOL_YYEMPTY) ------------------ | Branch (1936:7): [True: 3.37k, False: 0] ------------------ 1937| 3.37k| { 1938| 3.37k| int yyn; 1939| 3.37k| if (yyarg) ------------------ | Branch (1939:11): [True: 3.37k, False: 0] ------------------ 1940| 3.37k| yyarg[yycount] = yyctx->yytoken; 1941| 3.37k| ++yycount; 1942| 3.37k| yyn = yypcontext_expected_tokens (yyctx, 1943| 3.37k| yyarg ? yyarg + 1 : yyarg, yyargn - 1); ------------------ | Branch (1943:41): [True: 3.37k, False: 0] ------------------ 1944| 3.37k| if (yyn == YYENOMEM) ------------------ | Branch (1944:11): [True: 0, False: 3.37k] ------------------ 1945| 0| return YYENOMEM; 1946| 3.37k| else 1947| 3.37k| yycount += yyn; 1948| 3.37k| } 1949| 3.37k| return yycount; 1950| 3.37k|} bison_parser.cpp:_ZL26yypcontext_expected_tokensPK12yypcontext_tP15yysymbol_kind_ti: 1786| 3.37k|{ 1787| | /* Actual size of YYARG. */ 1788| 3.37k| int yycount = 0; 1789| 3.37k| int yyn = yypact[+*yyctx->yyssp]; 1790| 3.37k| if (!yypact_value_is_default (yyn)) ------------------ | | 990| 3.37k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 987| 3.37k|#define YYPACT_NINF (-527) | | ------------------ ------------------ | Branch (1790:7): [True: 3.37k, False: 0] ------------------ 1791| 3.37k| { 1792| | /* Start YYX at -YYN if negative to avoid negative indexes in 1793| | YYCHECK. In other words, skip the first -YYN actions for 1794| | this state because they are default actions. */ 1795| 3.37k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1795:22): [True: 1.03k, False: 2.34k] ------------------ 1796| | /* Stay within bounds of both yycheck and yytname. */ 1797| 3.37k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 791| 3.37k|#define YYLAST 872 ------------------ 1798| 3.37k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 794| 3.37k|#define YYNTOKENS 196 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 794| 3.37k|#define YYNTOKENS 196 ------------------ | Branch (1798:20): [True: 2, False: 3.37k] ------------------ 1799| 3.37k| int yyx; 1800| 550k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1800:28): [True: 547k, False: 2.78k] ------------------ 1801| 547k| if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror ------------------ | Branch (1801:13): [True: 7.89k, False: 539k] | Branch (1801:42): [True: 7.89k, False: 0] ------------------ 1802| 547k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 995| 7.89k| ((Yyn) == YYTABLE_NINF) | | ------------------ | | | | 992| 7.89k|#define YYTABLE_NINF (-333) | | ------------------ ------------------ | Branch (1802:16): [True: 7.84k, False: 53] ------------------ 1803| 7.84k| { 1804| 7.84k| if (!yyarg) ------------------ | Branch (1804:17): [True: 0, False: 7.84k] ------------------ 1805| 0| ++yycount; 1806| 7.84k| else if (yycount == yyargn) ------------------ | Branch (1806:22): [True: 586, False: 7.25k] ------------------ 1807| 586| return 0; 1808| 7.25k| else 1809| 7.25k| yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); ------------------ | | 111| 7.25k|# define YY_CAST(Type, Val) static_cast (Val) ------------------ 1810| 7.84k| } 1811| 3.37k| } 1812| 2.78k| if (yyarg && yycount == 0 && 0 < yyargn) ------------------ | Branch (1812:7): [True: 2.78k, False: 0] | Branch (1812:16): [True: 0, False: 2.78k] | Branch (1812:32): [True: 0, False: 0] ------------------ 1813| 0| yyarg[0] = YYSYMBOL_YYEMPTY; 1814| 2.78k| return yycount; 1815| 3.37k|} bison_parser.cpp:_ZL9yytnamerrPcPKc: 1866| 16.5k|{ 1867| 16.5k| if (*yystr == '"') ------------------ | Branch (1867:7): [True: 3.65k, False: 12.9k] ------------------ 1868| 3.65k| { 1869| 3.65k| YYPTRDIFF_T yyn = 0; ------------------ | | 540| 3.65k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1870| 3.65k| char const *yyp = yystr; 1871| 3.65k| for (;;) 1872| 43.9k| switch (*++yyp) 1873| 43.9k| { 1874| 0| case '\'': ------------------ | Branch (1874:11): [True: 0, False: 43.9k] ------------------ 1875| 0| case ',': ------------------ | Branch (1875:11): [True: 0, False: 43.9k] ------------------ 1876| 0| goto do_not_strip_quotes; 1877| | 1878| 0| case '\\': ------------------ | Branch (1878:11): [True: 0, False: 43.9k] ------------------ 1879| 0| if (*++yyp != '\\') ------------------ | Branch (1879:17): [True: 0, False: 0] ------------------ 1880| 0| goto do_not_strip_quotes; 1881| 0| else 1882| 0| goto append; 1883| | 1884| 0| append: 1885| 40.2k| default: ------------------ | Branch (1885:11): [True: 40.2k, False: 3.65k] ------------------ 1886| 40.2k| if (yyres) ------------------ | Branch (1886:17): [True: 20.1k, False: 20.1k] ------------------ 1887| 20.1k| yyres[yyn] = *yyp; 1888| 40.2k| yyn++; 1889| 40.2k| break; 1890| | 1891| 3.65k| case '"': ------------------ | Branch (1891:11): [True: 3.65k, False: 40.2k] ------------------ 1892| 3.65k| if (yyres) ------------------ | Branch (1892:17): [True: 1.82k, False: 1.82k] ------------------ 1893| 1.82k| yyres[yyn] = '\0'; 1894| 3.65k| return yyn; 1895| 43.9k| } 1896| 0| do_not_strip_quotes: ; 1897| 0| } 1898| | 1899| 12.9k| if (yyres) ------------------ | Branch (1899:7): [True: 6.45k, False: 6.45k] ------------------ 1900| 6.45k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1838| 6.45k|# define yystpcpy stpcpy ------------------ 1901| 6.45k| else 1902| 6.45k| return yystrlen (yystr); ------------------ | | 1822| 6.45k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 111| 6.45k|# define YY_CAST(Type, Val) static_cast (Val) | | ------------------ ------------------ 1903| 12.9k|} bison_parser.cpp:_ZL10yydestructPKc15yysymbol_kind_tP10HSQL_STYPEP15HSQL_CUST_LTYPEPN4hsql15SQLParserResultEPv: 2048| 52.5k|{ 2049| 52.5k| YY_USE (yyvaluep); ------------------ | | 613| 52.5k|# define YY_USE(E) ((void) (E)) ------------------ 2050| 52.5k| YY_USE (yylocationp); ------------------ | | 613| 52.5k|# define YY_USE(E) ((void) (E)) ------------------ 2051| 52.5k| YY_USE (result); ------------------ | | 613| 52.5k|# define YY_USE(E) ((void) (E)) ------------------ 2052| 52.5k| YY_USE (scanner); ------------------ | | 613| 52.5k|# define YY_USE(E) ((void) (E)) ------------------ 2053| 52.5k| if (!yymsg) ------------------ | Branch (2053:7): [True: 0, False: 52.5k] ------------------ 2054| 0| yymsg = "Deleting"; 2055| 52.5k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 2056| | 2057| 52.5k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2058| 52.5k| switch (yykind) 2059| 52.5k| { 2060| 2.07k| case YYSYMBOL_IDENTIFIER: /* IDENTIFIER */ ------------------ | Branch (2060:5): [True: 2.07k, False: 50.4k] ------------------ 2061| 2.07k|#line 181 "bison_parser.y" 2062| 2.07k| { free( (((*yyvaluep).sval)) ); } 2063| 2.07k|#line 2064 "bison_parser.cpp" 2064| 2.07k| break; 2065| | 2066| 50| case YYSYMBOL_STRING: /* STRING */ ------------------ | Branch (2066:5): [True: 50, False: 52.4k] ------------------ 2067| 50|#line 181 "bison_parser.y" 2068| 50| { free( (((*yyvaluep).sval)) ); } 2069| 50|#line 2070 "bison_parser.cpp" 2070| 50| break; 2071| | 2072| 26| case YYSYMBOL_FLOATVAL: /* FLOATVAL */ ------------------ | Branch (2072:5): [True: 26, False: 52.4k] ------------------ 2073| 26|#line 168 "bison_parser.y" 2074| 26| { } 2075| 26|#line 2076 "bison_parser.cpp" 2076| 26| break; 2077| | 2078| 37| case YYSYMBOL_INTVAL: /* INTVAL */ ------------------ | Branch (2078:5): [True: 37, False: 52.4k] ------------------ 2079| 37|#line 168 "bison_parser.y" 2080| 37| { } 2081| 37|#line 2082 "bison_parser.cpp" 2082| 37| break; 2083| | 2084| 480| case YYSYMBOL_statement_list: /* statement_list */ ------------------ | Branch (2084:5): [True: 480, False: 52.0k] ------------------ 2085| 480|#line 182 "bison_parser.y" 2086| 480| { 2087| 480| if (((*yyvaluep).stmt_vec)) { ------------------ | Branch (2087:11): [True: 480, False: 0] ------------------ 2088| 33.8k| for (auto ptr : *(((*yyvaluep).stmt_vec))) { ------------------ | Branch (2088:23): [True: 33.8k, False: 480] ------------------ 2089| 33.8k| delete ptr; 2090| 33.8k| } 2091| 480| } 2092| 480| delete (((*yyvaluep).stmt_vec)); 2093| 480| } 2094| 480|#line 2095 "bison_parser.cpp" 2095| 480| break; 2096| | 2097| 0| case YYSYMBOL_statement: /* statement */ ------------------ | Branch (2097:5): [True: 0, False: 52.5k] ------------------ 2098| 0|#line 190 "bison_parser.y" 2099| 0| { delete (((*yyvaluep).statement)); } 2100| 0|#line 2101 "bison_parser.cpp" 2101| 0| break; 2102| | 2103| 51| case YYSYMBOL_preparable_statement: /* preparable_statement */ ------------------ | Branch (2103:5): [True: 51, False: 52.4k] ------------------ 2104| 51|#line 190 "bison_parser.y" 2105| 51| { delete (((*yyvaluep).statement)); } 2106| 51|#line 2107 "bison_parser.cpp" 2107| 51| break; 2108| | 2109| 0| case YYSYMBOL_opt_hints: /* opt_hints */ ------------------ | Branch (2109:5): [True: 0, False: 52.5k] ------------------ 2110| 0|#line 182 "bison_parser.y" 2111| 0| { 2112| 0| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2112:11): [True: 0, False: 0] ------------------ 2113| 0| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2113:23): [True: 0, False: 0] ------------------ 2114| 0| delete ptr; 2115| 0| } 2116| 0| } 2117| 0| delete (((*yyvaluep).expr_vec)); 2118| 0| } 2119| 0|#line 2120 "bison_parser.cpp" 2120| 0| break; 2121| | 2122| 35| case YYSYMBOL_hint_list: /* hint_list */ ------------------ | Branch (2122:5): [True: 35, False: 52.4k] ------------------ 2123| 35|#line 182 "bison_parser.y" 2124| 35| { 2125| 35| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2125:11): [True: 35, False: 0] ------------------ 2126| 649| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2126:23): [True: 649, False: 35] ------------------ 2127| 649| delete ptr; 2128| 649| } 2129| 35| } 2130| 35| delete (((*yyvaluep).expr_vec)); 2131| 35| } 2132| 35|#line 2133 "bison_parser.cpp" 2133| 35| break; 2134| | 2135| 0| case YYSYMBOL_hint: /* hint */ ------------------ | Branch (2135:5): [True: 0, False: 52.5k] ------------------ 2136| 0|#line 190 "bison_parser.y" 2137| 0| { delete (((*yyvaluep).expr)); } 2138| 0|#line 2139 "bison_parser.cpp" 2139| 0| break; 2140| | 2141| 0| case YYSYMBOL_transaction_statement: /* transaction_statement */ ------------------ | Branch (2141:5): [True: 0, False: 52.5k] ------------------ 2142| 0|#line 190 "bison_parser.y" 2143| 0| { delete (((*yyvaluep).transaction_stmt)); } 2144| 0|#line 2145 "bison_parser.cpp" 2145| 0| break; 2146| | 2147| 1| case YYSYMBOL_prepare_statement: /* prepare_statement */ ------------------ | Branch (2147:5): [True: 1, False: 52.5k] ------------------ 2148| 1|#line 190 "bison_parser.y" 2149| 1| { delete (((*yyvaluep).prep_stmt)); } 2150| 1|#line 2151 "bison_parser.cpp" 2151| 1| break; 2152| | 2153| 0| case YYSYMBOL_prepare_target_query: /* prepare_target_query */ ------------------ | Branch (2153:5): [True: 0, False: 52.5k] ------------------ 2154| 0|#line 181 "bison_parser.y" 2155| 0| { free( (((*yyvaluep).sval)) ); } 2156| 0|#line 2157 "bison_parser.cpp" 2157| 0| break; 2158| | 2159| 0| case YYSYMBOL_execute_statement: /* execute_statement */ ------------------ | Branch (2159:5): [True: 0, False: 52.5k] ------------------ 2160| 0|#line 190 "bison_parser.y" 2161| 0| { delete (((*yyvaluep).exec_stmt)); } 2162| 0|#line 2163 "bison_parser.cpp" 2163| 0| break; 2164| | 2165| 0| case YYSYMBOL_import_statement: /* import_statement */ ------------------ | Branch (2165:5): [True: 0, False: 52.5k] ------------------ 2166| 0|#line 190 "bison_parser.y" 2167| 0| { delete (((*yyvaluep).import_stmt)); } 2168| 0|#line 2169 "bison_parser.cpp" 2169| 0| break; 2170| | 2171| 4| case YYSYMBOL_file_type: /* file_type */ ------------------ | Branch (2171:5): [True: 4, False: 52.5k] ------------------ 2172| 4|#line 168 "bison_parser.y" 2173| 4| { } 2174| 4|#line 2175 "bison_parser.cpp" 2175| 4| break; 2176| | 2177| 1| case YYSYMBOL_file_path: /* file_path */ ------------------ | Branch (2177:5): [True: 1, False: 52.5k] ------------------ 2178| 1|#line 181 "bison_parser.y" 2179| 1| { free( (((*yyvaluep).sval)) ); } 2180| 1|#line 2181 "bison_parser.cpp" 2181| 1| break; 2182| | 2183| 0| case YYSYMBOL_opt_file_type: /* opt_file_type */ ------------------ | Branch (2183:5): [True: 0, False: 52.5k] ------------------ 2184| 0|#line 168 "bison_parser.y" 2185| 0| { } 2186| 0|#line 2187 "bison_parser.cpp" 2187| 0| break; 2188| | 2189| 0| case YYSYMBOL_export_statement: /* export_statement */ ------------------ | Branch (2189:5): [True: 0, False: 52.5k] ------------------ 2190| 0|#line 190 "bison_parser.y" 2191| 0| { delete (((*yyvaluep).export_stmt)); } 2192| 0|#line 2193 "bison_parser.cpp" 2193| 0| break; 2194| | 2195| 0| case YYSYMBOL_show_statement: /* show_statement */ ------------------ | Branch (2195:5): [True: 0, False: 52.5k] ------------------ 2196| 0|#line 190 "bison_parser.y" 2197| 0| { delete (((*yyvaluep).show_stmt)); } 2198| 0|#line 2199 "bison_parser.cpp" 2199| 0| break; 2200| | 2201| 0| case YYSYMBOL_create_statement: /* create_statement */ ------------------ | Branch (2201:5): [True: 0, False: 52.5k] ------------------ 2202| 0|#line 190 "bison_parser.y" 2203| 0| { delete (((*yyvaluep).create_stmt)); } 2204| 0|#line 2205 "bison_parser.cpp" 2205| 0| break; 2206| | 2207| 622| case YYSYMBOL_opt_not_exists: /* opt_not_exists */ ------------------ | Branch (2207:5): [True: 622, False: 51.8k] ------------------ 2208| 622|#line 168 "bison_parser.y" 2209| 622| { } 2210| 622|#line 2211 "bison_parser.cpp" 2211| 622| break; 2212| | 2213| 554| case YYSYMBOL_table_elem_commalist: /* table_elem_commalist */ ------------------ | Branch (2213:5): [True: 554, False: 51.9k] ------------------ 2214| 554|#line 182 "bison_parser.y" 2215| 554| { 2216| 554| if (((*yyvaluep).table_element_vec)) { ------------------ | Branch (2216:11): [True: 554, False: 0] ------------------ 2217| 74.5k| for (auto ptr : *(((*yyvaluep).table_element_vec))) { ------------------ | Branch (2217:23): [True: 74.5k, False: 554] ------------------ 2218| 74.5k| delete ptr; 2219| 74.5k| } 2220| 554| } 2221| 554| delete (((*yyvaluep).table_element_vec)); 2222| 554| } 2223| 554|#line 2224 "bison_parser.cpp" 2224| 554| break; 2225| | 2226| 0| case YYSYMBOL_table_elem: /* table_elem */ ------------------ | Branch (2226:5): [True: 0, False: 52.5k] ------------------ 2227| 0|#line 190 "bison_parser.y" 2228| 0| { delete (((*yyvaluep).table_element_t)); } 2229| 0|#line 2230 "bison_parser.cpp" 2230| 0| break; 2231| | 2232| 0| case YYSYMBOL_column_def: /* column_def */ ------------------ | Branch (2232:5): [True: 0, False: 52.5k] ------------------ 2233| 0|#line 190 "bison_parser.y" 2234| 0| { delete (((*yyvaluep).column_t)); } 2235| 0|#line 2236 "bison_parser.cpp" 2236| 0| break; 2237| | 2238| 14| case YYSYMBOL_column_type: /* column_type */ ------------------ | Branch (2238:5): [True: 14, False: 52.4k] ------------------ 2239| 14|#line 168 "bison_parser.y" 2240| 14| { } 2241| 14|#line 2242 "bison_parser.cpp" 2242| 14| break; 2243| | 2244| 0| case YYSYMBOL_opt_time_precision: /* opt_time_precision */ ------------------ | Branch (2244:5): [True: 0, False: 52.5k] ------------------ 2245| 0|#line 168 "bison_parser.y" 2246| 0| { } 2247| 0|#line 2248 "bison_parser.cpp" 2248| 0| break; 2249| | 2250| 0| case YYSYMBOL_opt_decimal_specification: /* opt_decimal_specification */ ------------------ | Branch (2250:5): [True: 0, False: 52.5k] ------------------ 2251| 0|#line 190 "bison_parser.y" 2252| 0| { delete (((*yyvaluep).ival_pair)); } 2253| 0|#line 2254 "bison_parser.cpp" 2254| 0| break; 2255| | 2256| 0| case YYSYMBOL_opt_column_constraints: /* opt_column_constraints */ ------------------ | Branch (2256:5): [True: 0, False: 52.5k] ------------------ 2257| 0|#line 168 "bison_parser.y" 2258| 0| { } 2259| 0|#line 2260 "bison_parser.cpp" 2260| 0| break; 2261| | 2262| 9| case YYSYMBOL_column_constraint_set: /* column_constraint_set */ ------------------ | Branch (2262:5): [True: 9, False: 52.5k] ------------------ 2263| 9|#line 168 "bison_parser.y" 2264| 9| { } 2265| 9|#line 2266 "bison_parser.cpp" 2266| 9| break; 2267| | 2268| 0| case YYSYMBOL_column_constraint: /* column_constraint */ ------------------ | Branch (2268:5): [True: 0, False: 52.5k] ------------------ 2269| 0|#line 168 "bison_parser.y" 2270| 0| { } 2271| 0|#line 2272 "bison_parser.cpp" 2272| 0| break; 2273| | 2274| 0| case YYSYMBOL_table_constraint: /* table_constraint */ ------------------ | Branch (2274:5): [True: 0, False: 52.5k] ------------------ 2275| 0|#line 190 "bison_parser.y" 2276| 0| { delete (((*yyvaluep).table_constraint_t)); } 2277| 0|#line 2278 "bison_parser.cpp" 2278| 0| break; 2279| | 2280| 0| case YYSYMBOL_drop_statement: /* drop_statement */ ------------------ | Branch (2280:5): [True: 0, False: 52.5k] ------------------ 2281| 0|#line 190 "bison_parser.y" 2282| 0| { delete (((*yyvaluep).drop_stmt)); } 2283| 0|#line 2284 "bison_parser.cpp" 2284| 0| break; 2285| | 2286| 29| case YYSYMBOL_opt_exists: /* opt_exists */ ------------------ | Branch (2286:5): [True: 29, False: 52.4k] ------------------ 2287| 29|#line 168 "bison_parser.y" 2288| 29| { } 2289| 29|#line 2290 "bison_parser.cpp" 2290| 29| break; 2291| | 2292| 0| case YYSYMBOL_alter_statement: /* alter_statement */ ------------------ | Branch (2292:5): [True: 0, False: 52.5k] ------------------ 2293| 0|#line 190 "bison_parser.y" 2294| 0| { delete (((*yyvaluep).alter_stmt)); } 2295| 0|#line 2296 "bison_parser.cpp" 2296| 0| break; 2297| | 2298| 0| case YYSYMBOL_alter_action: /* alter_action */ ------------------ | Branch (2298:5): [True: 0, False: 52.5k] ------------------ 2299| 0|#line 190 "bison_parser.y" 2300| 0| { delete (((*yyvaluep).alter_action_t)); } 2301| 0|#line 2302 "bison_parser.cpp" 2302| 0| break; 2303| | 2304| 0| case YYSYMBOL_drop_action: /* drop_action */ ------------------ | Branch (2304:5): [True: 0, False: 52.5k] ------------------ 2305| 0|#line 190 "bison_parser.y" 2306| 0| { delete (((*yyvaluep).drop_action_t)); } 2307| 0|#line 2308 "bison_parser.cpp" 2308| 0| break; 2309| | 2310| 0| case YYSYMBOL_delete_statement: /* delete_statement */ ------------------ | Branch (2310:5): [True: 0, False: 52.5k] ------------------ 2311| 0|#line 190 "bison_parser.y" 2312| 0| { delete (((*yyvaluep).delete_stmt)); } 2313| 0|#line 2314 "bison_parser.cpp" 2314| 0| break; 2315| | 2316| 0| case YYSYMBOL_truncate_statement: /* truncate_statement */ ------------------ | Branch (2316:5): [True: 0, False: 52.5k] ------------------ 2317| 0|#line 190 "bison_parser.y" 2318| 0| { delete (((*yyvaluep).delete_stmt)); } 2319| 0|#line 2320 "bison_parser.cpp" 2320| 0| break; 2321| | 2322| 0| case YYSYMBOL_insert_statement: /* insert_statement */ ------------------ | Branch (2322:5): [True: 0, False: 52.5k] ------------------ 2323| 0|#line 190 "bison_parser.y" 2324| 0| { delete (((*yyvaluep).insert_stmt)); } 2325| 0|#line 2326 "bison_parser.cpp" 2326| 0| break; 2327| | 2328| 42| case YYSYMBOL_opt_column_list: /* opt_column_list */ ------------------ | Branch (2328:5): [True: 42, False: 52.4k] ------------------ 2329| 42|#line 173 "bison_parser.y" 2330| 42| { 2331| 42| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2331:11): [True: 17, False: 25] ------------------ 2332| 469| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2332:23): [True: 469, False: 17] ------------------ 2333| 469| free(ptr); 2334| 469| } 2335| 17| } 2336| 42| delete (((*yyvaluep).str_vec)); 2337| 42| } 2338| 42|#line 2339 "bison_parser.cpp" 2339| 42| break; 2340| | 2341| 0| case YYSYMBOL_update_statement: /* update_statement */ ------------------ | Branch (2341:5): [True: 0, False: 52.5k] ------------------ 2342| 0|#line 190 "bison_parser.y" 2343| 0| { delete (((*yyvaluep).update_stmt)); } 2344| 0|#line 2345 "bison_parser.cpp" 2345| 0| break; 2346| | 2347| 27| case YYSYMBOL_update_clause_commalist: /* update_clause_commalist */ ------------------ | Branch (2347:5): [True: 27, False: 52.4k] ------------------ 2348| 27|#line 182 "bison_parser.y" 2349| 27| { 2350| 27| if (((*yyvaluep).update_vec)) { ------------------ | Branch (2350:11): [True: 27, False: 0] ------------------ 2351| 78.2k| for (auto ptr : *(((*yyvaluep).update_vec))) { ------------------ | Branch (2351:23): [True: 78.2k, False: 27] ------------------ 2352| 78.2k| delete ptr; 2353| 78.2k| } 2354| 27| } 2355| 27| delete (((*yyvaluep).update_vec)); 2356| 27| } 2357| 27|#line 2358 "bison_parser.cpp" 2358| 27| break; 2359| | 2360| 0| case YYSYMBOL_update_clause: /* update_clause */ ------------------ | Branch (2360:5): [True: 0, False: 52.5k] ------------------ 2361| 0|#line 190 "bison_parser.y" 2362| 0| { delete (((*yyvaluep).update_t)); } 2363| 0|#line 2364 "bison_parser.cpp" 2364| 0| break; 2365| | 2366| 3| case YYSYMBOL_select_statement: /* select_statement */ ------------------ | Branch (2366:5): [True: 3, False: 52.5k] ------------------ 2367| 3|#line 190 "bison_parser.y" 2368| 3| { delete (((*yyvaluep).select_stmt)); } 2369| 3|#line 2370 "bison_parser.cpp" 2370| 3| break; 2371| | 2372| 39| case YYSYMBOL_select_within_set_operation: /* select_within_set_operation */ ------------------ | Branch (2372:5): [True: 39, False: 52.4k] ------------------ 2373| 39|#line 190 "bison_parser.y" 2374| 39| { delete (((*yyvaluep).select_stmt)); } 2375| 39|#line 2376 "bison_parser.cpp" 2376| 39| break; 2377| | 2378| 0| case YYSYMBOL_select_within_set_operation_no_parentheses: /* select_within_set_operation_no_parentheses */ ------------------ | Branch (2378:5): [True: 0, False: 52.5k] ------------------ 2379| 0|#line 190 "bison_parser.y" 2380| 0| { delete (((*yyvaluep).select_stmt)); } 2381| 0|#line 2382 "bison_parser.cpp" 2382| 0| break; 2383| | 2384| 44| case YYSYMBOL_select_with_paren: /* select_with_paren */ ------------------ | Branch (2384:5): [True: 44, False: 52.4k] ------------------ 2385| 44|#line 190 "bison_parser.y" 2386| 44| { delete (((*yyvaluep).select_stmt)); } 2387| 44|#line 2388 "bison_parser.cpp" 2388| 44| break; 2389| | 2390| 131| case YYSYMBOL_select_no_paren: /* select_no_paren */ ------------------ | Branch (2390:5): [True: 131, False: 52.3k] ------------------ 2391| 131|#line 190 "bison_parser.y" 2392| 131| { delete (((*yyvaluep).select_stmt)); } 2393| 131|#line 2394 "bison_parser.cpp" 2394| 131| break; 2395| | 2396| 847| case YYSYMBOL_set_operator: /* set_operator */ ------------------ | Branch (2396:5): [True: 847, False: 51.6k] ------------------ 2397| 847|#line 190 "bison_parser.y" 2398| 847| { delete (((*yyvaluep).set_operator_t)); } 2399| 847|#line 2400 "bison_parser.cpp" 2400| 847| break; 2401| | 2402| 0| case YYSYMBOL_set_type: /* set_type */ ------------------ | Branch (2402:5): [True: 0, False: 52.5k] ------------------ 2403| 0|#line 190 "bison_parser.y" 2404| 0| { delete (((*yyvaluep).set_operator_t)); } 2405| 0|#line 2406 "bison_parser.cpp" 2406| 0| break; 2407| | 2408| 0| case YYSYMBOL_opt_all: /* opt_all */ ------------------ | Branch (2408:5): [True: 0, False: 52.5k] ------------------ 2409| 0|#line 168 "bison_parser.y" 2410| 0| { } 2411| 0|#line 2412 "bison_parser.cpp" 2412| 0| break; 2413| | 2414| 1.33k| case YYSYMBOL_select_clause: /* select_clause */ ------------------ | Branch (2414:5): [True: 1.33k, False: 51.1k] ------------------ 2415| 1.33k|#line 190 "bison_parser.y" 2416| 1.33k| { delete (((*yyvaluep).select_stmt)); } 2417| 1.33k|#line 2418 "bison_parser.cpp" 2418| 1.33k| break; 2419| | 2420| 3.34k| case YYSYMBOL_opt_distinct: /* opt_distinct */ ------------------ | Branch (2420:5): [True: 3.34k, False: 49.1k] ------------------ 2421| 3.34k|#line 168 "bison_parser.y" 2422| 3.34k| { } 2423| 3.34k|#line 2424 "bison_parser.cpp" 2424| 3.34k| break; 2425| | 2426| 657| case YYSYMBOL_select_list: /* select_list */ ------------------ | Branch (2426:5): [True: 657, False: 51.8k] ------------------ 2427| 657|#line 182 "bison_parser.y" 2428| 657| { 2429| 657| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2429:11): [True: 657, False: 0] ------------------ 2430| 909| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2430:23): [True: 909, False: 657] ------------------ 2431| 909| delete ptr; 2432| 909| } 2433| 657| } 2434| 657| delete (((*yyvaluep).expr_vec)); 2435| 657| } 2436| 657|#line 2437 "bison_parser.cpp" 2437| 657| break; 2438| | 2439| 177| case YYSYMBOL_opt_from_clause: /* opt_from_clause */ ------------------ | Branch (2439:5): [True: 177, False: 52.3k] ------------------ 2440| 177|#line 190 "bison_parser.y" 2441| 177| { delete (((*yyvaluep).table)); } 2442| 177|#line 2443 "bison_parser.cpp" 2443| 177| break; 2444| | 2445| 0| case YYSYMBOL_from_clause: /* from_clause */ ------------------ | Branch (2445:5): [True: 0, False: 52.5k] ------------------ 2446| 0|#line 190 "bison_parser.y" 2447| 0| { delete (((*yyvaluep).table)); } 2448| 0|#line 2449 "bison_parser.cpp" 2449| 0| break; 2450| | 2451| 89| case YYSYMBOL_opt_where: /* opt_where */ ------------------ | Branch (2451:5): [True: 89, False: 52.4k] ------------------ 2452| 89|#line 190 "bison_parser.y" 2453| 89| { delete (((*yyvaluep).expr)); } 2454| 89|#line 2455 "bison_parser.cpp" 2455| 89| break; 2456| | 2457| 1| case YYSYMBOL_opt_group: /* opt_group */ ------------------ | Branch (2457:5): [True: 1, False: 52.5k] ------------------ 2458| 1|#line 190 "bison_parser.y" 2459| 1| { delete (((*yyvaluep).group_t)); } 2460| 1|#line 2461 "bison_parser.cpp" 2461| 1| break; 2462| | 2463| 0| case YYSYMBOL_opt_having: /* opt_having */ ------------------ | Branch (2463:5): [True: 0, False: 52.5k] ------------------ 2464| 0|#line 190 "bison_parser.y" 2465| 0| { delete (((*yyvaluep).expr)); } 2466| 0|#line 2467 "bison_parser.cpp" 2467| 0| break; 2468| | 2469| 397| case YYSYMBOL_opt_order: /* opt_order */ ------------------ | Branch (2469:5): [True: 397, False: 52.1k] ------------------ 2470| 397|#line 182 "bison_parser.y" 2471| 397| { 2472| 397| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2472:11): [True: 85, False: 312] ------------------ 2473| 6.93k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2473:23): [True: 6.93k, False: 85] ------------------ 2474| 6.93k| delete ptr; 2475| 6.93k| } 2476| 85| } 2477| 397| delete (((*yyvaluep).order_vec)); 2478| 397| } 2479| 397|#line 2480 "bison_parser.cpp" 2480| 397| break; 2481| | 2482| 134| case YYSYMBOL_order_list: /* order_list */ ------------------ | Branch (2482:5): [True: 134, False: 52.3k] ------------------ 2483| 134|#line 182 "bison_parser.y" 2484| 134| { 2485| 134| if (((*yyvaluep).order_vec)) { ------------------ | Branch (2485:11): [True: 134, False: 0] ------------------ 2486| 58.5k| for (auto ptr : *(((*yyvaluep).order_vec))) { ------------------ | Branch (2486:23): [True: 58.5k, False: 134] ------------------ 2487| 58.5k| delete ptr; 2488| 58.5k| } 2489| 134| } 2490| 134| delete (((*yyvaluep).order_vec)); 2491| 134| } 2492| 134|#line 2493 "bison_parser.cpp" 2493| 134| break; 2494| | 2495| 0| case YYSYMBOL_order_desc: /* order_desc */ ------------------ | Branch (2495:5): [True: 0, False: 52.5k] ------------------ 2496| 0|#line 190 "bison_parser.y" 2497| 0| { delete (((*yyvaluep).order)); } 2498| 0|#line 2499 "bison_parser.cpp" 2499| 0| break; 2500| | 2501| 1| case YYSYMBOL_opt_order_type: /* opt_order_type */ ------------------ | Branch (2501:5): [True: 1, False: 52.5k] ------------------ 2502| 1|#line 168 "bison_parser.y" 2503| 1| { } 2504| 1|#line 2505 "bison_parser.cpp" 2505| 1| break; 2506| | 2507| 2.21k| case YYSYMBOL_opt_top: /* opt_top */ ------------------ | Branch (2507:5): [True: 2.21k, False: 50.3k] ------------------ 2508| 2.21k|#line 190 "bison_parser.y" 2509| 2.21k| { delete (((*yyvaluep).limit)); } 2510| 2.21k|#line 2511 "bison_parser.cpp" 2511| 2.21k| break; 2512| | 2513| 49| case YYSYMBOL_opt_limit: /* opt_limit */ ------------------ | Branch (2513:5): [True: 49, False: 52.4k] ------------------ 2514| 49|#line 190 "bison_parser.y" 2515| 49| { delete (((*yyvaluep).limit)); } 2516| 49|#line 2517 "bison_parser.cpp" 2517| 49| break; 2518| | 2519| 542| case YYSYMBOL_expr_list: /* expr_list */ ------------------ | Branch (2519:5): [True: 542, False: 51.9k] ------------------ 2520| 542|#line 182 "bison_parser.y" 2521| 542| { 2522| 542| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2522:11): [True: 542, False: 0] ------------------ 2523| 72.1k| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2523:23): [True: 72.1k, False: 542] ------------------ 2524| 72.1k| delete ptr; 2525| 72.1k| } 2526| 542| } 2527| 542| delete (((*yyvaluep).expr_vec)); 2528| 542| } 2529| 542|#line 2530 "bison_parser.cpp" 2530| 542| break; 2531| | 2532| 28| case YYSYMBOL_opt_literal_list: /* opt_literal_list */ ------------------ | Branch (2532:5): [True: 28, False: 52.4k] ------------------ 2533| 28|#line 182 "bison_parser.y" 2534| 28| { 2535| 28| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2535:11): [True: 24, False: 4] ------------------ 2536| 602| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2536:23): [True: 602, False: 24] ------------------ 2537| 602| delete ptr; 2538| 602| } 2539| 24| } 2540| 28| delete (((*yyvaluep).expr_vec)); 2541| 28| } 2542| 28|#line 2543 "bison_parser.cpp" 2543| 28| break; 2544| | 2545| 18| case YYSYMBOL_literal_list: /* literal_list */ ------------------ | Branch (2545:5): [True: 18, False: 52.4k] ------------------ 2546| 18|#line 182 "bison_parser.y" 2547| 18| { 2548| 18| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2548:11): [True: 18, False: 0] ------------------ 2549| 260| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2549:23): [True: 260, False: 18] ------------------ 2550| 260| delete ptr; 2551| 260| } 2552| 18| } 2553| 18| delete (((*yyvaluep).expr_vec)); 2554| 18| } 2555| 18|#line 2556 "bison_parser.cpp" 2556| 18| break; 2557| | 2558| 0| case YYSYMBOL_expr_alias: /* expr_alias */ ------------------ | Branch (2558:5): [True: 0, False: 52.5k] ------------------ 2559| 0|#line 190 "bison_parser.y" 2560| 0| { delete (((*yyvaluep).expr)); } 2561| 0|#line 2562 "bison_parser.cpp" 2562| 0| break; 2563| | 2564| 220| case YYSYMBOL_expr: /* expr */ ------------------ | Branch (2564:5): [True: 220, False: 52.2k] ------------------ 2565| 220|#line 190 "bison_parser.y" 2566| 220| { delete (((*yyvaluep).expr)); } 2567| 220|#line 2568 "bison_parser.cpp" 2568| 220| break; 2569| | 2570| 1.83k| case YYSYMBOL_operand: /* operand */ ------------------ | Branch (2570:5): [True: 1.83k, False: 50.6k] ------------------ 2571| 1.83k|#line 190 "bison_parser.y" 2572| 1.83k| { delete (((*yyvaluep).expr)); } 2573| 1.83k|#line 2574 "bison_parser.cpp" 2574| 1.83k| break; 2575| | 2576| 0| case YYSYMBOL_scalar_expr: /* scalar_expr */ ------------------ | Branch (2576:5): [True: 0, False: 52.5k] ------------------ 2577| 0|#line 190 "bison_parser.y" 2578| 0| { delete (((*yyvaluep).expr)); } 2579| 0|#line 2580 "bison_parser.cpp" 2580| 0| break; 2581| | 2582| 0| case YYSYMBOL_unary_expr: /* unary_expr */ ------------------ | Branch (2582:5): [True: 0, False: 52.5k] ------------------ 2583| 0|#line 190 "bison_parser.y" 2584| 0| { delete (((*yyvaluep).expr)); } 2585| 0|#line 2586 "bison_parser.cpp" 2586| 0| break; 2587| | 2588| 0| case YYSYMBOL_binary_expr: /* binary_expr */ ------------------ | Branch (2588:5): [True: 0, False: 52.5k] ------------------ 2589| 0|#line 190 "bison_parser.y" 2590| 0| { delete (((*yyvaluep).expr)); } 2591| 0|#line 2592 "bison_parser.cpp" 2592| 0| break; 2593| | 2594| 0| case YYSYMBOL_logic_expr: /* logic_expr */ ------------------ | Branch (2594:5): [True: 0, False: 52.5k] ------------------ 2595| 0|#line 190 "bison_parser.y" 2596| 0| { delete (((*yyvaluep).expr)); } 2597| 0|#line 2598 "bison_parser.cpp" 2598| 0| break; 2599| | 2600| 0| case YYSYMBOL_in_expr: /* in_expr */ ------------------ | Branch (2600:5): [True: 0, False: 52.5k] ------------------ 2601| 0|#line 190 "bison_parser.y" 2602| 0| { delete (((*yyvaluep).expr)); } 2603| 0|#line 2604 "bison_parser.cpp" 2604| 0| break; 2605| | 2606| 0| case YYSYMBOL_case_expr: /* case_expr */ ------------------ | Branch (2606:5): [True: 0, False: 52.5k] ------------------ 2607| 0|#line 190 "bison_parser.y" 2608| 0| { delete (((*yyvaluep).expr)); } 2609| 0|#line 2610 "bison_parser.cpp" 2610| 0| break; 2611| | 2612| 231| case YYSYMBOL_case_list: /* case_list */ ------------------ | Branch (2612:5): [True: 231, False: 52.2k] ------------------ 2613| 231|#line 190 "bison_parser.y" 2614| 231| { delete (((*yyvaluep).expr)); } 2615| 231|#line 2616 "bison_parser.cpp" 2616| 231| break; 2617| | 2618| 0| case YYSYMBOL_exists_expr: /* exists_expr */ ------------------ | Branch (2618:5): [True: 0, False: 52.5k] ------------------ 2619| 0|#line 190 "bison_parser.y" 2620| 0| { delete (((*yyvaluep).expr)); } 2621| 0|#line 2622 "bison_parser.cpp" 2622| 0| break; 2623| | 2624| 0| case YYSYMBOL_comp_expr: /* comp_expr */ ------------------ | Branch (2624:5): [True: 0, False: 52.5k] ------------------ 2625| 0|#line 190 "bison_parser.y" 2626| 0| { delete (((*yyvaluep).expr)); } 2627| 0|#line 2628 "bison_parser.cpp" 2628| 0| break; 2629| | 2630| 0| case YYSYMBOL_function_expr: /* function_expr */ ------------------ | Branch (2630:5): [True: 0, False: 52.5k] ------------------ 2631| 0|#line 190 "bison_parser.y" 2632| 0| { delete (((*yyvaluep).expr)); } 2633| 0|#line 2634 "bison_parser.cpp" 2634| 0| break; 2635| | 2636| 2| case YYSYMBOL_opt_window: /* opt_window */ ------------------ | Branch (2636:5): [True: 2, False: 52.5k] ------------------ 2637| 2|#line 190 "bison_parser.y" 2638| 2| { delete (((*yyvaluep).window_description)); } 2639| 2|#line 2640 "bison_parser.cpp" 2640| 2| break; 2641| | 2642| 85| case YYSYMBOL_opt_partition: /* opt_partition */ ------------------ | Branch (2642:5): [True: 85, False: 52.4k] ------------------ 2643| 85|#line 182 "bison_parser.y" 2644| 85| { 2645| 85| if (((*yyvaluep).expr_vec)) { ------------------ | Branch (2645:11): [True: 0, False: 85] ------------------ 2646| 0| for (auto ptr : *(((*yyvaluep).expr_vec))) { ------------------ | Branch (2646:23): [True: 0, False: 0] ------------------ 2647| 0| delete ptr; 2648| 0| } 2649| 0| } 2650| 85| delete (((*yyvaluep).expr_vec)); 2651| 85| } 2652| 85|#line 2653 "bison_parser.cpp" 2653| 85| break; 2654| | 2655| 21| case YYSYMBOL_opt_frame_clause: /* opt_frame_clause */ ------------------ | Branch (2655:5): [True: 21, False: 52.4k] ------------------ 2656| 21|#line 190 "bison_parser.y" 2657| 21| { delete (((*yyvaluep).frame_description)); } 2658| 21|#line 2659 "bison_parser.cpp" 2659| 21| break; 2660| | 2661| 6| case YYSYMBOL_frame_type: /* frame_type */ ------------------ | Branch (2661:5): [True: 6, False: 52.5k] ------------------ 2662| 6|#line 168 "bison_parser.y" 2663| 6| { } 2664| 6|#line 2665 "bison_parser.cpp" 2665| 6| break; 2666| | 2667| 0| case YYSYMBOL_frame_bound: /* frame_bound */ ------------------ | Branch (2667:5): [True: 0, False: 52.5k] ------------------ 2668| 0|#line 190 "bison_parser.y" 2669| 0| { delete (((*yyvaluep).frame_bound)); } 2670| 0|#line 2671 "bison_parser.cpp" 2671| 0| break; 2672| | 2673| 0| case YYSYMBOL_extract_expr: /* extract_expr */ ------------------ | Branch (2673:5): [True: 0, False: 52.5k] ------------------ 2674| 0|#line 190 "bison_parser.y" 2675| 0| { delete (((*yyvaluep).expr)); } 2676| 0|#line 2677 "bison_parser.cpp" 2677| 0| break; 2678| | 2679| 0| case YYSYMBOL_cast_expr: /* cast_expr */ ------------------ | Branch (2679:5): [True: 0, False: 52.5k] ------------------ 2680| 0|#line 190 "bison_parser.y" 2681| 0| { delete (((*yyvaluep).expr)); } 2682| 0|#line 2683 "bison_parser.cpp" 2683| 0| break; 2684| | 2685| 214| case YYSYMBOL_datetime_field: /* datetime_field */ ------------------ | Branch (2685:5): [True: 214, False: 52.2k] ------------------ 2686| 214|#line 168 "bison_parser.y" 2687| 214| { } 2688| 214|#line 2689 "bison_parser.cpp" 2689| 214| break; 2690| | 2691| 0| case YYSYMBOL_datetime_field_plural: /* datetime_field_plural */ ------------------ | Branch (2691:5): [True: 0, False: 52.5k] ------------------ 2692| 0|#line 168 "bison_parser.y" 2693| 0| { } 2694| 0|#line 2695 "bison_parser.cpp" 2695| 0| break; 2696| | 2697| 0| case YYSYMBOL_duration_field: /* duration_field */ ------------------ | Branch (2697:5): [True: 0, False: 52.5k] ------------------ 2698| 0|#line 168 "bison_parser.y" 2699| 0| { } 2700| 0|#line 2701 "bison_parser.cpp" 2701| 0| break; 2702| | 2703| 0| case YYSYMBOL_array_expr: /* array_expr */ ------------------ | Branch (2703:5): [True: 0, False: 52.5k] ------------------ 2704| 0|#line 190 "bison_parser.y" 2705| 0| { delete (((*yyvaluep).expr)); } 2706| 0|#line 2707 "bison_parser.cpp" 2707| 0| break; 2708| | 2709| 0| case YYSYMBOL_array_index: /* array_index */ ------------------ | Branch (2709:5): [True: 0, False: 52.5k] ------------------ 2710| 0|#line 190 "bison_parser.y" 2711| 0| { delete (((*yyvaluep).expr)); } 2712| 0|#line 2713 "bison_parser.cpp" 2713| 0| break; 2714| | 2715| 0| case YYSYMBOL_between_expr: /* between_expr */ ------------------ | Branch (2715:5): [True: 0, False: 52.5k] ------------------ 2716| 0|#line 190 "bison_parser.y" 2717| 0| { delete (((*yyvaluep).expr)); } 2718| 0|#line 2719 "bison_parser.cpp" 2719| 0| break; 2720| | 2721| 1| case YYSYMBOL_column_name: /* column_name */ ------------------ | Branch (2721:5): [True: 1, False: 52.5k] ------------------ 2722| 1|#line 190 "bison_parser.y" 2723| 1| { delete (((*yyvaluep).expr)); } 2724| 1|#line 2725 "bison_parser.cpp" 2725| 1| break; 2726| | 2727| 0| case YYSYMBOL_literal: /* literal */ ------------------ | Branch (2727:5): [True: 0, False: 52.5k] ------------------ 2728| 0|#line 190 "bison_parser.y" 2729| 0| { delete (((*yyvaluep).expr)); } 2730| 0|#line 2731 "bison_parser.cpp" 2731| 0| break; 2732| | 2733| 0| case YYSYMBOL_string_literal: /* string_literal */ ------------------ | Branch (2733:5): [True: 0, False: 52.5k] ------------------ 2734| 0|#line 190 "bison_parser.y" 2735| 0| { delete (((*yyvaluep).expr)); } 2736| 0|#line 2737 "bison_parser.cpp" 2737| 0| break; 2738| | 2739| 0| case YYSYMBOL_bool_literal: /* bool_literal */ ------------------ | Branch (2739:5): [True: 0, False: 52.5k] ------------------ 2740| 0|#line 190 "bison_parser.y" 2741| 0| { delete (((*yyvaluep).expr)); } 2742| 0|#line 2743 "bison_parser.cpp" 2743| 0| break; 2744| | 2745| 0| case YYSYMBOL_num_literal: /* num_literal */ ------------------ | Branch (2745:5): [True: 0, False: 52.5k] ------------------ 2746| 0|#line 190 "bison_parser.y" 2747| 0| { delete (((*yyvaluep).expr)); } 2748| 0|#line 2749 "bison_parser.cpp" 2749| 0| break; 2750| | 2751| 3| case YYSYMBOL_int_literal: /* int_literal */ ------------------ | Branch (2751:5): [True: 3, False: 52.5k] ------------------ 2752| 3|#line 190 "bison_parser.y" 2753| 3| { delete (((*yyvaluep).expr)); } 2754| 3|#line 2755 "bison_parser.cpp" 2755| 3| break; 2756| | 2757| 0| case YYSYMBOL_null_literal: /* null_literal */ ------------------ | Branch (2757:5): [True: 0, False: 52.5k] ------------------ 2758| 0|#line 190 "bison_parser.y" 2759| 0| { delete (((*yyvaluep).expr)); } 2760| 0|#line 2761 "bison_parser.cpp" 2761| 0| break; 2762| | 2763| 0| case YYSYMBOL_date_literal: /* date_literal */ ------------------ | Branch (2763:5): [True: 0, False: 52.5k] ------------------ 2764| 0|#line 190 "bison_parser.y" 2765| 0| { delete (((*yyvaluep).expr)); } 2766| 0|#line 2767 "bison_parser.cpp" 2767| 0| break; 2768| | 2769| 0| case YYSYMBOL_interval_literal: /* interval_literal */ ------------------ | Branch (2769:5): [True: 0, False: 52.5k] ------------------ 2770| 0|#line 190 "bison_parser.y" 2771| 0| { delete (((*yyvaluep).expr)); } 2772| 0|#line 2773 "bison_parser.cpp" 2773| 0| break; 2774| | 2775| 0| case YYSYMBOL_param_expr: /* param_expr */ ------------------ | Branch (2775:5): [True: 0, False: 52.5k] ------------------ 2776| 0|#line 190 "bison_parser.y" 2777| 0| { delete (((*yyvaluep).expr)); } 2778| 0|#line 2779 "bison_parser.cpp" 2779| 0| break; 2780| | 2781| 0| case YYSYMBOL_table_ref: /* table_ref */ ------------------ | Branch (2781:5): [True: 0, False: 52.5k] ------------------ 2782| 0|#line 190 "bison_parser.y" 2783| 0| { delete (((*yyvaluep).table)); } 2784| 0|#line 2785 "bison_parser.cpp" 2785| 0| break; 2786| | 2787| 2.26k| case YYSYMBOL_table_ref_atomic: /* table_ref_atomic */ ------------------ | Branch (2787:5): [True: 2.26k, False: 50.2k] ------------------ 2788| 2.26k|#line 190 "bison_parser.y" 2789| 2.26k| { delete (((*yyvaluep).table)); } 2790| 2.26k|#line 2791 "bison_parser.cpp" 2791| 2.26k| break; 2792| | 2793| 0| case YYSYMBOL_nonjoin_table_ref_atomic: /* nonjoin_table_ref_atomic */ ------------------ | Branch (2793:5): [True: 0, False: 52.5k] ------------------ 2794| 0|#line 190 "bison_parser.y" 2795| 0| { delete (((*yyvaluep).table)); } 2796| 0|#line 2797 "bison_parser.cpp" 2797| 0| break; 2798| | 2799| 109| case YYSYMBOL_table_ref_commalist: /* table_ref_commalist */ ------------------ | Branch (2799:5): [True: 109, False: 52.4k] ------------------ 2800| 109|#line 182 "bison_parser.y" 2801| 109| { 2802| 109| if (((*yyvaluep).table_vec)) { ------------------ | Branch (2802:11): [True: 109, False: 0] ------------------ 2803| 32.6k| for (auto ptr : *(((*yyvaluep).table_vec))) { ------------------ | Branch (2803:23): [True: 32.6k, False: 109] ------------------ 2804| 32.6k| delete ptr; 2805| 32.6k| } 2806| 109| } 2807| 109| delete (((*yyvaluep).table_vec)); 2808| 109| } 2809| 109|#line 2810 "bison_parser.cpp" 2810| 109| break; 2811| | 2812| 0| case YYSYMBOL_table_ref_name: /* table_ref_name */ ------------------ | Branch (2812:5): [True: 0, False: 52.5k] ------------------ 2813| 0|#line 190 "bison_parser.y" 2814| 0| { delete (((*yyvaluep).table)); } 2815| 0|#line 2816 "bison_parser.cpp" 2816| 0| break; 2817| | 2818| 44| case YYSYMBOL_table_ref_name_no_alias: /* table_ref_name_no_alias */ ------------------ | Branch (2818:5): [True: 44, False: 52.4k] ------------------ 2819| 44|#line 190 "bison_parser.y" 2820| 44| { delete (((*yyvaluep).table)); } 2821| 44|#line 2822 "bison_parser.cpp" 2822| 44| break; 2823| | 2824| 669| case YYSYMBOL_table_name: /* table_name */ ------------------ | Branch (2824:5): [True: 669, False: 51.8k] ------------------ 2825| 669|#line 169 "bison_parser.y" 2826| 669| { 2827| 669| free( (((*yyvaluep).table_name).name) ); 2828| 669| free( (((*yyvaluep).table_name).schema) ); 2829| 669| } 2830| 669|#line 2831 "bison_parser.cpp" 2831| 669| break; 2832| | 2833| 15| case YYSYMBOL_opt_index_name: /* opt_index_name */ ------------------ | Branch (2833:5): [True: 15, False: 52.4k] ------------------ 2834| 15|#line 181 "bison_parser.y" 2835| 15| { free( (((*yyvaluep).sval)) ); } 2836| 15|#line 2837 "bison_parser.cpp" 2837| 15| break; 2838| | 2839| 0| case YYSYMBOL_table_alias: /* table_alias */ ------------------ | Branch (2839:5): [True: 0, False: 52.5k] ------------------ 2840| 0|#line 190 "bison_parser.y" 2841| 0| { delete (((*yyvaluep).alias_t)); } 2842| 0|#line 2843 "bison_parser.cpp" 2843| 0| break; 2844| | 2845| 2| case YYSYMBOL_opt_table_alias: /* opt_table_alias */ ------------------ | Branch (2845:5): [True: 2, False: 52.5k] ------------------ 2846| 2|#line 190 "bison_parser.y" 2847| 2| { delete (((*yyvaluep).alias_t)); } 2848| 2|#line 2849 "bison_parser.cpp" 2849| 2| break; 2850| | 2851| 0| case YYSYMBOL_alias: /* alias */ ------------------ | Branch (2851:5): [True: 0, False: 52.5k] ------------------ 2852| 0|#line 190 "bison_parser.y" 2853| 0| { delete (((*yyvaluep).alias_t)); } 2854| 0|#line 2855 "bison_parser.cpp" 2855| 0| break; 2856| | 2857| 1| case YYSYMBOL_opt_alias: /* opt_alias */ ------------------ | Branch (2857:5): [True: 1, False: 52.5k] ------------------ 2858| 1|#line 190 "bison_parser.y" 2859| 1| { delete (((*yyvaluep).alias_t)); } 2860| 1|#line 2861 "bison_parser.cpp" 2861| 1| break; 2862| | 2863| 0| case YYSYMBOL_opt_locking_clause: /* opt_locking_clause */ ------------------ | Branch (2863:5): [True: 0, False: 52.5k] ------------------ 2864| 0|#line 190 "bison_parser.y" 2865| 0| { delete (((*yyvaluep).locking_clause_vec)); } 2866| 0|#line 2867 "bison_parser.cpp" 2867| 0| break; 2868| | 2869| 26| case YYSYMBOL_opt_locking_clause_list: /* opt_locking_clause_list */ ------------------ | Branch (2869:5): [True: 26, False: 52.4k] ------------------ 2870| 26|#line 190 "bison_parser.y" 2871| 26| { delete (((*yyvaluep).locking_clause_vec)); } 2872| 26|#line 2873 "bison_parser.cpp" 2873| 26| break; 2874| | 2875| 0| case YYSYMBOL_locking_clause: /* locking_clause */ ------------------ | Branch (2875:5): [True: 0, False: 52.5k] ------------------ 2876| 0|#line 190 "bison_parser.y" 2877| 0| { delete (((*yyvaluep).locking_t)); } 2878| 0|#line 2879 "bison_parser.cpp" 2879| 0| break; 2880| | 2881| 5| case YYSYMBOL_row_lock_mode: /* row_lock_mode */ ------------------ | Branch (2881:5): [True: 5, False: 52.5k] ------------------ 2882| 5|#line 168 "bison_parser.y" 2883| 5| { } 2884| 5|#line 2885 "bison_parser.cpp" 2885| 5| break; 2886| | 2887| 1| case YYSYMBOL_opt_row_lock_policy: /* opt_row_lock_policy */ ------------------ | Branch (2887:5): [True: 1, False: 52.5k] ------------------ 2888| 1|#line 168 "bison_parser.y" 2889| 1| { } 2890| 1|#line 2891 "bison_parser.cpp" 2891| 1| break; 2892| | 2893| 2.62k| case YYSYMBOL_opt_with_clause: /* opt_with_clause */ ------------------ | Branch (2893:5): [True: 2.62k, False: 49.8k] ------------------ 2894| 2.62k|#line 190 "bison_parser.y" 2895| 2.62k| { delete (((*yyvaluep).with_description_vec)); } 2896| 2.62k|#line 2897 "bison_parser.cpp" 2897| 2.62k| break; 2898| | 2899| 0| case YYSYMBOL_with_clause: /* with_clause */ ------------------ | Branch (2899:5): [True: 0, False: 52.5k] ------------------ 2900| 0|#line 190 "bison_parser.y" 2901| 0| { delete (((*yyvaluep).with_description_vec)); } 2902| 0|#line 2903 "bison_parser.cpp" 2903| 0| break; 2904| | 2905| 38| case YYSYMBOL_with_description_list: /* with_description_list */ ------------------ | Branch (2905:5): [True: 38, False: 52.4k] ------------------ 2906| 38|#line 190 "bison_parser.y" 2907| 38| { delete (((*yyvaluep).with_description_vec)); } 2908| 38|#line 2909 "bison_parser.cpp" 2909| 38| break; 2910| | 2911| 0| case YYSYMBOL_with_description: /* with_description */ ------------------ | Branch (2911:5): [True: 0, False: 52.5k] ------------------ 2912| 0|#line 190 "bison_parser.y" 2913| 0| { delete (((*yyvaluep).with_description_t)); } 2914| 0|#line 2915 "bison_parser.cpp" 2915| 0| break; 2916| | 2917| 0| case YYSYMBOL_join_clause: /* join_clause */ ------------------ | Branch (2917:5): [True: 0, False: 52.5k] ------------------ 2918| 0|#line 190 "bison_parser.y" 2919| 0| { delete (((*yyvaluep).table)); } 2920| 0|#line 2921 "bison_parser.cpp" 2921| 0| break; 2922| | 2923| 2.24k| case YYSYMBOL_opt_join_type: /* opt_join_type */ ------------------ | Branch (2923:5): [True: 2.24k, False: 50.2k] ------------------ 2924| 2.24k|#line 168 "bison_parser.y" 2925| 2.24k| { } 2926| 2.24k|#line 2927 "bison_parser.cpp" 2927| 2.24k| break; 2928| | 2929| 0| case YYSYMBOL_join_condition: /* join_condition */ ------------------ | Branch (2929:5): [True: 0, False: 52.5k] ------------------ 2930| 0|#line 190 "bison_parser.y" 2931| 0| { delete (((*yyvaluep).expr)); } 2932| 0|#line 2933 "bison_parser.cpp" 2933| 0| break; 2934| | 2935| 45| case YYSYMBOL_ident_commalist: /* ident_commalist */ ------------------ | Branch (2935:5): [True: 45, False: 52.4k] ------------------ 2936| 45|#line 173 "bison_parser.y" 2937| 45| { 2938| 45| if (((*yyvaluep).str_vec)) { ------------------ | Branch (2938:11): [True: 45, False: 0] ------------------ 2939| 698k| for (auto ptr : *(((*yyvaluep).str_vec))) { ------------------ | Branch (2939:23): [True: 698k, False: 45] ------------------ 2940| 698k| free(ptr); 2941| 698k| } 2942| 45| } 2943| 45| delete (((*yyvaluep).str_vec)); 2944| 45| } 2945| 45|#line 2946 "bison_parser.cpp" 2946| 45| break; 2947| | 2948| 27.6k| default: ------------------ | Branch (2948:7): [True: 27.6k, False: 24.8k] ------------------ 2949| 27.6k| break; 2950| 52.5k| } 2951| 52.5k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2952| 52.5k|} _Z8hsql_lexP10HSQL_STYPEP15HSQL_CUST_LTYPEPv: 3325| 7.45M|{ 3326| 7.45M| yy_state_type yy_current_state; 3327| 7.45M| char *yy_cp, *yy_bp; 3328| 7.45M| int yy_act; 3329| 7.45M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3330| | 3331| 7.45M| yylval = yylval_param; ------------------ | | 3138| 7.45M| # define yylval yyg->yylval_r ------------------ 3332| | 3333| 7.45M| yylloc = yylloc_param; ------------------ | | 3140| 7.45M| # define yylloc yyg->yylloc_r ------------------ 3334| | 3335| 7.45M| if ( !yyg->yy_init ) ------------------ | Branch (3335:7): [True: 5.22k, False: 7.45M] ------------------ 3336| 5.22k| { 3337| 5.22k| yyg->yy_init = 1; 3338| | 3339| |#ifdef YY_USER_INIT 3340| | YY_USER_INIT; 3341| |#endif 3342| | 3343| 5.22k| if ( ! yyg->yy_start ) ------------------ | Branch (3343:8): [True: 5.22k, False: 0] ------------------ 3344| 5.22k| yyg->yy_start = 1; /* first start state */ 3345| | 3346| 5.22k| if ( ! yyin ) ------------------ | | 356| 5.22k|#define yyin yyg->yyin_r ------------------ | Branch (3346:8): [True: 5.22k, False: 0] ------------------ 3347| 5.22k| yyin = stdin; ------------------ | | 356| 5.22k|#define yyin yyg->yyin_r ------------------ 3348| | 3349| 5.22k| if ( ! yyout ) ------------------ | | 357| 5.22k|#define yyout yyg->yyout_r ------------------ | Branch (3349:8): [True: 5.22k, False: 0] ------------------ 3350| 5.22k| yyout = stdout; ------------------ | | 357| 5.22k|#define yyout yyg->yyout_r ------------------ 3351| | 3352| 5.22k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 502| 5.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.22k, False: 0] | | ------------------ | | 503| 5.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.22k| : NULL) ------------------ | Branch (3352:8): [True: 0, False: 5.22k] ------------------ 3353| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack hsql_ensure_buffer_stack ------------------ 3354| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3355| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer hsql__create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 0|#define YY_BUF_SIZE 16384 ------------------ 3356| 0| } 3357| | 3358| 5.22k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 5.22k|#define yy_load_buffer_state hsql__load_buffer_state ------------------ 3359| 5.22k| } 3360| | 3361| 7.45M| { 3362| 7.45M|#line 57 "flex_lexer.l" 3363| | 3364| | 3365| 7.45M|#line 3365 "flex_lexer.cpp" 3366| | 3367| 8.16M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (3367:23): [Folded - Ignored] ------------------ 3368| 8.16M| { 3369| 8.16M| yy_cp = yyg->yy_c_buf_p; 3370| | 3371| | /* Support of yytext. */ 3372| 8.16M| *yy_cp = yyg->yy_hold_char; 3373| | 3374| | /* yy_bp points to the position in yy_ch_buf of the start of 3375| | * the current run. 3376| | */ 3377| 8.16M| yy_bp = yy_cp; 3378| | 3379| 8.16M| yy_current_state = yyg->yy_start; 3380| 8.16M|yy_match: 3381| 8.16M| do 3382| 37.4M| { 3383| 37.4M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 37.4M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 3384| 37.4M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (3384:9): [True: 29.2M, False: 8.16M] ------------------ 3385| 29.2M| { 3386| 29.2M| yyg->yy_last_accepting_state = yy_current_state; 3387| 29.2M| yyg->yy_last_accepting_cpos = yy_cp; 3388| 29.2M| } 3389| 66.7M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (3389:12): [True: 29.3M, False: 37.4M] ------------------ 3390| 29.3M| { 3391| 29.3M| yy_current_state = (int) yy_def[yy_current_state]; 3392| 29.3M| if ( yy_current_state >= 1332 ) ------------------ | Branch (3392:10): [True: 21.1M, False: 8.16M] ------------------ 3393| 21.1M| yy_c = yy_meta[yy_c]; 3394| 29.3M| } 3395| 37.4M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 3396| 37.4M| ++yy_cp; 3397| 37.4M| } 3398| 37.4M| while ( yy_current_state != 1331 ); ------------------ | Branch (3398:11): [True: 29.2M, False: 8.16M] ------------------ 3399| 8.16M| yy_cp = yyg->yy_last_accepting_cpos; 3400| 8.16M| yy_current_state = yyg->yy_last_accepting_state; 3401| | 3402| 8.16M|yy_find_action: 3403| 8.16M| yy_act = yy_accept[yy_current_state]; 3404| | 3405| 8.16M| YY_DO_BEFORE_ACTION; ------------------ | | 571| 8.16M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 560| 8.16M|#define yytext_ptr yytext_r | | ------------------ | | 572| 8.16M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 8.16M|#define yyleng yyg->yyleng_r | | ------------------ | | 573| 8.16M| yyg->yy_hold_char = *yy_cp; \ | | 574| 8.16M| *yy_cp = '\0'; \ | | 575| 8.16M| yyg->yy_c_buf_p = yy_cp; ------------------ 3406| | 3407| 8.17M|do_action: /* This label is used only to access EOF actions. */ 3408| | 3409| 8.17M| switch ( yy_act ) 3410| 8.17M| { /* beginning of action switch */ 3411| 23| case 0: /* must back up */ ------------------ | Branch (3411:4): [True: 23, False: 8.17M] ------------------ 3412| | /* undo the effects of YY_DO_BEFORE_ACTION */ 3413| 23| *yy_cp = yyg->yy_hold_char; 3414| 23| yy_cp = yyg->yy_last_accepting_cpos; 3415| 23| yy_current_state = yyg->yy_last_accepting_state; 3416| 23| goto yy_find_action; 3417| | 3418| 1.90k|case 1: ------------------ | Branch (3418:1): [True: 1.90k, False: 8.16M] ------------------ 3419| 1.90k|YY_RULE_SETUP ------------------ | | 3320| 1.90k| YY_USER_ACTION | | ------------------ | | | | 66| 1.90k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.90k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.90k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.71k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.71k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.81k, False: 1.90k] | | | | ------------------ | | | | 69| 3.81k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.81k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.81k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.81k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.81k| } else { \ | | | | 75| 3.81k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.81k| } \ | | | | 77| 3.81k| } | | ------------------ ------------------ 3420| 1.90k|#line 59 "flex_lexer.l" 3421| 1.90k|BEGIN(COMMENT); ------------------ | | 369| 1.90k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(COMMENT); ------------------ | | 3082| 1.90k|#define COMMENT 2 ------------------ 3422| 1.90k| YY_BREAK ------------------ | | 3316| 1.90k|#define YY_BREAK /*LINTED*/break; ------------------ 3423| 1.59k|case 2: ------------------ | Branch (3423:1): [True: 1.59k, False: 8.16M] ------------------ 3424| 1.59k|YY_RULE_SETUP ------------------ | | 3320| 1.59k| YY_USER_ACTION | | ------------------ | | | | 66| 1.59k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.59k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 98.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 98.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 96.8k, False: 1.59k] | | | | ------------------ | | | | 69| 96.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 96.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 96.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 96.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 96.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 96.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 96.8k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 96.8k| } else { \ | | | | 75| 96.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 96.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 96.8k| } \ | | | | 77| 96.8k| } | | ------------------ ------------------ 3425| 1.59k|#line 60 "flex_lexer.l" 3426| 1.59k|/* skipping comment content until a end of line is read */; 3427| 1.59k| YY_BREAK ------------------ | | 3316| 1.59k|#define YY_BREAK /*LINTED*/break; ------------------ 3428| 1.70k|case 3: ------------------ | Branch (3428:1): [True: 1.70k, False: 8.16M] ------------------ 3429| |/* rule 3 can match eol */ 3430| 1.70k|YY_RULE_SETUP ------------------ | | 3320| 1.70k| YY_USER_ACTION | | ------------------ | | | | 66| 1.70k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.70k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.40k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.40k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.70k, False: 1.70k] | | | | ------------------ | | | | 69| 1.70k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.70k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.70k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.70k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 1.70k, False: 0] | | | | ------------------ | | | | 72| 1.70k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 1.70k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 1.70k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.70k| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 1.70k| } | | ------------------ ------------------ 3431| 1.70k|#line 61 "flex_lexer.l" 3432| 1.70k|BEGIN(INITIAL); ------------------ | | 369| 1.70k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 3080| 1.70k|#define INITIAL 0 ------------------ 3433| 1.70k| YY_BREAK ------------------ | | 3316| 1.70k|#define YY_BREAK /*LINTED*/break; ------------------ 3434| 678k|case 4: ------------------ | Branch (3434:1): [True: 678k, False: 7.49M] ------------------ 3435| |/* rule 4 can match eol */ 3436| 678k|YY_RULE_SETUP ------------------ | | 3320| 678k| YY_USER_ACTION | | ------------------ | | | | 66| 678k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 678k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 678k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 678k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 678k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 678k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.36M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.36M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 688k, False: 678k] | | | | ------------------ | | | | 69| 688k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 688k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 688k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 688k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 688k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 688k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 165k, False: 523k] | | | | ------------------ | | | | 72| 165k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 165k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 165k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 165k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 523k| } else { \ | | | | 75| 523k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 523k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 523k| } \ | | | | 77| 688k| } | | ------------------ ------------------ 3437| 678k|#line 63 "flex_lexer.l" 3438| 678k|/* skip whitespace */; 3439| 678k| YY_BREAK ------------------ | | 3316| 678k|#define YY_BREAK /*LINTED*/break; ------------------ 3440| 2|case 5: ------------------ | Branch (3440:1): [True: 2, False: 8.17M] ------------------ 3441| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3442| 2|#line 65 "flex_lexer.l" 3443| 2|TOKEN(ADD) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3444| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3445| 2|case 6: ------------------ | Branch (3445:1): [True: 2, False: 8.17M] ------------------ 3446| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3447| 2|#line 66 "flex_lexer.l" 3448| 2|TOKEN(AFTER) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3449| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3450| 1.16k|case 7: ------------------ | Branch (3450:1): [True: 1.16k, False: 8.16M] ------------------ 3451| 1.16k|YY_RULE_SETUP ------------------ | | 3320| 1.16k| YY_USER_ACTION | | ------------------ | | | | 66| 1.16k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.16k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.49k, False: 1.16k] | | | | ------------------ | | | | 69| 3.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.49k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.49k| } else { \ | | | | 75| 3.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.49k| } \ | | | | 77| 3.49k| } | | ------------------ ------------------ 3452| 1.16k|#line 67 "flex_lexer.l" 3453| 1.16k|TOKEN(ALL) ------------------ | | 3060| 1.16k|#define TOKEN(name) { return SQL_##name; } ------------------ 3454| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3455| 4|case 8: ------------------ | Branch (3455:1): [True: 4, False: 8.17M] ------------------ 3456| 4|YY_RULE_SETUP ------------------ | | 3320| 4| YY_USER_ACTION | | ------------------ | | | | 66| 4| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 24| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 24|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 20, False: 4] | | | | ------------------ | | | | 69| 20| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 20| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 20|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 20] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 20| } else { \ | | | | 75| 20| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 20| } \ | | | | 77| 20| } | | ------------------ ------------------ 3457| 4|#line 68 "flex_lexer.l" 3458| 4|TOKEN(ALTER) ------------------ | | 3060| 4|#define TOKEN(name) { return SQL_##name; } ------------------ 3459| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3460| 0|case 9: ------------------ | Branch (3460:1): [True: 0, False: 8.17M] ------------------ 3461| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3462| 0|#line 69 "flex_lexer.l" 3463| 0|TOKEN(ANALYZE) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3464| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3465| 895|case 10: ------------------ | Branch (3465:1): [True: 895, False: 8.16M] ------------------ 3466| 895|YY_RULE_SETUP ------------------ | | 3320| 895| YY_USER_ACTION | | ------------------ | | | | 66| 895| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 895| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 895| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 895| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 895| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 895| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.58k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.58k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.68k, False: 895] | | | | ------------------ | | | | 69| 2.68k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.68k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.68k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.68k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.68k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.68k| } else { \ | | | | 75| 2.68k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.68k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.68k| } \ | | | | 77| 2.68k| } | | ------------------ ------------------ 3467| 895|#line 70 "flex_lexer.l" 3468| 895|TOKEN(AND) ------------------ | | 3060| 895|#define TOKEN(name) { return SQL_##name; } ------------------ 3469| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3470| 893|case 11: ------------------ | Branch (3470:1): [True: 893, False: 8.16M] ------------------ 3471| 893|YY_RULE_SETUP ------------------ | | 3320| 893| YY_USER_ACTION | | ------------------ | | | | 66| 893| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 893| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 893| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 893| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 893| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 893| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.46k, False: 893] | | | | ------------------ | | | | 69| 4.46k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.46k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.46k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.46k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.46k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.46k| } else { \ | | | | 75| 4.46k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.46k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.46k| } \ | | | | 77| 4.46k| } | | ------------------ ------------------ 3472| 893|#line 71 "flex_lexer.l" 3473| 893|TOKEN(ARRAY) ------------------ | | 3060| 893|#define TOKEN(name) { return SQL_##name; } ------------------ 3474| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3475| 3.38k|case 12: ------------------ | Branch (3475:1): [True: 3.38k, False: 8.16M] ------------------ 3476| 3.38k|YY_RULE_SETUP ------------------ | | 3320| 3.38k| YY_USER_ACTION | | ------------------ | | | | 66| 3.38k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.38k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.76k, False: 3.38k] | | | | ------------------ | | | | 69| 6.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.76k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.76k| } else { \ | | | | 75| 6.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.76k| } \ | | | | 77| 6.76k| } | | ------------------ ------------------ 3477| 3.38k|#line 72 "flex_lexer.l" 3478| 3.38k|TOKEN(AS) ------------------ | | 3060| 3.38k|#define TOKEN(name) { return SQL_##name; } ------------------ 3479| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3480| 590|case 13: ------------------ | Branch (3480:1): [True: 590, False: 8.16M] ------------------ 3481| 590|YY_RULE_SETUP ------------------ | | 3320| 590| YY_USER_ACTION | | ------------------ | | | | 66| 590| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 590| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 590| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 590| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 590| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 590| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.77k, False: 590] | | | | ------------------ | | | | 69| 1.77k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.77k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.77k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.77k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.77k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.77k| } else { \ | | | | 75| 1.77k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.77k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.77k| } \ | | | | 77| 1.77k| } | | ------------------ ------------------ 3482| 590|#line 73 "flex_lexer.l" 3483| 590|TOKEN(ASC) ------------------ | | 3060| 590|#define TOKEN(name) { return SQL_##name; } ------------------ 3484| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3485| 2|case 14: ------------------ | Branch (3485:1): [True: 2, False: 8.17M] ------------------ 3486| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3487| 2|#line 74 "flex_lexer.l" 3488| 2|TOKEN(BEFORE) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3489| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3490| 66.4k|case 15: ------------------ | Branch (3490:1): [True: 66.4k, False: 8.10M] ------------------ 3491| 66.4k|YY_RULE_SETUP ------------------ | | 3320| 66.4k| YY_USER_ACTION | | ------------------ | | | | 66| 66.4k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 66.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 66.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 66.4k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 66.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 66.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 398k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 398k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 332k, False: 66.4k] | | | | ------------------ | | | | 69| 332k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 332k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 332k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 332k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 332k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 332k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 332k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 332k| } else { \ | | | | 75| 332k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 332k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 332k| } \ | | | | 77| 332k| } | | ------------------ ------------------ 3492| 66.4k|#line 75 "flex_lexer.l" 3493| 66.4k|TOKEN(BEGIN) ------------------ | | 3060| 66.4k|#define TOKEN(name) { return SQL_##name; } ------------------ 3494| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3495| 482|case 16: ------------------ | Branch (3495:1): [True: 482, False: 8.16M] ------------------ 3496| 482|YY_RULE_SETUP ------------------ | | 3320| 482| YY_USER_ACTION | | ------------------ | | | | 66| 482| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 482| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 482| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 482| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 482| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 482| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.85k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.37k, False: 482] | | | | ------------------ | | | | 69| 3.37k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.37k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.37k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.37k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.37k| } else { \ | | | | 75| 3.37k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.37k| } \ | | | | 77| 3.37k| } | | ------------------ ------------------ 3497| 482|#line 76 "flex_lexer.l" 3498| 482|TOKEN(BETWEEN) ------------------ | | 3060| 482|#define TOKEN(name) { return SQL_##name; } ------------------ 3499| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3500| 766|case 17: ------------------ | Branch (3500:1): [True: 766, False: 8.16M] ------------------ 3501| 766|YY_RULE_SETUP ------------------ | | 3320| 766| YY_USER_ACTION | | ------------------ | | | | 66| 766| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 766| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 766| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 766| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 766| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 766| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.59k, False: 766] | | | | ------------------ | | | | 69| 4.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.59k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.59k| } else { \ | | | | 75| 4.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.59k| } \ | | | | 77| 4.59k| } | | ------------------ ------------------ 3502| 766|#line 77 "flex_lexer.l" 3503| 766|TOKEN(BIGINT) ------------------ | | 3060| 766|#define TOKEN(name) { return SQL_##name; } ------------------ 3504| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3505| 680|case 18: ------------------ | Branch (3505:1): [True: 680, False: 8.16M] ------------------ 3506| 680|YY_RULE_SETUP ------------------ | | 3320| 680| YY_USER_ACTION | | ------------------ | | | | 66| 680| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 680| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 680| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.76k, False: 680] | | | | ------------------ | | | | 69| 4.76k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.76k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.76k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.76k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.76k| } else { \ | | | | 75| 4.76k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.76k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.76k| } \ | | | | 77| 4.76k| } | | ------------------ ------------------ 3507| 680|#line 78 "flex_lexer.l" 3508| 680|TOKEN(BOOLEAN) ------------------ | | 3060| 680|#define TOKEN(name) { return SQL_##name; } ------------------ 3509| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3510| 3.41k|case 19: ------------------ | Branch (3510:1): [True: 3.41k, False: 8.16M] ------------------ 3511| 3.41k|YY_RULE_SETUP ------------------ | | 3320| 3.41k| YY_USER_ACTION | | ------------------ | | | | 66| 3.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.83k, False: 3.41k] | | | | ------------------ | | | | 69| 6.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.83k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.83k| } else { \ | | | | 75| 6.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.83k| } \ | | | | 77| 6.83k| } | | ------------------ ------------------ 3512| 3.41k|#line 79 "flex_lexer.l" 3513| 3.41k|TOKEN(BY) ------------------ | | 3060| 3.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 3514| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3515| 2|case 20: ------------------ | Branch (3515:1): [True: 2, False: 8.17M] ------------------ 3516| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 2] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3517| 2|#line 80 "flex_lexer.l" 3518| 2|TOKEN(CALL) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3519| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3520| 1|case 21: ------------------ | Branch (3520:1): [True: 1, False: 8.17M] ------------------ 3521| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7, False: 1] | | | | ------------------ | | | | 69| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7| } else { \ | | | | 75| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 7| } | | ------------------ ------------------ 3522| 1|#line 81 "flex_lexer.l" 3523| 1|TOKEN(CASCADE) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3524| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3525| 2.41k|case 22: ------------------ | Branch (3525:1): [True: 2.41k, False: 8.16M] ------------------ 3526| 2.41k|YY_RULE_SETUP ------------------ | | 3320| 2.41k| YY_USER_ACTION | | ------------------ | | | | 66| 2.41k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.41k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.65k, False: 2.41k] | | | | ------------------ | | | | 69| 9.65k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.65k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.65k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.65k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.65k| } else { \ | | | | 75| 9.65k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.65k| } \ | | | | 77| 9.65k| } | | ------------------ ------------------ 3527| 2.41k|#line 82 "flex_lexer.l" 3528| 2.41k|TOKEN(CASE) ------------------ | | 3060| 2.41k|#define TOKEN(name) { return SQL_##name; } ------------------ 3529| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3530| 739|case 23: ------------------ | Branch (3530:1): [True: 739, False: 8.16M] ------------------ 3531| 739|YY_RULE_SETUP ------------------ | | 3320| 739| YY_USER_ACTION | | ------------------ | | | | 66| 739| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 739| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.95k, False: 739] | | | | ------------------ | | | | 69| 2.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.95k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.95k| } else { \ | | | | 75| 2.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.95k| } \ | | | | 77| 2.95k| } | | ------------------ ------------------ 3532| 739|#line 83 "flex_lexer.l" 3533| 739|TOKEN(CAST) ------------------ | | 3060| 739|#define TOKEN(name) { return SQL_##name; } ------------------ 3534| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3535| 391|case 24: ------------------ | Branch (3535:1): [True: 391, False: 8.16M] ------------------ 3536| 391|YY_RULE_SETUP ------------------ | | 3320| 391| YY_USER_ACTION | | ------------------ | | | | 66| 391| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 391| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 391| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 391| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 391| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 391| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.95k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.56k, False: 391] | | | | ------------------ | | | | 69| 1.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.56k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.56k| } else { \ | | | | 75| 1.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.56k| } \ | | | | 77| 1.56k| } | | ------------------ ------------------ 3537| 391|#line 84 "flex_lexer.l" 3538| 391|TOKEN(CHAR) ------------------ | | 3060| 391|#define TOKEN(name) { return SQL_##name; } ------------------ 3539| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3540| 1|case 25: ------------------ | Branch (3540:1): [True: 1, False: 8.17M] ------------------ 3541| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3542| 1|#line 85 "flex_lexer.l" 3543| 1|TOKEN(COLUMN) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3544| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3545| 468|case 26: ------------------ | Branch (3545:1): [True: 468, False: 8.16M] ------------------ 3546| 468|YY_RULE_SETUP ------------------ | | 3320| 468| YY_USER_ACTION | | ------------------ | | | | 66| 468| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 468| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 468| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.74k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.74k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.27k, False: 468] | | | | ------------------ | | | | 69| 3.27k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.27k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.27k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.27k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.27k| } else { \ | | | | 75| 3.27k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.27k| } \ | | | | 77| 3.27k| } | | ------------------ ------------------ 3547| 468|#line 86 "flex_lexer.l" 3548| 468|TOKEN(COLUMNS) ------------------ | | 3060| 468|#define TOKEN(name) { return SQL_##name; } ------------------ 3549| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3550| 552|case 27: ------------------ | Branch (3550:1): [True: 552, False: 8.16M] ------------------ 3551| 552|YY_RULE_SETUP ------------------ | | 3320| 552| YY_USER_ACTION | | ------------------ | | | | 66| 552| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 552| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 552| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 552| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 552| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 552| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.86k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.86k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.31k, False: 552] | | | | ------------------ | | | | 69| 3.31k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.31k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.31k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.31k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.31k| } else { \ | | | | 75| 3.31k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.31k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.31k| } \ | | | | 77| 3.31k| } | | ------------------ ------------------ 3552| 552|#line 87 "flex_lexer.l" 3553| 552|TOKEN(COMMIT) ------------------ | | 3060| 552|#define TOKEN(name) { return SQL_##name; } ------------------ 3554| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3555| 0|case 28: ------------------ | Branch (3555:1): [True: 0, False: 8.17M] ------------------ 3556| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3557| 0|#line 88 "flex_lexer.l" 3558| 0|TOKEN(CONTROL) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3559| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3560| 2.45k|case 29: ------------------ | Branch (3560:1): [True: 2.45k, False: 8.16M] ------------------ 3561| 2.45k|YY_RULE_SETUP ------------------ | | 3320| 2.45k| YY_USER_ACTION | | ------------------ | | | | 66| 2.45k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.45k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.82k, False: 2.45k] | | | | ------------------ | | | | 69| 9.82k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.82k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.82k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.82k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.82k| } else { \ | | | | 75| 9.82k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.82k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.82k| } \ | | | | 77| 9.82k| } | | ------------------ ------------------ 3562| 2.45k|#line 89 "flex_lexer.l" 3563| 2.45k|TOKEN(COPY) ------------------ | | 3060| 2.45k|#define TOKEN(name) { return SQL_##name; } ------------------ 3564| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3565| 3.01k|case 30: ------------------ | Branch (3565:1): [True: 3.01k, False: 8.16M] ------------------ 3566| 3.01k|YY_RULE_SETUP ------------------ | | 3320| 3.01k| YY_USER_ACTION | | ------------------ | | | | 66| 3.01k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.01k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 21.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 21.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 18.0k, False: 3.01k] | | | | ------------------ | | | | 69| 18.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 18.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 18.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 18.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 18.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 18.0k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 18.0k| } else { \ | | | | 75| 18.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 18.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 18.0k| } \ | | | | 77| 18.0k| } | | ------------------ ------------------ 3567| 3.01k|#line 90 "flex_lexer.l" 3568| 3.01k|TOKEN(CREATE) ------------------ | | 3060| 3.01k|#define TOKEN(name) { return SQL_##name; } ------------------ 3569| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3570| 544|case 31: ------------------ | Branch (3570:1): [True: 544, False: 8.16M] ------------------ 3571| 544|YY_RULE_SETUP ------------------ | | 3320| 544| YY_USER_ACTION | | ------------------ | | | | 66| 544| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 544| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 544| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 544| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 544| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 544| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.26k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.26k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.72k, False: 544] | | | | ------------------ | | | | 69| 2.72k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.72k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.72k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.72k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.72k| } else { \ | | | | 75| 2.72k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.72k| } \ | | | | 77| 2.72k| } | | ------------------ ------------------ 3572| 544|#line 91 "flex_lexer.l" 3573| 544|TOKEN(CROSS) ------------------ | | 3060| 544|#define TOKEN(name) { return SQL_##name; } ------------------ 3574| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3575| 587|case 32: ------------------ | Branch (3575:1): [True: 587, False: 8.16M] ------------------ 3576| 587|YY_RULE_SETUP ------------------ | | 3320| 587| YY_USER_ACTION | | ------------------ | | | | 66| 587| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 587| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 587| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.34k, False: 587] | | | | ------------------ | | | | 69| 2.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.34k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.34k| } else { \ | | | | 75| 2.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.34k| } \ | | | | 77| 2.34k| } | | ------------------ ------------------ 3577| 587|#line 92 "flex_lexer.l" 3578| 587|TOKEN(DATE) ------------------ | | 3060| 587|#define TOKEN(name) { return SQL_##name; } ------------------ 3579| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3580| 560|case 33: ------------------ | Branch (3580:1): [True: 560, False: 8.16M] ------------------ 3581| 560|YY_RULE_SETUP ------------------ | | 3320| 560| YY_USER_ACTION | | ------------------ | | | | 66| 560| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 560| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.48k, False: 560] | | | | ------------------ | | | | 69| 4.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.48k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.48k| } else { \ | | | | 75| 4.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.48k| } \ | | | | 77| 4.48k| } | | ------------------ ------------------ 3582| 560|#line 93 "flex_lexer.l" 3583| 560|TOKEN(DATETIME) ------------------ | | 3060| 560|#define TOKEN(name) { return SQL_##name; } ------------------ 3584| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3585| 1.34k|case 34: ------------------ | Branch (3585:1): [True: 1.34k, False: 8.16M] ------------------ 3586| 1.34k|YY_RULE_SETUP ------------------ | | 3320| 1.34k| YY_USER_ACTION | | ------------------ | | | | 66| 1.34k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.34k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.36k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.36k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.02k, False: 1.34k] | | | | ------------------ | | | | 69| 4.02k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.02k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.02k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.02k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.02k| } else { \ | | | | 75| 4.02k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.02k| } \ | | | | 77| 4.02k| } | | ------------------ ------------------ 3587| 1.34k|#line 94 "flex_lexer.l" 3588| 1.34k|TOKEN(DAY) ------------------ | | 3060| 1.34k|#define TOKEN(name) { return SQL_##name; } ------------------ 3589| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3590| 585|case 35: ------------------ | Branch (3590:1): [True: 585, False: 8.16M] ------------------ 3591| 585|YY_RULE_SETUP ------------------ | | 3320| 585| YY_USER_ACTION | | ------------------ | | | | 66| 585| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 585| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 585| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 585| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 585| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 585| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.92k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.92k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.34k, False: 585] | | | | ------------------ | | | | 69| 2.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.34k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.34k| } else { \ | | | | 75| 2.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.34k| } \ | | | | 77| 2.34k| } | | ------------------ ------------------ 3592| 585|#line 95 "flex_lexer.l" 3593| 585|TOKEN(DAYS) ------------------ | | 3060| 585|#define TOKEN(name) { return SQL_##name; } ------------------ 3594| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3595| 748|case 36: ------------------ | Branch (3595:1): [True: 748, False: 8.16M] ------------------ 3596| 748|YY_RULE_SETUP ------------------ | | 3320| 748| YY_USER_ACTION | | ------------------ | | | | 66| 748| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 748| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 748| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.48k, False: 748] | | | | ------------------ | | | | 69| 7.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.48k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.48k| } else { \ | | | | 75| 7.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.48k| } \ | | | | 77| 7.48k| } | | ------------------ ------------------ 3597| 748|#line 96 "flex_lexer.l" 3598| 748|TOKEN(DEALLOCATE) ------------------ | | 3060| 748|#define TOKEN(name) { return SQL_##name; } ------------------ 3599| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3600| 1.02k|case 37: ------------------ | Branch (3600:1): [True: 1.02k, False: 8.16M] ------------------ 3601| 1.02k|YY_RULE_SETUP ------------------ | | 3320| 1.02k| YY_USER_ACTION | | ------------------ | | | | 66| 1.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.21k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.18k, False: 1.02k] | | | | ------------------ | | | | 69| 7.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.18k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.18k| } else { \ | | | | 75| 7.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.18k| } \ | | | | 77| 7.18k| } | | ------------------ ------------------ 3602| 1.02k|#line 97 "flex_lexer.l" 3603| 1.02k|TOKEN(DECIMAL) ------------------ | | 3060| 1.02k|#define TOKEN(name) { return SQL_##name; } ------------------ 3604| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3605| 1|case 38: ------------------ | Branch (3605:1): [True: 1, False: 8.17M] ------------------ 3606| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7, False: 1] | | | | ------------------ | | | | 69| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7| } else { \ | | | | 75| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 7| } | | ------------------ ------------------ 3607| 1|#line 98 "flex_lexer.l" 3608| 1|TOKEN(DEFAULT) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3609| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3610| 1.19k|case 39: ------------------ | Branch (3610:1): [True: 1.19k, False: 8.16M] ------------------ 3611| 1.19k|YY_RULE_SETUP ------------------ | | 3320| 1.19k| YY_USER_ACTION | | ------------------ | | | | 66| 1.19k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.19k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.19k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.33k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.33k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.14k, False: 1.19k] | | | | ------------------ | | | | 69| 7.14k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.14k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.14k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.14k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.14k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.14k| } else { \ | | | | 75| 7.14k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.14k| } \ | | | | 77| 7.14k| } | | ------------------ ------------------ 3612| 1.19k|#line 99 "flex_lexer.l" 3613| 1.19k|TOKEN(DELETE) ------------------ | | 3060| 1.19k|#define TOKEN(name) { return SQL_##name; } ------------------ 3614| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3615| 3|case 40: ------------------ | Branch (3615:1): [True: 3, False: 8.17M] ------------------ 3616| 3|YY_RULE_SETUP ------------------ | | 3320| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 15, False: 3] | | | | ------------------ | | | | 69| 15| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 15| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 15] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 15| } else { \ | | | | 75| 15| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 15| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 15| } \ | | | | 77| 15| } | | ------------------ ------------------ 3617| 3|#line 100 "flex_lexer.l" 3618| 3|TOKEN(DELTA) ------------------ | | 3060| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3619| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3620| 515|case 41: ------------------ | Branch (3620:1): [True: 515, False: 8.16M] ------------------ 3621| 515|YY_RULE_SETUP ------------------ | | 3320| 515| YY_USER_ACTION | | ------------------ | | | | 66| 515| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 515| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 515| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 515| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 515| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 515| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.57k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.06k, False: 515] | | | | ------------------ | | | | 69| 2.06k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.06k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.06k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.06k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.06k| } else { \ | | | | 75| 2.06k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.06k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.06k| } \ | | | | 77| 2.06k| } | | ------------------ ------------------ 3622| 515|#line 101 "flex_lexer.l" 3623| 515|TOKEN(DESC) ------------------ | | 3060| 515|#define TOKEN(name) { return SQL_##name; } ------------------ 3624| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3625| 953|case 42: ------------------ | Branch (3625:1): [True: 953, False: 8.16M] ------------------ 3626| 953|YY_RULE_SETUP ------------------ | | 3320| 953| YY_USER_ACTION | | ------------------ | | | | 66| 953| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 953| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 953| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 953| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 953| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 953| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.57k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.62k, False: 953] | | | | ------------------ | | | | 69| 7.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.62k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.62k| } else { \ | | | | 75| 7.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.62k| } \ | | | | 77| 7.62k| } | | ------------------ ------------------ 3627| 953|#line 102 "flex_lexer.l" 3628| 953|TOKEN(DESCRIBE) ------------------ | | 3060| 953|#define TOKEN(name) { return SQL_##name; } ------------------ 3629| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3630| 1|case 43: ------------------ | Branch (3630:1): [True: 1, False: 8.17M] ------------------ 3631| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3632| 1|#line 103 "flex_lexer.l" 3633| 1|TOKEN(DIRECT) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3634| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3635| 717|case 44: ------------------ | Branch (3635:1): [True: 717, False: 8.16M] ------------------ 3636| 717|YY_RULE_SETUP ------------------ | | 3320| 717| YY_USER_ACTION | | ------------------ | | | | 66| 717| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 717| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 717| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 717| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 717| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 717| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.45k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.73k, False: 717] | | | | ------------------ | | | | 69| 5.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.73k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.73k| } else { \ | | | | 75| 5.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.73k| } \ | | | | 77| 5.73k| } | | ------------------ ------------------ 3637| 717|#line 104 "flex_lexer.l" 3638| 717|TOKEN(DISTINCT) ------------------ | | 3060| 717|#define TOKEN(name) { return SQL_##name; } ------------------ 3639| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3640| 814|case 45: ------------------ | Branch (3640:1): [True: 814, False: 8.16M] ------------------ 3641| 814|YY_RULE_SETUP ------------------ | | 3320| 814| YY_USER_ACTION | | ------------------ | | | | 66| 814| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 814| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 814| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.88k, False: 814] | | | | ------------------ | | | | 69| 4.88k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.88k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.88k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.88k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.88k| } else { \ | | | | 75| 4.88k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.88k| } \ | | | | 77| 4.88k| } | | ------------------ ------------------ 3642| 814|#line 105 "flex_lexer.l" 3643| 814|TOKEN(DOUBLE) ------------------ | | 3060| 814|#define TOKEN(name) { return SQL_##name; } ------------------ 3644| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3645| 2.51k|case 46: ------------------ | Branch (3645:1): [True: 2.51k, False: 8.16M] ------------------ 3646| 2.51k|YY_RULE_SETUP ------------------ | | 3320| 2.51k| YY_USER_ACTION | | ------------------ | | | | 66| 2.51k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.51k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.51k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.0k, False: 2.51k] | | | | ------------------ | | | | 69| 10.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.0k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.0k| } else { \ | | | | 75| 10.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.0k| } \ | | | | 77| 10.0k| } | | ------------------ ------------------ 3647| 2.51k|#line 106 "flex_lexer.l" 3648| 2.51k|TOKEN(DROP) ------------------ | | 3060| 2.51k|#define TOKEN(name) { return SQL_##name; } ------------------ 3649| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3650| 1.02k|case 47: ------------------ | Branch (3650:1): [True: 1.02k, False: 8.16M] ------------------ 3651| 1.02k|YY_RULE_SETUP ------------------ | | 3320| 1.02k| YY_USER_ACTION | | ------------------ | | | | 66| 1.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.09k, False: 1.02k] | | | | ------------------ | | | | 69| 4.09k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.09k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.09k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.09k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.09k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.09k| } else { \ | | | | 75| 4.09k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.09k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.09k| } \ | | | | 77| 4.09k| } | | ------------------ ------------------ 3652| 1.02k|#line 107 "flex_lexer.l" 3653| 1.02k|TOKEN(ELSE) ------------------ | | 3060| 1.02k|#define TOKEN(name) { return SQL_##name; } ------------------ 3654| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3655| 1.81k|case 48: ------------------ | Branch (3655:1): [True: 1.81k, False: 8.16M] ------------------ 3656| 1.81k|YY_RULE_SETUP ------------------ | | 3320| 1.81k| YY_USER_ACTION | | ------------------ | | | | 66| 1.81k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.81k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.81k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.25k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.25k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.43k, False: 1.81k] | | | | ------------------ | | | | 69| 5.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.43k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.43k| } else { \ | | | | 75| 5.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.43k| } \ | | | | 77| 5.43k| } | | ------------------ ------------------ 3657| 1.81k|#line 108 "flex_lexer.l" 3658| 1.81k|TOKEN(END) ------------------ | | 3060| 1.81k|#define TOKEN(name) { return SQL_##name; } ------------------ 3659| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3660| 2|case 49: ------------------ | Branch (3660:1): [True: 2, False: 8.17M] ------------------ 3661| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3662| 2|#line 109 "flex_lexer.l" 3663| 2|TOKEN(ESCAPE) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3664| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3665| 221|case 50: ------------------ | Branch (3665:1): [True: 221, False: 8.16M] ------------------ 3666| 221|YY_RULE_SETUP ------------------ | | 3320| 221| YY_USER_ACTION | | ------------------ | | | | 66| 221| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 221| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 221| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 221| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 221| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 221| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.54k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.54k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.32k, False: 221] | | | | ------------------ | | | | 69| 1.32k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.32k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.32k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.32k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.32k| } else { \ | | | | 75| 1.32k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.32k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.32k| } \ | | | | 77| 1.32k| } | | ------------------ ------------------ 3667| 221|#line 110 "flex_lexer.l" 3668| 221|TOKEN(EXCEPT) ------------------ | | 3060| 221|#define TOKEN(name) { return SQL_##name; } ------------------ 3669| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3670| 2.42k|case 51: ------------------ | Branch (3670:1): [True: 2.42k, False: 8.16M] ------------------ 3671| 2.42k|YY_RULE_SETUP ------------------ | | 3320| 2.42k| YY_USER_ACTION | | ------------------ | | | | 66| 2.42k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.42k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 19.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 19.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16.9k, False: 2.42k] | | | | ------------------ | | | | 69| 16.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 16.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16.9k| } else { \ | | | | 75| 16.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16.9k| } \ | | | | 77| 16.9k| } | | ------------------ ------------------ 3672| 2.42k|#line 111 "flex_lexer.l" 3673| 2.42k|TOKEN(EXECUTE) ------------------ | | 3060| 2.42k|#define TOKEN(name) { return SQL_##name; } ------------------ 3674| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3675| 1.20k|case 52: ------------------ | Branch (3675:1): [True: 1.20k, False: 8.16M] ------------------ 3676| 1.20k|YY_RULE_SETUP ------------------ | | 3320| 1.20k| YY_USER_ACTION | | ------------------ | | | | 66| 1.20k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.20k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.45k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.24k, False: 1.20k] | | | | ------------------ | | | | 69| 7.24k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.24k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.24k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.24k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.24k| } else { \ | | | | 75| 7.24k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.24k| } \ | | | | 77| 7.24k| } | | ------------------ ------------------ 3677| 1.20k|#line 112 "flex_lexer.l" 3678| 1.20k|TOKEN(EXISTS) ------------------ | | 3060| 1.20k|#define TOKEN(name) { return SQL_##name; } ------------------ 3679| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3680| 1|case 53: ------------------ | Branch (3680:1): [True: 1, False: 8.17M] ------------------ 3681| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7, False: 1] | | | | ------------------ | | | | 69| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7| } else { \ | | | | 75| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 7| } | | ------------------ ------------------ 3682| 1|#line 113 "flex_lexer.l" 3683| 1|TOKEN(EXPLAIN) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3684| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3685| 509|case 54: ------------------ | Branch (3685:1): [True: 509, False: 8.16M] ------------------ 3686| 509|YY_RULE_SETUP ------------------ | | 3320| 509| YY_USER_ACTION | | ------------------ | | | | 66| 509| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 509| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 509| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 509| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 509| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 509| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.07k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.07k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.56k, False: 509] | | | | ------------------ | | | | 69| 3.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.56k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.56k| } else { \ | | | | 75| 3.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.56k| } \ | | | | 77| 3.56k| } | | ------------------ ------------------ 3687| 509|#line 114 "flex_lexer.l" 3688| 509|TOKEN(EXTRACT) ------------------ | | 3060| 509|#define TOKEN(name) { return SQL_##name; } ------------------ 3689| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3690| 687|case 55: ------------------ | Branch (3690:1): [True: 687, False: 8.16M] ------------------ 3691| 687|YY_RULE_SETUP ------------------ | | 3320| 687| YY_USER_ACTION | | ------------------ | | | | 66| 687| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 687| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 687| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 687| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 687| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 687| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.43k, False: 687] | | | | ------------------ | | | | 69| 3.43k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.43k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.43k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.43k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.43k| } else { \ | | | | 75| 3.43k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.43k| } \ | | | | 77| 3.43k| } | | ------------------ ------------------ 3692| 687|#line 115 "flex_lexer.l" 3693| 687|TOKEN(FALSE) ------------------ | | 3060| 687|#define TOKEN(name) { return SQL_##name; } ------------------ 3694| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3695| 3|case 56: ------------------ | Branch (3695:1): [True: 3, False: 8.17M] ------------------ 3696| 3|YY_RULE_SETUP ------------------ | | 3320| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 3] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3697| 3|#line 116 "flex_lexer.l" 3698| 3|TOKEN(FILE) ------------------ | | 3060| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3699| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3700| 707|case 57: ------------------ | Branch (3700:1): [True: 707, False: 8.16M] ------------------ 3701| 707|YY_RULE_SETUP ------------------ | | 3320| 707| YY_USER_ACTION | | ------------------ | | | | 66| 707| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 707| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.53k, False: 707] | | | | ------------------ | | | | 69| 3.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.53k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.53k| } else { \ | | | | 75| 3.53k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.53k| } \ | | | | 77| 3.53k| } | | ------------------ ------------------ 3702| 707|#line 117 "flex_lexer.l" 3703| 707|TOKEN(FLOAT) ------------------ | | 3060| 707|#define TOKEN(name) { return SQL_##name; } ------------------ 3704| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3705| 0|case 58: ------------------ | Branch (3705:1): [True: 0, False: 8.17M] ------------------ 3706| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3707| 0|#line 118 "flex_lexer.l" 3708| 0|TOKEN(FOLLOWING) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3709| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3710| 7.89k|case 59: ------------------ | Branch (3710:1): [True: 7.89k, False: 8.16M] ------------------ 3711| 7.89k|YY_RULE_SETUP ------------------ | | 3320| 7.89k| YY_USER_ACTION | | ------------------ | | | | 66| 7.89k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 7.89k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 7.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 31.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 31.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 23.6k, False: 7.89k] | | | | ------------------ | | | | 69| 23.6k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 23.6k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 23.6k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 23.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 23.6k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 23.6k| } else { \ | | | | 75| 23.6k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 23.6k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 23.6k| } \ | | | | 77| 23.6k| } | | ------------------ ------------------ 3712| 7.89k|#line 119 "flex_lexer.l" 3713| 7.89k|TOKEN(FOR) ------------------ | | 3060| 7.89k|#define TOKEN(name) { return SQL_##name; } ------------------ 3714| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3715| 1|case 60: ------------------ | Branch (3715:1): [True: 1, False: 8.17M] ------------------ 3716| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 3717| 1|#line 120 "flex_lexer.l" 3718| 1|TOKEN(FORMAT) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3719| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3720| 4.53k|case 61: ------------------ | Branch (3720:1): [True: 4.53k, False: 8.16M] ------------------ 3721| 4.53k|YY_RULE_SETUP ------------------ | | 3320| 4.53k| YY_USER_ACTION | | ------------------ | | | | 66| 4.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 22.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 22.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 18.1k, False: 4.53k] | | | | ------------------ | | | | 69| 18.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 18.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 18.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 18.1k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 18.1k| } else { \ | | | | 75| 18.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 18.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 18.1k| } \ | | | | 77| 18.1k| } | | ------------------ ------------------ 3722| 4.53k|#line 121 "flex_lexer.l" 3723| 4.53k|TOKEN(FROM) ------------------ | | 3060| 4.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 3724| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3725| 763|case 62: ------------------ | Branch (3725:1): [True: 763, False: 8.16M] ------------------ 3726| 763|YY_RULE_SETUP ------------------ | | 3320| 763| YY_USER_ACTION | | ------------------ | | | | 66| 763| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 763| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 763| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.81k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.81k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.05k, False: 763] | | | | ------------------ | | | | 69| 3.05k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.05k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.05k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.05k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.05k| } else { \ | | | | 75| 3.05k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.05k| } \ | | | | 77| 3.05k| } | | ------------------ ------------------ 3727| 763|#line 122 "flex_lexer.l" 3728| 763|TOKEN(FULL) ------------------ | | 3060| 763|#define TOKEN(name) { return SQL_##name; } ------------------ 3729| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3730| 2|case 63: ------------------ | Branch (3730:1): [True: 2, False: 8.17M] ------------------ 3731| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3732| 2|#line 123 "flex_lexer.l" 3733| 2|TOKEN(GLOBAL) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3734| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3735| 1.37k|case 64: ------------------ | Branch (3735:1): [True: 1.37k, False: 8.16M] ------------------ 3736| 1.37k|YY_RULE_SETUP ------------------ | | 3320| 1.37k| YY_USER_ACTION | | ------------------ | | | | 66| 1.37k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.37k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.37k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.85k, False: 1.37k] | | | | ------------------ | | | | 69| 6.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.85k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.85k| } else { \ | | | | 75| 6.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.85k| } \ | | | | 77| 6.85k| } | | ------------------ ------------------ 3737| 1.37k|#line 124 "flex_lexer.l" 3738| 1.37k|TOKEN(GROUP) ------------------ | | 3060| 1.37k|#define TOKEN(name) { return SQL_##name; } ------------------ 3739| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3740| 4|case 65: ------------------ | Branch (3740:1): [True: 4, False: 8.17M] ------------------ 3741| 4|YY_RULE_SETUP ------------------ | | 3320| 4| YY_USER_ACTION | | ------------------ | | | | 66| 4| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 28| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 28|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 24, False: 4] | | | | ------------------ | | | | 69| 24| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 24| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 24| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 24| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 24| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 24|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 24] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 24| } else { \ | | | | 75| 24| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 24| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 24| } \ | | | | 77| 24| } | | ------------------ ------------------ 3742| 4|#line 125 "flex_lexer.l" 3743| 4|TOKEN(GROUPS) ------------------ | | 3060| 4|#define TOKEN(name) { return SQL_##name; } ------------------ 3744| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3745| 3|case 66: ------------------ | Branch (3745:1): [True: 3, False: 8.17M] ------------------ 3746| 3|YY_RULE_SETUP ------------------ | | 3320| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 3] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3747| 3|#line 126 "flex_lexer.l" 3748| 3|TOKEN(HASH) ------------------ | | 3060| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3749| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3750| 574|case 67: ------------------ | Branch (3750:1): [True: 574, False: 8.16M] ------------------ 3751| 574|YY_RULE_SETUP ------------------ | | 3320| 574| YY_USER_ACTION | | ------------------ | | | | 66| 574| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 574| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 574| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.01k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.01k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.44k, False: 574] | | | | ------------------ | | | | 69| 3.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.44k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.44k| } else { \ | | | | 75| 3.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.44k| } \ | | | | 77| 3.44k| } | | ------------------ ------------------ 3752| 574|#line 127 "flex_lexer.l" 3753| 574|TOKEN(HAVING) ------------------ | | 3060| 574|#define TOKEN(name) { return SQL_##name; } ------------------ 3754| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3755| 868|case 68: ------------------ | Branch (3755:1): [True: 868, False: 8.16M] ------------------ 3756| 868|YY_RULE_SETUP ------------------ | | 3320| 868| YY_USER_ACTION | | ------------------ | | | | 66| 868| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 868| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 868| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.47k, False: 868] | | | | ------------------ | | | | 69| 3.47k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.47k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.47k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.47k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.47k| } else { \ | | | | 75| 3.47k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.47k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.47k| } \ | | | | 77| 3.47k| } | | ------------------ ------------------ 3757| 868|#line 128 "flex_lexer.l" 3758| 868|TOKEN(HINT) ------------------ | | 3060| 868|#define TOKEN(name) { return SQL_##name; } ------------------ 3759| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3760| 532|case 69: ------------------ | Branch (3760:1): [True: 532, False: 8.16M] ------------------ 3761| 532|YY_RULE_SETUP ------------------ | | 3320| 532| YY_USER_ACTION | | ------------------ | | | | 66| 532| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 532| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 532| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.12k, False: 532] | | | | ------------------ | | | | 69| 2.12k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.12k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.12k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.12k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.12k| } else { \ | | | | 75| 2.12k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.12k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.12k| } \ | | | | 77| 2.12k| } | | ------------------ ------------------ 3762| 532|#line 129 "flex_lexer.l" 3763| 532|TOKEN(HOUR) ------------------ | | 3060| 532|#define TOKEN(name) { return SQL_##name; } ------------------ 3764| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3765| 700|case 70: ------------------ | Branch (3765:1): [True: 700, False: 8.16M] ------------------ 3766| 700|YY_RULE_SETUP ------------------ | | 3320| 700| YY_USER_ACTION | | ------------------ | | | | 66| 700| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 700| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.50k, False: 700] | | | | ------------------ | | | | 69| 3.50k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.50k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.50k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.50k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.50k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.50k| } else { \ | | | | 75| 3.50k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.50k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.50k| } \ | | | | 77| 3.50k| } | | ------------------ ------------------ 3767| 700|#line 130 "flex_lexer.l" 3768| 700|TOKEN(HOURS) ------------------ | | 3060| 700|#define TOKEN(name) { return SQL_##name; } ------------------ 3769| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3770| 197|case 71: ------------------ | Branch (3770:1): [True: 197, False: 8.17M] ------------------ 3771| 197|YY_RULE_SETUP ------------------ | | 3320| 197| YY_USER_ACTION | | ------------------ | | | | 66| 197| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 197| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 197| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 197| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 197| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 197| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 591| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 591|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 394, False: 197] | | | | ------------------ | | | | 69| 394| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 394| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 394| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 394| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 394| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 394|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 394] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 394| } else { \ | | | | 75| 394| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 394| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 394| } \ | | | | 77| 394| } | | ------------------ ------------------ 3772| 197|#line 131 "flex_lexer.l" 3773| 197|TOKEN(IF) ------------------ | | 3060| 197|#define TOKEN(name) { return SQL_##name; } ------------------ 3774| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3775| 732|case 72: ------------------ | Branch (3775:1): [True: 732, False: 8.16M] ------------------ 3776| 732|YY_RULE_SETUP ------------------ | | 3320| 732| YY_USER_ACTION | | ------------------ | | | | 66| 732| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 732| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 732| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.66k, False: 732] | | | | ------------------ | | | | 69| 3.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.66k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.66k| } else { \ | | | | 75| 3.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.66k| } \ | | | | 77| 3.66k| } | | ------------------ ------------------ 3777| 732|#line 132 "flex_lexer.l" 3778| 732|TOKEN(ILIKE) ------------------ | | 3060| 732|#define TOKEN(name) { return SQL_##name; } ------------------ 3779| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3780| 126|case 73: ------------------ | Branch (3780:1): [True: 126, False: 8.17M] ------------------ 3781| 126|YY_RULE_SETUP ------------------ | | 3320| 126| YY_USER_ACTION | | ------------------ | | | | 66| 126| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 126| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 126| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 126| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 126| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 126| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 882| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 882|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 756, False: 126] | | | | ------------------ | | | | 69| 756| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 756| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 756| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 756| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 756| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 756|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 756] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 756| } else { \ | | | | 75| 756| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 756| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 756| } \ | | | | 77| 756| } | | ------------------ ------------------ 3782| 126|#line 133 "flex_lexer.l" 3783| 126|TOKEN(IMPORT) ------------------ | | 3060| 126|#define TOKEN(name) { return SQL_##name; } ------------------ 3784| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3785| 1.33k|case 74: ------------------ | Branch (3785:1): [True: 1.33k, False: 8.16M] ------------------ 3786| 1.33k|YY_RULE_SETUP ------------------ | | 3320| 1.33k| YY_USER_ACTION | | ------------------ | | | | 66| 1.33k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.33k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.99k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.99k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.66k, False: 1.33k] | | | | ------------------ | | | | 69| 2.66k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.66k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.66k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.66k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.66k| } else { \ | | | | 75| 2.66k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.66k| } \ | | | | 77| 2.66k| } | | ------------------ ------------------ 3787| 1.33k|#line 134 "flex_lexer.l" 3788| 1.33k|TOKEN(IN) ------------------ | | 3060| 1.33k|#define TOKEN(name) { return SQL_##name; } ------------------ 3789| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3790| 1.99k|case 75: ------------------ | Branch (3790:1): [True: 1.99k, False: 8.16M] ------------------ 3791| 1.99k|YY_RULE_SETUP ------------------ | | 3320| 1.99k| YY_USER_ACTION | | ------------------ | | | | 66| 1.99k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.99k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.95k, False: 1.99k] | | | | ------------------ | | | | 69| 9.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.95k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.95k| } else { \ | | | | 75| 9.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.95k| } \ | | | | 77| 9.95k| } | | ------------------ ------------------ 3792| 1.99k|#line 135 "flex_lexer.l" 3793| 1.99k|TOKEN(INDEX) ------------------ | | 3060| 1.99k|#define TOKEN(name) { return SQL_##name; } ------------------ 3794| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3795| 719|case 76: ------------------ | Branch (3795:1): [True: 719, False: 8.16M] ------------------ 3796| 719|YY_RULE_SETUP ------------------ | | 3320| 719| YY_USER_ACTION | | ------------------ | | | | 66| 719| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 719| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 719| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.31k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.31k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.59k, False: 719] | | | | ------------------ | | | | 69| 3.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.59k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.59k| } else { \ | | | | 75| 3.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.59k| } \ | | | | 77| 3.59k| } | | ------------------ ------------------ 3797| 719|#line 136 "flex_lexer.l" 3798| 719|TOKEN(INNER) ------------------ | | 3060| 719|#define TOKEN(name) { return SQL_##name; } ------------------ 3799| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3800| 1.64k|case 77: ------------------ | Branch (3800:1): [True: 1.64k, False: 8.16M] ------------------ 3801| 1.64k|YY_RULE_SETUP ------------------ | | 3320| 1.64k| YY_USER_ACTION | | ------------------ | | | | 66| 1.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.5k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.89k, False: 1.64k] | | | | ------------------ | | | | 69| 9.89k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.89k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.89k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.89k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.89k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.89k| } else { \ | | | | 75| 9.89k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.89k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.89k| } \ | | | | 77| 9.89k| } | | ------------------ ------------------ 3802| 1.64k|#line 137 "flex_lexer.l" 3803| 1.64k|TOKEN(INSERT) ------------------ | | 3060| 1.64k|#define TOKEN(name) { return SQL_##name; } ------------------ 3804| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3805| 268k|case 78: ------------------ | Branch (3805:1): [True: 268k, False: 7.90M] ------------------ 3806| 268k|YY_RULE_SETUP ------------------ | | 3320| 268k| YY_USER_ACTION | | ------------------ | | | | 66| 268k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 268k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 268k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 268k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 268k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 268k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.07M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.07M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 806k, False: 268k] | | | | ------------------ | | | | 69| 806k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 806k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 806k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 806k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 806k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 806k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 806k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 806k| } else { \ | | | | 75| 806k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 806k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 806k| } \ | | | | 77| 806k| } | | ------------------ ------------------ 3807| 268k|#line 138 "flex_lexer.l" 3808| 268k|TOKEN(INT) ------------------ | | 3060| 268k|#define TOKEN(name) { return SQL_##name; } ------------------ 3809| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3810| 605|case 79: ------------------ | Branch (3810:1): [True: 605, False: 8.16M] ------------------ 3811| 605|YY_RULE_SETUP ------------------ | | 3320| 605| YY_USER_ACTION | | ------------------ | | | | 66| 605| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 605| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 605| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 605| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 605| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 605| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.23k, False: 605] | | | | ------------------ | | | | 69| 4.23k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.23k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.23k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.23k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.23k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.23k| } else { \ | | | | 75| 4.23k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.23k| } \ | | | | 77| 4.23k| } | | ------------------ ------------------ 3812| 605|#line 139 "flex_lexer.l" 3813| 605|TOKEN(INTEGER) ------------------ | | 3060| 605|#define TOKEN(name) { return SQL_##name; } ------------------ 3814| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3815| 618|case 80: ------------------ | Branch (3815:1): [True: 618, False: 8.16M] ------------------ 3816| 618|YY_RULE_SETUP ------------------ | | 3320| 618| YY_USER_ACTION | | ------------------ | | | | 66| 618| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 618| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 618| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 618| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 618| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 618| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.56k, False: 618] | | | | ------------------ | | | | 69| 5.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.56k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.56k| } else { \ | | | | 75| 5.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.56k| } \ | | | | 77| 5.56k| } | | ------------------ ------------------ 3817| 618|#line 140 "flex_lexer.l" 3818| 618|TOKEN(INTERSECT) ------------------ | | 3060| 618|#define TOKEN(name) { return SQL_##name; } ------------------ 3819| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3820| 3.26k|case 81: ------------------ | Branch (3820:1): [True: 3.26k, False: 8.16M] ------------------ 3821| 3.26k|YY_RULE_SETUP ------------------ | | 3320| 3.26k| YY_USER_ACTION | | ------------------ | | | | 66| 3.26k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.26k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 29.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 29.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 26.1k, False: 3.26k] | | | | ------------------ | | | | 69| 26.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 26.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 26.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 26.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 26.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 26.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 26.1k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 26.1k| } else { \ | | | | 75| 26.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 26.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 26.1k| } \ | | | | 77| 26.1k| } | | ------------------ ------------------ 3822| 3.26k|#line 141 "flex_lexer.l" 3823| 3.26k|TOKEN(INTERVAL) ------------------ | | 3060| 3.26k|#define TOKEN(name) { return SQL_##name; } ------------------ 3824| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3825| 1.64k|case 82: ------------------ | Branch (3825:1): [True: 1.64k, False: 8.16M] ------------------ 3826| 1.64k|YY_RULE_SETUP ------------------ | | 3320| 1.64k| YY_USER_ACTION | | ------------------ | | | | 66| 1.64k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.64k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.20k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.20k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.56k, False: 1.64k] | | | | ------------------ | | | | 69| 6.56k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.56k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.56k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.56k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.56k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.56k| } else { \ | | | | 75| 6.56k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.56k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.56k| } \ | | | | 77| 6.56k| } | | ------------------ ------------------ 3827| 1.64k|#line 142 "flex_lexer.l" 3828| 1.64k|TOKEN(INTO) ------------------ | | 3060| 1.64k|#define TOKEN(name) { return SQL_##name; } ------------------ 3829| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3830| 478|case 83: ------------------ | Branch (3830:1): [True: 478, False: 8.16M] ------------------ 3831| 478|YY_RULE_SETUP ------------------ | | 3320| 478| YY_USER_ACTION | | ------------------ | | | | 66| 478| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 478| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 478| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 478| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 478| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 478| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 956, False: 478] | | | | ------------------ | | | | 69| 956| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 956| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 956| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 956| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 956| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 956|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 956] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 956| } else { \ | | | | 75| 956| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 956| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 956| } \ | | | | 77| 956| } | | ------------------ ------------------ 3832| 478|#line 143 "flex_lexer.l" 3833| 478|TOKEN(IS) ------------------ | | 3060| 478|#define TOKEN(name) { return SQL_##name; } ------------------ 3834| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3835| 536|case 84: ------------------ | Branch (3835:1): [True: 536, False: 8.16M] ------------------ 3836| 536|YY_RULE_SETUP ------------------ | | 3320| 536| YY_USER_ACTION | | ------------------ | | | | 66| 536| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 536| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 536| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 536| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 536| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 536| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.75k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.21k, False: 536] | | | | ------------------ | | | | 69| 3.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.21k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.21k| } else { \ | | | | 75| 3.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.21k| } \ | | | | 77| 3.21k| } | | ------------------ ------------------ 3837| 536|#line 144 "flex_lexer.l" 3838| 536|TOKEN(ISNULL) ------------------ | | 3060| 536|#define TOKEN(name) { return SQL_##name; } ------------------ 3839| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3840| 113k|case 85: ------------------ | Branch (3840:1): [True: 113k, False: 8.05M] ------------------ 3841| 113k|YY_RULE_SETUP ------------------ | | 3320| 113k| YY_USER_ACTION | | ------------------ | | | | 66| 113k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 113k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 113k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 565k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 565k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 452k, False: 113k] | | | | ------------------ | | | | 69| 452k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 452k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 452k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 452k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 452k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 452k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 452k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 452k| } else { \ | | | | 75| 452k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 452k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 452k| } \ | | | | 77| 452k| } | | ------------------ ------------------ 3842| 113k|#line 145 "flex_lexer.l" 3843| 113k|TOKEN(JOIN) ------------------ | | 3060| 113k|#define TOKEN(name) { return SQL_##name; } ------------------ 3844| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3845| 1.88k|case 86: ------------------ | Branch (3845:1): [True: 1.88k, False: 8.16M] ------------------ 3846| 1.88k|YY_RULE_SETUP ------------------ | | 3320| 1.88k| YY_USER_ACTION | | ------------------ | | | | 66| 1.88k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.88k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.88k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.52k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.52k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.64k, False: 1.88k] | | | | ------------------ | | | | 69| 5.64k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.64k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.64k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.64k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.64k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.64k| } else { \ | | | | 75| 5.64k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.64k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.64k| } \ | | | | 77| 5.64k| } | | ------------------ ------------------ 3847| 1.88k|#line 146 "flex_lexer.l" 3848| 1.88k|TOKEN(KEY) ------------------ | | 3060| 1.88k|#define TOKEN(name) { return SQL_##name; } ------------------ 3849| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3850| 958|case 87: ------------------ | Branch (3850:1): [True: 958, False: 8.16M] ------------------ 3851| 958|YY_RULE_SETUP ------------------ | | 3320| 958| YY_USER_ACTION | | ------------------ | | | | 66| 958| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 958| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 958| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 958| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 958| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 958| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.79k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.83k, False: 958] | | | | ------------------ | | | | 69| 3.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.83k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.83k| } else { \ | | | | 75| 3.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.83k| } \ | | | | 77| 3.83k| } | | ------------------ ------------------ 3852| 958|#line 147 "flex_lexer.l" 3853| 958|TOKEN(LEFT) ------------------ | | 3060| 958|#define TOKEN(name) { return SQL_##name; } ------------------ 3854| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3855| 738|case 88: ------------------ | Branch (3855:1): [True: 738, False: 8.16M] ------------------ 3856| 738|YY_RULE_SETUP ------------------ | | 3320| 738| YY_USER_ACTION | | ------------------ | | | | 66| 738| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 738| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.95k, False: 738] | | | | ------------------ | | | | 69| 2.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.95k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.95k| } else { \ | | | | 75| 2.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.95k| } \ | | | | 77| 2.95k| } | | ------------------ ------------------ 3857| 738|#line 148 "flex_lexer.l" 3858| 738|TOKEN(LIKE) ------------------ | | 3060| 738|#define TOKEN(name) { return SQL_##name; } ------------------ 3859| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3860| 3.43k|case 89: ------------------ | Branch (3860:1): [True: 3.43k, False: 8.16M] ------------------ 3861| 3.43k|YY_RULE_SETUP ------------------ | | 3320| 3.43k| YY_USER_ACTION | | ------------------ | | | | 66| 3.43k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.43k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.43k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 20.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 20.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 17.1k, False: 3.43k] | | | | ------------------ | | | | 69| 17.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 17.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 17.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 17.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 17.1k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 17.1k| } else { \ | | | | 75| 17.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 17.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 17.1k| } \ | | | | 77| 17.1k| } | | ------------------ ------------------ 3862| 3.43k|#line 149 "flex_lexer.l" 3863| 3.43k|TOKEN(LIMIT) ------------------ | | 3060| 3.43k|#define TOKEN(name) { return SQL_##name; } ------------------ 3864| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3865| 2|case 90: ------------------ | Branch (3865:1): [True: 2, False: 8.17M] ------------------ 3866| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 2] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3867| 2|#line 150 "flex_lexer.l" 3868| 2|TOKEN(LOAD) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3869| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3870| 1|case 91: ------------------ | Branch (3870:1): [True: 1, False: 8.17M] ------------------ 3871| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5, False: 1] | | | | ------------------ | | | | 69| 5| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5| } else { \ | | | | 75| 5| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5| } \ | | | | 77| 5| } | | ------------------ ------------------ 3872| 1|#line 151 "flex_lexer.l" 3873| 1|TOKEN(LOCAL) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3874| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3875| 2|case 92: ------------------ | Branch (3875:1): [True: 2, False: 8.17M] ------------------ 3876| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3877| 2|#line 152 "flex_lexer.l" 3878| 2|TOKEN(LOCKED) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3879| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3880| 568|case 93: ------------------ | Branch (3880:1): [True: 568, False: 8.16M] ------------------ 3881| 568|YY_RULE_SETUP ------------------ | | 3320| 568| YY_USER_ACTION | | ------------------ | | | | 66| 568| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 568| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 568| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 568| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 568| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 568| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.84k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.84k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.27k, False: 568] | | | | ------------------ | | | | 69| 2.27k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.27k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.27k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.27k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.27k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.27k| } else { \ | | | | 75| 2.27k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.27k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.27k| } \ | | | | 77| 2.27k| } | | ------------------ ------------------ 3882| 568|#line 153 "flex_lexer.l" 3883| 568|TOKEN(LONG) ------------------ | | 3060| 568|#define TOKEN(name) { return SQL_##name; } ------------------ 3884| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3885| 2|case 94: ------------------ | Branch (3885:1): [True: 2, False: 8.17M] ------------------ 3886| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3887| 2|#line 154 "flex_lexer.l" 3888| 2|TOKEN(MERGE) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3889| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3890| 2|case 95: ------------------ | Branch (3890:1): [True: 2, False: 8.17M] ------------------ 3891| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10, False: 2] | | | | ------------------ | | | | 69| 10| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10| } else { \ | | | | 75| 10| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10| } \ | | | | 77| 10| } | | ------------------ ------------------ 3892| 2|#line 155 "flex_lexer.l" 3893| 2|TOKEN(MINUS) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 3894| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3895| 576|case 96: ------------------ | Branch (3895:1): [True: 576, False: 8.16M] ------------------ 3896| 576|YY_RULE_SETUP ------------------ | | 3320| 576| YY_USER_ACTION | | ------------------ | | | | 66| 576| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 576| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 576| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.03k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.03k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.45k, False: 576] | | | | ------------------ | | | | 69| 3.45k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.45k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.45k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.45k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.45k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.45k| } else { \ | | | | 75| 3.45k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.45k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.45k| } \ | | | | 77| 3.45k| } | | ------------------ ------------------ 3897| 576|#line 156 "flex_lexer.l" 3898| 576|TOKEN(MINUTE) ------------------ | | 3060| 576|#define TOKEN(name) { return SQL_##name; } ------------------ 3899| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3900| 653|case 97: ------------------ | Branch (3900:1): [True: 653, False: 8.16M] ------------------ 3901| 653|YY_RULE_SETUP ------------------ | | 3320| 653| YY_USER_ACTION | | ------------------ | | | | 66| 653| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 653| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 653| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.57k, False: 653] | | | | ------------------ | | | | 69| 4.57k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.57k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.57k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.57k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.57k| } else { \ | | | | 75| 4.57k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.57k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.57k| } \ | | | | 77| 4.57k| } | | ------------------ ------------------ 3902| 653|#line 157 "flex_lexer.l" 3903| 653|TOKEN(MINUTES) ------------------ | | 3060| 653|#define TOKEN(name) { return SQL_##name; } ------------------ 3904| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3905| 739|case 98: ------------------ | Branch (3905:1): [True: 739, False: 8.16M] ------------------ 3906| 739|YY_RULE_SETUP ------------------ | | 3320| 739| YY_USER_ACTION | | ------------------ | | | | 66| 739| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 739| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 739| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.43k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.43k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.69k, False: 739] | | | | ------------------ | | | | 69| 3.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.69k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.69k| } else { \ | | | | 75| 3.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.69k| } \ | | | | 77| 3.69k| } | | ------------------ ------------------ 3907| 739|#line 158 "flex_lexer.l" 3908| 739|TOKEN(MONTH) ------------------ | | 3060| 739|#define TOKEN(name) { return SQL_##name; } ------------------ 3909| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3910| 809|case 99: ------------------ | Branch (3910:1): [True: 809, False: 8.16M] ------------------ 3911| 809|YY_RULE_SETUP ------------------ | | 3320| 809| YY_USER_ACTION | | ------------------ | | | | 66| 809| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 809| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 809| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 809| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 809| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 809| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.66k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.66k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.85k, False: 809] | | | | ------------------ | | | | 69| 4.85k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.85k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.85k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.85k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.85k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.85k| } else { \ | | | | 75| 4.85k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.85k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.85k| } \ | | | | 77| 4.85k| } | | ------------------ ------------------ 3912| 809|#line 159 "flex_lexer.l" 3913| 809|TOKEN(MONTHS) ------------------ | | 3060| 809|#define TOKEN(name) { return SQL_##name; } ------------------ 3914| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3915| 684|case 100: ------------------ | Branch (3915:1): [True: 684, False: 8.16M] ------------------ 3916| 684|YY_RULE_SETUP ------------------ | | 3320| 684| YY_USER_ACTION | | ------------------ | | | | 66| 684| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 684| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 684| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 684| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 684| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 684| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.47k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.47k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.78k, False: 684] | | | | ------------------ | | | | 69| 4.78k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.78k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.78k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.78k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.78k| } else { \ | | | | 75| 4.78k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.78k| } \ | | | | 77| 4.78k| } | | ------------------ ------------------ 3917| 684|#line 160 "flex_lexer.l" 3918| 684|TOKEN(NATURAL) ------------------ | | 3060| 684|#define TOKEN(name) { return SQL_##name; } ------------------ 3919| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3920| 6|case 101: ------------------ | Branch (3920:1): [True: 6, False: 8.17M] ------------------ 3921| 6|YY_RULE_SETUP ------------------ | | 3320| 6| YY_USER_ACTION | | ------------------ | | | | 66| 6| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 6| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 6] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3922| 6|#line 161 "flex_lexer.l" 3923| 6|TOKEN(NO) ------------------ | | 3060| 6|#define TOKEN(name) { return SQL_##name; } ------------------ 3924| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3925| 3.20k|case 102: ------------------ | Branch (3925:1): [True: 3.20k, False: 8.16M] ------------------ 3926| 3.20k|YY_RULE_SETUP ------------------ | | 3320| 3.20k| YY_USER_ACTION | | ------------------ | | | | 66| 3.20k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.20k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.20k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.60k, False: 3.20k] | | | | ------------------ | | | | 69| 9.60k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.60k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.60k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.60k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.60k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.60k| } else { \ | | | | 75| 9.60k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.60k| } \ | | | | 77| 9.60k| } | | ------------------ ------------------ 3927| 3.20k|#line 162 "flex_lexer.l" 3928| 3.20k|TOKEN(NOT) ------------------ | | 3060| 3.20k|#define TOKEN(name) { return SQL_##name; } ------------------ 3929| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3930| 580|case 103: ------------------ | Branch (3930:1): [True: 580, False: 8.16M] ------------------ 3931| 580|YY_RULE_SETUP ------------------ | | 3320| 580| YY_USER_ACTION | | ------------------ | | | | 66| 580| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 580| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.06k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.06k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.48k, False: 580] | | | | ------------------ | | | | 69| 3.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.48k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.48k| } else { \ | | | | 75| 3.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.48k| } \ | | | | 77| 3.48k| } | | ------------------ ------------------ 3932| 580|#line 163 "flex_lexer.l" 3933| 580|TOKEN(NOWAIT) ------------------ | | 3060| 580|#define TOKEN(name) { return SQL_##name; } ------------------ 3934| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3935| 4.72k|case 104: ------------------ | Branch (3935:1): [True: 4.72k, False: 8.16M] ------------------ 3936| 4.72k|YY_RULE_SETUP ------------------ | | 3320| 4.72k| YY_USER_ACTION | | ------------------ | | | | 66| 4.72k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.72k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 23.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 23.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 18.9k, False: 4.72k] | | | | ------------------ | | | | 69| 18.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 18.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 18.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 18.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 18.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 18.9k| } else { \ | | | | 75| 18.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 18.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 18.9k| } \ | | | | 77| 18.9k| } | | ------------------ ------------------ 3937| 4.72k|#line 164 "flex_lexer.l" 3938| 4.72k|TOKEN(NULL) ------------------ | | 3060| 4.72k|#define TOKEN(name) { return SQL_##name; } ------------------ 3939| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3940| 1|case 105: ------------------ | Branch (3940:1): [True: 1, False: 8.17M] ------------------ 3941| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 1] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 3942| 1|#line 165 "flex_lexer.l" 3943| 1|TOKEN(NVARCHAR) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 3944| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3945| 290|case 106: ------------------ | Branch (3945:1): [True: 290, False: 8.16M] ------------------ 3946| 290|YY_RULE_SETUP ------------------ | | 3320| 290| YY_USER_ACTION | | ------------------ | | | | 66| 290| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 290| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 290| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 290| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 290| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 290| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 870| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 870|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 580, False: 290] | | | | ------------------ | | | | 69| 580| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 580| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 580| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 580|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 580] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 580| } else { \ | | | | 75| 580| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 580| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 580| } \ | | | | 77| 580| } | | ------------------ ------------------ 3947| 290|#line 166 "flex_lexer.l" 3948| 290|TOKEN(OF) ------------------ | | 3060| 290|#define TOKEN(name) { return SQL_##name; } ------------------ 3949| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3950| 3|case 107: ------------------ | Branch (3950:1): [True: 3, False: 8.17M] ------------------ 3951| 3|YY_RULE_SETUP ------------------ | | 3320| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9, False: 3] | | | | ------------------ | | | | 69| 9| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9| } else { \ | | | | 75| 9| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9| } \ | | | | 77| 9| } | | ------------------ ------------------ 3952| 3|#line 167 "flex_lexer.l" 3953| 3|TOKEN(OFF) ------------------ | | 3060| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3954| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3955| 1.25k|case 108: ------------------ | Branch (3955:1): [True: 1.25k, False: 8.16M] ------------------ 3956| 1.25k|YY_RULE_SETUP ------------------ | | 3320| 1.25k| YY_USER_ACTION | | ------------------ | | | | 66| 1.25k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.25k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.25k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8.79k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8.79k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.53k, False: 1.25k] | | | | ------------------ | | | | 69| 7.53k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.53k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.53k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.53k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.53k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.53k| } else { \ | | | | 75| 7.53k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.53k| } \ | | | | 77| 7.53k| } | | ------------------ ------------------ 3957| 1.25k|#line 168 "flex_lexer.l" 3958| 1.25k|TOKEN(OFFSET) ------------------ | | 3060| 1.25k|#define TOKEN(name) { return SQL_##name; } ------------------ 3959| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3960| 110k|case 109: ------------------ | Branch (3960:1): [True: 110k, False: 8.06M] ------------------ 3961| 110k|YY_RULE_SETUP ------------------ | | 3320| 110k| YY_USER_ACTION | | ------------------ | | | | 66| 110k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 110k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 110k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 330k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 330k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 220k, False: 110k] | | | | ------------------ | | | | 69| 220k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 220k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 220k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 220k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 220k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 220k| } else { \ | | | | 75| 220k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 220k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 220k| } \ | | | | 77| 220k| } | | ------------------ ------------------ 3962| 110k|#line 169 "flex_lexer.l" 3963| 110k|TOKEN(ON) ------------------ | | 3060| 110k|#define TOKEN(name) { return SQL_##name; } ------------------ 3964| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3965| 350|case 110: ------------------ | Branch (3965:1): [True: 350, False: 8.16M] ------------------ 3966| 350|YY_RULE_SETUP ------------------ | | 3320| 350| YY_USER_ACTION | | ------------------ | | | | 66| 350| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 350| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 350| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 700, False: 350] | | | | ------------------ | | | | 69| 700| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 700| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 700| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 700|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 700] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 700| } else { \ | | | | 75| 700| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 700| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 700| } \ | | | | 77| 700| } | | ------------------ ------------------ 3967| 350|#line 170 "flex_lexer.l" 3968| 350|TOKEN(OR) ------------------ | | 3060| 350|#define TOKEN(name) { return SQL_##name; } ------------------ 3969| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3970| 2.07k|case 111: ------------------ | Branch (3970:1): [True: 2.07k, False: 8.16M] ------------------ 3971| 2.07k|YY_RULE_SETUP ------------------ | | 3320| 2.07k| YY_USER_ACTION | | ------------------ | | | | 66| 2.07k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.07k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.07k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.3k, False: 2.07k] | | | | ------------------ | | | | 69| 10.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.3k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.3k| } else { \ | | | | 75| 10.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.3k| } \ | | | | 77| 10.3k| } | | ------------------ ------------------ 3972| 2.07k|#line 171 "flex_lexer.l" 3973| 2.07k|TOKEN(ORDER) ------------------ | | 3060| 2.07k|#define TOKEN(name) { return SQL_##name; } ------------------ 3974| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3975| 1.05k|case 112: ------------------ | Branch (3975:1): [True: 1.05k, False: 8.16M] ------------------ 3976| 1.05k|YY_RULE_SETUP ------------------ | | 3320| 1.05k| YY_USER_ACTION | | ------------------ | | | | 66| 1.05k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.05k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.34k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.28k, False: 1.05k] | | | | ------------------ | | | | 69| 5.28k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.28k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.28k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.28k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.28k| } else { \ | | | | 75| 5.28k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.28k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.28k| } \ | | | | 77| 5.28k| } | | ------------------ ------------------ 3977| 1.05k|#line 172 "flex_lexer.l" 3978| 1.05k|TOKEN(OUTER) ------------------ | | 3060| 1.05k|#define TOKEN(name) { return SQL_##name; } ------------------ 3979| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3980| 874|case 113: ------------------ | Branch (3980:1): [True: 874, False: 8.16M] ------------------ 3981| 874|YY_RULE_SETUP ------------------ | | 3320| 874| YY_USER_ACTION | | ------------------ | | | | 66| 874| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 874| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 874| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 874| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 874| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 874| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.37k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.37k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.49k, False: 874] | | | | ------------------ | | | | 69| 3.49k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.49k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.49k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.49k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.49k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.49k| } else { \ | | | | 75| 3.49k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.49k| } \ | | | | 77| 3.49k| } | | ------------------ ------------------ 3982| 874|#line 173 "flex_lexer.l" 3983| 874|TOKEN(OVER) ------------------ | | 3060| 874|#define TOKEN(name) { return SQL_##name; } ------------------ 3984| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3985| 0|case 114: ------------------ | Branch (3985:1): [True: 0, False: 8.17M] ------------------ 3986| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3987| 0|#line 174 "flex_lexer.l" 3988| 0|TOKEN(PARAMETERS) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3989| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3990| 0|case 115: ------------------ | Branch (3990:1): [True: 0, False: 8.17M] ------------------ 3991| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 3992| 0|#line 175 "flex_lexer.l" 3993| 0|TOKEN(PARTITION) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 3994| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 3995| 3|case 116: ------------------ | Branch (3995:1): [True: 3, False: 8.17M] ------------------ 3996| 3|YY_RULE_SETUP ------------------ | | 3320| 3| YY_USER_ACTION | | ------------------ | | | | 66| 3| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 3] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 3997| 3|#line 176 "flex_lexer.l" 3998| 3|TOKEN(PLAN) ------------------ | | 3060| 3|#define TOKEN(name) { return SQL_##name; } ------------------ 3999| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4000| 0|case 117: ------------------ | Branch (4000:1): [True: 0, False: 8.17M] ------------------ 4001| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4002| 0|#line 177 "flex_lexer.l" 4003| 0|TOKEN(PRECEDING) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4004| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4005| 1.48k|case 118: ------------------ | Branch (4005:1): [True: 1.48k, False: 8.16M] ------------------ 4006| 1.48k|YY_RULE_SETUP ------------------ | | 3320| 1.48k| YY_USER_ACTION | | ------------------ | | | | 66| 1.48k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.48k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 11.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 11.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.3k, False: 1.48k] | | | | ------------------ | | | | 69| 10.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.3k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.3k| } else { \ | | | | 75| 10.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.3k| } \ | | | | 77| 10.3k| } | | ------------------ ------------------ 4007| 1.48k|#line 178 "flex_lexer.l" 4008| 1.48k|TOKEN(PREPARE) ------------------ | | 3060| 1.48k|#define TOKEN(name) { return SQL_##name; } ------------------ 4009| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4010| 1.83k|case 119: ------------------ | Branch (4010:1): [True: 1.83k, False: 8.16M] ------------------ 4011| 1.83k|YY_RULE_SETUP ------------------ | | 3320| 1.83k| YY_USER_ACTION | | ------------------ | | | | 66| 1.83k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.83k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14.6k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14.6k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12.8k, False: 1.83k] | | | | ------------------ | | | | 69| 12.8k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12.8k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.8k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12.8k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12.8k| } else { \ | | | | 75| 12.8k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12.8k| } \ | | | | 77| 12.8k| } | | ------------------ ------------------ 4012| 1.83k|#line 179 "flex_lexer.l" 4013| 1.83k|TOKEN(PRIMARY) ------------------ | | 3060| 1.83k|#define TOKEN(name) { return SQL_##name; } ------------------ 4014| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4015| 4|case 120: ------------------ | Branch (4015:1): [True: 4, False: 8.17M] ------------------ 4016| 4|YY_RULE_SETUP ------------------ | | 3320| 4| YY_USER_ACTION | | ------------------ | | | | 66| 4| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 24| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 24|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 20, False: 4] | | | | ------------------ | | | | 69| 20| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 20| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 20| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 20|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 20] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 20| } else { \ | | | | 75| 20| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 20| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 20| } \ | | | | 77| 20| } | | ------------------ ------------------ 4017| 4|#line 180 "flex_lexer.l" 4018| 4|TOKEN(RANGE) ------------------ | | 3060| 4|#define TOKEN(name) { return SQL_##name; } ------------------ 4019| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4020| 565|case 121: ------------------ | Branch (4020:1): [True: 565, False: 8.16M] ------------------ 4021| 565|YY_RULE_SETUP ------------------ | | 3320| 565| YY_USER_ACTION | | ------------------ | | | | 66| 565| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 565| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 565| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.82k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.82k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.26k, False: 565] | | | | ------------------ | | | | 69| 2.26k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.26k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.26k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.26k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.26k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.26k| } else { \ | | | | 75| 2.26k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.26k| } \ | | | | 77| 2.26k| } | | ------------------ ------------------ 4022| 565|#line 181 "flex_lexer.l" 4023| 565|TOKEN(REAL) ------------------ | | 3060| 565|#define TOKEN(name) { return SQL_##name; } ------------------ 4024| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4025| 2|case 122: ------------------ | Branch (4025:1): [True: 2, False: 8.17M] ------------------ 4026| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 4027| 2|#line 182 "flex_lexer.l" 4028| 2|TOKEN(RENAME) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4029| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4030| 1|case 123: ------------------ | Branch (4030:1): [True: 1, False: 8.17M] ------------------ 4031| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 1] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 4032| 1|#line 183 "flex_lexer.l" 4033| 1|TOKEN(RESTRICT) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 4034| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4035| 566|case 124: ------------------ | Branch (4035:1): [True: 566, False: 8.16M] ------------------ 4036| 566|YY_RULE_SETUP ------------------ | | 3320| 566| YY_USER_ACTION | | ------------------ | | | | 66| 566| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 566| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 566| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.83k, False: 566] | | | | ------------------ | | | | 69| 2.83k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.83k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.83k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.83k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.83k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.83k| } else { \ | | | | 75| 2.83k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.83k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.83k| } \ | | | | 77| 2.83k| } | | ------------------ ------------------ 4037| 566|#line 184 "flex_lexer.l" 4038| 566|TOKEN(RIGHT) ------------------ | | 3060| 566|#define TOKEN(name) { return SQL_##name; } ------------------ 4039| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4040| 369|case 125: ------------------ | Branch (4040:1): [True: 369, False: 8.16M] ------------------ 4041| 369|YY_RULE_SETUP ------------------ | | 3320| 369| YY_USER_ACTION | | ------------------ | | | | 66| 369| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 369| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 369| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 369| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 369| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 369| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.32k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.95k, False: 369] | | | | ------------------ | | | | 69| 2.95k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.95k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.95k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.95k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.95k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.95k| } else { \ | | | | 75| 2.95k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.95k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.95k| } \ | | | | 77| 2.95k| } | | ------------------ ------------------ 4042| 369|#line 185 "flex_lexer.l" 4043| 369|TOKEN(ROLLBACK) ------------------ | | 3060| 369|#define TOKEN(name) { return SQL_##name; } ------------------ 4044| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4045| 4|case 126: ------------------ | Branch (4045:1): [True: 4, False: 8.17M] ------------------ 4046| 4|YY_RULE_SETUP ------------------ | | 3320| 4| YY_USER_ACTION | | ------------------ | | | | 66| 4| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 20| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 20|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16, False: 4] | | | | ------------------ | | | | 69| 16| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 16] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16| } else { \ | | | | 75| 16| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 16| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16| } \ | | | | 77| 16| } | | ------------------ ------------------ 4047| 4|#line 186 "flex_lexer.l" 4048| 4|TOKEN(ROWS) ------------------ | | 3060| 4|#define TOKEN(name) { return SQL_##name; } ------------------ 4049| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4050| 2|case 127: ------------------ | Branch (4050:1): [True: 2, False: 8.17M] ------------------ 4051| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 4052| 2|#line 187 "flex_lexer.l" 4053| 2|TOKEN(SCHEMA) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4054| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4055| 2|case 128: ------------------ | Branch (4055:1): [True: 2, False: 8.17M] ------------------ 4056| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 14, False: 2] | | | | ------------------ | | | | 69| 14| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 14| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 14| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 14] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 14| } else { \ | | | | 75| 14| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 14| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 14| } \ | | | | 77| 14| } | | ------------------ ------------------ 4057| 2|#line 188 "flex_lexer.l" 4058| 2|TOKEN(SCHEMAS) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4059| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4060| 771|case 129: ------------------ | Branch (4060:1): [True: 771, False: 8.16M] ------------------ 4061| 771|YY_RULE_SETUP ------------------ | | 3320| 771| YY_USER_ACTION | | ------------------ | | | | 66| 771| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 771| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 771| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.39k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.39k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.62k, False: 771] | | | | ------------------ | | | | 69| 4.62k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.62k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.62k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.62k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.62k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.62k| } else { \ | | | | 75| 4.62k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.62k| } \ | | | | 77| 4.62k| } | | ------------------ ------------------ 4062| 771|#line 189 "flex_lexer.l" 4063| 771|TOKEN(SECOND) ------------------ | | 3060| 771|#define TOKEN(name) { return SQL_##name; } ------------------ 4064| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4065| 632|case 130: ------------------ | Branch (4065:1): [True: 632, False: 8.16M] ------------------ 4066| 632|YY_RULE_SETUP ------------------ | | 3320| 632| YY_USER_ACTION | | ------------------ | | | | 66| 632| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 632| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 632| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.05k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.42k, False: 632] | | | | ------------------ | | | | 69| 4.42k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.42k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.42k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.42k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.42k| } else { \ | | | | 75| 4.42k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.42k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.42k| } \ | | | | 77| 4.42k| } | | ------------------ ------------------ 4067| 632|#line 190 "flex_lexer.l" 4068| 632|TOKEN(SECONDS) ------------------ | | 3060| 632|#define TOKEN(name) { return SQL_##name; } ------------------ 4069| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4070| 24.8k|case 131: ------------------ | Branch (4070:1): [True: 24.8k, False: 8.14M] ------------------ 4071| 24.8k|YY_RULE_SETUP ------------------ | | 3320| 24.8k| YY_USER_ACTION | | ------------------ | | | | 66| 24.8k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 24.8k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 24.8k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 173k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 173k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 148k, False: 24.8k] | | | | ------------------ | | | | 69| 148k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 148k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 148k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 148k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 148k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 148k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 148k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 148k| } else { \ | | | | 75| 148k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 148k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 148k| } \ | | | | 77| 148k| } | | ------------------ ------------------ 4072| 24.8k|#line 191 "flex_lexer.l" 4073| 24.8k|TOKEN(SELECT) ------------------ | | 3060| 24.8k|#define TOKEN(name) { return SQL_##name; } ------------------ 4074| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4075| 971|case 132: ------------------ | Branch (4075:1): [True: 971, False: 8.16M] ------------------ 4076| 971|YY_RULE_SETUP ------------------ | | 3320| 971| YY_USER_ACTION | | ------------------ | | | | 66| 971| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 971| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 971| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 971| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 971| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 971| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.88k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.88k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.91k, False: 971] | | | | ------------------ | | | | 69| 2.91k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.91k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.91k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.91k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.91k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.91k| } else { \ | | | | 75| 2.91k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.91k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.91k| } \ | | | | 77| 2.91k| } | | ------------------ ------------------ 4077| 971|#line 192 "flex_lexer.l" 4078| 971|TOKEN(SET) ------------------ | | 3060| 971|#define TOKEN(name) { return SQL_##name; } ------------------ 4079| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4080| 7.08k|case 133: ------------------ | Branch (4080:1): [True: 7.08k, False: 8.16M] ------------------ 4081| 7.08k|YY_RULE_SETUP ------------------ | | 3320| 7.08k| YY_USER_ACTION | | ------------------ | | | | 66| 7.08k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 7.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 7.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 7.08k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 7.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 7.08k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 42.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 42.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 35.4k, False: 7.08k] | | | | ------------------ | | | | 69| 35.4k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 35.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 35.4k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 35.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 35.4k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 35.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 35.4k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 35.4k| } else { \ | | | | 75| 35.4k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 35.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 35.4k| } \ | | | | 77| 35.4k| } | | ------------------ ------------------ 4082| 7.08k|#line 193 "flex_lexer.l" 4083| 7.08k|TOKEN(SHARE) ------------------ | | 3060| 7.08k|#define TOKEN(name) { return SQL_##name; } ------------------ 4084| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4085| 1.58k|case 134: ------------------ | Branch (4085:1): [True: 1.58k, False: 8.16M] ------------------ 4086| 1.58k|YY_RULE_SETUP ------------------ | | 3320| 1.58k| YY_USER_ACTION | | ------------------ | | | | 66| 1.58k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.58k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.58k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.93k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.93k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.34k, False: 1.58k] | | | | ------------------ | | | | 69| 6.34k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.34k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.34k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.34k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.34k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.34k| } else { \ | | | | 75| 6.34k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.34k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.34k| } \ | | | | 77| 6.34k| } | | ------------------ ------------------ 4087| 1.58k|#line 194 "flex_lexer.l" 4088| 1.58k|TOKEN(SHOW) ------------------ | | 3060| 1.58k|#define TOKEN(name) { return SQL_##name; } ------------------ 4089| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4090| 2|case 135: ------------------ | Branch (4090:1): [True: 2, False: 8.17M] ------------------ 4091| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8, False: 2] | | | | ------------------ | | | | 69| 8| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8| } else { \ | | | | 75| 8| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8| } \ | | | | 77| 8| } | | ------------------ ------------------ 4092| 2|#line 195 "flex_lexer.l" 4093| 2|TOKEN(SKIP) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4094| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4095| 560|case 136: ------------------ | Branch (4095:1): [True: 560, False: 8.16M] ------------------ 4096| 560|YY_RULE_SETUP ------------------ | | 3320| 560| YY_USER_ACTION | | ------------------ | | | | 66| 560| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 560| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 560| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.04k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.04k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.48k, False: 560] | | | | ------------------ | | | | 69| 4.48k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.48k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.48k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.48k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.48k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.48k| } else { \ | | | | 75| 4.48k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.48k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.48k| } \ | | | | 77| 4.48k| } | | ------------------ ------------------ 4097| 560|#line 196 "flex_lexer.l" 4098| 560|TOKEN(SMALLINT) ------------------ | | 3060| 560|#define TOKEN(name) { return SQL_##name; } ------------------ 4099| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4100| 1|case 137: ------------------ | Branch (4100:1): [True: 1, False: 8.17M] ------------------ 4101| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6, False: 1] | | | | ------------------ | | | | 69| 6| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6| } else { \ | | | | 75| 6| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6| } \ | | | | 77| 6| } | | ------------------ ------------------ 4102| 1|#line 197 "flex_lexer.l" 4103| 1|TOKEN(SORTED) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 4104| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4105| 0|case 138: ------------------ | Branch (4105:1): [True: 0, False: 8.17M] ------------------ 4106| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4107| 0|#line 198 "flex_lexer.l" 4108| 0|TOKEN(SPATIAL) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4109| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4110| 2.14k|case 139: ------------------ | Branch (4110:1): [True: 2.14k, False: 8.16M] ------------------ 4111| 2.14k|YY_RULE_SETUP ------------------ | | 3320| 2.14k| YY_USER_ACTION | | ------------------ | | | | 66| 2.14k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.14k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.7k, False: 2.14k] | | | | ------------------ | | | | 69| 10.7k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.7k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.7k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.7k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.7k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.7k| } else { \ | | | | 75| 10.7k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10.7k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.7k| } \ | | | | 77| 10.7k| } | | ------------------ ------------------ 4112| 2.14k|#line 199 "flex_lexer.l" 4113| 2.14k|TOKEN(TABLE) ------------------ | | 3060| 2.14k|#define TOKEN(name) { return SQL_##name; } ------------------ 4114| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4115| 1.11k|case 140: ------------------ | Branch (4115:1): [True: 1.11k, False: 8.16M] ------------------ 4116| 1.11k|YY_RULE_SETUP ------------------ | | 3320| 1.11k| YY_USER_ACTION | | ------------------ | | | | 66| 1.11k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.11k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.11k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 7.78k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 7.78k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 6.67k, False: 1.11k] | | | | ------------------ | | | | 69| 6.67k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 6.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 6.67k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 6.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 6.67k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 6.67k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 6.67k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 6.67k| } else { \ | | | | 75| 6.67k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 6.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 6.67k| } \ | | | | 77| 6.67k| } | | ------------------ ------------------ 4117| 1.11k|#line 200 "flex_lexer.l" 4118| 1.11k|TOKEN(TABLES) ------------------ | | 3060| 1.11k|#define TOKEN(name) { return SQL_##name; } ------------------ 4119| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4120| 0|case 141: ------------------ | Branch (4120:1): [True: 0, False: 8.17M] ------------------ 4121| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4122| 0|#line 201 "flex_lexer.l" 4123| 0|TOKEN(TEMPORARY) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4124| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4125| 338|case 142: ------------------ | Branch (4125:1): [True: 338, False: 8.16M] ------------------ 4126| 338|YY_RULE_SETUP ------------------ | | 3320| 338| YY_USER_ACTION | | ------------------ | | | | 66| 338| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 338| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 338| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 338| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 338| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 338| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.69k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.35k, False: 338] | | | | ------------------ | | | | 69| 1.35k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.35k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.35k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.35k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.35k| } else { \ | | | | 75| 1.35k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.35k| } \ | | | | 77| 1.35k| } | | ------------------ ------------------ 4127| 338|#line 202 "flex_lexer.l" 4128| 338|TOKEN(TEXT) ------------------ | | 3060| 338|#define TOKEN(name) { return SQL_##name; } ------------------ 4129| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4130| 3.26k|case 143: ------------------ | Branch (4130:1): [True: 3.26k, False: 8.16M] ------------------ 4131| 3.26k|YY_RULE_SETUP ------------------ | | 3320| 3.26k| YY_USER_ACTION | | ------------------ | | | | 66| 3.26k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.26k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.26k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 13.0k, False: 3.26k] | | | | ------------------ | | | | 69| 13.0k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 13.0k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.0k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 13.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 13.0k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 13.0k| } else { \ | | | | 75| 13.0k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 13.0k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 13.0k| } \ | | | | 77| 13.0k| } | | ------------------ ------------------ 4132| 3.26k|#line 203 "flex_lexer.l" 4133| 3.26k|TOKEN(THEN) ------------------ | | 3060| 3.26k|#define TOKEN(name) { return SQL_##name; } ------------------ 4134| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4135| 44.9k|case 144: ------------------ | Branch (4135:1): [True: 44.9k, False: 8.12M] ------------------ 4136| 44.9k|YY_RULE_SETUP ------------------ | | 3320| 44.9k| YY_USER_ACTION | | ------------------ | | | | 66| 44.9k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 44.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 44.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 44.9k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 44.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 44.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 224k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 224k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 179k, False: 44.9k] | | | | ------------------ | | | | 69| 179k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 179k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 179k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 179k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 179k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 179k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 179k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 179k| } else { \ | | | | 75| 179k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 179k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 179k| } \ | | | | 77| 179k| } | | ------------------ ------------------ 4137| 44.9k|#line 204 "flex_lexer.l" 4138| 44.9k|TOKEN(TIME) ------------------ | | 3060| 44.9k|#define TOKEN(name) { return SQL_##name; } ------------------ 4139| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4140| 25.4k|case 145: ------------------ | Branch (4140:1): [True: 25.4k, False: 8.14M] ------------------ 4141| 25.4k|YY_RULE_SETUP ------------------ | | 3320| 25.4k| YY_USER_ACTION | | ------------------ | | | | 66| 25.4k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 25.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 25.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 25.4k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 25.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 25.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 254k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 254k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 228k, False: 25.4k] | | | | ------------------ | | | | 69| 228k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 228k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 228k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 228k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 228k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 228k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 228k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 228k| } else { \ | | | | 75| 228k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 228k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 228k| } \ | | | | 77| 228k| } | | ------------------ ------------------ 4142| 25.4k|#line 205 "flex_lexer.l" 4143| 25.4k|TOKEN(TIMESTAMP) ------------------ | | 3060| 25.4k|#define TOKEN(name) { return SQL_##name; } ------------------ 4144| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4145| 1.86k|case 146: ------------------ | Branch (4145:1): [True: 1.86k, False: 8.16M] ------------------ 4146| 1.86k|YY_RULE_SETUP ------------------ | | 3320| 1.86k| YY_USER_ACTION | | ------------------ | | | | 66| 1.86k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.86k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.86k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.73k, False: 1.86k] | | | | ------------------ | | | | 69| 3.73k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.73k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.73k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.73k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.73k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.73k| } else { \ | | | | 75| 3.73k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.73k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.73k| } \ | | | | 77| 3.73k| } | | ------------------ ------------------ 4147| 1.86k|#line 206 "flex_lexer.l" 4148| 1.86k|TOKEN(TO) ------------------ | | 3060| 1.86k|#define TOKEN(name) { return SQL_##name; } ------------------ 4149| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4150| 899|case 147: ------------------ | Branch (4150:1): [True: 899, False: 8.16M] ------------------ 4151| 899|YY_RULE_SETUP ------------------ | | 3320| 899| YY_USER_ACTION | | ------------------ | | | | 66| 899| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 899| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 899| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 899| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 899| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 899| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 3.59k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 3.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.69k, False: 899] | | | | ------------------ | | | | 69| 2.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.69k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.69k| } else { \ | | | | 75| 2.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.69k| } \ | | | | 77| 2.69k| } | | ------------------ ------------------ 4152| 899|#line 207 "flex_lexer.l" 4153| 899|TOKEN(TOP) ------------------ | | 3060| 899|#define TOKEN(name) { return SQL_##name; } ------------------ 4154| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4155| 0|case 148: ------------------ | Branch (4155:1): [True: 0, False: 8.17M] ------------------ 4156| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4157| 0|#line 208 "flex_lexer.l" 4158| 0|TOKEN(TRANSACTION) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4159| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4160| 514|case 149: ------------------ | Branch (4160:1): [True: 514, False: 8.16M] ------------------ 4161| 514|YY_RULE_SETUP ------------------ | | 3320| 514| YY_USER_ACTION | | ------------------ | | | | 66| 514| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 514| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 514| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 514| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 514| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 514| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.57k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.57k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.05k, False: 514] | | | | ------------------ | | | | 69| 2.05k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.05k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.05k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.05k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.05k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.05k| } else { \ | | | | 75| 2.05k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.05k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.05k| } \ | | | | 77| 2.05k| } | | ------------------ ------------------ 4162| 514|#line 209 "flex_lexer.l" 4163| 514|TOKEN(TRUE) ------------------ | | 3060| 514|#define TOKEN(name) { return SQL_##name; } ------------------ 4164| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4165| 699|case 150: ------------------ | Branch (4165:1): [True: 699, False: 8.16M] ------------------ 4166| 699|YY_RULE_SETUP ------------------ | | 3320| 699| YY_USER_ACTION | | ------------------ | | | | 66| 699| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 699| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 699| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 699| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 699| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 699| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.29k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.29k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.59k, False: 699] | | | | ------------------ | | | | 69| 5.59k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.59k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.59k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.59k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.59k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.59k| } else { \ | | | | 75| 5.59k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.59k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.59k| } \ | | | | 77| 5.59k| } | | ------------------ ------------------ 4167| 699|#line 210 "flex_lexer.l" 4168| 699|TOKEN(TRUNCATE) ------------------ | | 3060| 699|#define TOKEN(name) { return SQL_##name; } ------------------ 4169| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4170| 0|case 151: ------------------ | Branch (4170:1): [True: 0, False: 8.17M] ------------------ 4171| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4172| 0|#line 211 "flex_lexer.l" 4173| 0|TOKEN(UNBOUNDED) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4174| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4175| 2.65k|case 152: ------------------ | Branch (4175:1): [True: 2.65k, False: 8.16M] ------------------ 4176| 2.65k|YY_RULE_SETUP ------------------ | | 3320| 2.65k| YY_USER_ACTION | | ------------------ | | | | 66| 2.65k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2.65k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 15.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 15.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 13.2k, False: 2.65k] | | | | ------------------ | | | | 69| 13.2k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 13.2k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.2k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 13.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 13.2k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 13.2k| } else { \ | | | | 75| 13.2k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 13.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 13.2k| } \ | | | | 77| 13.2k| } | | ------------------ ------------------ 4177| 2.65k|#line 212 "flex_lexer.l" 4178| 2.65k|TOKEN(UNION) ------------------ | | 3060| 2.65k|#define TOKEN(name) { return SQL_##name; } ------------------ 4179| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4180| 59.5k|case 153: ------------------ | Branch (4180:1): [True: 59.5k, False: 8.11M] ------------------ 4181| 59.5k|YY_RULE_SETUP ------------------ | | 3320| 59.5k| YY_USER_ACTION | | ------------------ | | | | 66| 59.5k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 59.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 59.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 59.5k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 59.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 59.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 416k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 416k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 357k, False: 59.5k] | | | | ------------------ | | | | 69| 357k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 357k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 357k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 357k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 357k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 357k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 357k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 357k| } else { \ | | | | 75| 357k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 357k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 357k| } \ | | | | 77| 357k| } | | ------------------ ------------------ 4182| 59.5k|#line 213 "flex_lexer.l" 4183| 59.5k|TOKEN(UNIQUE) ------------------ | | 3060| 59.5k|#define TOKEN(name) { return SQL_##name; } ------------------ 4184| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4185| 2|case 154: ------------------ | Branch (4185:1): [True: 2, False: 8.17M] ------------------ 4186| 2|YY_RULE_SETUP ------------------ | | 3320| 2| YY_USER_ACTION | | ------------------ | | | | 66| 2| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 2| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 2| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 14| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 14|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12, False: 2] | | | | ------------------ | | | | 69| 12| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12| } else { \ | | | | 75| 12| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12| } \ | | | | 77| 12| } | | ------------------ ------------------ 4187| 2|#line 214 "flex_lexer.l" 4188| 2|TOKEN(UNLOAD) ------------------ | | 3060| 2|#define TOKEN(name) { return SQL_##name; } ------------------ 4189| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4190| 1.75k|case 155: ------------------ | Branch (4190:1): [True: 1.75k, False: 8.16M] ------------------ 4191| 1.75k|YY_RULE_SETUP ------------------ | | 3320| 1.75k| YY_USER_ACTION | | ------------------ | | | | 66| 1.75k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.75k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.2k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.2k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 10.5k, False: 1.75k] | | | | ------------------ | | | | 69| 10.5k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 10.5k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 10.5k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 10.5k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 10.5k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 10.5k| } else { \ | | | | 75| 10.5k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 10.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 10.5k| } \ | | | | 77| 10.5k| } | | ------------------ ------------------ 4192| 1.75k|#line 215 "flex_lexer.l" 4193| 1.75k|TOKEN(UPDATE) ------------------ | | 3060| 1.75k|#define TOKEN(name) { return SQL_##name; } ------------------ 4194| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4195| 1.53k|case 156: ------------------ | Branch (4195:1): [True: 1.53k, False: 8.16M] ------------------ 4196| 1.53k|YY_RULE_SETUP ------------------ | | 3320| 1.53k| YY_USER_ACTION | | ------------------ | | | | 66| 1.53k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.53k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.53k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.18k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7.65k, False: 1.53k] | | | | ------------------ | | | | 69| 7.65k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7.65k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7.65k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7.65k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7.65k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7.65k| } else { \ | | | | 75| 7.65k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7.65k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7.65k| } \ | | | | 77| 7.65k| } | | ------------------ ------------------ 4197| 1.53k|#line 216 "flex_lexer.l" 4198| 1.53k|TOKEN(USING) ------------------ | | 3060| 1.53k|#define TOKEN(name) { return SQL_##name; } ------------------ 4199| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4200| 626|case 157: ------------------ | Branch (4200:1): [True: 626, False: 8.16M] ------------------ 4201| 626|YY_RULE_SETUP ------------------ | | 3320| 626| YY_USER_ACTION | | ------------------ | | | | 66| 626| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 626| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 626| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 626| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 626| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 626| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.38k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.38k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.75k, False: 626] | | | | ------------------ | | | | 69| 3.75k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.75k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.75k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.75k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.75k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.75k| } else { \ | | | | 75| 3.75k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.75k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.75k| } \ | | | | 77| 3.75k| } | | ------------------ ------------------ 4202| 626|#line 217 "flex_lexer.l" 4203| 626|TOKEN(VALUES) ------------------ | | 3060| 626|#define TOKEN(name) { return SQL_##name; } ------------------ 4204| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4205| 778|case 158: ------------------ | Branch (4205:1): [True: 778, False: 8.16M] ------------------ 4206| 778|YY_RULE_SETUP ------------------ | | 3320| 778| YY_USER_ACTION | | ------------------ | | | | 66| 778| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 778| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 778| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 778| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 778| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 778| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.22k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.22k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.44k, False: 778] | | | | ------------------ | | | | 69| 5.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.44k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.44k| } else { \ | | | | 75| 5.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.44k| } \ | | | | 77| 5.44k| } | | ------------------ ------------------ 4207| 778|#line 218 "flex_lexer.l" 4208| 778|TOKEN(VARCHAR) ------------------ | | 3060| 778|#define TOKEN(name) { return SQL_##name; } ------------------ 4209| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4210| 1.36k|case 159: ------------------ | Branch (4210:1): [True: 1.36k, False: 8.16M] ------------------ 4211| 1.36k|YY_RULE_SETUP ------------------ | | 3320| 1.36k| YY_USER_ACTION | | ------------------ | | | | 66| 1.36k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.36k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.36k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.80k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.80k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.44k, False: 1.36k] | | | | ------------------ | | | | 69| 5.44k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.44k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.44k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.44k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.44k| } else { \ | | | | 75| 5.44k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.44k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.44k| } \ | | | | 77| 5.44k| } | | ------------------ ------------------ 4212| 1.36k|#line 219 "flex_lexer.l" 4213| 1.36k|TOKEN(VIEW) ------------------ | | 3060| 1.36k|#define TOKEN(name) { return SQL_##name; } ------------------ 4214| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4215| 1|case 160: ------------------ | Branch (4215:1): [True: 1, False: 8.17M] ------------------ 4216| 1|YY_RULE_SETUP ------------------ | | 3320| 1| YY_USER_ACTION | | ------------------ | | | | 66| 1| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 8| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 8|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 7, False: 1] | | | | ------------------ | | | | 69| 7| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 7| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 7| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 7|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 7] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 7| } else { \ | | | | 75| 7| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 7| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 7| } \ | | | | 77| 7| } | | ------------------ ------------------ 4217| 1|#line 220 "flex_lexer.l" 4218| 1|TOKEN(VIRTUAL) ------------------ | | 3060| 1|#define TOKEN(name) { return SQL_##name; } ------------------ 4219| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4220| 3.29k|case 161: ------------------ | Branch (4220:1): [True: 3.29k, False: 8.16M] ------------------ 4221| 3.29k|YY_RULE_SETUP ------------------ | | 3320| 3.29k| YY_USER_ACTION | | ------------------ | | | | 66| 3.29k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 3.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 3.29k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 3.29k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.4k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.4k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 13.1k, False: 3.29k] | | | | ------------------ | | | | 69| 13.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 13.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 13.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 13.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 13.1k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 13.1k| } else { \ | | | | 75| 13.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 13.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 13.1k| } \ | | | | 77| 13.1k| } | | ------------------ ------------------ 4222| 3.29k|#line 221 "flex_lexer.l" 4223| 3.29k|TOKEN(WHEN) ------------------ | | 3060| 3.29k|#define TOKEN(name) { return SQL_##name; } ------------------ 4224| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4225| 1.72k|case 162: ------------------ | Branch (4225:1): [True: 1.72k, False: 8.16M] ------------------ 4226| 1.72k|YY_RULE_SETUP ------------------ | | 3320| 1.72k| YY_USER_ACTION | | ------------------ | | | | 66| 1.72k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.72k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.72k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 10.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 10.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 8.61k, False: 1.72k] | | | | ------------------ | | | | 69| 8.61k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 8.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 8.61k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 8.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 8.61k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 8.61k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 8.61k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 8.61k| } else { \ | | | | 75| 8.61k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 8.61k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 8.61k| } \ | | | | 77| 8.61k| } | | ------------------ ------------------ 4227| 1.72k|#line 222 "flex_lexer.l" 4228| 1.72k|TOKEN(WHERE) ------------------ | | 3060| 1.72k|#define TOKEN(name) { return SQL_##name; } ------------------ 4229| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4230| 1.35k|case 163: ------------------ | Branch (4230:1): [True: 1.35k, False: 8.16M] ------------------ 4231| 1.35k|YY_RULE_SETUP ------------------ | | 3320| 1.35k| YY_USER_ACTION | | ------------------ | | | | 66| 1.35k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.35k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.35k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 6.76k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 6.76k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 5.40k, False: 1.35k] | | | | ------------------ | | | | 69| 5.40k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 5.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 5.40k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 5.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 5.40k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 5.40k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 5.40k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 5.40k| } else { \ | | | | 75| 5.40k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 5.40k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 5.40k| } \ | | | | 77| 5.40k| } | | ------------------ ------------------ 4232| 1.35k|#line 223 "flex_lexer.l" 4233| 1.35k|TOKEN(WITH) ------------------ | | 3060| 1.35k|#define TOKEN(name) { return SQL_##name; } ------------------ 4234| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4235| 545|case 164: ------------------ | Branch (4235:1): [True: 545, False: 8.16M] ------------------ 4236| 545|YY_RULE_SETUP ------------------ | | 3320| 545| YY_USER_ACTION | | ------------------ | | | | 66| 545| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 545| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 545| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 545| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 545| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 545| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.72k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.72k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 2.18k, False: 545] | | | | ------------------ | | | | 69| 2.18k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 2.18k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 2.18k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 2.18k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 2.18k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 2.18k| } else { \ | | | | 75| 2.18k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 2.18k| } \ | | | | 77| 2.18k| } | | ------------------ ------------------ 4237| 545|#line 224 "flex_lexer.l" 4238| 545|TOKEN(YEAR) ------------------ | | 3060| 545|#define TOKEN(name) { return SQL_##name; } ------------------ 4239| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4240| 738|case 165: ------------------ | Branch (4240:1): [True: 738, False: 8.16M] ------------------ 4241| 738|YY_RULE_SETUP ------------------ | | 3320| 738| YY_USER_ACTION | | ------------------ | | | | 66| 738| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 738| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 738| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 4.42k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 4.42k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 3.69k, False: 738] | | | | ------------------ | | | | 69| 3.69k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 3.69k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 3.69k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 3.69k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 3.69k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 3.69k| } else { \ | | | | 75| 3.69k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 3.69k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 3.69k| } \ | | | | 77| 3.69k| } | | ------------------ ------------------ 4242| 738|#line 225 "flex_lexer.l" 4243| 738|TOKEN(YEARS) ------------------ | | 3060| 738|#define TOKEN(name) { return SQL_##name; } ------------------ 4244| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4245| 0|case 166: ------------------ | Branch (4245:1): [True: 0, False: 8.17M] ------------------ 4246| |/* rule 166 can match eol */ 4247| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4248| 0|#line 227 "flex_lexer.l" 4249| 0|TOKEN(CURRENT_ROW) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4250| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4251| 0|case 167: ------------------ | Branch (4251:1): [True: 0, False: 8.17M] ------------------ 4252| |/* rule 167 can match eol */ 4253| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4254| 0|#line 228 "flex_lexer.l" 4255| 0|TOKEN(CHARACTER_VARYING) ------------------ | | 3060| 0|#define TOKEN(name) { return SQL_##name; } ------------------ 4256| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4257| |/* Allow =/== see https://sqlite.org/lang_expr.html#collateop */ 4258| 707|case 168: ------------------ | Branch (4258:1): [True: 707, False: 8.16M] ------------------ 4259| 707|YY_RULE_SETUP ------------------ | | 3320| 707| YY_USER_ACTION | | ------------------ | | | | 66| 707| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 707| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 707| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.12k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.12k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.41k, False: 707] | | | | ------------------ | | | | 69| 1.41k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.41k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.41k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.41k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.41k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.41k| } else { \ | | | | 75| 1.41k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.41k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.41k| } \ | | | | 77| 1.41k| } | | ------------------ ------------------ 4260| 707|#line 231 "flex_lexer.l" 4261| 707|TOKEN(EQUALS) ------------------ | | 3060| 707|#define TOKEN(name) { return SQL_##name; } ------------------ 4262| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4263| 440|case 169: ------------------ | Branch (4263:1): [True: 440, False: 8.16M] ------------------ 4264| 440|YY_RULE_SETUP ------------------ | | 3320| 440| YY_USER_ACTION | | ------------------ | | | | 66| 440| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 440| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 440| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 440| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 440| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 440| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.32k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.32k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 880, False: 440] | | | | ------------------ | | | | 69| 880| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 880| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 880| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 880| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 880| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 880|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 880] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 880| } else { \ | | | | 75| 880| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 880| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 880| } \ | | | | 77| 880| } | | ------------------ ------------------ 4265| 440|#line 232 "flex_lexer.l" 4266| 440|TOKEN(NOTEQUALS) ------------------ | | 3060| 440|#define TOKEN(name) { return SQL_##name; } ------------------ 4267| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4268| 307|case 170: ------------------ | Branch (4268:1): [True: 307, False: 8.16M] ------------------ 4269| 307|YY_RULE_SETUP ------------------ | | 3320| 307| YY_USER_ACTION | | ------------------ | | | | 66| 307| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 307| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 307| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 307| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 307| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 307| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 921| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 921|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 614, False: 307] | | | | ------------------ | | | | 69| 614| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 614| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 614| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 614|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 614] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 614| } else { \ | | | | 75| 614| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 614| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 614| } \ | | | | 77| 614| } | | ------------------ ------------------ 4270| 307|#line 233 "flex_lexer.l" 4271| 307|TOKEN(NOTEQUALS) ------------------ | | 3060| 307|#define TOKEN(name) { return SQL_##name; } ------------------ 4272| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4273| 453|case 171: ------------------ | Branch (4273:1): [True: 453, False: 8.16M] ------------------ 4274| 453|YY_RULE_SETUP ------------------ | | 3320| 453| YY_USER_ACTION | | ------------------ | | | | 66| 453| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 453| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 453| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.35k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.35k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 906, False: 453] | | | | ------------------ | | | | 69| 906| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 906| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 906| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 906|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 906] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 906| } else { \ | | | | 75| 906| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 906| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 906| } \ | | | | 77| 906| } | | ------------------ ------------------ 4275| 453|#line 234 "flex_lexer.l" 4276| 453|TOKEN(LESSEQ) ------------------ | | 3060| 453|#define TOKEN(name) { return SQL_##name; } ------------------ 4277| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4278| 428|case 172: ------------------ | Branch (4278:1): [True: 428, False: 8.16M] ------------------ 4279| 428|YY_RULE_SETUP ------------------ | | 3320| 428| YY_USER_ACTION | | ------------------ | | | | 66| 428| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 428| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 428| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 428| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 428| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 428| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.28k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.28k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 856, False: 428] | | | | ------------------ | | | | 69| 856| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 856| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 856| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 856|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 856] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 856| } else { \ | | | | 75| 856| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 856| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 856| } \ | | | | 77| 856| } | | ------------------ ------------------ 4280| 428|#line 235 "flex_lexer.l" 4281| 428|TOKEN(GREATEREQ) ------------------ | | 3060| 428|#define TOKEN(name) { return SQL_##name; } ------------------ 4282| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4283| 415|case 173: ------------------ | Branch (4283:1): [True: 415, False: 8.16M] ------------------ 4284| 415|YY_RULE_SETUP ------------------ | | 3320| 415| YY_USER_ACTION | | ------------------ | | | | 66| 415| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 415| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 415| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 415| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 415| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 415| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 1.24k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 1.24k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 830, False: 415] | | | | ------------------ | | | | 69| 830| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 830| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 830| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 830| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 830| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 830|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 830] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 830| } else { \ | | | | 75| 830| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 830| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 830| } \ | | | | 77| 830| } | | ------------------ ------------------ 4285| 415|#line 236 "flex_lexer.l" 4286| 415|TOKEN(CONCAT) ------------------ | | 3060| 415|#define TOKEN(name) { return SQL_##name; } ------------------ 4287| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4288| 4.67M|case 174: ------------------ | Branch (4288:1): [True: 4.67M, False: 3.49M] ------------------ 4289| 4.67M|YY_RULE_SETUP ------------------ | | 3320| 4.67M| YY_USER_ACTION | | ------------------ | | | | 66| 4.67M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.67M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 9.35M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 9.35M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.67M, False: 4.67M] | | | | ------------------ | | | | 69| 4.67M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.67M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.67M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.67M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.67M] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.67M| } else { \ | | | | 75| 4.67M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.67M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.67M| } \ | | | | 77| 4.67M| } | | ------------------ ------------------ 4290| 4.67M|#line 238 "flex_lexer.l" 4291| 4.67M|{ return yytext[0]; } ------------------ | | 360| 4.67M|#define yytext yyg->yytext_r ------------------ 4292| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4293| 261|case 175: ------------------ | Branch (4293:1): [True: 261, False: 8.16M] ------------------ 4294| 261|#line 241 "flex_lexer.l" 4295| 571|case 176: ------------------ | Branch (4295:1): [True: 310, False: 8.16M] ------------------ 4296| 571|YY_RULE_SETUP ------------------ | | 3320| 571| YY_USER_ACTION | | ------------------ | | | | 66| 571| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 571| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 571| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 571| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 571| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 571| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 2.44k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 2.44k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 1.87k, False: 571] | | | | ------------------ | | | | 69| 1.87k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 1.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 1.87k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 1.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 1.87k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 1.87k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 1.87k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 1.87k| } else { \ | | | | 75| 1.87k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 1.87k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 1.87k| } \ | | | | 77| 1.87k| } | | ------------------ ------------------ 4297| 571|#line 241 "flex_lexer.l" 4298| 571|{ 4299| 571| yylval->fval = atof(yytext); ------------------ | | 3138| 571| # define yylval yyg->yylval_r ------------------ yylval->fval = atof(yytext); ------------------ | | 360| 571|#define yytext yyg->yytext_r ------------------ 4300| 571| return SQL_FLOATVAL; 4301| 261|} 4302| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4303| |/* 4304| | * Regularly, negative literals are treated as . This does not work for LLONG_MIN, as it has no 4305| | * positive equivalent. We thus match for LLONG_MIN specifically. This is not an issue for floats, where 4306| | * numeric_limits::lowest() == -numeric_limits::max(); 4307| | */ 4308| 619|case 177: ------------------ | Branch (4308:1): [True: 619, False: 8.16M] ------------------ 4309| 619|YY_RULE_SETUP ------------------ | | 3320| 619| YY_USER_ACTION | | ------------------ | | | | 66| 619| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 619| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 619| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 12.9k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 12.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 12.3k, False: 619] | | | | ------------------ | | | | 69| 12.3k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 12.3k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 12.3k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 12.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 12.3k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 12.3k| } else { \ | | | | 75| 12.3k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 12.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 12.3k| } \ | | | | 77| 12.3k| } | | ------------------ ------------------ 4310| 619|#line 251 "flex_lexer.l" 4311| 619|{ 4312| 619| yylval->ival = LLONG_MIN; ------------------ | | 3138| 619| # define yylval yyg->yylval_r ------------------ 4313| 619| return SQL_INTVAL; 4314| 261|} 4315| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4316| 15.2k|case 178: ------------------ | Branch (4316:1): [True: 15.2k, False: 8.15M] ------------------ 4317| 15.2k|YY_RULE_SETUP ------------------ | | 3320| 15.2k| YY_USER_ACTION | | ------------------ | | | | 66| 15.2k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 15.2k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 15.2k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 32.1k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 32.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16.9k, False: 15.2k] | | | | ------------------ | | | | 69| 16.9k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16.9k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.9k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16.9k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 16.9k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16.9k| } else { \ | | | | 75| 16.9k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 16.9k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16.9k| } \ | | | | 77| 16.9k| } | | ------------------ ------------------ 4318| 15.2k|#line 256 "flex_lexer.l" 4319| 15.2k|{ 4320| 15.2k| errno = 0; 4321| 15.2k| yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 3138| 15.2k| # define yylval yyg->yylval_r ------------------ yylval->ival = strtoll(yytext, nullptr, 0); ------------------ | | 360| 15.2k|#define yytext yyg->yytext_r ------------------ 4322| 15.2k| if (errno) { 4323| 5| return fprintf(stderr, "[SQL-Lexer-Error] Integer cannot be parsed - is it out of range?"); 4324| 0| return 0; 4325| 5| } 4326| 15.2k| return SQL_INTVAL; 4327| 15.2k|} 4328| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4329| 1.96k|case 179: ------------------ | Branch (4329:1): [True: 1.96k, False: 8.16M] ------------------ 4330| 1.96k|YY_RULE_SETUP ------------------ | | 3320| 1.96k| YY_USER_ACTION | | ------------------ | | | | 66| 1.96k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.96k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.96k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 17.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 17.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 15.1k, False: 1.96k] | | | | ------------------ | | | | 69| 15.1k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 15.1k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 15.1k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 15.1k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 15.1k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 15.1k| } else { \ | | | | 75| 15.1k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 15.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 15.1k| } \ | | | | 77| 15.1k| } | | ------------------ ------------------ 4331| 1.96k|#line 266 "flex_lexer.l" 4332| 1.96k|{ 4333| | // Crop the leading and trailing quote char 4334| 1.96k| yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 3138| 1.96k| # define yylval yyg->yylval_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 360| 1.96k|#define yytext yyg->yytext_r ------------------ yylval->sval = hsql::substr(yytext, 1, strlen(yytext)-1); ------------------ | | 360| 1.96k|#define yytext yyg->yytext_r ------------------ 4335| 1.96k| return SQL_IDENTIFIER; 4336| 15.2k|} 4337| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4338| 1.89M|case 180: ------------------ | Branch (4338:1): [True: 1.89M, False: 6.27M] ------------------ 4339| 1.89M|YY_RULE_SETUP ------------------ | | 3320| 1.89M| YY_USER_ACTION | | ------------------ | | | | 66| 1.89M| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.89M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 1.89M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 1.89M| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.89M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 1.89M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 5.97M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 5.97M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 4.07M, False: 1.89M] | | | | ------------------ | | | | 69| 4.07M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 4.07M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 4.07M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 4.07M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 4.07M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 4.07M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 4.07M] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 4.07M| } else { \ | | | | 75| 4.07M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 4.07M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 4.07M| } \ | | | | 77| 4.07M| } | | ------------------ ------------------ 4340| 1.89M|#line 272 "flex_lexer.l" 4341| 1.89M|{ 4342| 1.89M| yylval->sval = strdup(yytext); ------------------ | | 3138| 1.89M| # define yylval yyg->yylval_r ------------------ yylval->sval = strdup(yytext); ------------------ | | 360| 1.89M|#define yytext yyg->yytext_r ------------------ 4343| 1.89M| return SQL_IDENTIFIER; 4344| 15.2k|} 4345| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4346| 9.15k|case 181: ------------------ | Branch (4346:1): [True: 9.15k, False: 8.16M] ------------------ 4347| 9.15k|YY_RULE_SETUP ------------------ | | 3320| 9.15k| YY_USER_ACTION | | ------------------ | | | | 66| 9.15k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 9.15k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18.3k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18.3k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.15k, False: 9.15k] | | | | ------------------ | | | | 69| 9.15k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.15k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.15k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.15k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.15k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.15k| } else { \ | | | | 75| 9.15k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.15k| } \ | | | | 77| 9.15k| } | | ------------------ ------------------ 4348| 9.15k|#line 277 "flex_lexer.l" 4349| 9.15k|{ BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 369| 9.15k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN singlequotedstring; strbuf.clear(); strbuf.str(""); } // Clear strbuf manually, see #170 ------------------ | | 3081| 9.15k|#define singlequotedstring 1 ------------------ 4350| 9.15k| YY_BREAK ------------------ | | 3316| 9.15k|#define YY_BREAK /*LINTED*/break; ------------------ 4351| 4.60k|case 182: ------------------ | Branch (4351:1): [True: 4.60k, False: 8.16M] ------------------ 4352| 4.60k|YY_RULE_SETUP ------------------ | | 3320| 4.60k| YY_USER_ACTION | | ------------------ | | | | 66| 4.60k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 4.60k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 4.60k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 13.8k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 13.8k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.21k, False: 4.60k] | | | | ------------------ | | | | 69| 9.21k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.21k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.21k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.21k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.21k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.21k| } else { \ | | | | 75| 9.21k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.21k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.21k| } \ | | | | 77| 9.21k| } | | ------------------ ------------------ 4353| 4.60k|#line 278 "flex_lexer.l" 4354| 4.60k|{ strbuf << '\''; } 4355| 4.60k| YY_BREAK ------------------ | | 3316| 4.60k|#define YY_BREAK /*LINTED*/break; ------------------ 4356| 6.33k|case 183: ------------------ | Branch (4356:1): [True: 6.33k, False: 8.16M] ------------------ 4357| |/* rule 183 can match eol */ 4358| 6.33k|YY_RULE_SETUP ------------------ | | 3320| 6.33k| YY_USER_ACTION | | ------------------ | | | | 66| 6.33k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 6.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 6.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 6.33k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 6.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 6.33k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 16.2M| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 16.2M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 16.2M, False: 6.33k] | | | | ------------------ | | | | 69| 16.2M| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 16.2M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 16.2M| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 16.2M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 16.2M| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 16.2M|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 11.1k, False: 16.2M] | | | | ------------------ | | | | 72| 11.1k| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 11.1k| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 11.1k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 16.2M| } else { \ | | | | 75| 16.2M| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 16.2M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 16.2M| } \ | | | | 77| 16.2M| } | | ------------------ ------------------ 4359| 6.33k|#line 279 "flex_lexer.l" 4360| 6.33k|{ strbuf << yytext; } ------------------ | | 360| 6.33k|#define yytext yyg->yytext_r ------------------ 4361| 6.33k| YY_BREAK ------------------ | | 3316| 6.33k|#define YY_BREAK /*LINTED*/break; ------------------ 4362| 9.02k|case 184: ------------------ | Branch (4362:1): [True: 9.02k, False: 8.16M] ------------------ 4363| 9.02k|YY_RULE_SETUP ------------------ | | 3320| 9.02k| YY_USER_ACTION | | ------------------ | | | | 66| 9.02k| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 9.02k| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 18.0k| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 18.0k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 9.02k, False: 9.02k] | | | | ------------------ | | | | 69| 9.02k| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 9.02k| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 9.02k| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 9.02k|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 9.02k] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 9.02k| } else { \ | | | | 75| 9.02k| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 9.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 9.02k| } \ | | | | 77| 9.02k| } | | ------------------ ------------------ 4364| 9.02k|#line 280 "flex_lexer.l" 4365| 9.02k|{ BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 369| 9.02k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN 0; yylval->sval = strdup(strbuf.str().c_str()); return SQL_STRING; } ------------------ | | 3138| 9.02k| # define yylval yyg->yylval_r ------------------ 4366| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4367| 132|case YY_STATE_EOF(singlequotedstring): ------------------ | | 377| 132|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 132|#define YY_END_OF_BUFFER 187 | | ------------------ ------------------ | Branch (4367:1): [True: 132, False: 8.17M] ------------------ 4368| 132|#line 281 "flex_lexer.l" 4369| 132|{ fprintf(stderr, "[SQL-Lexer-Error] Unterminated string\n"); return 0; } 4370| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4371| 151|case 185: ------------------ | Branch (4371:1): [True: 151, False: 8.17M] ------------------ 4372| 151|YY_RULE_SETUP ------------------ | | 3320| 151| YY_USER_ACTION | | ------------------ | | | | 66| 151| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 151| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 302| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 302|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 151, False: 151] | | | | ------------------ | | | | 69| 151| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 151| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 151| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 151|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 151] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 151| } else { \ | | | | 75| 151| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 151| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 151| } \ | | | | 77| 151| } | | ------------------ ------------------ 4373| 151|#line 283 "flex_lexer.l" 4374| 151|{ fprintf(stderr, "[SQL-Lexer-Error] Unknown Character: %c\n", yytext[0]); return 0; } ------------------ | | 360| 151|#define yytext yyg->yytext_r ------------------ 4375| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4376| 0|case 186: ------------------ | Branch (4376:1): [True: 0, False: 8.17M] ------------------ 4377| 0|YY_RULE_SETUP ------------------ | | 3320| 0| YY_USER_ACTION | | ------------------ | | | | 66| 0| yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_line = yylloc->last_line; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 67| 0| yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | yylloc->first_column = yylloc->last_column; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 68| 0| for (int i = 0; yytext[i] != '\0'; i++) { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (68:19): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| yylloc->total_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 70| 0| yylloc->string_length++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 71| 0| if (yytext[i] == '\n') { \ | | | | ------------------ | | | | | | 360| 0|#define yytext yyg->yytext_r | | | | ------------------ | | | | | Branch (71:9): [True: 0, False: 0] | | | | ------------------ | | | | 72| 0| yylloc->last_line++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 73| 0| yylloc->last_column = 0; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 74| 0| } else { \ | | | | 75| 0| yylloc->last_column++; \ | | | | ------------------ | | | | | | 3140| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | 76| 0| } \ | | | | 77| 0| } | | ------------------ ------------------ 4378| 0|#line 285 "flex_lexer.l" 4379| 0|ECHO; ------------------ | | 3235| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 360| 0|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 359| 0|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 357| 0|#define yyout yyg->yyout_r | | ------------------ | | | Branch (3235:23): [True: 0, False: 0] | | | Branch (3235:80): [Folded - Ignored] | | ------------------ ------------------ 4380| 0| YY_BREAK ------------------ | | 3316| 0|#define YY_BREAK /*LINTED*/break; ------------------ 4381| 0|#line 4381 "flex_lexer.cpp" 4382| 2.89k|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 2.89k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 2.89k|#define YY_END_OF_BUFFER 187 | | ------------------ ------------------ | Branch (4382:1): [True: 2.89k, False: 8.16M] ------------------ 4383| 2.95k|case YY_STATE_EOF(COMMENT): ------------------ | | 377| 2.95k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 2.95k|#define YY_END_OF_BUFFER 187 | | ------------------ ------------------ | Branch (4383:1): [True: 58, False: 8.17M] ------------------ 4384| 2.95k| yyterminate(); ------------------ | | 3279| 2.95k|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 2.95k|#define YY_NULL 0 | | ------------------ ------------------ 4385| | 4386| 7.60k| case YY_END_OF_BUFFER: ------------------ | | 577| 7.60k|#define YY_END_OF_BUFFER 187 ------------------ | Branch (4386:2): [True: 7.60k, False: 8.16M] ------------------ 4387| 7.60k| { 4388| | /* Amount of text matched not including the EOB char. */ 4389| 7.60k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 560| 7.60k|#define yytext_ptr yytext_r ------------------ 4390| | 4391| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 4392| 7.60k| *yy_cp = yyg->yy_hold_char; 4393| 7.60k| YY_RESTORE_YY_MORE_OFFSET 4394| | 4395| 7.60k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 508| 7.60k|#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 ) ------------------ | | 479| 7.60k|#define YY_BUFFER_NEW 0 ------------------ | Branch (4395:8): [True: 4.51k, False: 3.08k] ------------------ 4396| 4.51k| { 4397| | /* We're scanning a new file or input source. It's 4398| | * possible that this happened because the user 4399| | * just pointed yyin at a new source and called 4400| | * yylex(). If so, then we have to assure 4401| | * consistency between YY_CURRENT_BUFFER and our 4402| | * globals. Here is the right place to do so, because 4403| | * this is the first action (other than possibly a 4404| | * back-up) that will match for the new input source. 4405| | */ 4406| 4.51k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 4.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4407| 4.51k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 508| 4.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 4.51k|#define yyin yyg->yyin_r ------------------ 4408| 4.51k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 508| 4.51k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 480| 4.51k|#define YY_BUFFER_NORMAL 1 ------------------ 4409| 4.51k| } 4410| | 4411| | /* Note that here we test for yy_c_buf_p "<=" to the position 4412| | * of the first EOB in the buffer, since yy_c_buf_p will 4413| | * already have been incremented past the NUL character 4414| | * (since all states make transitions on EOB to the 4415| | * end-of-buffer state). Contrast this with the test 4416| | * in input(). 4417| | */ 4418| 7.60k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 508| 7.60k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4418:8): [True: 0, False: 7.60k] ------------------ 4419| 0| { /* This was really a NUL. */ 4420| 0| yy_state_type yy_next_state; 4421| | 4422| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4423| | 4424| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4425| | 4426| | /* Okay, we're now positioned to make the NUL 4427| | * transition. We couldn't have 4428| | * yy_get_previous_state() go ahead and do it 4429| | * for us because it doesn't know how to deal 4430| | * with the possibility of jamming (and we don't 4431| | * want to build jamming into it because then it 4432| | * will run more slowly). 4433| | */ 4434| | 4435| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 4436| | 4437| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 3041| 0|#define YY_MORE_ADJ 0 ------------------ 4438| | 4439| 0| if ( yy_next_state ) ------------------ | Branch (4439:9): [True: 0, False: 0] ------------------ 4440| 0| { 4441| | /* Consume the NUL. */ 4442| 0| yy_cp = ++yyg->yy_c_buf_p; 4443| 0| yy_current_state = yy_next_state; 4444| 0| goto yy_match; 4445| 0| } 4446| | 4447| 0| else 4448| 0| { 4449| 0| yy_cp = yyg->yy_last_accepting_cpos; 4450| 0| yy_current_state = yyg->yy_last_accepting_state; 4451| 0| goto yy_find_action; 4452| 0| } 4453| 0| } 4454| | 4455| 7.60k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (4455:17): [True: 0, False: 7.60k] ------------------ 4456| 7.60k| { 4457| 3.08k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 3.08k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (4457:4): [True: 3.08k, False: 4.52k] ------------------ 4458| 3.08k| { 4459| 3.08k| yyg->yy_did_buffer_switch_on_eof = 0; 4460| | 4461| 3.08k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 3.08k|#define yywrap hsql_wrap | | ------------------ | | | | 554| 3.08k|#define hsql_wrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (554:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 4462| 3.08k| { 4463| | /* Note: because we've taken care in 4464| | * yy_get_next_buffer() to have set up 4465| | * yytext, we can now set up 4466| | * yy_c_buf_p so that if some total 4467| | * hoser (like flex itself) wants to 4468| | * call the scanner after we return the 4469| | * YY_NULL, it'll still work - another 4470| | * YY_NULL will get returned. 4471| | */ 4472| 3.08k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 3.08k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 3041| 3.08k|#define YY_MORE_ADJ 0 ------------------ 4473| | 4474| 3.08k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 3.08k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 577| 3.08k|#define YY_END_OF_BUFFER 187 | | ------------------ ------------------ 4475| 3.08k| goto do_action; 4476| 3.08k| } 4477| | 4478| 0| else 4479| 0| { 4480| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (4480:11): [True: 0, False: 0] ------------------ 4481| 0| YY_NEW_FILE; ------------------ | | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart hsql_restart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 4482| 0| } 4483| 0| break; 4484| 3.08k| } 4485| | 4486| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (4486:4): [True: 0, False: 7.60k] ------------------ 4487| 0| yyg->yy_c_buf_p = 4488| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4489| | 4490| 0| yy_current_state = yy_get_previous_state( yyscanner ); 4491| | 4492| 0| yy_cp = yyg->yy_c_buf_p; 4493| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 3041| 0|#define YY_MORE_ADJ 0 ------------------ 4494| 0| goto yy_match; 4495| | 4496| 4.52k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 4.52k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (4496:4): [True: 4.52k, False: 3.08k] ------------------ 4497| 4.52k| yyg->yy_c_buf_p = 4498| 4.52k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 508| 4.52k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4499| | 4500| 4.52k| yy_current_state = yy_get_previous_state( yyscanner ); 4501| | 4502| 4.52k| yy_cp = yyg->yy_c_buf_p; 4503| 4.52k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 560| 4.52k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 3041| 4.52k|#define YY_MORE_ADJ 0 ------------------ 4504| 4.52k| goto yy_find_action; 4505| 7.60k| } 4506| 0| break; 4507| 7.60k| } 4508| | 4509| 0| default: ------------------ | Branch (4509:2): [True: 0, False: 8.17M] ------------------ 4510| 0| YY_FATAL_ERROR( ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4511| 8.17M| "fatal flex scanner internal error--no action found" ); 4512| 8.17M| } /* end of action switch */ 4513| 8.17M| } /* end of scanning one token */ 4514| 7.45M| } /* end of user's declarations */ 4515| 7.45M|} /* end of yylex */ _Z22hsql__switch_to_bufferP15yy_buffer_statePv: 4824| 5.22k|{ 4825| 5.22k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4826| | 4827| | /* TODO. We should be able to replace this entire function body 4828| | * with 4829| | * yypop_buffer_state(); 4830| | * yypush_buffer_state(new_buffer); 4831| | */ 4832| 5.22k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 5.22k|#define yyensure_buffer_stack hsql_ensure_buffer_stack ------------------ 4833| 5.22k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 502| 5.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.22k, False: 0] | | ------------------ | | 503| 5.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.22k| : NULL) ------------------ | Branch (4833:7): [True: 0, False: 5.22k] ------------------ 4834| 0| return; 4835| | 4836| 5.22k| if ( YY_CURRENT_BUFFER ) ------------------ | | 502| 5.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 5.22k] | | | Branch (502:29): [True: 5.22k, False: 0] | | ------------------ | | 503| 5.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.22k| : NULL) ------------------ 4837| 0| { 4838| | /* Flush out information for old buffer. */ 4839| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 4840| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4841| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4842| 0| } 4843| | 4844| 5.22k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 508| 5.22k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4845| 5.22k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 5.22k|#define yy_load_buffer_state hsql__load_buffer_state ------------------ 4846| | 4847| | /* We don't actually know whether we did this switch during 4848| | * EOF (yywrap()) processing, but the only time this flag 4849| | * is looked at is after yywrap() is called, so it's safe 4850| | * to go ahead and always set it. 4851| | */ 4852| 5.22k| yyg->yy_did_buffer_switch_on_eof = 1; 4853| 5.22k|} _Z19hsql__delete_bufferP15yy_buffer_statePv: 4899| 5.22k|{ 4900| 5.22k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4901| | 4902| 5.22k| if ( ! b ) ------------------ | Branch (4902:7): [True: 0, False: 5.22k] ------------------ 4903| 0| return; 4904| | 4905| 5.22k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 502| 5.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 5.22k, False: 0] | | ------------------ | | 503| 5.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.22k| : NULL) ------------------ | Branch (4905:7): [True: 5.22k, False: 0] ------------------ 4906| 5.22k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 508| 5.22k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4907| | 4908| 5.22k| if ( b->yy_is_our_buffer ) ------------------ | Branch (4908:7): [True: 5.22k, False: 0] ------------------ 4909| 5.22k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 5.22k|#define yyfree hsql_free ------------------ 4910| | 4911| 5.22k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 5.22k|#define yyfree hsql_free ------------------ 4912| 5.22k|} _Z17hsql__scan_bufferPcmPv: 5079| 5.22k|{ 5080| 5.22k| YY_BUFFER_STATE b; 5081| | 5082| 5.22k| if ( size < 2 || ------------------ | Branch (5082:7): [True: 0, False: 5.22k] ------------------ 5083| 5.22k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 380| 10.4k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (5083:7): [True: 0, False: 5.22k] ------------------ 5084| 5.22k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 380| 5.22k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (5084:7): [True: 0, False: 5.22k] ------------------ 5085| | /* They forgot to leave room for the EOB's. */ 5086| 0| return NULL; 5087| | 5088| 5.22k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 5.22k|#define yyalloc hsql_alloc ------------------ 5089| 5.22k| if ( ! b ) ------------------ | Branch (5089:7): [True: 0, False: 5.22k] ------------------ 5090| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 5091| | 5092| 5.22k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 5093| 5.22k| b->yy_buf_pos = b->yy_ch_buf = base; 5094| 5.22k| b->yy_is_our_buffer = 0; 5095| 5.22k| b->yy_input_file = NULL; 5096| 5.22k| b->yy_n_chars = b->yy_buf_size; 5097| 5.22k| b->yy_is_interactive = 0; 5098| 5.22k| b->yy_at_bol = 1; 5099| 5.22k| b->yy_fill_buffer = 0; 5100| 5.22k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 479| 5.22k|#define YY_BUFFER_NEW 0 ------------------ 5101| | 5102| 5.22k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 5.22k|#define yy_switch_to_buffer hsql__switch_to_buffer ------------------ 5103| | 5104| 5.22k| return b; 5105| 5.22k|} _Z17hsql__scan_stringPKcPv: 5116| 5.22k|{ 5117| | 5118| 5.22k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 5.22k|#define yy_scan_bytes hsql__scan_bytes ------------------ 5119| 5.22k|} _Z16hsql__scan_bytesPKciPv: 5129| 5.22k|{ 5130| 5.22k| YY_BUFFER_STATE b; 5131| 5.22k| char *buf; 5132| 5.22k| yy_size_t n; 5133| 5.22k| int i; 5134| | 5135| | /* Get memory for full buffer, including space for trailing EOB's. */ 5136| 5.22k| n = (yy_size_t) (_yybytes_len + 2); 5137| 5.22k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 236| 5.22k|#define yyalloc hsql_alloc ------------------ 5138| 5.22k| if ( ! buf ) ------------------ | Branch (5138:7): [True: 0, False: 5.22k] ------------------ 5139| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 5140| | 5141| 30.8M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (5141:15): [True: 30.8M, False: 5.22k] ------------------ 5142| 30.8M| buf[i] = yybytes[i]; 5143| | 5144| 5.22k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 5.22k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 5145| | 5146| 5.22k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 5.22k|#define yy_scan_buffer hsql__scan_buffer ------------------ 5147| 5.22k| if ( ! b ) ------------------ | Branch (5147:7): [True: 0, False: 5.22k] ------------------ 5148| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 5149| | 5150| | /* It's okay to grow etc. this buffer, and we should throw it 5151| | * away when we're done. 5152| | */ 5153| 5.22k| b->yy_is_our_buffer = 1; 5154| | 5155| 5.22k| return b; 5156| 5.22k|} _Z13hsql_lex_initPPv: 5364| 5.22k|{ 5365| 5.22k| if (ptr_yy_globals == NULL){ ------------------ | Branch (5365:9): [True: 0, False: 5.22k] ------------------ 5366| 0| errno = EINVAL; 5367| 0| return 1; 5368| 0| } 5369| | 5370| 5.22k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 236| 5.22k|#define yyalloc hsql_alloc ------------------ 5371| | 5372| 5.22k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (5372:9): [True: 0, False: 5.22k] ------------------ 5373| 0| errno = ENOMEM; 5374| 0| return 1; 5375| 0| } 5376| | 5377| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 5378| 5.22k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 5379| | 5380| 5.22k| return yy_init_globals ( *ptr_yy_globals ); 5381| 5.22k|} _Z16hsql_lex_destroyPv: 5452| 5.22k|{ 5453| 5.22k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5454| | 5455| | /* Pop the buffer stack, destroying each element. */ 5456| 5.22k| while(YY_CURRENT_BUFFER){ ------------------ | | 502| 5.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:27): [True: 0, False: 5.22k] | | | Branch (502:29): [True: 5.22k, False: 0] | | ------------------ | | 503| 5.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 5.22k| : NULL) ------------------ 5457| 0| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 0|#define yy_delete_buffer hsql__delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 502| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (502:29): [True: 0, False: 0] | | ------------------ | | 503| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 504| 0| : NULL) ------------------ 5458| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 5459| 0| yypop_buffer_state(yyscanner); ------------------ | | 80| 0|#define yypop_buffer_state hsql_pop_buffer_state ------------------ 5460| 0| } 5461| | 5462| | /* Destroy the stack itself. */ 5463| 5.22k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 5.22k|#define yyfree hsql_free ------------------ 5464| 5.22k| yyg->yy_buffer_stack = NULL; 5465| | 5466| | /* Destroy the start condition stack. */ 5467| 5.22k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 5.22k|#define yyfree hsql_free ------------------ 5468| 5.22k| yyg->yy_start_stack = NULL; 5469| | 5470| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 5471| | * yylex() is called, initialization will occur. */ 5472| 5.22k| yy_init_globals( yyscanner); 5473| | 5474| | /* Destroy the main struct (reentrant only). */ 5475| 5.22k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 5.22k|#define yyfree hsql_free ------------------ 5476| 5.22k| yyscanner = NULL; 5477| 5.22k| return 0; 5478| 5.22k|} _Z10hsql_allocmPv: 5508| 20.9k|{ 5509| 20.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5510| 20.9k| (void)yyg; 5511| 20.9k| return malloc(size); 5512| 20.9k|} _Z9hsql_freePvS_: 5530| 26.1k|{ 5531| 26.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5532| 26.1k| (void)yyg; 5533| 26.1k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 5534| 26.1k|} flex_lexer.cpp:_ZL18yy_get_next_bufferPv: 4525| 7.60k|{ 4526| 7.60k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4527| 7.60k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 508| 7.60k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4528| 7.60k| char *source = yyg->yytext_ptr; ------------------ | | 560| 7.60k|#define yytext_ptr yytext_r ------------------ 4529| 7.60k| int number_to_move, i; 4530| 7.60k| int ret_val; 4531| | 4532| 7.60k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 508| 7.60k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4532:7): [True: 0, False: 7.60k] ------------------ 4533| 0| YY_FATAL_ERROR( ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4534| 7.60k| "fatal flex scanner internal error--end of buffer missed" ); 4535| | 4536| 7.60k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 508| 7.60k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4536:7): [True: 7.60k, False: 0] ------------------ 4537| 7.60k| { /* Don't try to fill the buffer, so this is an EOF. */ 4538| 7.60k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 560| 7.60k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 3041| 7.60k|#define YY_MORE_ADJ 0 ------------------ | Branch (4538:8): [True: 3.08k, False: 4.52k] ------------------ 4539| 3.08k| { 4540| | /* We matched a single character, the EOB, so 4541| | * treat this as a final EOF. 4542| | */ 4543| 3.08k| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 3.08k|#define EOB_ACT_END_OF_FILE 1 ------------------ 4544| 3.08k| } 4545| | 4546| 4.52k| else 4547| 4.52k| { 4548| | /* We matched some text prior to the EOB, first 4549| | * process it. 4550| | */ 4551| 4.52k| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 4.52k|#define EOB_ACT_LAST_MATCH 2 ------------------ 4552| 4.52k| } 4553| 7.60k| } 4554| | 4555| | /* Try to read more data. */ 4556| | 4557| | /* First move last chars to start of buffer. */ 4558| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ 4559| | 4560| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (4560:15): [True: 0, False: 0] ------------------ 4561| 0| *(dest++) = *(source++); 4562| | 4563| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 508| 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 ) ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (4563:7): [True: 0, False: 0] ------------------ 4564| | /* don't do the read, it's not guaranteed to return an EOF, 4565| | * just force an EOF 4566| | */ 4567| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4568| | 4569| 0| else 4570| 0| { 4571| 0| int num_to_read = 4572| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4573| | 4574| 0| while ( num_to_read <= 0 ) ------------------ | Branch (4574:11): [True: 0, False: 0] ------------------ 4575| 0| { /* Not enough room in the buffer - grow it. */ 4576| | 4577| | /* just a shorter name for the current buffer */ 4578| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4579| | 4580| 0| int yy_c_buf_p_offset = 4581| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 4582| | 4583| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (4583:9): [True: 0, False: 0] ------------------ 4584| 0| { 4585| 0| int new_size = b->yy_buf_size * 2; 4586| | 4587| 0| if ( new_size <= 0 ) ------------------ | Branch (4587:10): [True: 0, False: 0] ------------------ 4588| 0| b->yy_buf_size += b->yy_buf_size / 8; 4589| 0| else 4590| 0| b->yy_buf_size *= 2; 4591| | 4592| 0| b->yy_ch_buf = (char *) 4593| | /* Include room in for 2 EOB chars. */ 4594| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 4595| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 4596| 0| } 4597| 0| else 4598| | /* Can't grow it, we don't own it. */ 4599| 0| b->yy_ch_buf = NULL; 4600| | 4601| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (4601:9): [True: 0, False: 0] ------------------ 4602| 0| YY_FATAL_ERROR( ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4603| 0| "fatal error - scanner input buffer overflow" ); 4604| | 4605| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 4606| | 4607| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4608| 0| number_to_move - 1; 4609| | 4610| 0| } 4611| | 4612| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 3226| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (4612:8): [True: 0, False: 0] ------------------ 4613| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 3226| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 4614| | 4615| | /* Read in more data. */ 4616| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 3243| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (3243:7): [True: 0, False: 0] | | ------------------ | | 3244| 0| { \ | | 3245| 0| int c = '*'; \ | | 3246| 0| int n; \ | | 3247| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (3247:16): [True: 0, False: 0] | | ------------------ | | 3248| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3248:9): [True: 0, False: 0] | | | Branch (3248:38): [True: 0, False: 0] | | ------------------ | | 3249| 0| buf[n] = (char) c; \ | | 3250| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (3250:8): [True: 0, False: 0] | | ------------------ | | 3251| 0| buf[n++] = (char) c; \ | | 3252| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3252:8): [True: 0, False: 0] | | | Branch (3252:20): [True: 0, False: 0] | | ------------------ | | 3253| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3254| 0| result = n; \ | | 3255| 0| } \ | | 3256| 0| else \ | | 3257| 0| { \ | | 3258| 0| errno=0; \ | | 3259| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (3259:11): [True: 0, False: 0] | | | Branch (3259:78): [True: 0, False: 0] | | ------------------ | | 3260| 0| { \ | | 3261| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (3261:8): [True: 0, False: 0] | | ------------------ | | 3262| 0| { \ | | 3263| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) | | ------------------ | | 3264| 0| break; \ | | 3265| 0| } \ | | 3266| 0| errno=0; \ | | 3267| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 3268| 0| } \ | | 3269| 0| }\ ------------------ 4617| 0| yyg->yy_n_chars, num_to_read ); 4618| | 4619| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4620| 0| } 4621| | 4622| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (4622:7): [True: 0, False: 0] ------------------ 4623| 0| { 4624| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 3041| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (4624:8): [True: 0, False: 0] ------------------ 4625| 0| { 4626| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 4627| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart hsql_restart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 4628| 0| } 4629| | 4630| 0| else 4631| 0| { 4632| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 4633| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4634| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 491| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 4635| 0| } 4636| 0| } 4637| | 4638| 0| else 4639| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 4640| | 4641| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4641:6): [True: 0, False: 0] ------------------ 4642| | /* Extend the array by 50%, plus the number we really need. */ 4643| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 4644| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 4645| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4646| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (4646:8): [True: 0, False: 0] ------------------ 4647| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 4648| | /* "- 2" to take care of EOB's */ 4649| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4650| 0| } 4651| | 4652| 0| yyg->yy_n_chars += number_to_move; 4653| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 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; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4654| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 508| 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; ------------------ | | 380| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 4655| | 4656| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 560| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 508| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4657| | 4658| 0| return ret_val; 4659| 0|} flex_lexer.cpp:_ZL21yy_get_previous_statePv: 4664| 4.52k|{ 4665| 4.52k| yy_state_type yy_current_state; 4666| 4.52k| char *yy_cp; 4667| 4.52k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4668| | 4669| 4.52k| yy_current_state = yyg->yy_start; 4670| | 4671| 8.56M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 560| 4.52k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 3041| 4.52k|#define YY_MORE_ADJ 0 ------------------ | Branch (4671:47): [True: 8.56M, False: 4.52k] ------------------ 4672| 8.56M| { 4673| 8.56M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 346| 8.56M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (4673:19): [True: 8.56M, False: 0] ------------------ 4674| 8.56M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (4674:8): [True: 8.54M, False: 16.5k] ------------------ 4675| 8.54M| { 4676| 8.54M| yyg->yy_last_accepting_state = yy_current_state; 4677| 8.54M| yyg->yy_last_accepting_cpos = yy_cp; 4678| 8.54M| } 4679| 17.1M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (4679:11): [True: 8.54M, False: 8.56M] ------------------ 4680| 8.54M| { 4681| 8.54M| yy_current_state = (int) yy_def[yy_current_state]; 4682| 8.54M| if ( yy_current_state >= 1332 ) ------------------ | Branch (4682:9): [True: 8.54M, False: 426] ------------------ 4683| 8.54M| yy_c = yy_meta[yy_c]; 4684| 8.54M| } 4685| 8.56M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 4686| 8.56M| } 4687| | 4688| 4.52k| return yy_current_state; 4689| 4.52k|} flex_lexer.cpp:_ZL23hsql__load_buffer_statePv: 4856| 10.4k|{ 4857| 10.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 4858| 10.4k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 508| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4859| 10.4k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 560| 10.4k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 508| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4860| 10.4k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 10.4k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 508| 10.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 4861| 10.4k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 4862| 10.4k|} flex_lexer.cpp:_ZL24hsql_ensure_buffer_stackPv: 5029| 5.22k|{ 5030| 5.22k| yy_size_t num_to_alloc; 5031| 5.22k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5032| | 5033| 5.22k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (5033:6): [True: 5.22k, False: 0] ------------------ 5034| | 5035| | /* First allocation is just for 2 elements, since we don't know if this 5036| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 5037| | * immediate realloc on the next call. 5038| | */ 5039| 5.22k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 5040| 5.22k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 5.22k|#define yyalloc hsql_alloc ------------------ 5041| 5.22k| (num_to_alloc * sizeof(struct yy_buffer_state*) 5042| 5.22k| , yyscanner); 5043| 5.22k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (5043:8): [True: 0, False: 5.22k] ------------------ 5044| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 5045| | 5046| 5.22k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 5047| | 5048| 5.22k| yyg->yy_buffer_stack_max = num_to_alloc; 5049| 5.22k| yyg->yy_buffer_stack_top = 0; 5050| 5.22k| return; 5051| 5.22k| } 5052| | 5053| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (5053:6): [True: 0, False: 0] ------------------ 5054| | 5055| | /* Increase the buffer to prepare for a possible push. */ 5056| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 5057| | 5058| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 5059| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc hsql_realloc ------------------ 5060| 0| (yyg->yy_buffer_stack, 5061| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 5062| 0| , yyscanner); 5063| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (5063:8): [True: 0, False: 0] ------------------ 5064| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 3289| 0|#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) ------------------ 5065| | 5066| | /* zero only the new slots.*/ 5067| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 5068| 0| yyg->yy_buffer_stack_max = num_to_alloc; 5069| 0| } 5070| 0|} flex_lexer.cpp:_ZL15yy_init_globalsPv: 5418| 10.4k|{ 5419| 10.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 5420| | /* Initialization is the same as for the non-reentrant scanner. 5421| | * This function is called from yylex_destroy(), so don't allocate here. 5422| | */ 5423| | 5424| 10.4k| yyg->yy_buffer_stack = NULL; 5425| 10.4k| yyg->yy_buffer_stack_top = 0; 5426| 10.4k| yyg->yy_buffer_stack_max = 0; 5427| 10.4k| yyg->yy_c_buf_p = NULL; 5428| 10.4k| yyg->yy_init = 0; 5429| 10.4k| yyg->yy_start = 0; 5430| | 5431| 10.4k| yyg->yy_start_stack_ptr = 0; 5432| 10.4k| yyg->yy_start_stack_depth = 0; 5433| 10.4k| yyg->yy_start_stack = NULL; 5434| | 5435| |/* Defined in main.c */ 5436| |#ifdef YY_STDINIT 5437| | yyin = stdin; 5438| | yyout = stdout; 5439| |#else 5440| 10.4k| yyin = NULL; ------------------ | | 356| 10.4k|#define yyin yyg->yyin_r ------------------ 5441| 10.4k| yyout = NULL; ------------------ | | 357| 10.4k|#define yyout yyg->yyout_r ------------------ 5442| 10.4k|#endif 5443| | 5444| | /* For future reference: Set errno on error, since we are called by 5445| | * yylex_init() 5446| | */ 5447| 10.4k| return 0; 5448| 10.4k|} _ZN4hsql15CreateStatementC2ENS_10CreateTypeE: 19| 2.35k| select(nullptr) {} _ZN4hsql15CreateStatementD2Ev: 21| 2.35k|CreateStatement::~CreateStatement() { 22| 2.35k| free(filePath); 23| 2.35k| free(schema); 24| 2.35k| free(tableName); 25| 2.35k| free(indexName); 26| 2.35k| delete select; 27| | 28| 2.35k| if (columns) { ------------------ | Branch (28:7): [True: 653, False: 1.70k] ------------------ 29| 274k| for (ColumnDefinition* def : *columns) { ------------------ | Branch (29:32): [True: 274k, False: 653] ------------------ 30| 274k| delete def; 31| 274k| } 32| 653| delete columns; 33| 653| } 34| | 35| 2.35k| if (tableConstraints) { ------------------ | Branch (35:7): [True: 653, False: 1.70k] ------------------ 36| 57.2k| for (TableConstraint* def : *tableConstraints) { ------------------ | Branch (36:31): [True: 57.2k, False: 653] ------------------ 37| 57.2k| delete def; 38| 57.2k| } 39| 653| delete tableConstraints; 40| 653| } 41| | 42| 2.35k| if (indexColumns) { ------------------ | Branch (42:7): [True: 1.21k, False: 1.14k] ------------------ 43| 1.41k| for (char* column : *indexColumns) { ------------------ | Branch (43:23): [True: 1.41k, False: 1.21k] ------------------ 44| 1.41k| free(column); 45| 1.41k| } 46| 1.21k| delete indexColumns; 47| 1.21k| } 48| | 49| 2.35k| if (viewColumns) { ------------------ | Branch (49:7): [True: 211, False: 2.14k] ------------------ 50| 405| for (char* column : *viewColumns) { ------------------ | Branch (50:23): [True: 405, False: 211] ------------------ 51| 405| free(column); 52| 405| } 53| 211| delete viewColumns; 54| 211| } 55| 2.35k|} _ZN4hsql15CreateStatement27setColumnDefsAndConstraintsEPNSt3__16vectorIPNS_12TableElementENS1_9allocatorIS4_EEEE: 57| 653|void CreateStatement::setColumnDefsAndConstraints(std::vector* tableElements) { 58| 653| columns = new std::vector(); 59| 653| tableConstraints = new std::vector(); 60| | 61| 331k| for (auto tableElem : *tableElements) { ------------------ | Branch (61:23): [True: 331k, False: 653] ------------------ 62| 331k| if (auto* colDef = dynamic_cast(tableElem)) { ------------------ | Branch (62:15): [True: 274k, False: 57.2k] ------------------ 63| 274k| columns->emplace_back(colDef); 64| 274k| } else if (auto* tableConstraint = dynamic_cast(tableElem)) { ------------------ | Branch (64:22): [True: 57.2k, False: 0] ------------------ 65| 57.2k| tableConstraints->emplace_back(tableConstraint); 66| 57.2k| } 67| 331k| } 68| 653|} _ZN4hsql12TableElementD2Ev: 18| 406k| virtual ~TableElement() {} _ZN4hsql16ColumnDefinition22trySetNullableExplicitEv: 39| 347k| bool trySetNullableExplicit() { 40| 347k| if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) { ------------------ | Branch (40:9): [True: 1.36k, False: 346k] | Branch (40:9): [True: 1.95k, False: 345k] | Branch (40:63): [True: 589, False: 345k] ------------------ 41| 1.95k| if (column_constraints->count(ConstraintType::Null)) { ------------------ | Branch (41:11): [True: 1.50k, False: 442] ------------------ 42| 1.50k| return false; 43| 1.50k| } 44| 442| nullable = false; 45| 442| } 46| | 47| 345k| return true; 48| 347k| } _ZN4hsql10FrameBoundC2ElNS_14FrameBoundTypeEb: 9| 1.61k| : offset{offset}, type{type}, unbounded{unbounded} {} _ZN4hsql16FrameDescriptionC2ENS_9FrameTypeEPNS_10FrameBoundES3_: 12| 806| : type{type}, start{start}, end{end} {} _ZN4hsql16FrameDescriptionD2Ev: 14| 806|FrameDescription::~FrameDescription() { 15| 806| delete start; 16| 806| delete end; 17| 806|} _ZN4hsql17WindowDescriptionC2EPNSt3__16vectorIPNS_4ExprENS1_9allocatorIS4_EEEEPNS2_IPNS_16OrderDescriptionENS5_ISA_EEEEPNS_16FrameDescriptionE: 21| 785| : partitionList{partitionList}, orderList{orderList}, frameDescription{frameDescription} {} _ZN4hsql17WindowDescriptionD2Ev: 23| 785|WindowDescription::~WindowDescription() { 24| 785| if (partitionList) { ------------------ | Branch (24:7): [True: 0, False: 785] ------------------ 25| 0| for (Expr* e : *partitionList) { ------------------ | Branch (25:18): [True: 0, False: 0] ------------------ 26| 0| delete e; 27| 0| } 28| 0| delete partitionList; 29| 0| } 30| | 31| 785| if (orderList) { ------------------ | Branch (31:7): [True: 206, False: 579] ------------------ 32| 753| for (OrderDescription* orderDescription : *orderList) { ------------------ | Branch (32:45): [True: 753, False: 206] ------------------ 33| 753| delete orderDescription; 34| 753| } 35| 206| delete orderList; 36| 206| } 37| | 38| 785| delete frameDescription; 39| 785|} _ZN4hsql4ExprC2ENS_8ExprTypeE: 58| 3.08M| windowDescription(nullptr) {} _ZN4hsql4ExprD2Ev: 60| 2.99M|Expr::~Expr() { 61| 2.99M| delete expr; 62| 2.99M| delete expr2; 63| 2.99M| delete select; 64| 2.99M| delete windowDescription; 65| | 66| 2.99M| free(name); 67| 2.99M| free(table); 68| 2.99M| free(alias); 69| | 70| 2.99M| if (exprList) { ------------------ | Branch (70:7): [True: 6.34k, False: 2.99M] ------------------ 71| 8.38k| for (Expr* e : *exprList) { ------------------ | Branch (71:18): [True: 8.38k, False: 6.34k] ------------------ 72| 8.38k| delete e; 73| 8.38k| } 74| 6.34k| delete exprList; 75| 6.34k| } 76| 2.99M|} _ZN4hsql4Expr4makeENS_8ExprTypeE: 78| 2.19k|Expr* Expr::make(ExprType type) { 79| 2.19k| Expr* e = new Expr(type); 80| 2.19k| return e; 81| 2.19k|} _ZN4hsql4Expr11makeOpUnaryENS_12OperatorTypeEPS0_: 83| 9.19k|Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) { 84| 9.19k| Expr* e = new Expr(kExprOperator); 85| 9.19k| e->opType = op; 86| 9.19k| e->expr = expr; 87| 9.19k| e->expr2 = nullptr; 88| 9.19k| return e; 89| 9.19k|} _ZN4hsql4Expr12makeOpBinaryEPS0_NS_12OperatorTypeES1_: 91| 1.23M|Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) { 92| 1.23M| Expr* e = new Expr(kExprOperator); 93| 1.23M| e->opType = op; 94| 1.23M| e->expr = expr1; 95| 1.23M| e->expr2 = expr2; 96| 1.23M| return e; 97| 1.23M|} _ZN4hsql4Expr11makeBetweenEPS0_S1_S1_: 99| 305|Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) { 100| 305| Expr* e = new Expr(kExprOperator); 101| 305| e->expr = expr; 102| 305| e->opType = kOpBetween; 103| 305| e->exprList = new std::vector(); 104| 305| e->exprList->push_back(left); 105| 305| e->exprList->push_back(right); 106| 305| return e; 107| 305|} _ZN4hsql4Expr12makeCaseListEPS0_: 109| 2.03k|Expr* Expr::makeCaseList(Expr* caseListElement) { 110| 2.03k| Expr* e = new Expr(kExprOperator); 111| | // Case list expressions are temporary and will be integrated into the case 112| | // expressions exprList - thus assign operator type kOpNone 113| 2.03k| e->opType = kOpNone; 114| 2.03k| e->exprList = new std::vector(); 115| 2.03k| e->exprList->push_back(caseListElement); 116| 2.03k| return e; 117| 2.03k|} _ZN4hsql4Expr19makeCaseListElementEPS0_S1_: 119| 3.25k|Expr* Expr::makeCaseListElement(Expr* when, Expr* then) { 120| 3.25k| Expr* e = new Expr(kExprOperator); 121| 3.25k| e->opType = kOpCaseListElement; 122| 3.25k| e->expr = when; 123| 3.25k| e->expr2 = then; 124| 3.25k| return e; 125| 3.25k|} _ZN4hsql4Expr14caseListAppendEPS0_S1_: 127| 1.22k|Expr* Expr::caseListAppend(Expr* caseList, Expr* caseListElement) { 128| 1.22k| caseList->exprList->push_back(caseListElement); 129| 1.22k| return caseList; 130| 1.22k|} _ZN4hsql4Expr8makeCaseEPS0_S1_S1_: 132| 1.80k|Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) { 133| 1.80k| Expr* e = new Expr(kExprOperator); 134| 1.80k| e->opType = kOpCase; 135| 1.80k| e->expr = expr; 136| 1.80k| e->expr2 = elseExpr; 137| 1.80k| e->exprList = caseList->exprList; 138| 1.80k| caseList->exprList = nullptr; 139| 1.80k| delete caseList; 140| 1.80k| return e; 141| 1.80k|} _ZN4hsql4Expr11makeLiteralEl: 143| 13.8k|Expr* Expr::makeLiteral(int64_t val) { 144| 13.8k| Expr* e = new Expr(kExprLiteralInt); 145| 13.8k| e->ival = val; 146| 13.8k| return e; 147| 13.8k|} _ZN4hsql4Expr11makeLiteralEd: 149| 545|Expr* Expr::makeLiteral(double value) { 150| 545| Expr* e = new Expr(kExprLiteralFloat); 151| 545| e->fval = value; 152| 545| return e; 153| 545|} _ZN4hsql4Expr11makeLiteralEPc: 155| 4.78k|Expr* Expr::makeLiteral(char* string) { 156| 4.78k| Expr* e = new Expr(kExprLiteralString); 157| 4.78k| e->name = string; 158| 4.78k| return e; 159| 4.78k|} _ZN4hsql4Expr11makeLiteralEb: 161| 1.19k|Expr* Expr::makeLiteral(bool val) { 162| 1.19k| Expr* e = new Expr(kExprLiteralInt); 163| 1.19k| e->ival = (int)val; 164| 1.19k| e->isBoolLiteral = true; 165| 1.19k| return e; 166| 1.19k|} _ZN4hsql4Expr15makeNullLiteralEv: 168| 258|Expr* Expr::makeNullLiteral() { 169| 258| Expr* e = new Expr(kExprLiteralNull); 170| 258| return e; 171| 258|} _ZN4hsql4Expr15makeDateLiteralEPc: 173| 194|Expr* Expr::makeDateLiteral(char* string) { 174| 194| Expr* e = new Expr(kExprLiteralDate); 175| 194| e->name = string; 176| 194| return e; 177| 194|} _ZN4hsql4Expr19makeIntervalLiteralElNS_13DatetimeFieldE: 179| 10.5k|Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) { 180| 10.5k| Expr* e = new Expr(kExprLiteralInterval); 181| 10.5k| e->ival = duration; 182| 10.5k| e->datetimeField = unit; 183| 10.5k| return e; 184| 10.5k|} _ZN4hsql4Expr13makeColumnRefEPc: 186| 390k|Expr* Expr::makeColumnRef(char* name) { 187| 390k| Expr* e = new Expr(kExprColumnRef); 188| 390k| e->name = name; 189| 390k| return e; 190| 390k|} _ZN4hsql4Expr13makeColumnRefEPcS1_: 192| 472|Expr* Expr::makeColumnRef(char* table, char* name) { 193| 472| Expr* e = new Expr(kExprColumnRef); 194| 472| e->name = name; 195| 472| e->table = table; 196| 472| return e; 197| 472|} _ZN4hsql4Expr8makeStarEv: 199| 1.08M|Expr* Expr::makeStar(void) { 200| 1.08M| Expr* e = new Expr(kExprStar); 201| 1.08M| return e; 202| 1.08M|} _ZN4hsql4Expr8makeStarEPc: 204| 195|Expr* Expr::makeStar(char* table) { 205| 195| Expr* e = new Expr(kExprStar); 206| 195| e->table = table; 207| 195| return e; 208| 195|} _ZN4hsql4Expr15makeFunctionRefEPcPNSt3__16vectorIPS0_NS2_9allocatorIS4_EEEEbPNS_17WindowDescriptionE: 210| 2.70k|Expr* Expr::makeFunctionRef(char* func_name, std::vector* exprList, bool distinct, WindowDescription* window) { 211| 2.70k| Expr* e = new Expr(kExprFunctionRef); 212| 2.70k| e->name = func_name; 213| 2.70k| e->exprList = exprList; 214| 2.70k| e->distinct = distinct; 215| 2.70k| e->windowDescription = window; 216| 2.70k| return e; 217| 2.70k|} _ZN4hsql4Expr9makeArrayEPNSt3__16vectorIPS0_NS1_9allocatorIS3_EEEE: 219| 480|Expr* Expr::makeArray(std::vector* exprList) { 220| 480| Expr* e = new Expr(kExprArray); 221| 480| e->exprList = exprList; 222| 480| return e; 223| 480|} _ZN4hsql4Expr14makeArrayIndexEPS0_l: 225| 66|Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) { 226| 66| Expr* e = new Expr(kExprArrayIndex); 227| 66| e->expr = expr; 228| 66| e->ival = index; 229| 66| return e; 230| 66|} _ZN4hsql4Expr13makeParameterEi: 232| 316k|Expr* Expr::makeParameter(int id) { 233| 316k| Expr* e = new Expr(kExprParameter); 234| 316k| e->ival = id; 235| 316k| return e; 236| 316k|} _ZN4hsql4Expr10makeSelectEPNS_15SelectStatementE: 238| 794|Expr* Expr::makeSelect(SelectStatement* select) { 239| 794| Expr* e = new Expr(kExprSelect); 240| 794| e->select = select; 241| 794| return e; 242| 794|} _ZN4hsql4Expr10makeExistsEPNS_15SelectStatementE: 244| 846|Expr* Expr::makeExists(SelectStatement* select) { 245| 846| Expr* e = new Expr(kExprOperator); 246| 846| e->opType = kOpExists; 247| 846| e->select = select; 248| 846| return e; 249| 846|} _ZN4hsql4Expr14makeInOperatorEPS0_PNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 251| 526|Expr* Expr::makeInOperator(Expr* expr, std::vector* exprList) { 252| 526| Expr* e = new Expr(kExprOperator); 253| 526| e->opType = kOpIn; 254| 526| e->expr = expr; 255| 526| e->exprList = exprList; 256| | 257| 526| return e; 258| 526|} _ZN4hsql4Expr14makeInOperatorEPS0_PNS_15SelectStatementE: 260| 592|Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) { 261| 592| Expr* e = new Expr(kExprOperator); 262| 592| e->opType = kOpIn; 263| 592| e->expr = expr; 264| 592| e->select = select; 265| | 266| 592| return e; 267| 592|} _ZN4hsql4Expr11makeExtractENS_13DatetimeFieldEPS0_: 269| 274|Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) { 270| 274| Expr* e = new Expr(kExprExtract); 271| 274| e->datetimeField = datetimeField; 272| 274| e->expr = expr; 273| 274| return e; 274| 274|} _ZN4hsql4Expr8makeCastEPS0_NS_10ColumnTypeE: 276| 386|Expr* Expr::makeCast(Expr* expr, ColumnType columnType) { 277| 386| Expr* e = new Expr(kExprCast); 278| 386| e->columnType = columnType; 279| 386| e->expr = expr; 280| 386| return e; 281| 386|} _ZN4hsql6substrEPKcii: 301| 1.96k|char* substr(const char* source, int from, int to) { 302| 1.96k| int len = to - from; 303| 1.96k| char* copy = (char*)malloc(len + 1); 304| 1.96k| ; 305| 1.96k| strncpy(copy, source + from, len); 306| 1.96k| copy[len] = '\0'; 307| 1.96k| return copy; 308| 1.96k|} _ZN4hsql16PrepareStatementC2Ev: 6| 737|PrepareStatement::PrepareStatement() : SQLStatement(kStmtPrepare), name(nullptr), query(nullptr) {} _ZN4hsql16PrepareStatementD2Ev: 8| 737|PrepareStatement::~PrepareStatement() { 9| 737| free(name); 10| 737| free(query); 11| 737|} _ZN4hsql12SQLStatementC2ENS_13StatementTypeE: 7| 107k|SQLStatement::SQLStatement(StatementType type) : hints(nullptr), type_(type) {} _ZN4hsql12SQLStatementD2Ev: 9| 107k|SQLStatement::~SQLStatement() { 10| 107k| if (hints) { ------------------ | Branch (10:7): [True: 813, False: 106k] ------------------ 11| 1.54k| for (Expr* hint : *hints) { ------------------ | Branch (11:21): [True: 1.54k, False: 813] ------------------ 12| 1.54k| delete hint; 13| 1.54k| } 14| 813| } 15| 107k| delete hints; 16| 107k|} _ZN4hsql15TableConstraintC2ENS_14ConstraintTypeEPNSt3__16vectorIPcNS2_9allocatorIS4_EEEE: 8| 58.6k| : type(type), columnNames(columnNames) {} _ZN4hsql15TableConstraintD2Ev: 10| 58.6k|TableConstraint::~TableConstraint() { 11| 58.8k| for (char* def : *columnNames) { ------------------ | Branch (11:18): [True: 58.8k, False: 58.6k] ------------------ 12| 58.8k| free(def); 13| 58.8k| } 14| 58.6k| delete columnNames; 15| 58.6k|} _ZN4hsql16ColumnDefinitionC2EPcNS_10ColumnTypeEPNSt3__113unordered_setINS_14ConstraintTypeENS3_4hashIS5_EENS3_8equal_toIS5_EENS3_9allocatorIS5_EEEE: 19| 347k| : column_constraints(column_constraints), name(name), type(type), nullable(true) {} _ZN4hsql16ColumnDefinitionD2Ev: 21| 347k|ColumnDefinition::~ColumnDefinition() { 22| 347k| free(name); 23| 347k| delete column_constraints; 24| 347k|} _ZN4hsql10ColumnTypeC2ENS_8DataTypeElll: 27| 3.42M| : data_type(data_type), length(length), precision(precision), scale(scale) {} _ZN4hsql15DeleteStatementC2Ev: 91| 1.85k|DeleteStatement::DeleteStatement() : SQLStatement(kStmtDelete), schema(nullptr), tableName(nullptr), expr(nullptr) {} _ZN4hsql15DeleteStatementD2Ev: 93| 1.85k|DeleteStatement::~DeleteStatement() { 94| 1.85k| free(schema); 95| 1.85k| free(tableName); 96| 1.85k| delete expr; 97| 1.85k|} _ZN4hsql13DropStatementC2ENS_8DropTypeE: 101| 3.19k| : SQLStatement(kStmtDrop), type(type), schema(nullptr), name(nullptr), indexName(nullptr) {} _ZN4hsql13DropStatementD2Ev: 103| 3.19k|DropStatement::~DropStatement() { 104| 3.19k| free(schema); 105| 3.19k| free(name); 106| 3.19k| free(indexName); 107| 3.19k|} _ZN4hsql20TransactionStatementC2ENS_18TransactionCommandE: 131| 67.4k| : SQLStatement(kStmtTransaction), command(command) {} _ZN4hsql20TransactionStatementD2Ev: 133| 67.4k|TransactionStatement::~TransactionStatement() {} _ZN4hsql16ExecuteStatementC2Ev: 136| 2.37k|ExecuteStatement::ExecuteStatement() : SQLStatement(kStmtExecute), name(nullptr), parameters(nullptr) {} _ZN4hsql16ExecuteStatementD2Ev: 138| 2.37k|ExecuteStatement::~ExecuteStatement() { 139| 2.37k| free(name); 140| | 141| 2.37k| if (parameters) { ------------------ | Branch (141:7): [True: 80, False: 2.29k] ------------------ 142| 327| for (Expr* param : *parameters) { ------------------ | Branch (142:22): [True: 327, False: 80] ------------------ 143| 327| delete param; 144| 327| } 145| 80| delete parameters; 146| 80| } 147| 2.37k|} _ZN4hsql15ExportStatementC2ENS_10ImportTypeE: 151| 1.85k| : SQLStatement(kStmtExport), type(type), filePath(nullptr), schema(nullptr), tableName(nullptr), select(nullptr) {} _ZN4hsql15ExportStatementD2Ev: 153| 1.85k|ExportStatement::~ExportStatement() { 154| 1.85k| free(filePath); 155| 1.85k| free(schema); 156| 1.85k| free(tableName); 157| 1.85k| delete select; 158| 1.85k|} _ZN4hsql15ImportStatementC2ENS_10ImportTypeE: 167| 562| whereClause(nullptr) {} _ZN4hsql15ImportStatementD2Ev: 169| 562|ImportStatement::~ImportStatement() { 170| 562| free(filePath); 171| 562| free(schema); 172| 562| free(tableName); 173| 562| delete whereClause; 174| 562|} _ZN4hsql15InsertStatementC2ENS_10InsertTypeE: 184| 1.57k| select(nullptr) {} _ZN4hsql15InsertStatementD2Ev: 186| 1.57k|InsertStatement::~InsertStatement() { 187| 1.57k| free(schema); 188| 1.57k| free(tableName); 189| 1.57k| delete select; 190| | 191| 1.57k| if (columns) { ------------------ | Branch (191:7): [True: 248, False: 1.33k] ------------------ 192| 442| for (char* column : *columns) { ------------------ | Branch (192:23): [True: 442, False: 248] ------------------ 193| 442| free(column); 194| 442| } 195| 248| delete columns; 196| 248| } 197| | 198| 1.57k| if (values) { ------------------ | Branch (198:7): [True: 605, False: 973] ------------------ 199| 972| for (Expr* expr : *values) { ------------------ | Branch (199:21): [True: 972, False: 605] ------------------ 200| 972| delete expr; 201| 972| } 202| 605| delete values; 203| 605| } 204| 1.57k|} _ZN4hsql13ShowStatementC2ENS_8ShowTypeE: 207| 2.49k|ShowStatement::ShowStatement(ShowType type) : SQLStatement(kStmtShow), type(type), schema(nullptr), name(nullptr) {} _ZN4hsql13ShowStatementD2Ev: 209| 2.49k|ShowStatement::~ShowStatement() { 210| 2.49k| free(schema); 211| 2.49k| free(name); 212| 2.49k|} _ZN4hsql16OrderDescriptionC2ENS_9OrderTypeEPNS_4ExprE: 217| 71.8k|OrderDescription::OrderDescription(OrderType type, Expr* expr) : type(type), expr(expr) {} _ZN4hsql16OrderDescriptionD2Ev: 219| 71.8k|OrderDescription::~OrderDescription() { delete expr; } _ZN4hsql16LimitDescriptionC2EPNS_4ExprES2_: 222| 4.46k|LimitDescription::LimitDescription(Expr* limit, Expr* offset) : limit(limit), offset(offset) {} _ZN4hsql16LimitDescriptionD2Ev: 224| 4.46k|LimitDescription::~LimitDescription() { 225| 4.46k| delete limit; 226| 4.46k| delete offset; 227| 4.46k|} _ZN4hsql18GroupByDescriptionC2Ev: 230| 1.27k|GroupByDescription::GroupByDescription() : columns(nullptr), having(nullptr) {} _ZN4hsql18GroupByDescriptionD2Ev: 232| 1.27k|GroupByDescription::~GroupByDescription() { 233| 1.27k| delete having; 234| | 235| 1.27k| if (columns) { ------------------ | Branch (235:7): [True: 1.27k, False: 0] ------------------ 236| 1.66k| for (Expr* expr : *columns) { ------------------ | Branch (236:21): [True: 1.66k, False: 1.27k] ------------------ 237| 1.66k| delete expr; 238| 1.66k| } 239| 1.27k| delete columns; 240| 1.27k| } 241| 1.27k|} _ZN4hsql15WithDescriptionD2Ev: 243| 1.55k|WithDescription::~WithDescription() { 244| 1.55k| free(alias); 245| 1.55k| delete select; 246| 1.55k|} _ZN4hsql15SelectStatementC2Ev: 260| 22.5k| lockings(nullptr) {} _ZN4hsql15SelectStatementD2Ev: 262| 22.3k|SelectStatement::~SelectStatement() { 263| 22.3k| delete fromTable; 264| 22.3k| delete whereClause; 265| 22.3k| delete groupBy; 266| 22.3k| delete limit; 267| | 268| | // Delete each element in the select list. 269| 22.3k| if (selectList) { ------------------ | Branch (269:7): [True: 22.3k, False: 0] ------------------ 270| 87.9k| for (Expr* expr : *selectList) { ------------------ | Branch (270:21): [True: 87.9k, False: 22.3k] ------------------ 271| 87.9k| delete expr; 272| 87.9k| } 273| 22.3k| delete selectList; 274| 22.3k| } 275| | 276| 22.3k| if (order) { ------------------ | Branch (276:7): [True: 865, False: 21.4k] ------------------ 277| 3.59k| for (OrderDescription* desc : *order) { ------------------ | Branch (277:33): [True: 3.59k, False: 865] ------------------ 278| 3.59k| delete desc; 279| 3.59k| } 280| 865| delete order; 281| 865| } 282| | 283| 22.3k| if (withDescriptions) { ------------------ | Branch (283:7): [True: 364, False: 21.9k] ------------------ 284| 1.55k| for (WithDescription* desc : *withDescriptions) { ------------------ | Branch (284:32): [True: 1.55k, False: 364] ------------------ 285| 1.55k| delete desc; 286| 1.55k| } 287| 364| delete withDescriptions; 288| 364| } 289| | 290| 22.3k| if (setOperations) { ------------------ | Branch (290:7): [True: 2.36k, False: 19.9k] ------------------ 291| 2.63k| for (SetOperation* setOperation : *setOperations) { ------------------ | Branch (291:37): [True: 2.63k, False: 2.36k] ------------------ 292| 2.63k| delete setOperation; 293| 2.63k| } 294| 2.36k| delete setOperations; 295| 2.36k| } 296| | 297| 22.3k| if (lockings) { ------------------ | Branch (297:7): [True: 450, False: 21.8k] ------------------ 298| 6.54k| for (LockingClause* lockingClause : *lockings) { ------------------ | Branch (298:39): [True: 6.54k, False: 450] ------------------ 299| 6.54k| if (lockingClause->tables) { ------------------ | Branch (299:11): [True: 206, False: 6.33k] ------------------ 300| 536| for (char* dtable : *lockingClause->tables) { ------------------ | Branch (300:27): [True: 536, False: 206] ------------------ 301| 536| free(dtable); 302| 536| } 303| 206| delete lockingClause->tables; 304| 206| } 305| 6.54k| delete lockingClause; 306| 6.54k| } 307| 450| delete lockings; 308| 450| } 309| 22.3k|} _ZN4hsql15UpdateStatementC2Ev: 312| 922|UpdateStatement::UpdateStatement() : SQLStatement(kStmtUpdate), table(nullptr), updates(nullptr), where(nullptr) {} _ZN4hsql15UpdateStatementD2Ev: 314| 922|UpdateStatement::~UpdateStatement() { 315| 922| delete table; 316| 922| delete where; 317| | 318| 922| if (updates) { ------------------ | Branch (318:7): [True: 922, False: 0] ------------------ 319| 133k| for (UpdateClause* update : *updates) { ------------------ | Branch (319:31): [True: 133k, False: 922] ------------------ 320| 133k| free(update->column); 321| 133k| delete update->value; 322| 133k| delete update; 323| 133k| } 324| 922| delete updates; 325| 922| } 326| 922|} _ZN4hsql5AliasC2EPcPNSt3__16vectorIS1_NS2_9allocatorIS1_EEEE: 329| 7.93k|Alias::Alias(char* name, std::vector* columns) : name(name), columns(columns) {} _ZN4hsql5AliasD2Ev: 331| 7.93k|Alias::~Alias() { 332| 7.93k| free(name); 333| 7.93k| if (columns) { ------------------ | Branch (333:7): [True: 317, False: 7.61k] ------------------ 334| 913| for (char* column : *columns) { ------------------ | Branch (334:23): [True: 913, False: 317] ------------------ 335| 913| free(column); 336| 913| } 337| 317| delete columns; 338| 317| } 339| 7.93k|} _ZN4hsql8TableRefC2ENS_12TableRefTypeE: 343| 264k| : type(type), schema(nullptr), name(nullptr), alias(nullptr), select(nullptr), list(nullptr), join(nullptr) {} _ZN4hsql8TableRefD2Ev: 345| 264k|TableRef::~TableRef() { 346| 264k| free(schema); 347| 264k| free(name); 348| | 349| 264k| delete select; 350| 264k| delete join; 351| 264k| delete alias; 352| | 353| 264k| if (list) { ------------------ | Branch (353:7): [True: 802, False: 263k] ------------------ 354| 5.33k| for (TableRef* table : *list) { ------------------ | Branch (354:26): [True: 5.33k, False: 802] ------------------ 355| 5.33k| delete table; 356| 5.33k| } 357| 802| delete list; 358| 802| } 359| 264k|} _ZNK4hsql8TableRef7getNameEv: 363| 4.65k|const char* TableRef::getName() const { 364| 4.65k| if (alias) ------------------ | Branch (364:7): [True: 368, False: 4.28k] ------------------ 365| 368| return alias->name; 366| 4.28k| else 367| 4.28k| return name; 368| 4.65k|} _ZN4hsql14JoinDefinitionC2Ev: 371| 111k|JoinDefinition::JoinDefinition() : left(nullptr), right(nullptr), condition(nullptr), type(kJoinInner) {} _ZN4hsql14JoinDefinitionD2Ev: 373| 111k|JoinDefinition::~JoinDefinition() { 374| 111k| delete left; 375| 111k| delete right; 376| 111k| delete condition; 377| 111k|} _ZN4hsql12SetOperationC2Ev: 379| 3.47k|SetOperation::SetOperation() : nestedSelectStatement(nullptr), resultOrder(nullptr), resultLimit(nullptr) {} _ZN4hsql12SetOperationD2Ev: 381| 3.47k|SetOperation::~SetOperation() { 382| 3.47k| delete nestedSelectStatement; 383| 3.47k| delete resultLimit; 384| | 385| 3.47k| if (resultOrder) { ------------------ | Branch (385:7): [True: 655, False: 2.82k] ------------------ 386| 2.01k| for (OrderDescription* desc : *resultOrder) { ------------------ | Branch (386:33): [True: 2.01k, False: 655] ------------------ 387| 2.01k| delete desc; 388| 2.01k| } 389| 655| delete resultOrder; 390| 655| } 391| 3.47k|}