it's complementary to MDEV-250

twiteer commits:
https://github.com/twitter/mysql/commit/d6fbb29baca84e91be9c9b7822ae19a9e786319f
https://github.com/twitter/mysql/commit/2bb4adb1e920e87c35700bbd400ab6083c155f63#sql/sql_parse.cc
https://github.com/twitter/mysql/commit/8a29e0b65cf008f82338efc3cbafc628997c718b#sql/sql_parse.cc
https://github.com/twitter/mysql/commit/d6fbb29baca84e91be9c9b7822ae19a9e786319f#sql/sql_parse.cc

should be nice change it a bit...
kill is only usefull if table is being locked for a long time, and not only being executed by a long time....
example... only one user running a select that need 1 minute, and kill time set to 30seconds, it will never execute right? but if table is only being used to select, why not execute it? example:

where we need kill:
1) select very slow.... kill_time=30s
2) update table with very slow select.... this will lock for only 30seconds
3) lock table xxx, this will wait 30s and update to lock

where we don't need kill
1) select very slow.... kill_time=30s
2) anothers selects...

mysql-5.7.4 has it

possible implementation:

• session level variables @@max_query_time.
• can be set per statement too (with SET STATEMENT
• now
  • on query start we remember when it must end
  • in thd_kill_level() we check that current time is not beyond the end
• or
  • separate alarm thread
  • sets thd->killed appropriately
  • this approach significantly reduces the number of get_time() calls
• or
  • check what 5.7 does

We already have one implementation of this task. We are just waiting for the sponsor to pay for it so that we can push it.

hi guys! any news?

—
hi monty! could you tell some details about this implementation?
we will have a separate alarm thread, get_time() calls, or do what 5.7 does (what 5.7 do?) ?

—
to everybody:
any idea if the second part of this MDEV could be done? only kill the query that is blocking another query
for example if i have a
select * from a big_table, executing for a long time (> max statment time)
but mariadb don't have another query waiting for a table lock, update, delete or anything else, just leave the query running and don't kill?

thanks guys

This is now implemented in 10.1 and I plan to push it into 10.1

Implementation details:

• Not same code as in MySQL 5.7
• Separate thread who handle signaling of timeouts.
• One code for all platforms: Based on pthread_cond_timedwait()
• Works by sending the internal KILL_QUERY signal to the thread. Exactly same as doing 'KILL QUERY ...'.
• One can kill anything except stored procedures (Different than in 5.7).
• Uses set_timespec_nsec() to specify time (uses my_hrtime() internally).
• Code in mysys/thr_timer.cc

Second part could be relatively easily be done by adding some test in 'THD::awake()' (at least for table_locks).
However for this case, there is a need to add some new syntax to mark queries that should only be killed if someone else needs the resource.

Code pushed to 10.1 tree.
Will now update documentation.

nice news i'm cloning and testing right now

should i open another MDEV just to explain the "PAUSE" and track?

i'm reading patch code , there's a timeout_hard, is it being used or any plan about it? or it's something about killing mysqld and the thread have a kill_timeout condition and change it to timeout_hard? didn't found where it is used

+ KILL_TIMEOUT= 8,
+ KILL_TIMEOUT_HARD= 9,

other doubt, i didn't understood reading the source code

how timeout thread know if we are timedout or not
for example...
1) we have a global thread that check each connection and send signals about timeout or not
2) each connection with max timeout variable create a second thread to check timeout (not a global thread, but a per query thread)

Yes, please create another mdev for new features.

The HARD option is an addition to MariaDB. You can use HARD as an option for the KILL command. It means that the query should be killed as soon as possible, even if it would leave the table in an inconsistent state.
See https://mariadb.com/kb/en/data-manipulation-kill-connection-query/ for details.

It's 1)
There is one thread created to handle timeout for all other threads. This works by doing a pthread_cond_timedwait() for the next timeout.
See mysys/thr_timer.c for details of how this is implemented.

nice =] created

about the hard, it's not being used yet by the timeout right? i'm considering that the current design could be the 'hard timeout' and we could create a soft timeout, the soft when the process receive the kill_timeout it will check if the current thread is or isn't blocking others process, i don't know the best method to do this but i think at the thread running is easier than a external process, since we alread have a lock about the current process and we just need to check mdl (at a first version) + storage level (partition/page/row) locks (in a second version), just to think about an roadmap about how to implmeemnt the "soft" timeout