mariadb

Commit Graph

Author	SHA1	Message	Date
Alexander Barkov	6340c23933	MDEV-33281 Implement optimizer hints Implementing a recursive descent parser for optimizer hints.	1 year ago
Vasilii Lakhin	40c5b62531	Fix remaining typos	6 months ago
Dmitry Shulga	ecb7c9b692	MDEV-10164: Add support for TRIGGERS that fire on multiple events Added capability to create a trigger associated with several trigger events. For this goal, the syntax of the CREATE TRIGGER statement was extended to support the syntax structure { event [ OR ... ] } for the `trigger_event` clause. Since one trigger will be able to handle several events it should be provided a way to determine what kind of event is handled on execution of a trigger. For this goal support of the clauses INSERTING, UPDATING , DELETING was added by this patch. These clauses can be used inside a trigger body to detect what kind of trigger action is currently processed using the following boilerplate: IF INSERTING THEN ... ELSIF UPDATING THEN ... ELSIF DELETING THEN ... In case one of the clauses INSERTING, UPDATING, DELETING specified in a trigger's body not matched with a trigger event type, the error ER_INCOMPATIBLE_EVENT_FLAG is emitted. After this patch be pushed, one Trigger object will be associated with several trigger events. It means that the array Table_triggers_list::triggers can contain several pointers to the same Trigger object in array members corresponding to different events. Moreover, support of several trigger events for the same trigger requires that the data members `next` and `action_order` of the Trigger class be converted to arrays to store relating information per trigger event base. Ability to specify the same trigger for different event types results in necessity to handle invalid cases on execution of the multi-event trigger, when the OLD or NEW qualifiers doesn't match a current event type against that the trigger is run. The clause OLD should produces the NULL value for INSERT event, whereas the clause NEW should produce the NULL value for DELETE event.	6 months ago
Alexander Barkov	f11504af51	MDEV-20034 Add support for the pre-defined weak SYS_REFCURSOR This patch adds support for SYS_REFCURSOR (a weakly typed cursor) for both sql_mode=ORACLE and sql_mode=DEFAULT. Works as a regular stored routine variable, parameter and return value: - can be passed as an IN parameter to stored functions and procedures - can be passed as an INOUT and OUT parameter to stored procedures - can be returned from a stored function Note, strongly typed REF CURSOR will be added separately. Note, to maintain dependencies easier, some parts of sql_class.h and item.h were moved to new header files: - select_results.h: class select_result_sink class select_result class select_result_interceptor - sp_cursor.h: class sp_cursor_statistics class sp_cursor - sp_rcontext_handler.h class Sp_rcontext_handler and its descendants The implementation consists of the following parts: - A new class sp_cursor_array deriving from Dynamic_array - A new class Statement_rcontext which contains data shared between sub-statements of a compound statement. It has a member m_statement_cursors of the sp_cursor_array data type, as well as open cursor counter. THD inherits from Statement_rcontext. - A new data type handler Type_handler_sys_refcursor in plugins/type_cursor/ It is designed to store uint16 references - positions of the cursor in THD::m_statement_cursors. - Type_handler_sys_refcursor suppresses some derived numeric features. When a SYS_REFCURSOR variable is used as an integer an error is raised. - A new abstract class sp_instr_fetch_cursor. It's needed to share the common code between "OPEN cur" (for static cursors) and "OPER cur FOR stmt" (for SYS_REFCURSORs). - New sp_instr classes: * sp_instr_copen_by_ref - OPEN sys_ref_curor FOR stmt; * sp_instr_cfetch_by_ref - FETCH sys_ref_cursor INTO targets; * sp_instr_cclose_by_ref - CLOSE sys_ref_cursor; * sp_instr_destruct_variable - to destruct SYS_REFCURSOR variables when the execution goes out of the BEGIN..END block where SYS_REFCURSOR variables are declared. - New methods in LEX: * sp_open_cursor_for_stmt - handles "OPEN sys_ref_cursor FOR stmt". * sp_add_instr_fetch_cursor - "FETCH cur INTO targets" for both static cursors and SYS_REFCURSORs. * sp_close - handles "CLOSE cur" both for static cursors and SYS_REFCURSORs. - Changes in cursor functions to handle both static cursors and SYS_REFCURSORs: * Item_func_cursor_isopen * Item_func_cursor_found * Item_func_cursor_notfound * Item_func_cursor_rowcount - A new system variable @@max_open_cursors - to limit the number of cursors (static and SYS_REFCURSORs) opened at the same time. Its allowed range is [0-65536], with 50 by default. - A new virtual method Type_handler::can_return_bool() telling if calling item->val_bool() is allowed for Items of this data type, or if otherwise the "Illegal parameter for operation" error should be raised at fix_fields() time. - New methods in Sp_rcontext_handler: * get_cursor() * get_cursor_by_ref() - A new class Sp_rcontext_handler_statement to handle top level statement wide cursors which are shared by all substatements. - A new virtual method expr_event_handler() in classes Item and Field. It's needed to close (and make available for a new OPEN) unused THD::m_statement_cursors elements which do not have any references any more. It can happen in various moments in time, e.g. * after evaluation parameters of an SQL routine * after assigning a cursor expression into a SYS_REFCURSOR variable * when leaving a BEGIN..END block with SYS_REFCURSOR variables * after setting OUT/INOUT routine actual parameters from formal parameters.	2 years ago
Vasilii Lakhin	717c12de0e	Fix typos in C comments inside sql/	7 months ago
ParadoxV5	7094a75596	MDEV-25674: Add CHANGE MASTER TO master_retry_count This new CHANGE MASTER TO field specifies the `--master-retry-count` (global option: the number of Primary connection attempts) for each multi-source replica; i.e, per-channel `performance_schema.` `replication_connection_configuration.CONNECTION_RETRY_COUNT`. `--master-retry-count` remains the default for new `CHANGE MASTER TO`s. This new keyword and `master-info` entry matches those of pre-‘REPLICATION SOURCE’ MySQL.	8 months ago
Alexander Barkov	b7d67ceb5f	MDEV-36047 Package body variables are not allowed as FETCH targets It was not possible to use a package body variable as a fetch target: CREATE PACKAGE BODY pkg AS vc INT := 0; FUNCTION f1 RETURN INT AS CURSOR cur IS SELECT 1 AS c FROM DUAL; BEGIN OPEN cur; FETCH cur INTO vc; -- this returned "Undeclared variable: vc" error. CLOSE cur; RETURN vc; END; END; FETCH assumed that all fetch targets reside of the same sp_rcontext instance with the cursor. This patch fixes the problem. Now a cursor and its fetch target can reside in different sp_rcontext instances. Details: - Adding a helper class sp_rcontext_addr (a combination of Sp_rcontext_handler pointer and an offset in the rcontext) - Adding a new class sp_fetch_target deriving from sp_rcontext_addr. Fetch targets in "FETCH cur INTO target1, target2 ..." are now collected into this structure instead of sp_variable. sp_variable cannot be used any more to store fetch targets, because it does not have a pointer to Sp_rcontext_handler (it only has the current rcontext offset). - Removing members sp_instr_set members m_rcontext_handler and m_offset. Deriving sp_instr_set from sp_rcontext_addr instead. - Renaming sp_instr_cfetch member "List<sp_variable> m_varlist" to "List<sp_fetch_target> m_fetch_target_list". - Fixing LEX::sp_add_cfetch() to return the pointer to the created sp_fetch_target instance (instead of returning bool). This helps to make the grammar in sql_yacc.c simpler - Renaming LEX::sp_add_cfetch() to LEX::sp_add_instr_cfetch(), as `if(sp_add_cfetch())` changed its meaning to the opposite, to avoid automatic wrong merge from earlier versions. - Chaning the "List<sp_variable> vars" parameter to sp_cursor::fetch to have the data type "List<sp_fetch_target> ". - Changing the data type of "List<sp_variable> &vars" in sp_cursor::Select_fetch_into_spvars::send_data_to_variable_list() to "List<sp_fetch_target> &". - Adding THD helper methods get_rcontext() and get_variable(). - Moving the code from sql_yacc.yy into a new LEX method LEX::make_fetch_target(). - Simplifying the grammar in sql_yacc.yy using the new LEX method. Changing the data type of the bison rule sp_fetch_list from "void" to "List<sp_fetch_target> *".	8 months ago
Sergei Petrunia	0e21ff8ca4	MDEV-35318 Assertion `tl->jtbm_subselect' failed in JOIN::calc_allowed_top_level_tables Alternative, more general fix, Variant 2. The problem was as follows: Suppose we are running a PS/SP statement and we get an error while doing optimization that is done once per statement life. This may leave the statement data structures in an undefined state, where it is not safe to execute it again. The fix: introduce LEX::needs_reprepare and set it in such cases. Make PS and SP runtime check it and re-prepare the statement before executing it again. We do not use Reprepare_observer, because it turns out it is tightly tied to watching versions of statement's objects. For example, it must not be used when running the statement for the first time, exactly when the once-per-statement-lifetime optimizations are done.	9 months ago
Iqbal Hassan	dfdbec1636	MDEV-10862: Stored procedures: default values for parameters (optional parameters) Implement default values for parameters of stored routines in both default and oracle mode. - Default values for cursor parameters are NOT supported yet. - An IN parameter with DEFAULT followed by an OUT param is not supported yet. This combination will be enabled together with the arrow syntax: sp1(v=>p2) The default values can be either literals or expressions. When it is an expression, it is only evaluated if the parameter has not been supplied by the caller (important if the expression has side effects).	11 months ago
Iqbal Hassan	9f5adf0ce4	MDEV-34317: Implement RECORD type Implement `DECLARE TYPE type_name IS RECORD (..)` with scalar members in stored routines and anonymous blocks	1 year ago
Dmitry Shulga	759df4cc5f	MDEV-34551: Column list in the trigger definition Added support of the clause `UPDATE OF <columns>` for BEFORE/AFTER UPDATE triggers. Triggers defined with this clause are fired and run actions only in case an UPDATE statement affects any of the listed columns. For columns not specified in the clause `UPDATE OF <columns>`, an UPDATE statement with such columns as targets don't result in running a trigger. Output of SHOW TRIGGERS isn't affected by this task. Output of the statement SHOW CREATE TRIGGER shows the clause `UPDATE OF <columns>` if it was specified on trigger creation. Tests accompany this task don't include tests that checking for cooperation of the statement LOAD DATA and the clause `UPDATE OF <columns>` for BEFORE/AFTER UPDATE triggers since the statement LOAD DATA is treated like the statement INSERT INTO and therefore doesn't fire BEFORE/AFTER UPDATE triggers.	9 months ago
Brandon Nesterenko	d8c841d0d4	MDEV-35096: History is stored in different partitions on different nodes when using SYSTEM VERSION Row-injection updates don’t correctly set the historical partition for tables with system versioning and system_time partitions. This results in inconsistencies between the master and slave when replicating transactions that target such tables (i.e. the primary server would correctly distribute archived rows amongst its partitions, whereas the replica would have all archived rows in a single partition). The function partition_info::vers_set_hist_part(THD) is used to set the partition; however, its initial check for vers_require_hist_part(THD) returns false, bypassing the rest of the function (which sets up the partition to use). This is because the actual check uses the LEX sql_command (via LEX::vers_history_generating()) to determine if the command is valid to generate history. Row injections don’t have sql_commands though. This patch provides a fix which extends the check in vers_history_generating() to additionally allow row injections to be history generating (via the function LEX::is_stmt_row_injection()). Special thanks to Jan Lindstrom <jan.lindstrom@galeracluster.com> for his work in reproducing the bug, and providing an initial test case. Reviewed By ============ Kristian Nielsen <knielsen@knielsen-hq.org> Aleksey Midenkov <midenok@mariadb.com>	9 months ago
Aleksey Midenkov	cc183489da	MDEV-27293 Allow converting a versioned table from implicit to explicit row_start/row_end columns In case of adding both system fields of same type (length, unsigned flag) as old implicit system fields do the rename of implicit system fields to the ones specified in ALTER, remove SYSTEM_INVISIBLE flag in that case. Correct PERIOD clause must be specified in ALTER as well. MDEV-34904 Inplace alter for implicit to explicit versioning is broken Whether ALTER goes inplace and how it goes inplace depends on handler_flags which goes from alter_info->flags by this logic: ha_alter_info->handler_flags\|= (alter_info->flags & ~flags_to_remove); ALTER_VERS_EXPLICIT was not in flags_to_remove and its value (1ULL << 35) clashed with ALTER_ADD_NON_UNIQUE_NON_PRIM_INDEX. ALTER_VERS_EXPLICIT must not affect inplace, it is SQL-only so we remove it from handler_flags.	12 months ago
Yuchen Pei	4b6922a315	MDEV-25008: UPDATE/DELETE: Cost-based choice IN->EXISTS vs Materialization Single-table UPDATE/DELETE didn't provide outer_lookup_keys value for subqueries. This didn't allow to make a meaningful choice between IN->EXISTS and Materialization strategies for subqueries. Fix this: * Make UPDATE/DELETE save Sql_cmd_dml::scanned_rows, * Then, subquery's JOIN::choose_subquery_plan() can fetch it from there for outer_lookup_keys Details: UPDATE/DELETE now calls select_lex->optimize_unflattened_subqueries() twice, like SELECT does (first call optimize_constant_subquries() in JOIN::optimize_inner(), then call optimize_unflattened_subqueries() in JOIN::optimize_stage2()): 1. Call with const_only=true before any optimizations. This allows range optimizer and others to use the values of cheap const subqueries. 2. Call it with const_only=false after range optimizer, partition pruning, etc. outer_lookup_keys value is provided, so it's possible to pick a good subquery strategy. Note: PROTECT_STATEMENT_MEMROOT requires that first SP execution performs subquery optimization for all subqueries, even for degenerate query plans like "Impossible WHERE". Due to that, we ensure that the call to optimize_unflattened_subqueries (with const_only=false) even for degenerate query plans still happens, as was the case before this change.	1 year ago
Alexander Barkov	e1cd3c4033	MDEV-12252 ROW data type for stored function return values Adding support for the ROW data type in the stored function RETURNS clause: - explicit ROW(..members...) for both sql_mode=DEFAULT and sql_mode=ORACLE CREATE FUNCTION f1() RETURNS ROW(a INT, b VARCHAR(32)) ... - anchored "ROW TYPE OF [db1.]table1" declarations for sql_mode=DEFAULT CREATE FUNCTION f1() RETURNS ROW TYPE OF test.t1 ... - anchored "[db1.]table1%ROWTYPE" declarations for sql_mode=ORACLE CREATE FUNCTION f1() RETURN test.t1%ROWTYPE ... Adding support for anchored scalar data types in RETURNS clause: - "TYPE OF [db1.]table1.column1" for sql_mode=DEFAULT CREATE FUNCTION f1() RETURNS TYPE OF test.t1.column1; - "[db1.]table1.column1" for sql_mode=ORACLE CREATE FUNCTION f1() RETURN test.t1.column1%TYPE; Details: - Adding a new sql_mode_t parameter to sp_head::create() sp_head::sp_head() sp_package::create() sp_package::sp_package() to guarantee early initialization of sp_head::m_sql_mode. Before this change, this member was not initialized at all during CREATE FUNCTION/PROCEDURE/PACKAGE statements, and was not used. Now it needs to be initialized to write properly the mysql.proc.returns column, according to the create time sql_mode. - Code refactoring to make the things simpler and functions smaller: * Adding a new method Field_row::row_create_fields(THD thd, List<Spvar_definition> list) to make a Virtual_tmp_table with Fields for ROW members from an explicit definition. * Adding a new method Field_row::row_create_fields(THD thd, const Spvar_definition &def) to make a Virtual_tmp_table with Fields for ROW members from an explicit or a table anchored definition. Adding a new method Item_args::add_array_of_item_field(THD thd, const Virtual_tmp_table &vtable) to create and array of Item_field corresponding to all Field instances in a Virtual_tmp_table Removing Item_field_row::row_create_items(). It was decomposed into the new methods described above. * Moving the code from the loop body in sp_rcontext::init_var_items() into a separate method Spvar_definition::make_item_field_row(), to make the code clearer (smaller functions). make_item_field_row() itself uses the new methods described above. - Changing the data type of sp_head::m_return_field_def from Column_definition to Spvar_definition. So now it supports not only SQL column field types, but also explicit ROW and anchored ROW data types, as well as anchored column types. - Adding a new Column_definition parameter to sp_head::create_result_field(). Before this patch, create_result_field() took the definition only from m_return_field_def. Now it's also called with a local Column_definition variable which contains the explicit definition resolved from an anchored defition. - Modifying sql_yacc.yy to support the new grammar. Adding new helper methods: * sf_return_fill_definition_row() * sf_return_fill_definition_rowtype_of() * sf_return_fill_definition_type_of() - Fixing tests in: * Virtual_tmp_table::setup_field_pointers() in sql_select.cc * Send_field::normalize() in field.h * store_column_type() to prevent calling Type_handler_row::field_type(), which is implemented a DBUG_ASSERT(0). Before this patch the affected methods and functions were called only for scalar data types. Now ROW is also possible. - Adding a new virtual method Field::cols() - Overriding methods: Item_func_sp::cols() Item_func_sp::element_index() Item_func_sp::check_cols() Item_func_sp::bring_value() to support the ROW data type. - Extending the rule sp_return_type to support * explicit ROW and anchored ROW data types * anchored scalar data types - Overriding Field_row::sql_type() to print the data type of an explicit ROW.	2 years ago
Yuchen Pei	d2eba35653	MDEV-34716 Allow arbitrary options in CREATE SERVER The existing syntax for CREATE SERVER CREATE [OR REPLACE] SERVER [IF NOT EXISTS] server_name FOREIGN DATA WRAPPER wrapper_name OPTIONS (option [, option] ...) option: { HOST character-literal \| DATABASE character-literal \| USER character-literal \| PASSWORD character-literal \| SOCKET character-literal \| OWNER character-literal \| PORT numeric-literal } With this change we have: option: { HOST character-literal \| DATABASE character-literal \| USER character-literal \| PASSWORD character-literal \| SOCKET character-literal \| OWNER character-literal \| PORT numeric-literal \| PORT quoted-numerical-literal \| identifier character-literal} We store these options as a JSON field in the mysql.servers system table. We retain the restriction that PORT needs to be a number, but also allow it to be a quoted number, so that SHOW CREATE SERVER can be used for dumping. Without an accompanied implementation of SHOW CREATE SERVER, some mysqldump tests will fail. Therefore this commit should be immediately followed by the one implementating SHOW CREATE SERVER, with testing covering both.	1 year ago
Rex	9315452ea0	MDEV-34941 MDEV-31466-fix column count issue with union in derived table In specifying a derived table with a union, for example CREATE TABLE t (c1 INT KEY,c2 INT,c3 INT) ENGINE=MyISAM; SELECT * FROM (SELECT * FROM t UNION SELECT * FROM t) AS d (d1,d2); we bypass an earlier check for the correct number of specified column names, causing a crash. Fixed by adding a check for the correct number of supplied arguments in st_select_lex_unit::rename_types_list()	1 year ago
Rex	10008b3d3e	MDEV-31466 Add optional correlation column list for derived tables Extend derived table syntax to support column name assignment. (subquery expression) [as\|=] ident [comma separated column name list]. Prior to this patch, the optional comma separated column name list is not supported. Processing within the unit of the subquery expression will use original column names, outside the unit will use the new names. For example, in the query select a1, a2 from (select c1, c2, c3 from t1 where c2 > 0) as dt (a1, a2, a3) where a2 > 10; we see the second column of the derived table dt being used both within, (where c2 > 0), and outside, (where a2 > 10), the specification. Both conditions apply to t1.c2. When multiple unit preparations are required, such as when being used within a prepared statement or procedure, original column names are needed for correct resolution. Original names are reset within mysql_derived_reinit(). Item_holder items, used for result tables in both TVC and union preparations are renamed before use within st_select_lex_unit::prepare(). During wildcard expansion, if column names are present, items names are set directly after creation. Reviewed by Igor Babaev (igor@mariadb.com)	1 year ago
Oleksandr Byelkin	8d810e9426	MDEV-29537 Creation of view with UNION and SELECT ... FOR UPDATE in definition is failed with error lock_type is writen in the last SELECT of the unit even if it parsed last, so it should be printed last from the last select of the unit.	1 year ago
Yuchen Pei	2c3e07df47	MDEV-34447: Memory leakage is detected on running the test main.ps against the server 11.1 The memory leak happened on second execution of a prepared statement that runs UPDATE statement with correlated subquery in right hand side of the SET clause. In this case, invocation of the method table->stat_records() could return the zero value that results in going into the 'if' branch that handles impossible where condition. The issue is that this condition branch missed saving of leaf tables that has to be performed as first condition optimization activity. Later the PS statement memory root is marked as read only on finishing first time execution of the prepared statement. Next time the same statement is executed it hits the assertion on attempt to allocate a memory on the PS memory root marked as read only. This memory allocation takes place by the sequence of the following invocations: Prepared_statement::execute mysql_execute_command Sql_cmd_dml::execute Sql_cmd_update::execute_inner Sql_cmd_update::update_single_table st_select_lex::save_leaf_tables List<TABLE_LIST>::push_back To fix the issue, add the flag SELECT_LEX::leaf_tables_saved to control whether the method SELECT_LEX::save_leaf_tables() has to be called or it has been already invoked and no more invocation required. Similar issue could take place on running the DELETE statement with the LIMIT clause in PS/SP mode. The reason of memory leak is the same as for UPDATE case and be fixed in the same way.	1 year ago
Monty	25b5c63905	MDEV-33856: Alternative Replication Lag Representation via Received/Executed Master Binlog Event Timestamps This commit adds 3 new status variables to 'show all slaves status': - Master_last_event_time ; timestamp of the last event read from the master by the IO thread. - Slave_last_event_time ; Master timestamp of the last event committed on the slave. - Master_Slave_time_diff: The difference of the above two timestamps. All the above variables are NULL until the slave has started and the slave has read one query event from the master that changes data. - Added information_schema.slave_status, which allows us to remove: - show_master_info(), show_master_info_get_fields(), send_show_master_info_data(), show_all_master_info() - class Sql_cmd_show_slave_status. - Protocol::store(I_List<i_string_pair>* str_list) as it is not used anymore. - Changed old SHOW SLAVE STATUS and SHOW ALL SLAVES STATUS to use the SELECT code path, as all other SHOW ... STATUS commands. Other things: - Xid_log_time is set to time of commit to allow slave that reads the binary log to calculate Master_last_event_time and Slave_last_event_time. This is needed as there is not 'exec_time' for row events. - Fixed that Load_log_event calculates exec_time identically to Query_event. - Updated RESET SLAVE to reset Master/Slave_last_event_time - Updated SQL thread's update on first transaction read-in to only update Slave_last_event_time on group events. - Fixed possible (unlikely) bugs in sql_show.cc ...old_format() functions if allocation of 'field' would fail. Reviewed By: Brandon Nesterenko <brandon.nesterenko@mariadb.com> Kristian Nielsen <knielsen@knielsen-hq.org>	1 year ago
Alexander Barkov	2f4b0ba328	Moving a part of sql_lex.h into other .h files - Lex_ident_cli into a new file sql/lex_ident_cli.h - Lex_ident_sys* into a new file sql/lex_ident_sys.h - Well_formed_prefix into include/m_ctype.h This change is needed to the optimizer hint parser coming soon.	1 year ago
Dmitry Shulga	e012407397	MDEV-34447: Memory leakage is detected on running the test main.ps against the server 11.1 The memory leak happened on second execution of a prepared statement that runs UPDATE statement with correlated subquery in right hand side of the SET clause. In this case, invocation of the method table->stat_records() could return the zero value that results in going into the 'if' branch that handles impossible where condition. The issue is that this condition branch missed saving of leaf tables that has to be performed as first condition optimization activity. Later the PS statement memory root is marked as read only on finishing first time execution of the prepared statement. Next time the same statement is executed it hits the assertion on attempt to allocate a memory on the PS memory root marked as read only. This memory allocation takes place by the sequence of the following invocations: Prepared_statement::execute mysql_execute_command Sql_cmd_dml::execute Sql_cmd_update::execute_inner Sql_cmd_update::update_single_table st_select_lex::save_leaf_tables List<TABLE_LIST>::push_back To fix the issue, add the flag SELECT_LEX::leaf_tables_saved to control whether the method SELECT_LEX::save_leaf_tables() has to be called or it has been already invoked and no more invocation required. Similar issue could take place on running the DELETE statement with the LIMIT clause in PS/SP mode. The reason of memory leak is the same as for UPDATE case and be fixed in the same way.	1 year ago
Rex	9e800eda86	MDEV-32583 UUID() should be treated as stochastic for the purposes of forcing query materialization RAND() and UUID() are treated differently with respect to subquery materialization both should be marked as uncacheable, forcing materialization. Altered Create_func_uuid(_short)::create_builder(). Added comment in header about UNCACHEABLE_RAND meaning also unmergeable.	2 years ago
Alexander Barkov	76e0dc18b6	MDEV-34288 SET NAMES DEFAULT crashes `mariadbd --collation-server=utf8mb4_unicode_ci` The @@global.character_set_client variable could erroneously be set to a non-default collation of its character set, which further made the `SET NAMES DEFAULT` statement crash the server. Fixing the code to make sure that the global value these variables: @@character_set_client @@character_set_connection @@character_set_server @@character_set_database @@character_set_connection point to the default compiled collations of the character set.	1 year ago
Dmitry Shulga	5e6c122427	MDEV-33769: Memory leak found in the test main.rownum run with --ps-protocol against a server built with the option -DWITH_PROTECT_STATEMENT_MEMROOT A memory leak happens on the second execution of a query that run in PS mode and uses the function ROWNUM(). A memory leak took place on allocation of an instance of the class Item_int for storing a limit value that is performed at the function set_limit_for_unit indirectly called from JOIN::optimize_inner. Typical trace to the place where the memory leak occurred is below: JOIN::optimize_inner optimize_rownum process_direct_rownum_comparison set_limit_for_unit new (thd->mem_root) Item_int(thd, lim, MAX_BIGINT_WIDTH); To fix this memory leak, calling of the function optimize_rownum() has to be performed only once on first execution and never called after that. To control it, the new data member first_rownum_optimization added into the structure st_select_lex.	1 year ago
Alexander Barkov	fd247cc21f	MDEV-31340 Remove MY_COLLATION_HANDLER::strcasecmp() This patch also fixes: MDEV-33050 Build-in schemas like oracle_schema are accent insensitive MDEV-33084 LASTVAL(t1) and LASTVAL(T1) do not work well with lower-case-table-names=0 MDEV-33085 Tables T1 and t1 do not work well with ENGINE=CSV and lower-case-table-names=0 MDEV-33086 SHOW OPEN TABLES IN DB1 -- is case insensitive with lower-case-table-names=0 MDEV-33088 Cannot create triggers in the database `MYSQL` MDEV-33103 LOCK TABLE t1 AS t2 -- alias is not case sensitive with lower-case-table-names=0 MDEV-33109 DROP DATABASE MYSQL -- does not drop SP with lower-case-table-names=0 MDEV-33110 HANDLER commands are case insensitive with lower-case-table-names=0 MDEV-33119 User is case insensitive in INFORMATION_SCHEMA.VIEWS MDEV-33120 System log table names are case insensitive with lower-cast-table-names=0 - Removing the virtual function strnncoll() from MY_COLLATION_HANDLER - Adding a wrapper function CHARSET_INFO::streq(), to compare two strings for equality. For now it calls strnncoll() internally. In the future it will turn into a virtual function. - Adding new accent sensitive case insensitive collations: - utf8mb4_general1400_as_ci - utf8mb3_general1400_as_ci They implement accent sensitive case insensitive comparison. The weight of a character is equal to the code point of its upper case variant. These collations use Unicode-14.0.0 casefolding data. The result of my_charset_utf8mb3_general1400_as_ci.strcoll() is very close to the former my_charset_utf8mb3_general_ci.strcasecmp() There is only a difference in a couple dozen rare characters, because: - the switch from "tolower" to "toupper" comparison, to make utf8mb3_general1400_as_ci closer to utf8mb3_general_ci - the switch from Unicode-3.0.0 to Unicode-14.0.0 This difference should be tolarable. See the list of affected characters in the MDEV description. Note, utf8mb4_general1400_as_ci correctly handles non-BMP characters! Unlike utf8mb4_general_ci, it does not treat all BMP characters as equal. - Adding classes representing names of the file based database objects: Lex_ident_db Lex_ident_table Lex_ident_trigger Their comparison collation depends on the underlying file system case sensitivity and on --lower-case-table-names and can be either my_charset_bin or my_charset_utf8mb3_general1400_as_ci. - Adding classes representing names of other database objects, whose names have case insensitive comparison style, using my_charset_utf8mb3_general1400_as_ci: Lex_ident_column Lex_ident_sys_var Lex_ident_user_var Lex_ident_sp_var Lex_ident_ps Lex_ident_i_s_table Lex_ident_window Lex_ident_func Lex_ident_partition Lex_ident_with_element Lex_ident_rpl_filter Lex_ident_master_info Lex_ident_host Lex_ident_locale Lex_ident_plugin Lex_ident_engine Lex_ident_server Lex_ident_savepoint Lex_ident_charset engine_option_value::Name - All the mentioned Lex_ident_xxx classes implement a method streq(): if (ident1.streq(ident2)) do_equal(); This method works as a wrapper for CHARSET_INFO::streq(). - Changing a lot of "LEX_CSTRING name" to "Lex_ident_xxx name" in class members and in function/method parameters. - Replacing all calls like system_charset_info->coll->strcasecmp(ident1, ident2) to ident1.streq(ident2) - Taking advantage of the c++11 user defined literal operator for LEX_CSTRING (see m_strings.h) and Lex_ident_xxx (see lex_ident.h) data types. Use example: const Lex_ident_column primary_key_name= "PRIMARY"_Lex_ident_column; is now a shorter version of: const Lex_ident_column primary_key_name= Lex_ident_column({STRING_WITH_LEN("PRIMARY")});	3 years ago
Marko Mäkelä	09d991d01c	MDEV-33478: Tests massively fail with clang-18 -fsanitize=memory Starting with clang-16, MemorySanitizer appears to check that uninitialized values not be passed by value nor returned. Previously, it was allowed to copy uninitialized data in such cases. get_foreign_key_info(): Remove a local variable that was passed uninitialized to a function. DsMrr_impl: Initialize key_buffer, because DsMrr_impl::dsmrr_init() is reading it. test_bind_result_ext1(): MYSQL_TYPE_LONG is 32 bits, hence we must use a 32-bit type, such as int. sizeof(long) differs between LP64 and LLP64 targets.	2 years ago
Alexander Barkov	929c2e06aa	MDEV-31531 Remove my_casedn_str() and my_caseup_str() Under terms of MDEV 27490 we'll add support for non-BMP identifiers and upgrade casefolding information to Unicode version 14.0.0. In Unicode-14.0.0 conversion to lower and upper cases can increase octet length of the string, so conversion won't be possible in-place any more. This patch removes virtual functions performing in-place casefolding: - my_charset_handler_st::casedn_str() - my_charset_handler_st::caseup_str() and fixes the code to use the non-inplace functions instead: - my_charset_handler_st::casedn() - my_charset_handler_st::caseup()	2 years ago
Yuchen Pei	374783c3d9	MDEV-28152 Features for sequences - Add `as <int_type>` to sequence creation options - int_type can be signed or unsigned integer types, including tinyint, smallint, mediumint, int and bigint - Limitation: when alter sequence as <new_int_type>, cannot have any other alter options in the same statement - Limitation: increment remains signed longlong, and the hidden constraint (cache_size x abs(increment) < longlong_max) stays for unsigned types. This means for bigint unsigned, neither abs(increment) nor (cache_size x abs(increment)) can be between longlong_max and ulonglong_max - Truncating maxvalue and minvalue from user input to the nearest max or min value of the type, plus or minus 1. When the truncation happens, a warning is emitted - Information schema table for sequences	2 years ago
Igor Babaev	54ed3939f7	MDEV-31657 Crash on query using CTE with the same name as a base table If a query contained a CTE whose name coincided with the name of one of the base tables used in the specification of the CTE and the query had at least two references to this CTE in the specifications of other CTEs then processing of the query led to unlimited recursion that ultimately caused a crash of the server. Any secondary non-recursive reference to a CTE requires creation of a copy of the CTE specification. All the references to CTEs in this copy must be resolved. If the specification contains a reference to a base table whose name coincides with the name of then CTE then it should be ensured that this reference in no way can be resolved against the name of the CTE.	2 years ago
Alexander Barkov	aed9c656a9	MDEV-32101 CREATE PACKAGE [BODY] for sql_mode=DEFAULT This patch adds PACKAGE support with SQL/PSM dialect for sql_mode=DEFAULT: - CREATE PACKAGE - DROP PACKAGE - CREATE PACKAGE BODY - DROP PACKAGE BODY - Package function and procedure invocation from outside of the package: -- using two step identifiers SELECT pkg.f1(); CALL pkg.p1() -- using three step identifiers SELECT db.pkg.f1(); CALL db.pkg.p1(); This is a non-standard MariaDB extension. However, later this code can be used to implement the SQL Standard and DB2 dialects of CREATE MODULE.	2 years ago
Aleksey Midenkov	5462b61b0c	MDEV-22164 without validation for exchange partition/convert in 1. WITHOUT/WITH VALIDATION may be added to EXCHANGE PARTITION or CONVERT TABLE: alter table tp exchange partition p1 with table t with validation; alter table tp exchange partition p1 with table t; -- same as with validation alter table tp exchange partition p1 with table t without validation; 2. Optional THAN keyword for RANGE partitioning. Normally you type: create table tp (a int primary key) partition by range (a) ( partition p0 values less than (100), partition p1 values less than maxvalue); Now you may type (PARTITION keyword is also optional): create table tp (a int primary key) partition by range (a) ( p0 values less (100), p1 values less maxvalue);	2 years ago
Rex	2c1345ab27	MDEV-31995 Fix2 allocate memory in mem_root properly. Lex_ident_sys had no new operator and was used incorrectly in save_item_list_names(), so leaked memory.	2 years ago
Rex	8b509a5d64	Merge 10.4 into 10.5	2 years ago
Alexander Barkov	b0379ea4b3	Cleanup: Adding "const" to the member Spvar_definition::m_column_type_ref and to related methods and their parameters: - The return value of Spvar_definition::m_column_type_ref() - The parameter of Spvar_definition::set_column_type_ref() - The method Qualified_column_ident::resolve_type_ref() - The parameter of LEX::sp_variable_declarations_column_type_finalize()	2 years ago
Alexander Barkov	2b6d241ee4	MDEV-27744 LPAD in vcol created in ORACLE mode makes table corrupted in non-ORACLE The crash happened with an indexed virtual column whose value is evaluated using a function that has a different meaning in sql_mode='' vs sql_mode=ORACLE: - DECODE() - LTRIM() - RTRIM() - LPAD() - RPAD() - REPLACE() - SUBSTR() For example: CREATE TABLE t1 ( b VARCHAR(1), g CHAR(1) GENERATED ALWAYS AS (SUBSTR(b,0,0)) VIRTUAL, KEY g(g) ); So far we had replacement XXX_ORACLE() functions for all mentioned function, e.g. SUBSTR_ORACLE() for SUBSTR(). So it was possible to correctly re-parse SUBSTR_ORACLE() even in sql_mode=''. But it was not possible to re-parse the MariaDB version of SUBSTR() after switching to sql_mode=ORACLE. It was erroneously mis-interpreted as SUBSTR_ORACLE(). As a result, this combination worked fine: SET sql_mode=ORACLE; CREATE TABLE t1 ... g CHAR(1) GENERATED ALWAYS AS (SUBSTR(b,0,0)) VIRTUAL, ...; INSERT ... FLUSH TABLES; SET sql_mode=''; INSERT ... But the other way around it crashed: SET sql_mode=''; CREATE TABLE t1 ... g CHAR(1) GENERATED ALWAYS AS (SUBSTR(b,0,0)) VIRTUAL, ...; INSERT ... FLUSH TABLES; SET sql_mode=ORACLE; INSERT ... At CREATE time, SUBSTR was instantiated as Item_func_substr and printed in the FRM file as substr(). At re-open time with sql_mode=ORACLE, "substr()" was erroneously instantiated as Item_func_substr_oracle. Fix: The fix proposes a symmetric solution. It provides a way to re-parse reliably all sql_mode dependent functions to their original CREATE TABLE time meaning, no matter what the open-time sql_mode is. We take advantage of the same idea we previously used to resolve sql_mode dependent data types. Now all sql_mode dependent functions are printed by SHOW using a schema qualifier when the current sql_mode differs from the function sql_mode: SET sql_mode=''; CREATE TABLE t1 ... SUBSTR(a,b,c) ..; SET sql_mode=ORACLE; SHOW CREATE TABLE t1; -> mariadb_schema.substr(a,b,c) SET sql_mode=ORACLE; CREATE TABLE t2 ... SUBSTR(a,b,c) ..; SET sql_mode=''; SHOW CREATE TABLE t1; -> oracle_schema.substr(a,b,c) Old replacement names like substr_oracle() are still understood for backward compatibility and used in FRM files (for downgrade compatibility), but they are not printed by SHOW any more.	4 years ago
Rex	eb8053b377	MDEV-31995 Bogus error executing PS for query using CTE with renaming of columns This commit addresses column naming issues with CTEs in the use of prepared statements and stored procedures. Usage of either prepared statements or procedures with Common Table Expressions and column renaming may be affected. There are three related but different issues addressed here. 1) First execution issue. Consider the following prepare s from "with cte (col1, col2) as (select a as c1, b as c2 from t order by c1) select col1, col2 from cte"; execute s; After parsing, items in the select are named (c1,c2), order by (and group by) resolution is performed, then item names are set to (col1, col2). When the statement is executed, context analysis is again performed, but resolution of elements in the order by statement will not be able to find c1, because it was renamed to col1 and remains this way. The solution is to save the names of these items during context resolution before they have been renamed. We can then reset item names back to those after parsing so first execution can resolve items referred to in order and group by clauses. 2) Second Execution Issue When the derived table contains more than one select 'unioned' together we could reasonably think that dealing with only items in the first select (which determines names in the resultant table) would be sufficient. This can lead to a different problem. Consider prepare st from "with cte (c1,c2) as (select a as col1, sum(b) as col2 from t1 where a > 0 group by col1 union select a as col3, sum(b) as col4 from t2 where b > 2 group by col3) select * from cte where c1=1"; When the optimizer (only run during the first execution) pushes the outside condition "c1=1" into every select in the derived table union, it renames the items to make the condition valid. In this example, this leaves the first item in the second select named 'c1'. The second execution will now fail 'group by' resolution. Again, the solution is to save the names during context analysis, resetting before subsequent resolution, but making sure that we save/reset the item names in all the selects in this union. 3) Memory Leak During parsing Item::set_name() is used to allocate memory in the statement arena. We cannot use this call during statement execution as this represents a memory leak. We directly set the item list names to those in the column list of this CTE (also allocated during parsing). Approved by Igor Babaev <igor@mariadb.com>	2 years ago
Brandon Nesterenko	0c1bf5e247	MDEV-27247: Add keywords "SQL_BEFORE_GTIDS" and "SQL_AFTER_GTIDS" for START SLAVE UNTIL New Feature: ============ This patch extends the START SLAVE UNTIL command with options SQL_BEFORE_GTIDS and SQL_AFTER_GTIDS to allow user control of whether the replica stops before or after a provided GTID state. Its syntax is: START SLAVE UNTIL (SQL_BEFORE_GTIDS\|SQL_AFTER_GTIDS)=”<gtid_list>” When providing SQL_BEFORE_GTIDS=”<gtid_list>”, for each domain specified in the gtid_list, the replica will execute transactions up to the GTID found, and immediately stop processing events in that domain (without executing the transaction of the specified GTID). Once all domains have stopped, the replica will stop. Events originating from domains that are not specified in the list are not replicated. START SLAVE UNTIL SQL_AFTER_GTIDS=”<gtid_list>” is an alias to the default behavior of START SLAVE UNTIL master_gtid_pos=”<gtid_list>”. That is, the replica will only execute transactions originating from domain ids provided in the list, and will stop once all transactions provided in the UNTIL list have all been executed. Example: ========= If a primary server has a binary log consisting of the following GTIDs: 0-1-1 1-1-1 0-1-2 1-1-2 0-1-3 1-1-3 If a fresh replica (i.e. one with an empty GTID position, @@gtid_slave_pos='') is started with SQL_BEFORE_GTIDS, i.e. START SLAVE UNTIL SQL_BEFORE_GTIDS=”1-1-2” The resulting gtid_slave_pos of the replica will be “1-1-1”. This is because the replica will execute only events from domain 1 until it sees the transaction with sequence number 2, and immediately stop without executing it. If the replica is started with SQL_AFTER_GTIDS, i.e. START SLAVE UNTIL SQL_AFTER_GTIDS=”1-1-2” then the resulting gtid_slave_pos of the replica will be “1-1-2”. This is because it will only execute events from domain 1 until it has executed the provided GTID. Reviewed By: ============ Kristian Nielson <knielsen@knielsen-hq.org>	2 years ago
Alexander Barkov	534a2bf1c6	MDEV-32275 getting error 'Illegal parameter data types row and bigint for operation '+' ' when using ITERATE in a FOR..DO An "ITERATE innerLoop" did not work properly inside a WHILE loop, which itself is inside an outer FOR loop: outerLoop: FOR ... innerLoop: WHILE ... ITERATE innerLoop; ... END WHILE; ... END FOR; It erroneously generated an integer increment code for the outer FOR loop. There were two problems: 1. "ITERATE innerLoop" worked like "ITERATE outerLoop" 2. It was always integer increment, even in case of FOR cursor loops. Background: - A FOR loop automatically creates a dedicated sp_pcontext stack entry, to put the iteration and bound variables on it. - Other loop types (LOOP, WHILE, REPEAT), do not generate a dedicated slack entry. The old code erroneously assumed that sp_pcontext::m_for_loop either describes the most inner loop (in case the inner loop is FOR), or is empty (in case the inner loop is not FOR). But in fact, sp_pcontext::m_for_loop is never empty inside a FOR loop: it describes the closest FOR loop, even if this FOR loop has nested non-FOR loops inside. So when we're near the ITERATE statement in the above script, sp_pcontext::m_for_loop is not empty - it stores information about the FOR loop labeled as "outrLoop:". Fix: - Adding a new member sp_pcontext::Lex_for_loop::m_start_label, to remember the explicit or the auto-generated label correspoding to the start of the FOR body. It's used during generation of "ITERATE loop_label" code to check if "loop_label" belongs to the current FOR loop pointed by sp_pcontext::m_for_loop, or belongs to a non-FOR nested loop. - Adding LEX methods sp_for_loop_intrange_iterate() and sp_for_loop_cursor_iterate() to reuse the code between methods handling: * ITERATE * END FOR - Adding a test for Lex_for_loop::is_for_loop_cursor() and generate a code either a cursor fetch, or for an integer increment. Before this change, it always erroneously generated an integer increment version. - Cleanup: Initialize Lex_for_loop_st::m_cursor_offset inside Lex_for_loop_st::init(), to avoid not initialized members. - Cleanup: Removing a redundant method: Lex_for_loop_st::init(const Lex_for_loop_st &other) Using Lex_for_loop_st::operator(const Lex_for_loop_st &other) instead.	2 years ago
Igor Babaev	4e2594768d	MDEV-32259 Test from win.test fails with statement memory protection The function setup_windows() called at the prepare phase of processing a select builds a list of all window specifications used in the select. This list is built on the statement memory and it must be done only once. Approved by Oleksandr Byelkin <sanja@mariadb.com>	2 years ago
Igor Babaev	47f0135d7a	MDEV-32245 Test from subselect.test fails with statement memory protection With this patch st_select_lex::ref_pointer_array is never re-allocated. Approved by Oleksandr Byelkin <sanja@mariadb.com>	2 years ago
Alexander Barkov	d75ef02ac2	MDEV-32220 sql_yacc.yy: unify the drop_routine rule - Removing two copies of the drop_routine. Adding a shared and much simplified version. - Removing LEX metods: bool stmt_drop_function(const DDL_options_st &options, const Lex_ident_sys_st &db, const Lex_ident_sys_st &name); bool stmt_drop_function(const DDL_options_st &options, const Lex_ident_sys_st &name); bool stmt_drop_procedure(const DDL_options_st &options, sp_name name); The code inside the methods was very similar. Adding one method instead: bool stmt_drop_routine(const Sp_handler sph, const DDL_options_st &options, const Lex_ident_sys_st &db, const Lex_ident_sys_st &name); - Adding a new virtual method Sp_handler:sqlcom_drop(). It helped to unify the code inside the new stmt_drop_routine().	2 years ago
Alexander Barkov	f5aae71661	MDEV-31606 Refactor check_db_name() to get a const argument Problem: Under terms of MDEV-27490, we'll update Unicode version used to compare identifiers to 14.0.0. Unlike in the old Unicode version, in the new version a string can grow during lower-case. We cannot perform check_db_name() inplace any more. Change summary: - Allocate memory to store lower-cased identifiers in memory root - Removing check_db_name() performing both in-place lower-casing and validation at the same time. Splitting it into two separate stages: * creating a memory-root lower-cased copy of an identifier (using new MEM_ROOT functions and Query_arena wrapper methods) * performing validation on a constant string (using Lex_ident_fs methods) Implementation details: - Adding a mysys helper function to allocate lower-cased strings on MEM_ROOT: lex_string_casedn_root() and a Query_arena wrappers for it: make_ident_casedn() make_ident_opt_casedn() - Adding a Query_arena method to perform both MEM_ROOT lower-casing and database name validation at the same time: to_ident_db_internal_with_error() This method is very close to the old (pre-11.3) check_db_name(), but performs lower-casing to a newly allocated MEM_ROOT memory (instead of performing lower-casing the original string in-place). - Adding a Table_ident method which additionally handles derived table names: to_ident_db_internal_with_error() - Removing the old check_db_name()	2 years ago
Alexander Barkov	495c32d9ad	MDEV-31972 Change parameter of make_sp_name() from LEX_CSTRING to Lex_ident_sys_st Changing LEX_CSTRING parameters of LEX::make_sp_name() to Lex_ident_sys_st. This makes the code clear because a value of Lex_ident_sys_st has some guaranteed additional constraints over a base LEX_CSTRING: - Its LEX_CSTRING::str is not NULL (sql_yacc.yy would abort otherwise) - Its LEX_CSTRING::str is 0-terminated - Its a valid utf8 string - The string pointed by LEX_CSTRING::str was created on THD::mem_root Also changing "pass by pointer" to "pass by reference", as these parameters can never be NULL - they are Bison stack variables.	2 years ago
Nikita Malyavin	500787c72a	Add const to alloc-related thd methods Also update abi declarations. The abi itself is unchanged, since const doesn't affect C-style exported name.	2 years ago
Sergei Golubchik	98de11723c	cleanup: extern -> static in particular, this fixes a compiler warning: sql/sql_lex.h:406:19: warning: ‘sp_data_access_name’ defined but not used [-Wunused-variable]	2 years ago
Dmitry Shulga	1ee1979ed6	MDEV-5816: Stored programs: validation of stored program statements This patch is the second part of implementation for cursor's statement re-parsing. The patch does the following changes: - on re-parsing a failed SP instruction that does need to get access to LEX a new lex is instantiated for every SP instruction except cursor relating SP instructions. - items created on re-parsing a cursor relating statement are moved to the free_list of sp_lex_cursor.	2 years ago
Dmitry Shulga	465c81b323	MDEV-5816: Stored programs: validation of stored program statements Added re-parsing of failed statements inside a stored routine. General idea of the patch is to install an instance of the class Reprepare_observer before executing a next SP instruction and re-parse a statement of this SP instruction in case of its execution failure. To implement the described approach the class sp_lex_keeper has been extended with the method validate_lex_and_exec_core() that is just a wrapper around the method reset_lex_and_exec_core() with additional setting/resetting an instance of the class Reprepare_observer on each iteration of SP instruction execution. If reset_lex_and_exec_core() returns error and an instance of the class Reprepare_observer is installed before running a SP instruction then a number of attempts to re-run the SP instruction is checked against a max. limit and in case it doesn't reach the limit a statement for the failed SP instruction is re-parsed. Re-parsing of a statement for the failed SP instruction is implemented by the new method sp_le_inst::parse_expr() that prepends a SP instruction's statement with the clause 'SELECT' and parse it. Own SP instruction MEM_ROOT and a separate free_list is used for parsing of a SP statement. On successful re-parsing of SP instruction's statement the virtual methods adjust_sql_command() and on_after_expr_parsing() of the class sp_lex_instr is called to update the SP instruction state with a new data created on parsing the statement. Few words about reason for prepending a SP instruction's statement with the clause 'SELECT' - this is required step to produce a valid SQL statement, since for some SP instructions the instructions statement is not a valid SQL statement. Wrapping such text into 'SELECT ( )' produces a correct operator from SQL syntax point of view.	2 years ago
Dmitry Shulga	5a8b9a16d1	MDEV-5816: Stored programs: validation of stored program statements For those SP instructions that need to get access to ia LEX object on execution, added storing of their original sql expressions inside classes derived from the class sp_lex_instr. A stored sql expression is returned by the abstract method sp_lex_instr::get_expr_query redefined in derived classes. Since an expression constituting a SP instruction can be invalid SQL statement in general case (not parseable statement), the virtual method sp_lex_instr::get_query() is introduced to return a valid string for a statement that corresponds to the given instruction. Additionally, introduced the rule remember_start_opt in the grammar. The new rule intended to get correct position of a current token taking into attention the fact whether lookahead was done or not.	2 years ago

1 2 3 4 5 ...

2868 Commits (6340c239334005c8dddf697c9af53a68b1e5a83b)