23
23
Handler-calling-functions
30
#include "drizzled/my_hash.h"
26
#include "drizzled/server_includes.h"
27
#include "mysys/hash.h"
31
28
#include "drizzled/error.h"
32
29
#include "drizzled/gettext.h"
33
30
#include "drizzled/probes.h"
34
31
#include "drizzled/sql_parse.h"
35
#include "drizzled/optimizer/cost_vector.h"
32
#include "drizzled/cost_vect.h"
36
33
#include "drizzled/session.h"
37
34
#include "drizzled/sql_base.h"
38
35
#include "drizzled/transaction_services.h"
39
#include "drizzled/replication_services.h"
40
36
#include "drizzled/lock.h"
41
37
#include "drizzled/item/int.h"
42
38
#include "drizzled/item/empty_string.h"
39
#include "drizzled/unireg.h" // for mysql_frm_type
43
40
#include "drizzled/field/timestamp.h"
44
41
#include "drizzled/message/table.pb.h"
45
#include "drizzled/plugin/client.h"
46
#include "drizzled/internal/my_sys.h"
47
#include "drizzled/transaction_services.h"
49
43
using namespace std;
45
extern drizzled::TransactionServices transaction_services;
47
KEY_CREATE_INFO default_key_create_info= { HA_KEY_ALG_UNDEF, 0, {NULL,0}, {NULL,0} };
49
/* number of entries in storage_engines[] */
51
/* number of storage engines (from storage_engines[]) that support 2pc */
52
uint32_t total_ha_2pc= 0;
53
/* size of savepoint storage area (see ha_init) */
54
uint32_t savepoint_alloc_size= 0;
56
const char *ha_row_type[] = {
57
"", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "PAGE", "?","?","?"
60
const char *tx_isolation_names[] =
61
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
64
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
65
tx_isolation_names, NULL};
69
Register handler error messages for use with my_error().
77
int ha_init_errors(void)
79
#define SETMSG(nr, msg) errmsgs[(nr) - HA_ERR_FIRST]= (msg)
82
/* Allocate a pointer array for the error message strings. */
83
/* Zerofill it to avoid uninitialized gaps. */
84
if (! (errmsgs= (const char**) malloc(HA_ERR_ERRORS * sizeof(char*))))
86
memset(errmsgs, 0, HA_ERR_ERRORS * sizeof(char *));
88
/* Set the dedicated error messages. */
89
SETMSG(HA_ERR_KEY_NOT_FOUND, ER(ER_KEY_NOT_FOUND));
90
SETMSG(HA_ERR_FOUND_DUPP_KEY, ER(ER_DUP_KEY));
91
SETMSG(HA_ERR_RECORD_CHANGED, "Update wich is recoverable");
92
SETMSG(HA_ERR_WRONG_INDEX, "Wrong index given to function");
93
SETMSG(HA_ERR_CRASHED, ER(ER_NOT_KEYFILE));
94
SETMSG(HA_ERR_WRONG_IN_RECORD, ER(ER_CRASHED_ON_USAGE));
95
SETMSG(HA_ERR_OUT_OF_MEM, "Table handler out of memory");
96
SETMSG(HA_ERR_NOT_A_TABLE, "Incorrect file format '%.64s'");
97
SETMSG(HA_ERR_WRONG_COMMAND, "Command not supported");
98
SETMSG(HA_ERR_OLD_FILE, ER(ER_OLD_KEYFILE));
99
SETMSG(HA_ERR_NO_ACTIVE_RECORD, "No record read in update");
100
SETMSG(HA_ERR_RECORD_DELETED, "Intern record deleted");
101
SETMSG(HA_ERR_RECORD_FILE_FULL, ER(ER_RECORD_FILE_FULL));
102
SETMSG(HA_ERR_INDEX_FILE_FULL, "No more room in index file '%.64s'");
103
SETMSG(HA_ERR_END_OF_FILE, "End in next/prev/first/last");
104
SETMSG(HA_ERR_UNSUPPORTED, ER(ER_ILLEGAL_HA));
105
SETMSG(HA_ERR_TO_BIG_ROW, "Too big row");
106
SETMSG(HA_WRONG_CREATE_OPTION, "Wrong create option");
107
SETMSG(HA_ERR_FOUND_DUPP_UNIQUE, ER(ER_DUP_UNIQUE));
108
SETMSG(HA_ERR_UNKNOWN_CHARSET, "Can't open charset");
109
SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF, ER(ER_WRONG_MRG_TABLE));
110
SETMSG(HA_ERR_CRASHED_ON_REPAIR, ER(ER_CRASHED_ON_REPAIR));
111
SETMSG(HA_ERR_CRASHED_ON_USAGE, ER(ER_CRASHED_ON_USAGE));
112
SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT, ER(ER_LOCK_WAIT_TIMEOUT));
113
SETMSG(HA_ERR_LOCK_TABLE_FULL, ER(ER_LOCK_TABLE_FULL));
114
SETMSG(HA_ERR_READ_ONLY_TRANSACTION, ER(ER_READ_ONLY_TRANSACTION));
115
SETMSG(HA_ERR_LOCK_DEADLOCK, ER(ER_LOCK_DEADLOCK));
116
SETMSG(HA_ERR_CANNOT_ADD_FOREIGN, ER(ER_CANNOT_ADD_FOREIGN));
117
SETMSG(HA_ERR_NO_REFERENCED_ROW, ER(ER_NO_REFERENCED_ROW_2));
118
SETMSG(HA_ERR_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED_2));
119
SETMSG(HA_ERR_NO_SAVEPOINT, "No savepoint with that name");
120
SETMSG(HA_ERR_NON_UNIQUE_BLOCK_SIZE, "Non unique key block size");
121
SETMSG(HA_ERR_NO_SUCH_TABLE, "No such table: '%.64s'");
122
SETMSG(HA_ERR_TABLE_EXIST, ER(ER_TABLE_EXISTS_ERROR));
123
SETMSG(HA_ERR_NO_CONNECTION, "Could not connect to storage engine");
124
SETMSG(HA_ERR_TABLE_DEF_CHANGED, ER(ER_TABLE_DEF_CHANGED));
125
SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY, "FK constraint would lead to duplicate key");
126
SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE, ER(ER_TABLE_NEEDS_UPGRADE));
127
SETMSG(HA_ERR_TABLE_READONLY, ER(ER_OPEN_AS_READONLY));
128
SETMSG(HA_ERR_AUTOINC_READ_FAILED, ER(ER_AUTOINC_READ_FAILED));
129
SETMSG(HA_ERR_AUTOINC_ERANGE, ER(ER_WARN_DATA_OUT_OF_RANGE));
131
/* Register the error messages for use with my_error(). */
132
return my_error_register(errmsgs, HA_ERR_FIRST, HA_ERR_LAST);
137
Unregister handler error messages.
144
static int ha_finish_errors(void)
146
const char **errmsgs;
148
/* Allocate a pointer array for the error message strings. */
149
if (! (errmsgs= my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST)))
151
free((unsigned char*) errmsgs);
159
assert(total_ha < MAX_HA);
161
Check if there is a transaction-capable storage engine besides the
162
binary log (which is considered a transaction-capable storage engine in
165
savepoint_alloc_size+= sizeof(SAVEPOINT);
174
This should be eventualy based on the graceful shutdown flag.
175
So if flag is equal to HA_PANIC_CLOSE, the deallocate
178
if (ha_finish_errors())
186
/* ========================================================================
187
======================= TRANSACTIONS ===================================*/
190
Transaction handling in the server
191
==================================
193
In each client connection, MySQL maintains two transactional
195
- a statement transaction,
196
- a standard, also called normal transaction.
200
"Statement transaction" is a non-standard term that comes
201
from the times when MySQL supported BerkeleyDB storage engine.
203
First of all, it should be said that in BerkeleyDB auto-commit
204
mode auto-commits operations that are atomic to the storage
205
engine itself, such as a write of a record, and are too
206
high-granular to be atomic from the application perspective
207
(MySQL). One SQL statement could involve many BerkeleyDB
208
auto-committed operations and thus BerkeleyDB auto-commit was of
211
Secondly, instead of SQL standard savepoints, BerkeleyDB
212
provided the concept of "nested transactions". In a nutshell,
213
transactions could be arbitrarily nested, but when the parent
214
transaction was committed or aborted, all its child (nested)
215
transactions were handled committed or aborted as well.
216
Commit of a nested transaction, in turn, made its changes
217
visible, but not durable: it destroyed the nested transaction,
218
all its changes would become available to the parent and
219
currently active nested transactions of this parent.
221
So the mechanism of nested transactions was employed to
222
provide "all or nothing" guarantee of SQL statements
223
required by the standard.
224
A nested transaction would be created at start of each SQL
225
statement, and destroyed (committed or aborted) at statement
226
end. Such nested transaction was internally referred to as
227
a "statement transaction" and gave birth to the term.
229
<Historical note ends>
231
Since then a statement transaction is started for each statement
232
that accesses transactional tables or uses the binary log. If
233
the statement succeeds, the statement transaction is committed.
234
If the statement fails, the transaction is rolled back. Commits
235
of statement transactions are not durable -- each such
236
transaction is nested in the normal transaction, and if the
237
normal transaction is rolled back, the effects of all enclosed
238
statement transactions are undone as well. Technically,
239
a statement transaction can be viewed as a savepoint which is
240
maintained automatically in order to make effects of one
243
The normal transaction is started by the user and is ended
244
usually upon a user request as well. The normal transaction
245
encloses transactions of all statements issued between
246
its beginning and its end.
247
In autocommit mode, the normal transaction is equivalent
248
to the statement transaction.
250
Since MySQL supports PSEA (pluggable storage engine
251
architecture), more than one transactional engine can be
252
active at a time. Hence transactions, from the server
253
point of view, are always distributed. In particular,
254
transactional state is maintained independently for each
255
engine. In order to commit a transaction the two phase
256
commit protocol is employed.
258
Not all statements are executed in context of a transaction.
259
Administrative and status information statements do not modify
260
engine data, and thus do not start a statement transaction and
261
also have no effect on the normal transaction. Examples of such
262
statements are SHOW STATUS and RESET SLAVE.
264
Similarly DDL statements are not transactional,
265
and therefore a transaction is [almost] never started for a DDL
266
statement. The difference between a DDL statement and a purely
267
administrative statement though is that a DDL statement always
268
commits the current transaction before proceeding, if there is
271
At last, SQL statements that work with non-transactional
272
engines also have no effect on the transaction state of the
273
connection. Even though they are written to the binary log,
274
and the binary log is, overall, transactional, the writes
275
are done in "write-through" mode, directly to the binlog
276
file, followed with a OS cache sync, in other words,
277
bypassing the binlog undo log (translog).
278
They do not commit the current normal transaction.
279
A failure of a statement that uses non-transactional tables
280
would cause a rollback of the statement transaction, but
281
in case there no non-transactional tables are used,
282
no statement transaction is started.
287
The server stores its transaction-related data in
288
session->transaction. This structure has two members of type
289
Session_TRANS. These members correspond to the statement and
290
normal transactions respectively:
292
- session->transaction.stmt contains a list of engines
293
that are participating in the given statement
294
- session->transaction.all contains a list of engines that
295
have participated in any of the statement transactions started
296
within the context of the normal transaction.
297
Each element of the list contains a pointer to the storage
298
engine, engine-specific transactional data, and engine-specific
301
In autocommit mode session->transaction.all is empty.
302
Instead, data of session->transaction.stmt is
303
used to commit/rollback the normal transaction.
305
The list of registered engines has a few important properties:
306
- no engine is registered in the list twice
307
- engines are present in the list a reverse temporal order --
308
new participants are always added to the beginning of the list.
310
Transaction life cycle
311
----------------------
313
When a new connection is established, session->transaction
314
members are initialized to an empty state.
315
If a statement uses any tables, all affected engines
316
are registered in the statement engine list. In
317
non-autocommit mode, the same engines are registered in
318
the normal transaction list.
319
At the end of the statement, the server issues a commit
320
or a roll back for all engines in the statement list.
321
At this point transaction flags of an engine, if any, are
322
propagated from the statement list to the list of the normal
324
When commit/rollback is finished, the statement list is
325
cleared. It will be filled in again by the next statement,
326
and emptied again at the next statement's end.
328
The normal transaction is committed in a similar way
329
(by going over all engines in session->transaction.all list)
330
but at different times:
331
- upon COMMIT SQL statement is issued by the user
332
- implicitly, by the server, at the beginning of a DDL statement
333
or SET AUTOCOMMIT={0|1} statement.
335
The normal transaction can be rolled back as well:
336
- if the user has requested so, by issuing ROLLBACK SQL
338
- if one of the storage engines requested a rollback
339
by setting session->transaction_rollback_request. This may
340
happen in case, e.g., when the transaction in the engine was
341
chosen a victim of the internal deadlock resolution algorithm
342
and rolled back internally. When such a situation happens, there
343
is little the server can do and the only option is to rollback
344
transactions in all other participating engines. In this case
345
the rollback is accompanied by an error sent to the user.
347
As follows from the use cases above, the normal transaction
348
is never committed when there is an outstanding statement
349
transaction. In most cases there is no conflict, since
350
commits of the normal transaction are issued by a stand-alone
351
administrative or DDL statement, thus no outstanding statement
352
transaction of the previous statement exists. Besides,
353
all statements that manipulate with the normal transaction
354
are prohibited in stored functions and triggers, therefore
355
no conflicting situation can occur in a sub-statement either.
356
The remaining rare cases when the server explicitly has
357
to commit the statement transaction prior to committing the normal
358
one cover error-handling scenarios (see for example
361
When committing a statement or a normal transaction, the server
362
either uses the two-phase commit protocol, or issues a commit
363
in each engine independently. The two-phase commit protocol
365
- all participating engines support two-phase commit (provide
366
StorageEngine::prepare PSEA API call) and
367
- transactions in at least two engines modify data (i.e. are
370
Note that the two phase commit is used for
371
statement transactions, even though they are not durable anyway.
372
This is done to ensure logical consistency of data in a multiple-
374
For example, imagine that some day MySQL supports unique
375
constraint checks deferred till the end of statement. In such
376
case a commit in one of the engines may yield ER_DUP_KEY,
377
and MySQL should be able to gracefully abort statement
378
transactions of other participants.
380
After the normal transaction has been committed,
381
session->transaction.all list is cleared.
383
When a connection is closed, the current normal transaction, if
386
Roles and responsibilities
387
--------------------------
389
The server has no way to know that an engine participates in
390
the statement and a transaction has been started
391
in it unless the engine says so. Thus, in order to be
392
a part of a transaction, the engine must "register" itself.
393
This is done by invoking trans_register_ha() server call.
394
Normally the engine registers itself whenever handler::external_lock()
395
is called. trans_register_ha() can be invoked many times: if
396
an engine is already registered, the call does nothing.
397
In case autocommit is not set, the engine must register itself
398
twice -- both in the statement list and in the normal transaction
400
In which list to register is a parameter of trans_register_ha().
402
Note, that although the registration interface in itself is
403
fairly clear, the current usage practice often leads to undesired
404
effects. E.g. since a call to trans_register_ha() in most engines
405
is embedded into implementation of handler::external_lock(), some
406
DDL statements start a transaction (at least from the server
407
point of view) even though they are not expected to. E.g.
408
CREATE TABLE does not start a transaction, since
409
handler::external_lock() is never called during CREATE TABLE. But
410
CREATE TABLE ... SELECT does, since handler::external_lock() is
411
called for the table that is being selected from. This has no
412
practical effects currently, but must be kept in mind
415
Once an engine is registered, the server will do the rest
418
During statement execution, whenever any of data-modifying
419
PSEA API methods is used, e.g. handler::write_row() or
420
handler::update_row(), the read-write flag is raised in the
421
statement transaction for the involved engine.
422
Currently All PSEA calls are "traced", and the data can not be
423
changed in a way other than issuing a PSEA call. Important:
424
unless this invariant is preserved the server will not know that
425
a transaction in a given engine is read-write and will not
426
involve the two-phase commit protocol!
428
At the end of a statement, server call
429
ha_autocommit_or_rollback() is invoked. This call in turn
430
invokes StorageEngine::prepare() for every involved engine.
431
Prepare is followed by a call to StorageEngine::commit_one_phase()
432
If a one-phase commit will suffice, StorageEngine::prepare() is not
433
invoked and the server only calls StorageEngine::commit_one_phase().
434
At statement commit, the statement-related read-write engine
435
flag is propagated to the corresponding flag in the normal
436
transaction. When the commit is complete, the list of registered
439
Rollback is handled in a similar fashion.
441
Additional notes on DDL and the normal transaction.
442
---------------------------------------------------
444
DDLs and operations with non-transactional engines
445
do not "register" in session->transaction lists, and thus do not
446
modify the transaction state. Besides, each DDL in
447
MySQL is prefixed with an implicit normal transaction commit
448
(a call to Session::endActiveTransaction()), and thus leaves nothing
450
However, as it has been pointed out with CREATE TABLE .. SELECT,
451
some DDL statements can start a *new* transaction.
453
Behaviour of the server in this case is currently badly
455
DDL statements use a form of "semantic" logging
456
to maintain atomicity: if CREATE TABLE .. SELECT failed,
457
the newly created table is deleted.
458
In addition, some DDL statements issue interim transaction
459
commits: e.g. ALTER Table issues a commit after data is copied
460
from the original table to the internal temporary table. Other
461
statements, e.g. CREATE TABLE ... SELECT do not always commit
463
And finally there is a group of DDL statements such as
464
RENAME/DROP Table that doesn't start a new transaction
467
This diversity makes it hard to say what will happen if
468
by chance a stored function is invoked during a DDL --
469
whether any modifications it makes will be committed or not
470
is not clear. Fortunately, SQL grammar of few DDLs allows
471
invocation of a stored function.
473
A consistent behaviour is perhaps to always commit the normal
474
transaction after all DDLs, just like the statement transaction
475
is always committed at the end of all statements.
479
Register a storage engine for a transaction.
481
Every storage engine MUST call this function when it starts
482
a transaction or a statement (that is it must be called both for the
483
"beginning of transaction" and "beginning of statement").
484
Only storage engines registered for the transaction/statement
485
will know when to commit/rollback it.
488
trans_register_ha is idempotent - storage engine may register many
489
times per transaction.
492
void trans_register_ha(Session *session, bool all, StorageEngine *engine)
494
Session_TRANS *trans;
495
Ha_trx_info *ha_info;
499
trans= &session->transaction.all;
500
session->server_status|= SERVER_STATUS_IN_TRANS;
503
trans= &session->transaction.stmt;
505
ha_info= session->ha_data[engine->getSlot()].ha_info + static_cast<unsigned>(all);
507
if (ha_info->is_started())
508
return; /* already registered, return */
510
ha_info->register_ha(trans, engine);
512
trans->no_2pc|= not engine->has_2pc();
513
if (session->transaction.xid_state.xid.is_null())
514
session->transaction.xid_state.xid.set(session->query_id);
518
Check if we can skip the two-phase commit.
520
A helper function to evaluate if two-phase commit is mandatory.
521
As a side effect, propagates the read-only/read-write flags
522
of the statement transaction to its enclosing normal transaction.
524
@retval true we must run a two-phase commit. Returned
525
if we have at least two engines with read-write changes.
526
@retval false Don't need two-phase commit. Even if we have two
527
transactional engines, we can run two independent
528
commits if changes in one of the engines are read-only.
533
ha_check_and_coalesce_trx_read_only(Session *session, Ha_trx_info *ha_list,
536
/* The number of storage engines that have actual changes. */
537
unsigned rw_ha_count= 0;
538
Ha_trx_info *ha_info;
540
for (ha_info= ha_list; ha_info; ha_info= ha_info->next())
542
if (ha_info->is_trx_read_write())
547
Ha_trx_info *ha_info_all= &session->ha_data[ha_info->engine()->getSlot()].ha_info[1];
548
assert(ha_info != ha_info_all);
550
Merge read-only/read-write information about statement
551
transaction to its enclosing normal transaction. Do this
552
only if in a real transaction -- that is, if we know
553
that ha_info_all is registered in session->transaction.all.
554
Since otherwise we only clutter the normal transaction flags.
556
if (ha_info_all->is_started()) /* false if autocommit. */
557
ha_info_all->coalesce_trx_with(ha_info);
559
else if (rw_ha_count > 1)
562
It is a normal transaction, so we don't need to merge read/write
563
information up, and the need for two-phase commit has been
564
already established. Break the loop prematurely.
569
return rw_ha_count > 1;
577
1 transaction was rolled back
579
2 error during commit, data may be inconsistent
582
Since we don't support nested statement transactions in 5.0,
583
we can't commit or rollback stmt transactions while we are inside
584
stored functions or triggers. So we simply do nothing now.
585
TODO: This should be fixed in later ( >= 5.1) releases.
587
int ha_commit_trans(Session *session, bool all)
589
int error= 0, cookie= 0;
591
'all' means that this is either an explicit commit issued by
592
user, or an implicit commit issued by a DDL.
594
Session_TRANS *trans= all ? &session->transaction.all : &session->transaction.stmt;
595
bool is_real_trans= all || session->transaction.all.ha_list == 0;
596
Ha_trx_info *ha_info= trans->ha_list;
599
We must not commit the normal transaction if a statement
600
transaction is pending. Otherwise statement transaction
601
flags will not get propagated to its normal transaction's
604
assert(session->transaction.stmt.ha_list == NULL ||
605
trans == &session->transaction.stmt);
611
if (is_real_trans && wait_if_global_read_lock(session, 0, 0))
613
ha_rollback_trans(session, all);
617
must_2pc= ha_check_and_coalesce_trx_read_only(session, ha_info, all);
619
if (!trans->no_2pc && must_2pc)
621
for (; ha_info && !error; ha_info= ha_info->next())
624
StorageEngine *engine= ha_info->engine();
626
Do not call two-phase commit if this particular
627
transaction is read-only. This allows for simpler
628
implementation in engines that are always read-only.
630
if (! ha_info->is_trx_read_write())
633
Sic: we know that prepare() is not NULL since otherwise
634
trans->no_2pc would have been set.
636
if ((err= engine->prepare(session, all)))
638
my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
641
status_var_increment(session->status_var.ha_prepare_count);
645
ha_rollback_trans(session, all);
650
error=ha_commit_one_phase(session, all) ? (cookie ? 2 : 1) : 0;
653
start_waiting_global_read_lock(session);
660
This function does not care about global read lock. A caller should.
662
int ha_commit_one_phase(Session *session, bool all)
665
Session_TRANS *trans=all ? &session->transaction.all : &session->transaction.stmt;
666
bool is_real_trans=all || session->transaction.all.ha_list == 0;
667
Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
670
for (; ha_info; ha_info= ha_info_next)
673
StorageEngine *engine= ha_info->engine();
674
if ((err= engine->commit(session, all)))
676
my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
679
status_var_increment(session->status_var.ha_commit_count);
680
ha_info_next= ha_info->next();
681
ha_info->reset(); /* keep it conveniently zero-filled */
686
session->transaction.xid_state.xid.null();
689
session->variables.tx_isolation=session->session_tx_isolation;
690
session->transaction.cleanup();
697
int ha_rollback_trans(Session *session, bool all)
700
Session_TRANS *trans=all ? &session->transaction.all : &session->transaction.stmt;
701
Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
702
bool is_real_trans=all || session->transaction.all.ha_list == 0;
705
We must not rollback the normal transaction if a statement
706
transaction is pending.
708
assert(session->transaction.stmt.ha_list == NULL ||
709
trans == &session->transaction.stmt);
713
for (; ha_info; ha_info= ha_info_next)
716
StorageEngine *engine= ha_info->engine();
717
if ((err= engine->rollback(session, all)))
719
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
722
status_var_increment(session->status_var.ha_rollback_count);
723
ha_info_next= ha_info->next();
724
ha_info->reset(); /* keep it conveniently zero-filled */
729
session->transaction.xid_state.xid.null();
732
session->variables.tx_isolation=session->session_tx_isolation;
733
session->transaction.cleanup();
737
session->transaction_rollback_request= false;
740
If a non-transactional table was updated, warn; don't warn if this is a
741
slave thread (because when a slave thread executes a ROLLBACK, it has
742
been read from the binary log, so it's 100% sure and normal to produce
743
error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
744
slave SQL thread, it would not stop the thread but just be printed in
745
the error log; but we don't want users to wonder why they have this
746
message in the error log, so we don't send it.
748
if (is_real_trans && session->transaction.all.modified_non_trans_table && session->killed != Session::KILL_CONNECTION)
749
push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
750
ER_WARNING_NOT_COMPLETE_ROLLBACK,
751
ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
756
This is used to commit or rollback a single statement depending on
760
Note that if the autocommit is on, then the following call inside
761
InnoDB will commit or rollback the whole transaction (= the statement). The
762
autocommit mechanism built into InnoDB is based on counting locks, but if
763
the user has used LOCK TABLES then that mechanism does not know to do the
766
int ha_autocommit_or_rollback(Session *session, int error)
768
if (session->transaction.stmt.ha_list)
772
if (ha_commit_trans(session, 0))
777
(void) ha_rollback_trans(session, 0);
778
if (session->transaction_rollback_request)
779
(void) ha_rollback(session);
782
session->variables.tx_isolation=session->session_tx_isolation;
792
return the list of XID's to a client, the same way SHOW commands do.
795
I didn't find in XA specs that an RM cannot return the same XID twice,
796
so mysql_xa_recover does not filter XID's to ensure uniqueness.
797
It can be easily fixed later, if necessary.
799
bool mysql_xa_recover(Session *session)
801
List<Item> field_list;
802
Protocol *protocol= session->protocol;
806
field_list.push_back(new Item_int("formatID", 0, MY_INT32_NUM_DECIMAL_DIGITS));
807
field_list.push_back(new Item_int("gtrid_length", 0, MY_INT32_NUM_DECIMAL_DIGITS));
808
field_list.push_back(new Item_int("bqual_length", 0, MY_INT32_NUM_DECIMAL_DIGITS));
809
field_list.push_back(new Item_empty_string("data",XIDDATASIZE));
811
if (protocol->sendFields(&field_list,
812
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
815
pthread_mutex_lock(&LOCK_xid_cache);
816
while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
818
if (xs->xa_state==XA_PREPARED)
820
protocol->prepareForResend();
821
protocol->store((int64_t)xs->xid.formatID);
822
protocol->store((int64_t)xs->xid.gtrid_length);
823
protocol->store((int64_t)xs->xid.bqual_length);
824
protocol->store(xs->xid.data, xs->xid.gtrid_length+xs->xid.bqual_length);
825
if (protocol->write())
827
pthread_mutex_unlock(&LOCK_xid_cache);
833
pthread_mutex_unlock(&LOCK_xid_cache);
839
int ha_rollback_to_savepoint(Session *session, SAVEPOINT *sv)
842
Session_TRANS *trans= &session->transaction.all;
843
Ha_trx_info *ha_info, *ha_info_next;
847
rolling back to savepoint in all storage engines that were part of the
848
transaction when the savepoint was set
850
for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
853
StorageEngine *engine= ha_info->engine();
855
if ((err= engine->savepoint_rollback(session,
858
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
861
status_var_increment(session->status_var.ha_savepoint_rollback_count);
862
trans->no_2pc|= not engine->has_2pc();
865
rolling back the transaction in all storage engines that were not part of
866
the transaction when the savepoint was set
868
for (ha_info= trans->ha_list; ha_info != sv->ha_list;
869
ha_info= ha_info_next)
872
StorageEngine *engine= ha_info->engine();
873
if ((err= engine->rollback(session, !(0))))
875
my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
878
status_var_increment(session->status_var.ha_rollback_count);
879
ha_info_next= ha_info->next();
880
ha_info->reset(); /* keep it conveniently zero-filled */
882
trans->ha_list= sv->ha_list;
888
according to the sql standard (ISO/IEC 9075-2:2003)
889
section "4.33.4 SQL-statements and transaction states",
890
SAVEPOINT is *not* transaction-initiating SQL-statement
892
int ha_savepoint(Session *session, SAVEPOINT *sv)
895
Session_TRANS *trans= &session->transaction.all;
896
Ha_trx_info *ha_info= trans->ha_list;
897
for (; ha_info; ha_info= ha_info->next())
900
StorageEngine *engine= ha_info->engine();
902
#ifdef NOT_IMPLEMENTED /*- TODO (examine this againt the original code base) */
903
if (! engine->savepoint_set)
905
my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
910
if ((err= engine->savepoint_set(session, (void *)(sv+1))))
912
my_error(ER_GET_ERRNO, MYF(0), err);
915
status_var_increment(session->status_var.ha_savepoint_count);
918
Remember the list of registered storage engines. All new
919
engines are prepended to the beginning of the list.
921
sv->ha_list= trans->ha_list;
925
int ha_release_savepoint(Session *session, SAVEPOINT *sv)
928
Ha_trx_info *ha_info= sv->ha_list;
930
for (; ha_info; ha_info= ha_info->next())
933
StorageEngine *engine= ha_info->engine();
934
/* Savepoint life time is enclosed into transaction life time. */
936
if ((err= engine->savepoint_release(session,
939
my_error(ER_GET_ERRNO, MYF(0), err);
54
950
/****************************************************************************
55
** General Cursor functions
951
** General handler functions
56
952
****************************************************************************/
57
Cursor::Cursor(plugin::StorageEngine &engine_arg,
58
TableShare &share_arg)
59
: table_share(&share_arg), table(0),
60
estimation_rows_to_insert(0), engine(&engine_arg),
61
ref(0), in_range_check_pushed_down(false),
62
key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
63
ref_length(sizeof(internal::my_off_t)),
65
locked(false), implicit_emptied(0),
66
next_insert_id(0), insert_id_for_cur_row(0)
953
handler::~handler(void)
71
955
assert(locked == false);
72
956
/* TODO: assert(inited == NONE); */
76
Cursor *Cursor::clone(memory::Root *mem_root)
960
handler *handler::clone(MEM_ROOT *mem_root)
78
Cursor *new_handler= table->s->db_type()->getCursor(*table->s, mem_root);
962
handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
81
Allocate Cursor->ref here because otherwise ha_open will allocate it
964
Allocate handler->ref here because otherwise ha_open will allocate it
82
965
on this->table->mem_root and we will not be able to reclaim that memory
83
when the clone Cursor object is destroyed.
966
when the clone handler object is destroyed.
85
968
if (!(new_handler->ref= (unsigned char*) alloc_root(mem_root, ALIGN_SIZE(ref_length)*2)))
619
void Cursor::drop_table(const char *)
1557
void handler::print_keydup_error(uint32_t key_nr, const char *msg)
1559
/* Write the duplicated key in the error message */
1560
char key[MAX_KEY_LENGTH];
1561
String str(key,sizeof(key),system_charset_info);
1563
if (key_nr == MAX_KEY)
1565
/* Key is unknown */
1566
str.copy("", 0, system_charset_info);
1567
my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(), "*UNKNOWN*");
1571
/* Table is opened and defined at this point */
1572
key_unpack(&str,table,(uint32_t) key_nr);
1573
uint32_t max_length=DRIZZLE_ERRMSG_SIZE-(uint32_t) strlen(msg);
1574
if (str.length() >= max_length)
1576
str.length(max_length-4);
1577
str.append(STRING_WITH_LEN("..."));
1579
my_printf_error(ER_DUP_ENTRY, msg,
1580
MYF(0), str.c_ptr(), table->key_info[key_nr].name);
1586
Print error that we got from handler function.
1589
In case of delete table it's only safe to use the following parts of
1590
the 'table' structure:
1594
void handler::print_error(int error, myf errflag)
1596
int textno=ER_GET_ERRNO;
1599
textno=ER_OPEN_AS_READONLY;
1602
textno=ER_FILE_USED;
1605
textno=ER_FILE_NOT_FOUND;
1607
case HA_ERR_KEY_NOT_FOUND:
1608
case HA_ERR_NO_ACTIVE_RECORD:
1609
case HA_ERR_END_OF_FILE:
1610
textno=ER_KEY_NOT_FOUND;
1612
case HA_ERR_WRONG_MRG_TABLE_DEF:
1613
textno=ER_WRONG_MRG_TABLE;
1615
case HA_ERR_FOUND_DUPP_KEY:
1617
uint32_t key_nr=get_dup_key(error);
1618
if ((int) key_nr >= 0)
1620
print_keydup_error(key_nr, ER(ER_DUP_ENTRY_WITH_KEY_NAME));
1626
case HA_ERR_FOREIGN_DUPLICATE_KEY:
1628
uint32_t key_nr= get_dup_key(error);
1629
if ((int) key_nr >= 0)
1631
uint32_t max_length;
1632
/* Write the key in the error message */
1633
char key[MAX_KEY_LENGTH];
1634
String str(key,sizeof(key),system_charset_info);
1635
/* Table is opened and defined at this point */
1636
key_unpack(&str,table,(uint32_t) key_nr);
1637
max_length= (DRIZZLE_ERRMSG_SIZE-
1638
(uint32_t) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
1639
if (str.length() >= max_length)
1641
str.length(max_length-4);
1642
str.append(STRING_WITH_LEN("..."));
1644
my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table_share->table_name.str,
1645
str.c_ptr(), key_nr+1);
1651
case HA_ERR_FOUND_DUPP_UNIQUE:
1652
textno=ER_DUP_UNIQUE;
1654
case HA_ERR_RECORD_CHANGED:
1655
textno=ER_CHECKREAD;
1657
case HA_ERR_CRASHED:
1658
textno=ER_NOT_KEYFILE;
1660
case HA_ERR_WRONG_IN_RECORD:
1661
textno= ER_CRASHED_ON_USAGE;
1663
case HA_ERR_CRASHED_ON_USAGE:
1664
textno=ER_CRASHED_ON_USAGE;
1666
case HA_ERR_NOT_A_TABLE:
1669
case HA_ERR_CRASHED_ON_REPAIR:
1670
textno=ER_CRASHED_ON_REPAIR;
1672
case HA_ERR_OUT_OF_MEM:
1673
textno=ER_OUT_OF_RESOURCES;
1675
case HA_ERR_WRONG_COMMAND:
1676
textno=ER_ILLEGAL_HA;
1678
case HA_ERR_OLD_FILE:
1679
textno=ER_OLD_KEYFILE;
1681
case HA_ERR_UNSUPPORTED:
1682
textno=ER_UNSUPPORTED_EXTENSION;
1684
case HA_ERR_RECORD_FILE_FULL:
1685
case HA_ERR_INDEX_FILE_FULL:
1686
textno=ER_RECORD_FILE_FULL;
1688
case HA_ERR_LOCK_WAIT_TIMEOUT:
1689
textno=ER_LOCK_WAIT_TIMEOUT;
1691
case HA_ERR_LOCK_TABLE_FULL:
1692
textno=ER_LOCK_TABLE_FULL;
1694
case HA_ERR_LOCK_DEADLOCK:
1695
textno=ER_LOCK_DEADLOCK;
1697
case HA_ERR_READ_ONLY_TRANSACTION:
1698
textno=ER_READ_ONLY_TRANSACTION;
1700
case HA_ERR_CANNOT_ADD_FOREIGN:
1701
textno=ER_CANNOT_ADD_FOREIGN;
1703
case HA_ERR_ROW_IS_REFERENCED:
1706
get_error_message(error, &str);
1707
my_error(ER_ROW_IS_REFERENCED_2, MYF(0), str.c_ptr_safe());
1710
case HA_ERR_NO_REFERENCED_ROW:
1713
get_error_message(error, &str);
1714
my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
1717
case HA_ERR_TABLE_DEF_CHANGED:
1718
textno=ER_TABLE_DEF_CHANGED;
1720
case HA_ERR_NO_SUCH_TABLE:
1721
my_error(ER_NO_SUCH_TABLE, MYF(0), table_share->db.str,
1722
table_share->table_name.str);
1724
case HA_ERR_RBR_LOGGING_FAILED:
1725
textno= ER_BINLOG_ROW_LOGGING_FAILED;
1727
case HA_ERR_DROP_INDEX_FK:
1729
const char *ptr= "???";
1730
uint32_t key_nr= get_dup_key(error);
1731
if ((int) key_nr >= 0)
1732
ptr= table->key_info[key_nr].name;
1733
my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
1736
case HA_ERR_TABLE_NEEDS_UPGRADE:
1737
textno=ER_TABLE_NEEDS_UPGRADE;
1739
case HA_ERR_TABLE_READONLY:
1740
textno= ER_OPEN_AS_READONLY;
1742
case HA_ERR_AUTOINC_READ_FAILED:
1743
textno= ER_AUTOINC_READ_FAILED;
1745
case HA_ERR_AUTOINC_ERANGE:
1746
textno= ER_WARN_DATA_OUT_OF_RANGE;
1748
case HA_ERR_LOCK_OR_ACTIVE_TRANSACTION:
1749
my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
1750
ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
1754
/* The error was "unknown" to this function.
1755
Ask handler if it has got a message for this error */
1756
bool temporary= false;
1758
temporary= get_error_message(error, &str);
1759
if (!str.is_empty())
1761
const char* engine_name= engine->getName().c_str();
1763
my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(),
1766
my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine_name);
1770
my_error(ER_GET_ERRNO,errflag,error);
1775
my_error(textno, errflag, table_share->table_name.str, error);
1780
Return an error message specific to this handler.
1782
@param error error code previously returned by handler
1783
@param buf pointer to String where to add error message
1786
Returns true if this is a temporary error
1788
bool handler::get_error_message(int , String* )
1794
/* Code left, but Drizzle has no legacy yet (while MySQL did) */
1795
int handler::check_old_types()
1802
key if error because of duplicated keys
1804
uint32_t handler::get_dup_key(int error)
1806
table->file->errkey = (uint32_t) -1;
1807
if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOREIGN_DUPLICATE_KEY ||
1808
error == HA_ERR_FOUND_DUPP_UNIQUE ||
1809
error == HA_ERR_DROP_INDEX_FK)
1810
info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
1811
return(table->file->errkey);
1814
void handler::drop_table(const char *name)
1817
engine->deleteTable(ha_session(), name);
added
removed
drizzled/handler.cc
