« back to all changes in this revision
Viewing changes to server/sql_class.cc
- browse files at revision 77.1.66
- compare with another revision
- compare with revision 77.3.19
- download diff
- download tarball
- view history from revision 77.1.66
- Committer: Monty Taylor
- Date: 2008-07-11 10:33:22 UTC
- mfrom: (132 drizzle)
- mto: (77.6.1 glibclient-merge)
- mto: This revision was merged to the branch mainline in revision 134.
- Revision ID: monty@inaugust.com-20080711103322-0a3sppn0usxty41l
Merged from trunk.
- files removed:
- client/mysqlshow.c
- files modified:
- client/Makefile.am
added
removed
server/sql_class.cc
149
149
else
150
150
{
151
151
if (!b->generated)
152
return TRUE; // No foreign key
152
return true; // No foreign key
153
153
swap_variables(Key*, a, b); // Put generated key in 'a'
154
154
}
155
155
156
156
/* Test if 'a' is a prefix of 'b' */
157
157
if (a->columns.elements > b->columns.elements)
158
return TRUE; // Can't be prefix
158
return true; // Can't be prefix
159
159
160
160
List_iterator<Key_part_spec> col_it1(a->columns);
161
161
List_iterator<Key_part_spec> col_it2(b->columns);
170
170
{
171
171
if (*col1 == *col2)
172
172
{
173
found= TRUE;
173
found= true;
174
174
break;
175
175
}
176
176
}
177
177
if (!found)
178
return TRUE; // Error
178
return true; // Error
179
179
}
180
return FALSE; // Is prefix
180
return false; // Is prefix
181
181
#else
182
182
while ((col1= col_it1++))
183
183
{
184
184
col2= col_it2++;
185
185
if (!(*col1 == *col2))
186
return TRUE;
186
return true;
187
187
}
188
return FALSE; // Is prefix
188
return false; // Is prefix
189
189
#endif
190
190
}
191
191
244
244
const unsigned int calling_line __attribute__((__unused__)))
245
245
{
246
246
const char *old_info= thd->proc_info;
247
DBUG_PRINT("proc_info", ("%s:%d %s", calling_file, calling_line,
248
(info != NULL) ? info : "(null)"));
249
247
thd->proc_info= info;
250
248
return old_info;
251
249
}
356
354
void
357
355
Diagnostics_area::reset_diagnostics_area()
358
356
{
359
#ifdef DBUG_OFF
360
can_overwrite_status= FALSE;
357
can_overwrite_status= false;
361
358
/** Don't take chances in production */
362
359
m_message[0]= '\0';
363
360
m_sql_errno= 0;
365
362
m_affected_rows= 0;
366
363
m_last_insert_id= 0;
367
364
m_total_warn_count= 0;
368
#endif
369
is_sent= FALSE;
365
is_sent= false;
370
366
/** Tiny reset in debug mode to see garbage right away */
371
367
m_status= DA_EMPTY;
372
368
}
382
378
ulonglong last_insert_id_arg,
383
379
const char *message_arg)
384
380
{
385
DBUG_ASSERT(! is_set());
386
#ifdef DBUG_OFF
381
assert(! is_set());
387
382
/*
388
383
In production, refuse to overwrite an error or a custom response
389
384
with an OK packet.
390
385
*/
391
386
if (is_error() || is_disabled())
392
387
return;
393
#endif
394
388
/** Only allowed to report success if has not yet reported an error */
395
389
396
390
m_server_status= thd->server_status;
414
408
{
415
409
/** Only allowed to report eof if has not yet reported an error */
416
410
417
DBUG_ASSERT(! is_set());
418
#ifdef DBUG_OFF
411
assert(! is_set());
419
412
/*
420
413
In production, refuse to overwrite an error or a custom response
421
414
with an EOF packet.
422
415
*/
423
416
if (is_error() || is_disabled())
424
417
return;
425
#endif
426
418
427
419
m_server_status= thd->server_status;
428
420
/*
449
441
The only exception is when we flush the message to the client,
450
442
an error can happen during the flush.
451
443
*/
452
DBUG_ASSERT(! is_set() || can_overwrite_status);
453
#ifdef DBUG_OFF
444
assert(! is_set() || can_overwrite_status);
454
445
/*
455
446
In production, refuse to overwrite a custom response with an
456
447
ERROR packet.
457
448
*/
458
449
if (is_disabled())
459
450
return;
460
#endif
461
451
462
452
m_sql_errno= sql_errno_arg;
463
453
strmake(m_message, message_arg, sizeof(m_message) - 1);
477
467
void
478
468
Diagnostics_area::disable_status()
479
469
{
480
DBUG_ASSERT(! is_set());
470
assert(! is_set());
481
471
m_status= DA_DISABLED;
482
472
}
483
473
489
479
lock_id(&main_lock_id),
490
480
user_time(0), in_sub_stmt(0),
491
481
binlog_table_maps(0), binlog_flags(0UL),
492
arg_of_last_insert_id_function(FALSE),
482
arg_of_last_insert_id_function(false),
493
483
first_successful_insert_id_in_prev_stmt(0),
494
484
first_successful_insert_id_in_prev_stmt_for_binlog(0),
495
485
first_successful_insert_id_in_cur_stmt(0),
496
stmt_depends_on_first_successful_insert_id_in_prev_stmt(FALSE),
486
stmt_depends_on_first_successful_insert_id_in_prev_stmt(false),
497
487
global_read_lock(0),
498
488
is_fatal_error(0),
499
489
transaction_rollback_request(0),
502
492
time_zone_used(0),
503
493
in_lock_tables(0),
504
494
bootstrap(0),
505
derived_tables_processing(FALSE),
495
derived_tables_processing(false),
506
496
m_lip(NULL),
507
497
/*
508
498
@todo The following is a work around for online backup and the DDL blocker.
510
500
This is needed to ensure the restore (which uses DDL) is not blocked
511
501
when the DDL blocker is engaged.
512
502
*/
513
DDL_exception(FALSE)
503
DDL_exception(false)
514
504
{
515
505
ulong tmp;
516
506
530
520
count_cuted_fields= CHECK_FIELD_IGNORE;
531
521
killed= NOT_KILLED;
532
522
col_access=0;
533
is_slave_error= thread_specific_used= FALSE;
523
is_slave_error= thread_specific_used= false;
534
524
hash_clear(&handler_tables_hash);
535
525
tmp_table=0;
536
526
used_tables=0;
554
544
db_charset= global_system_variables.collation_database;
555
545
bzero(ha_data, sizeof(ha_data));
556
546
mysys_var=0;
557
binlog_evt_union.do_union= FALSE;
547
binlog_evt_union.do_union= false;
558
548
enable_slow_log= 0;
559
#ifndef DBUG_OFF
560
549
dbug_sentry=THD_SENTRY_MAGIC;
561
#endif
562
550
net.vio=0;
563
551
client_capabilities= 0; // minimalistic client
564
552
system_thread= NON_SYSTEM_THREAD;
601
589
tablespace_op= false;
602
590
tmp= sql_rnd_with_mutex();
603
591
randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::global_query_id);
604
substitute_null_with_insert_id = FALSE;
592
substitute_null_with_insert_id = false;
605
593
thr_lock_info_init(&lock_info); /* safety: will be reset after start */
606
594
thr_lock_owner_init(&main_lock_id, &lock_info);
607
595
615
603
TODO: The current implementation is limited to 1 handler at a time only.
616
604
THD and sp_rcontext need to be modified to use a common handler stack.
617
605
*/
618
DBUG_ASSERT(m_internal_handler == NULL);
606
assert(m_internal_handler == NULL);
619
607
m_internal_handler= handler;
620
608
}
621
609
628
616
return m_internal_handler->handle_error(sql_errno, message, level, this);
629
617
}
630
618
631
return FALSE; // 'FALSE', as per coding style
619
return false; // 'false', as per coding style
632
620
}
633
621
634
622
635
623
void THD::pop_internal_handler()
636
624
{
637
DBUG_ASSERT(m_internal_handler != NULL);
625
assert(m_internal_handler != NULL);
638
626
m_internal_handler= NULL;
639
627
}
640
628
712
700
else
713
701
options &= ~OPTION_BIG_SELECTS;
714
702
715
transaction.all.modified_non_trans_table= transaction.stmt.modified_non_trans_table= FALSE;
703
transaction.all.modified_non_trans_table= transaction.stmt.modified_non_trans_table= false;
716
704
open_options=ha_open_options;
717
705
update_lock_default= (variables.low_priority_updates ?
718
706
TL_WRITE_LOW_PRIORITY :
736
724
void THD::init_for_queries()
737
725
{
738
726
set_time();
739
ha_enable_transaction(this,TRUE);
727
ha_enable_transaction(this,true);
740
728
741
729
reset_root_defaults(mem_root, variables.query_alloc_block_size,
742
730
variables.query_prealloc_size);
752
740
753
741
void THD::cleanup(void)
754
742
{
755
DBUG_ENTER("THD::cleanup");
756
DBUG_ASSERT(cleanup_done == 0);
743
assert(cleanup_done == 0);
757
744
758
745
killed= KILL_CONNECTION;
759
746
#ifdef ENABLE_WHEN_BINLOG_WILL_BE_ABLE_TO_PREPARE
783
770
unlock_global_read_lock(this);
784
771
785
772
cleanup_done=1;
786
DBUG_VOID_RETURN;
787
}
788
789
790
/*
791
Set the proc_info field.
792
Do not use this method directly, use THD_SET_PROC_INFO instead.
793
*/
794
#ifndef DBUG_OFF
795
void THD::set_proc_info(const char* file, int line, const char* info)
796
{
797
/*
798
Implementation note:
799
file and line correspond to the __FILE__ and __LINE__ where
800
THD_SET_PROC_INFO was called.
801
These two parameters are provided to help instrumenting the code.
802
*/
803
804
DBUG_PRINT("info", ("THD::set_proc_info(%s, %d, %s)",
805
file, line, (info ? info : NullS)));
806
807
proc_info= info;
808
}
809
#endif
810
773
return;
774
}
811
775
812
776
THD::~THD()
813
777
{
814
778
THD_CHECK_SENTRY(this);
815
DBUG_ENTER("~THD()");
816
779
/* Ensure that no one is using THD */
817
780
pthread_mutex_lock(&LOCK_delete);
818
781
pthread_mutex_unlock(&LOCK_delete);
830
793
ha_close_connection(this);
831
794
plugin_thdvar_cleanup(this);
832
795
833
DBUG_PRINT("info", ("freeing security context"));
834
796
main_security_ctx.destroy();
835
797
safeFree(db);
836
798
free_root(&warn_root,MYF(0));
837
799
free_root(&transaction.mem_root,MYF(0));
838
800
mysys_var=0; // Safety (shouldn't be needed)
839
801
pthread_mutex_destroy(&LOCK_delete);
840
#ifndef DBUG_OFF
841
802
dbug_sentry= THD_SENTRY_GONE;
842
#endif
843
803
if (rli_fake)
844
804
{
845
805
delete rli_fake;
847
807
}
848
808
849
809
free_root(&main_mem_root, MYF(0));
850
DBUG_VOID_RETURN;
810
return;
851
811
}
852
812
853
813
904
864
905
865
void THD::awake(THD::killed_state state_to_set)
906
866
{
907
DBUG_ENTER("THD::awake");
908
DBUG_PRINT("enter", ("this: 0x%lx", (long) this));
909
867
THD_CHECK_SENTRY(this);
910
868
safe_mutex_assert_owner(&LOCK_delete);
911
869
964
922
}
965
923
pthread_mutex_unlock(&mysys_var->mutex);
966
924
}
967
DBUG_VOID_RETURN;
925
return;
968
926
}
969
927
970
928
/*
978
936
Assert that thread_stack is initialized: it's necessary to be able
979
937
to track stack overrun.
980
938
*/
981
DBUG_ASSERT(thread_stack);
939
assert(thread_stack);
982
940
983
941
if (my_pthread_setspecific_ptr(THR_THD, this) ||
984
942
my_pthread_setspecific_ptr(THR_MALLOC, &mem_root))
1041
999
first_successful_insert_id_in_prev_stmt=
1042
1000
first_successful_insert_id_in_cur_stmt;
1043
1001
first_successful_insert_id_in_cur_stmt= 0;
1044
substitute_null_with_insert_id= TRUE;
1002
substitute_null_with_insert_id= true;
1045
1003
}
1046
1004
arg_of_last_insert_id_function= 0;
1047
1005
/* Free Items that were created during this execution */
1057
1015
@param lex_str pointer to LEX_STRING object to be initialized
1058
1016
@param str initializer to be copied into lex_str
1059
1017
@param length length of str, in bytes
1060
@param allocate_lex_string if TRUE, allocate new LEX_STRING object,
1018
@param allocate_lex_string if true, allocate new LEX_STRING object,
1061
1019
instead of using lex_str value
1062
1020
@return NULL on failure, or pointer to the LEX_STRING object
1063
1021
*/
1099
1057
const char *from, uint from_length,
1100
1058
CHARSET_INFO *from_cs)
1101
1059
{
1102
DBUG_ENTER("convert_string");
1103
1060
size_t new_length= to_cs->mbmaxlen * from_length;
1104
1061
uint dummy_errors;
1105
1062
if (!(to->str= (char*) alloc(new_length+1)))
1106
1063
{
1107
1064
to->length= 0; // Safety fix
1108
DBUG_RETURN(1); // EOM
1065
return(1); // EOM
1109
1066
}
1110
1067
to->length= copy_and_convert((char*) to->str, new_length, to_cs,
1111
1068
from, from_length, from_cs, &dummy_errors);
1112
1069
to->str[to->length]=0; // Safety
1113
DBUG_RETURN(0);
1070
return(0);
1114
1071
}
1115
1072
1116
1073
1133
1090
{
1134
1091
uint dummy_errors;
1135
1092
if (convert_buffer.copy(s->ptr(), s->length(), from_cs, to_cs, &dummy_errors))
1136
return TRUE;
1093
return true;
1137
1094
/* If convert_buffer >> s copying is more efficient long term */
1138
1095
if (convert_buffer.alloced_length() >= convert_buffer.length() * 2 ||
1139
1096
!s->is_alloced())
1141
1098
return s->copy(convert_buffer);
1142
1099
}
1143
1100
s->swap(convert_buffer);
1144
return FALSE;
1101
return false;
1145
1102
}
1146
1103
1147
1104
1181
1138
1182
1139
void THD::add_changed_table(TABLE *table)
1183
1140
{
1184
DBUG_ENTER("THD::add_changed_table(table)");
1185
1186
DBUG_ASSERT((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
1141
assert((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
1187
1142
table->file->has_transactions());
1188
1143
add_changed_table(table->s->table_cache_key.str,
1189
1144
(long) table->s->table_cache_key.length);
1190
DBUG_VOID_RETURN;
1145
return;
1191
1146
}
1192
1147
1193
1148
1194
1149
void THD::add_changed_table(const char *key, long key_length)
1195
1150
{
1196
DBUG_ENTER("THD::add_changed_table(key)");
1197
1151
CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables;
1198
1152
CHANGED_TABLE_LIST *curr = transaction.changed_tables;
1199
1153
1203
1157
if (cmp < 0)
1204
1158
{
1205
1159
list_include(prev_changed, curr, changed_table_dup(key, key_length));
1206
DBUG_PRINT("info",
1207
("key_length: %ld %u", key_length,
1208
(*prev_changed)->key_length));
1209
DBUG_VOID_RETURN;
1160
return;
1210
1161
}
1211
1162
else if (cmp == 0)
1212
1163
{
1214
1165
if (cmp < 0)
1215
1166
{
1216
1167
list_include(prev_changed, curr, changed_table_dup(key, key_length));
1217
DBUG_PRINT("info",
1218
("key_length: %ld %u", key_length,
1219
(*prev_changed)->key_length));
1220
DBUG_VOID_RETURN;
1168
return;
1221
1169
}
1222
1170
else if (cmp == 0)
1223
1171
{
1224
DBUG_PRINT("info", ("already in list"));
1225
DBUG_VOID_RETURN;
1172
return;
1226
1173
}
1227
1174
}
1228
1175
}
1229
1176
*prev_changed = changed_table_dup(key, key_length);
1230
DBUG_PRINT("info", ("key_length: %ld %u", key_length,
1231
(*prev_changed)->key_length));
1232
DBUG_VOID_RETURN;
1177
return;
1233
1178
}
1234
1179
1235
1180
1296
1241
#ifdef SIGNAL_WITH_VIO_CLOSE
1297
1242
void THD::close_active_vio()
1298
1243
{
1299
DBUG_ENTER("close_active_vio");
1300
1244
safe_mutex_assert_owner(&LOCK_delete);
1301
1245
if (active_vio)
1302
1246
{
1303
1247
vio_close(active_vio);
1304
1248
active_vio = 0;
1305
1249
}
1306
DBUG_VOID_RETURN;
1250
return;
1307
1251
}
1308
1252
#endif
1309
1253
1360
1304
{
1361
1305
I_List_iterator<Item_change_record> it(change_list);
1362
1306
Item_change_record *change;
1363
DBUG_ENTER("rollback_item_tree_changes");
1364
1307
1365
1308
while ((change= it++))
1366
1309
*change->place= change->old_value;
1367
1310
/* We can forget about changes memory: it's allocated in runtime memroot */
1368
1311
change_list.empty();
1369
DBUG_VOID_RETURN;
1312
return;
1370
1313
}
1371
1314
1372
1315
1380
1323
1381
1324
/* End of input is signaled by poll if the socket is aborted. */
1382
1325
if (vio_poll_read(net.vio, 0))
1383
return TRUE;
1326
return true;
1384
1327
1385
1328
/* Socket is aborted if signaled but no data is available. */
1386
1329
if (vio_peek_read(net.vio, &bytes))
1387
return TRUE;
1330
return true;
1388
1331
1389
return bytes ? TRUE : FALSE;
1332
return bytes ? true : false;
1390
1333
}
1391
1334
1392
1335
1413
1356
bool select_result::check_simple_select() const
1414
1357
{
1415
1358
my_error(ER_SP_BAD_CURSOR_QUERY, MYF(0));
1416
return TRUE;
1359
return true;
1417
1360
}
1418
1361
1419
1362
1445
1388
1446
1389
void select_send::abort()
1447
1390
{
1448
DBUG_ENTER("select_send::abort");
1449
DBUG_VOID_RETURN;
1391
return;
1450
1392
}
1451
1393
1452
1394
1458
1400
1459
1401
void select_send::cleanup()
1460
1402
{
1461
is_result_set_started= FALSE;
1403
is_result_set_started= false;
1462
1404
}
1463
1405
1464
1406
/* Send data to client. Returns 0 if ok */
1482
1424
Protocol *protocol= thd->protocol;
1483
1425
char buff[MAX_FIELD_WIDTH];
1484
1426
String buffer(buff, sizeof(buff), &my_charset_bin);
1485
DBUG_ENTER("select_send::send_data");
1486
1427
1487
1428
protocol->prepare_for_resend();
1488
1429
Item *item;
1499
1440
if (thd->is_error())
1500
1441
{
1501
1442
protocol->remove_last_row();
1502
DBUG_RETURN(1);
1443
return(1);
1503
1444
}
1504
1445
if (thd->vio_ok())
1505
DBUG_RETURN(protocol->write());
1506
DBUG_RETURN(0);
1446
return(protocol->write());
1447
return(0);
1507
1448
}
1508
1449
1509
1450
bool select_send::send_eof()
1523
1464
}
1524
1465
::my_eof(thd);
1525
1466
is_result_set_started= 0;
1526
return FALSE;
1467
return false;
1527
1468
}
1528
1469
1529
1470
1667
1608
select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
1668
1609
{
1669
1610
bool blob_flag=0;
1670
bool string_results= FALSE, non_string_results= FALSE;
1611
bool string_results= false, non_string_results= false;
1671
1612
unit= u;
1672
1613
if ((uint) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
1673
1614
strmake(path,exchange->file_name,FN_REFLEN-1);
1686
1627
break;
1687
1628
}
1688
1629
if (item->result_type() == STRING_RESULT)
1689
string_results= TRUE;
1630
string_results= true;
1690
1631
else
1691
non_string_results= TRUE;
1632
non_string_results= true;
1692
1633
}
1693
1634
}
1694
1635
field_term_length=exchange->field_term->length();
1717
1658
{
1718
1659
push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
1719
1660
ER_AMBIGUOUS_FIELD_TERM, ER(ER_AMBIGUOUS_FIELD_TERM));
1720
is_ambiguous_field_term= TRUE;
1661
is_ambiguous_field_term= true;
1721
1662
}
1722
1663
else
1723
is_ambiguous_field_term= FALSE;
1664
is_ambiguous_field_term= false;
1724
1665
1725
1666
return 0;
1726
1667
}
1734
1675
1735
1676
bool select_export::send_data(List<Item> &items)
1736
1677
{
1737
1738
DBUG_ENTER("select_export::send_data");
1739
1678
char buff[MAX_FIELD_WIDTH],null_buff[2],space[MAX_FIELD_WIDTH];
1740
1679
bool space_inited=0;
1741
1680
String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1744
1683
if (unit->offset_limit_cnt)
1745
1684
{ // using limit offset,count
1746
1685
unit->offset_limit_cnt--;
1747
DBUG_RETURN(0);
1686
return(0);
1748
1687
}
1749
1688
row_count++;
1750
1689
Item *item;
1801
1740
bool check_second_byte= (res_charset == &my_charset_bin) &&
1802
1741
character_set_client->
1803
1742
escape_with_backslash_is_dangerous;
1804
DBUG_ASSERT(character_set_client->mbmaxlen == 2 ||
1743
assert(character_set_client->mbmaxlen == 2 ||
1805
1744
!character_set_client->escape_with_backslash_is_dangerous);
1806
1745
for (start=pos=(char*) res->ptr(),end=pos+used_length ;
1807
1746
pos != end ;
1848
1787
mbcharlen is equal to 2, because there are no
1849
1788
character sets with mbmaxlen longer than 2
1850
1789
and with escape_with_backslash_is_dangerous set.
1851
DBUG_ASSERT before the loop makes that sure.
1790
assert before the loop makes that sure.
1852
1791
*/
1853
1792
1854
1793
if ((NEED_ESCAPING(*pos) ||
1916
1855
if (my_b_write(&cache,(uchar*) exchange->line_term->ptr(),
1917
1856
exchange->line_term->length()))
1918
1857
goto err;
1919
DBUG_RETURN(0);
1858
return(0);
1920
1859
err:
1921
DBUG_RETURN(1);
1860
return(1);
1922
1861
}
1923
1862
1924
1863
1943
1882
String tmp(buff,sizeof(buff),&my_charset_bin),*res;
1944
1883
tmp.length(0);
1945
1884
Item *item;
1946
DBUG_ENTER("select_dump::send_data");
1947
1885
1948
1886
if (unit->offset_limit_cnt)
1949
1887
{ // using limit offset,count
1950
1888
unit->offset_limit_cnt--;
1951
DBUG_RETURN(0);
1889
return(0);
1952
1890
}
1953
1891
if (row_count++ > 1)
1954
1892
{
1969
1907
goto err;
1970
1908
}
1971
1909
}
1972
DBUG_RETURN(0);
1910
return(0);
1973
1911
err:
1974
DBUG_RETURN(1);
1912
return(1);
1975
1913
}
1976
1914
1977
1915
1983
1921
1984
1922
bool select_singlerow_subselect::send_data(List<Item> &items)
1985
1923
{
1986
DBUG_ENTER("select_singlerow_subselect::send_data");
1987
1924
Item_singlerow_subselect *it= (Item_singlerow_subselect *)item;
1988
1925
if (it->assigned())
1989
1926
{
1990
1927
my_message(ER_SUBQUERY_NO_1_ROW, ER(ER_SUBQUERY_NO_1_ROW), MYF(0));
1991
DBUG_RETURN(1);
1928
return(1);
1992
1929
}
1993
1930
if (unit->offset_limit_cnt)
1994
1931
{ // Using limit offset,count
1995
1932
unit->offset_limit_cnt--;
1996
DBUG_RETURN(0);
1933
return(0);
1997
1934
}
1998
1935
List_iterator_fast<Item> li(items);
1999
1936
Item *val_item;
2000
1937
for (uint i= 0; (val_item= li++); i++)
2001
1938
it->store(i, val_item);
2002
1939
it->assigned(1);
2003
DBUG_RETURN(0);
1940
return(0);
2004
1941
}
2005
1942
2006
1943
2007
1944
void select_max_min_finder_subselect::cleanup()
2008
1945
{
2009
DBUG_ENTER("select_max_min_finder_subselect::cleanup");
2010
1946
cache= 0;
2011
DBUG_VOID_RETURN;
1947
return;
2012
1948
}
2013
1949
2014
1950
2015
1951
bool select_max_min_finder_subselect::send_data(List<Item> &items)
2016
1952
{
2017
DBUG_ENTER("select_max_min_finder_subselect::send_data");
2018
1953
Item_maxmin_subselect *it= (Item_maxmin_subselect *)item;
2019
1954
List_iterator_fast<Item> li(items);
2020
1955
Item *val_item= li++;
2046
1981
break;
2047
1982
case ROW_RESULT:
2048
1983
// This case should never be choosen
2049
DBUG_ASSERT(0);
1984
assert(0);
2050
1985
op= 0;
2051
1986
}
2052
1987
}
2054
1989
it->store(0, cache);
2055
1990
}
2056
1991
it->assigned(1);
2057
DBUG_RETURN(0);
1992
return(0);
2058
1993
}
2059
1994
2060
1995
bool select_max_min_finder_subselect::cmp_real()
2118
2053
2119
2054
bool select_exists_subselect::send_data(List<Item> &items __attribute__((__unused__)))
2120
2055
{
2121
DBUG_ENTER("select_exists_subselect::send_data");
2122
2056
Item_exists_subselect *it= (Item_exists_subselect *)item;
2123
2057
if (unit->offset_limit_cnt)
2124
2058
{ // Using limit offset,count
2125
2059
unit->offset_limit_cnt--;
2126
DBUG_RETURN(0);
2060
return(0);
2127
2061
}
2128
2062
it->value= 1;
2129
2063
it->assigned(1);
2130
DBUG_RETURN(0);
2064
return(0);
2131
2065
}
2132
2066
2133
2067
2152
2086
bool select_dumpvar::check_simple_select() const
2153
2087
{
2154
2088
my_error(ER_SP_BAD_CURSOR_SELECT, MYF(0));
2155
return TRUE;
2089
return true;
2156
2090
}
2157
2091
2158
2092
2165
2099
void Query_arena::free_items()
2166
2100
{
2167
2101
Item *next;
2168
DBUG_ENTER("Query_arena::free_items");
2169
2102
/* This works because items are allocated with sql_alloc() */
2170
2103
for (; free_list; free_list= next)
2171
2104
{
2173
2106
free_list->delete_self();
2174
2107
}
2175
2108
/* Postcondition: free_list is 0 */
2176
DBUG_VOID_RETURN;
2109
return;
2177
2110
}
2178
2111
2179
2112
2187
2120
2188
2121
void Query_arena::cleanup_stmt()
2189
2122
{
2190
DBUG_ASSERT("Query_arena::cleanup_stmt()" == "not implemented");
2123
assert("Query_arena::cleanup_stmt()" == "not implemented");
2191
2124
}
2192
2125
2193
2126
/*
2222
2155
void
2223
2156
Statement::set_n_backup_statement(Statement *stmt, Statement *backup)
2224
2157
{
2225
DBUG_ENTER("Statement::set_n_backup_statement");
2226
2158
backup->set_statement(this);
2227
2159
set_statement(stmt);
2228
DBUG_VOID_RETURN;
2160
return;
2229
2161
}
2230
2162
2231
2163
2232
2164
void Statement::restore_backup_statement(Statement *stmt, Statement *backup)
2233
2165
{
2234
DBUG_ENTER("Statement::restore_backup_statement");
2235
2166
stmt->set_statement(this);
2236
2167
set_statement(backup);
2237
DBUG_VOID_RETURN;
2168
return;
2238
2169
}
2239
2170
2240
2171
2255
2186
2256
2187
void THD::set_n_backup_active_arena(Query_arena *set, Query_arena *backup)
2257
2188
{
2258
DBUG_ENTER("THD::set_n_backup_active_arena");
2259
DBUG_ASSERT(backup->is_backup_arena == FALSE);
2189
assert(backup->is_backup_arena == false);
2260
2190
2261
2191
backup->set_query_arena(this);
2262
2192
set_query_arena(set);
2263
#ifndef DBUG_OFF
2264
backup->is_backup_arena= TRUE;
2265
#endif
2266
DBUG_VOID_RETURN;
2193
backup->is_backup_arena= true;
2194
return;
2267
2195
}
2268
2196
2269
2197
2270
2198
void THD::restore_active_arena(Query_arena *set, Query_arena *backup)
2271
2199
{
2272
DBUG_ENTER("THD::restore_active_arena");
2273
DBUG_ASSERT(backup->is_backup_arena);
2200
assert(backup->is_backup_arena);
2274
2201
set->set_query_arena(this);
2275
2202
set_query_arena(backup);
2276
#ifndef DBUG_OFF
2277
backup->is_backup_arena= FALSE;
2278
#endif
2279
DBUG_VOID_RETURN;
2203
backup->is_backup_arena= false;
2204
return;
2280
2205
}
2281
2206
2282
2207
bool select_dumpvar::send_data(List<Item> &items)
2285
2210
List_iterator<Item> it(items);
2286
2211
Item *item;
2287
2212
my_var *mv;
2288
DBUG_ENTER("select_dumpvar::send_data");
2289
2213
2290
2214
if (unit->offset_limit_cnt)
2291
2215
{ // using limit offset,count
2292
2216
unit->offset_limit_cnt--;
2293
DBUG_RETURN(0);
2217
return(0);
2294
2218
}
2295
2219
if (row_count++)
2296
2220
{
2297
2221
my_message(ER_TOO_MANY_ROWS, ER(ER_TOO_MANY_ROWS), MYF(0));
2298
DBUG_RETURN(1);
2222
return(1);
2299
2223
}
2300
2224
while ((mv= var_li++) && (item= it++))
2301
2225
{
2307
2231
suv->update();
2308
2232
}
2309
2233
}
2310
DBUG_RETURN(thd->is_error());
2234
return(thd->is_error());
2311
2235
}
2312
2236
2313
2237
bool select_dumpvar::send_eof()
2330
2254
2331
2255
void TMP_TABLE_PARAM::init()
2332
2256
{
2333
DBUG_ENTER("TMP_TABLE_PARAM::init");
2334
DBUG_PRINT("enter", ("this: 0x%lx", (ulong)this));
2335
2257
field_count= sum_func_count= func_count= hidden_field_count= 0;
2336
2258
group_parts= group_length= group_null_parts= 0;
2337
2259
quick_group= 1;
2338
2260
table_charset= 0;
2339
2261
precomputed_group_by= 0;
2340
2262
bit_fields_as_long= 0;
2341
DBUG_VOID_RETURN;
2263
return;
2342
2264
}
2343
2265
2344
2266
2407
2329
2408
2330
void THD::reset_n_backup_open_tables_state(Open_tables_state *backup)
2409
2331
{
2410
DBUG_ENTER("reset_n_backup_open_tables_state");
2411
2332
backup->set_open_tables_state(this);
2412
2333
reset_open_tables_state();
2413
2334
state_flags|= Open_tables_state::BACKUPS_AVAIL;
2414
DBUG_VOID_RETURN;
2335
return;
2415
2336
}
2416
2337
2417
2338
2418
2339
void THD::restore_backup_open_tables_state(Open_tables_state *backup)
2419
2340
{
2420
DBUG_ENTER("restore_backup_open_tables_state");
2421
2341
/*
2422
2342
Before we will throw away current open tables state we want
2423
2343
to be sure that it was properly cleaned up.
2424
2344
*/
2425
DBUG_ASSERT(open_tables == 0 && temporary_tables == 0 &&
2345
assert(open_tables == 0 && temporary_tables == 0 &&
2426
2346
handler_tables == 0 && derived_tables == 0 &&
2427
2347
lock == 0 && locked_tables == 0);
2428
2348
set_open_tables_state(backup);
2429
DBUG_VOID_RETURN;
2349
return;
2430
2350
}
2431
2351
2432
2352
/**
2488
2408
Mark transaction to rollback and mark error as fatal to a sub-statement.
2489
2409
2490
2410
@param thd Thread handle
2491
@param all TRUE <=> rollback main transaction.
2411
@param all true <=> rollback main transaction.
2492
2412
*/
2493
2413
2494
2414
void mark_transaction_to_rollback(THD *thd, bool all)
2495
2415
{
2496
2416
if (thd)
2497
2417
{
2498
thd->is_fatal_sub_stmt_error= TRUE;
2418
thd->is_fatal_sub_stmt_error= true;
2499
2419
thd->transaction_rollback_request= all;
2500
2420
}
2501
2421
}
2571
2491
bool xid_cache_insert(XID_STATE *xid_state)
2572
2492
{
2573
2493
pthread_mutex_lock(&LOCK_xid_cache);
2574
DBUG_ASSERT(hash_search(&xid_cache, xid_state->xid.key(),
2494
assert(hash_search(&xid_cache, xid_state->xid.key(),
2575
2495
xid_state->xid.key_length())==0);
2576
2496
my_bool res=my_hash_insert(&xid_cache, (uchar*)xid_state);
2577
2497
pthread_mutex_unlock(&LOCK_xid_cache);
2621
2541
bool is_transactional,
2622
2542
RowsEventT *hint __attribute__((unused)))
2623
2543
{
2624
DBUG_ENTER("binlog_prepare_pending_rows_event");
2625
2544
/* Pre-conditions */
2626
DBUG_ASSERT(table->s->table_map_id != ~0UL);
2545
assert(table->s->table_map_id != ~0UL);
2627
2546
2628
2547
/* Fetch the type code for the RowsEventT template parameter */
2629
2548
int const type_code= RowsEventT::TYPE_CODE;
2633
2552
have to do it here.
2634
2553
*/
2635
2554
if (binlog_setup_trx_data())
2636
DBUG_RETURN(NULL);
2555
return(NULL);
2637
2556
2638
2557
Rows_log_event* pending= binlog_get_pending_rows_event();
2639
2558
2640
2559
if (unlikely(pending && !pending->is_valid()))
2641
DBUG_RETURN(NULL);
2560
return(NULL);
2642
2561
2643
2562
/*
2644
2563
Check if the current event is non-NULL and a write-rows
2670
2589
ev= new RowsEventT(this, table, table->s->table_map_id,
2671
2590
is_transactional);
2672
2591
if (unlikely(!ev))
2673
DBUG_RETURN(NULL);
2592
return(NULL);
2674
2593
ev->server_id= serv_id; // I don't like this, it's too easy to forget.
2675
2594
/*
2676
2595
flush the pending event and replace it with the newly created
2679
2598
if (unlikely(mysql_bin_log.flush_and_set_pending_rows_event(this, ev)))
2680
2599
{
2681
2600
delete ev;
2682
DBUG_RETURN(NULL);
2601
return(NULL);
2683
2602
}
2684
2603
2685
DBUG_RETURN(ev); /* This is the new pending event */
2604
return(ev); /* This is the new pending event */
2686
2605
}
2687
DBUG_RETURN(pending); /* This is the current pending event */
2606
return(pending); /* This is the current pending event */
2688
2607
}
2689
2608
2690
2609
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
2736
2655
Row_data_memory(TABLE *table, size_t const len1)
2737
2656
: m_memory(0)
2738
2657
{
2739
#ifndef DBUG_OFF
2740
m_alloc_checked= FALSE;
2741
#endif
2658
m_alloc_checked= false;
2742
2659
allocate_memory(table, len1);
2743
2660
m_ptr[0]= has_memory() ? m_memory : 0;
2744
2661
m_ptr[1]= 0;
2747
2664
Row_data_memory(TABLE *table, size_t const len1, size_t const len2)
2748
2665
: m_memory(0)
2749
2666
{
2750
#ifndef DBUG_OFF
2751
m_alloc_checked= FALSE;
2752
#endif
2667
m_alloc_checked= false;
2753
2668
allocate_memory(table, len1 + len2);
2754
2669
m_ptr[0]= has_memory() ? m_memory : 0;
2755
2670
m_ptr[1]= has_memory() ? m_memory + len1 : 0;
2768
2683
@retval false Memory allocation failed
2769
2684
*/
2770
2685
bool has_memory() const {
2771
#ifndef DBUG_OFF
2772
m_alloc_checked= TRUE;
2773
#endif
2686
m_alloc_checked= true;
2774
2687
return m_memory != 0;
2775
2688
}
2776
2689
2777
2690
uchar *slot(uint s)
2778
2691
{
2779
DBUG_ASSERT(s < sizeof(m_ptr)/sizeof(*m_ptr));
2780
DBUG_ASSERT(m_ptr[s] != 0);
2781
DBUG_ASSERT(m_alloc_checked == TRUE);
2692
assert(s < sizeof(m_ptr)/sizeof(*m_ptr));
2693
assert(m_ptr[s] != 0);
2694
assert(m_alloc_checked == true);
2782
2695
return m_ptr[s];
2783
2696
}
2784
2697
2808
2721
table->write_row_record=
2809
2722
(uchar *) alloc_root(&table->mem_root, 2 * maxlen);
2810
2723
m_memory= table->write_row_record;
2811
m_release_memory_on_destruction= FALSE;
2724
m_release_memory_on_destruction= false;
2812
2725
}
2813
2726
else
2814
2727
{
2815
2728
m_memory= (uchar *) my_malloc(total_length, MYF(MY_WME));
2816
m_release_memory_on_destruction= TRUE;
2729
m_release_memory_on_destruction= true;
2817
2730
}
2818
2731
}
2819
2732
2820
#ifndef DBUG_OFF
2821
2733
mutable bool m_alloc_checked;
2822
#endif
2823
2734
bool m_release_memory_on_destruction;
2824
2735
uchar *m_memory;
2825
2736
uchar *m_ptr[2];
2830
2741
int THD::binlog_write_row(TABLE* table, bool is_trans,
2831
2742
uchar const *record)
2832
2743
{
2833
DBUG_ASSERT(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2744
assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2834
2745
2835
2746
/*
2836
2747
Pack records into format for transfer. We are allocating more
2858
2769
const uchar *before_record,
2859
2770
const uchar *after_record)
2860
2771
{
2861
DBUG_ASSERT(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2772
assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2862
2773
2863
2774
size_t const before_maxlen = max_row_length(table, before_record);
2864
2775
size_t const after_maxlen = max_row_length(table, after_record);
2875
2786
size_t const after_size= pack_row(table, table->write_set, after_row,
2876
2787
after_record);
2877
2788
2878
/*
2879
Don't print debug messages when running valgrind since they can
2880
trigger false warnings.
2881
*/
2882
#ifndef HAVE_purify
2883
DBUG_DUMP("before_record", before_record, table->s->reclength);
2884
DBUG_DUMP("after_record", after_record, table->s->reclength);
2885
DBUG_DUMP("before_row", before_row, before_size);
2886
DBUG_DUMP("after_row", after_row, after_size);
2887
#endif
2888
2889
2789
Rows_log_event* const ev=
2890
2790
binlog_prepare_pending_rows_event(table, server_id,
2891
2791
before_size + after_size, is_trans,
2902
2802
int THD::binlog_delete_row(TABLE* table, bool is_trans,
2903
2803
uchar const *record)
2904
2804
{
2905
DBUG_ASSERT(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2805
assert(current_stmt_binlog_row_based && mysql_bin_log.is_open());
2906
2806
2907
2807
/*
2908
2808
Pack records into format for transfer. We are allocating more
2914
2814
2915
2815
uchar *row_data= memory.slot(0);
2916
2816
2917
DBUG_DUMP("table->read_set", (uchar*) table->read_set->bitmap, (table->s->fields + 7) / 8);
2918
2817
size_t const len= pack_row(table, table->read_set, row_data, record);
2919
2818
2920
2819
Rows_log_event* const ev=
2930
2829
2931
2830
int THD::binlog_flush_pending_rows_event(bool stmt_end)
2932
2831
{
2933
DBUG_ENTER("THD::binlog_flush_pending_rows_event");
2934
2832
/*
2935
2833
We shall flush the pending event even if we are not in row-based
2936
2834
mode: it might be the case that we left row-based mode before
2937
2835
flushing anything (e.g., if we have explicitly locked tables).
2938
2836
*/
2939
2837
if (!mysql_bin_log.is_open())
2940
DBUG_RETURN(0);
2838
return(0);
2941
2839
2942
2840
/*
2943
2841
Mark the event as the last event of a statement if the stmt_end
2956
2854
error= mysql_bin_log.flush_and_set_pending_rows_event(this, 0);
2957
2855
}
2958
2856
2959
DBUG_RETURN(error);
2857
return(error);
2960
2858
}
2961
2859
2962
2860
2987
2885
ulong query_len, bool is_trans, bool suppress_use,
2988
2886
THD::killed_state killed_status_arg)
2989
2887
{
2990
DBUG_ENTER("THD::binlog_query");
2991
DBUG_PRINT("enter", ("qtype: %d query: '%s'", qtype, query_arg));
2992
DBUG_ASSERT(query_arg && mysql_bin_log.is_open());
2888
assert(query_arg && mysql_bin_log.is_open());
2993
2889
2994
if (int error= binlog_flush_pending_rows_event(TRUE))
2995
DBUG_RETURN(error);
2890
if (int error= binlog_flush_pending_rows_event(true))
2891
return(error);
2996
2892
2997
2893
/*
2998
2894
If we are in statement mode and trying to log an unsafe statement,
3001
2897
if (lex->is_stmt_unsafe() &&
3002
2898
variables.binlog_format == BINLOG_FORMAT_STMT)
3003
2899
{
3004
DBUG_ASSERT(this->query != NULL);
2900
assert(this->query != NULL);
3005
2901
push_warning(this, MYSQL_ERROR::WARN_LEVEL_WARN,
3006
2902
ER_BINLOG_UNSAFE_STATEMENT,
3007
2903
ER(ER_BINLOG_UNSAFE_STATEMENT));
3018
2914
switch (qtype) {
3019
2915
case THD::ROW_QUERY_TYPE:
3020
2916
if (current_stmt_binlog_row_based)
3021
DBUG_RETURN(0);
2917
return(0);
3022
2918
/* Otherwise, we fall through */
3023
2919
case THD::MYSQL_QUERY_TYPE:
3024
2920
/*
3046
2942
*/
3047
2943
int error= mysql_bin_log.write(&qinfo);
3048
2944
binlog_table_maps= 0;
3049
DBUG_RETURN(error);
2945
return(error);
3050
2946
}
3051
2947
break;
3052
2948
3053
2949
case THD::QUERY_TYPE_COUNT:
3054
2950
default:
3055
DBUG_ASSERT(0 <= qtype && qtype < QUERY_TYPE_COUNT);
2951
assert(0 <= qtype && qtype < QUERY_TYPE_COUNT);
3056
2952
}
3057
DBUG_RETURN(0);
2953
return(0);
3058
2954
}
3059
2955
3060
2956
bool Discrete_intervals_list::append(ulonglong start, ulonglong val,
3061
2957
ulonglong incr)
3062
2958
{
3063
DBUG_ENTER("Discrete_intervals_list::append");
3064
2959
/* first, see if this can be merged with previous */
3065
2960
if ((head == NULL) || tail->merge_if_contiguous(start, val, incr))
3066
2961
{
3067
2962
/* it cannot, so need to add a new interval */
3068
2963
Discrete_interval *new_interval= new Discrete_interval(start, val, incr);
3069
DBUG_RETURN(append(new_interval));
2964
return(append(new_interval));
3070
2965
}
3071
DBUG_RETURN(0);
2966
return(0);
3072
2967
}
3073
2968
3074
2969
bool Discrete_intervals_list::append(Discrete_interval *new_interval)
3075
2970
{
3076
DBUG_ENTER("Discrete_intervals_list::append");
3077
2971
if (unlikely(new_interval == NULL))
3078
DBUG_RETURN(1);
3079
DBUG_PRINT("info",("adding new auto_increment interval"));
2972
return(1);
3080
2973
if (head == NULL)
3081
2974
head= current= new_interval;
3082
2975
else
3083
2976
tail->next= new_interval;
3084
2977
tail= new_interval;
3085
2978
elements++;
3086
DBUG_RETURN(0);
2979
return(0);
3087
2980
}
3088
2981
3089
2982
#endif /* !defined(MYSQL_CLIENT) */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1