From fb1a54aac330baf31f39622f42a36a597441c6c2 Mon Sep 17 00:00:00 2001 From: "lzhou/root@dev3-138.dev.cn.tlan" <> Date: Fri, 13 Oct 2006 13:48:04 +0000 Subject: [PATCH 01/73] BUG#21296 Add error messages when upgrading data node --- storage/ndb/src/kernel/error/ErrorReporter.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/storage/ndb/src/kernel/error/ErrorReporter.cpp b/storage/ndb/src/kernel/error/ErrorReporter.cpp index 6c8bb1fe615..6e54c8a5f99 100644 --- a/storage/ndb/src/kernel/error/ErrorReporter.cpp +++ b/storage/ndb/src/kernel/error/ErrorReporter.cpp @@ -25,6 +25,7 @@ #include #include #include +#include "EventLogger.hpp" #include @@ -40,7 +41,7 @@ static void dumpJam(FILE* jamStream, Uint32 thrdTheEmulatedJamIndex, Uint8 thrdTheEmulatedJam[]); - +extern EventLogger g_eventLogger; const char* ErrorReporter::formatTimeStampString(){ TimeModule DateTime; /* To create "theDateTimeString" */ @@ -196,6 +197,9 @@ ErrorReporter::handleError(int messageID, WriteMessage(messageID, problemData, objRef, theEmulatedJamIndex, theEmulatedJam); + g_eventLogger.info(problemData); + g_eventLogger.info(objRef); + childReportError(messageID); if(messageID == NDBD_EXIT_ERROR_INSERT){ From 53f7d72a5b46cb2e425673da4221d56db3f771d4 Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Mon, 5 Feb 2007 16:48:08 +0800 Subject: [PATCH 02/73] BUG#24363 If the table structure has been changed, the default action about the restore will fail. You can skip the table structure check with --skip-table-check (-s) option. --- storage/ndb/tools/restore/consumer.hpp | 1 + .../ndb/tools/restore/consumer_restore.cpp | 56 +++++++++++++++++++ .../ndb/tools/restore/consumer_restore.hpp | 1 + storage/ndb/tools/restore/restore_main.cpp | 20 +++++++ 4 files changed, 78 insertions(+) diff --git a/storage/ndb/tools/restore/consumer.hpp b/storage/ndb/tools/restore/consumer.hpp index 37f67884e01..1f141bf0cda 100644 --- a/storage/ndb/tools/restore/consumer.hpp +++ b/storage/ndb/tools/restore/consumer.hpp @@ -41,6 +41,7 @@ public: NODE_GROUP_MAP *m_nodegroup_map; uint m_nodegroup_map_len; virtual bool has_temp_error() {return false;} + virtual bool table_equal(const TableS &) {return true;} }; #endif diff --git a/storage/ndb/tools/restore/consumer_restore.cpp b/storage/ndb/tools/restore/consumer_restore.cpp index bd8edc4c47c..6aa10323a2b 100644 --- a/storage/ndb/tools/restore/consumer_restore.cpp +++ b/storage/ndb/tools/restore/consumer_restore.cpp @@ -666,6 +666,62 @@ err: return result; } +bool +BackupRestore::table_equal(const TableS &tableS){ + const char *tablename = tableS.getTableName(); + + if(tableS.m_dictTable == NULL){ + ndbout<<"Table %s has no m_dictTable " << tablename << endl; + return false; + } + /** + * Ignore blob tables + */ + if(match_blob(tablename) >= 0) + return true; + + const NdbTableImpl & tmptab = NdbTableImpl::getImpl(* tableS.m_dictTable); + if ((int) tmptab.m_indexType != (int) NdbDictionary::Index::Undefined){ + return true; + } + + BaseString tmp(tablename); + Vector split; + if(tmp.split(split, "/") != 3){ + err << "Invalid table name format " << tablename << endl; + return false; + } + + m_ndb->setDatabaseName(split[0].c_str()); + m_ndb->setSchemaName(split[1].c_str()); + + NdbDictionary::Dictionary* dict = m_ndb->getDictionary(); + const NdbDictionary::Table* tab = dict->getTable(split[2].c_str()); + if(tab == 0){ + err << "Unable to find table: " << split[2].c_str() << endl; + return false; + } + + if(tab->getNoOfColumns() != tableS.m_dictTable->getNoOfColumns()) + { + ndbout_c("m_columns.size %d != %d",tab->getNoOfColumns(), + tableS.m_dictTable->getNoOfColumns()); + return false; + } + + for(int i = 0; igetNoOfColumns(); i++) + { + if(!tab->getColumn(i)->equal(*(tableS.m_dictTable->getColumn(i)))) + { + ndbout_c("m_columns %s != %s",tab->getColumn(i)->getName(), + tableS.m_dictTable->getColumn(i)->getName()); + return false; + } + } + + return true; +} + bool BackupRestore::createSystable(const TableS & tables){ const char *tablename = tables.getTableName(); diff --git a/storage/ndb/tools/restore/consumer_restore.hpp b/storage/ndb/tools/restore/consumer_restore.hpp index 3d20cb3041e..e4bf481d231 100644 --- a/storage/ndb/tools/restore/consumer_restore.hpp +++ b/storage/ndb/tools/restore/consumer_restore.hpp @@ -74,6 +74,7 @@ public: virtual bool finalize_table(const TableS &); virtual bool has_temp_error(); virtual bool createSystable(const TableS & table); + virtual bool table_equal(const TableS & table); virtual bool update_apply_status(const RestoreMetaData &metaData); void connectToMysql(); bool map_in_frm(char *new_data, const char *data, diff --git a/storage/ndb/tools/restore/restore_main.cpp b/storage/ndb/tools/restore/restore_main.cpp index 8a632d388e0..1e73b372a8d 100644 --- a/storage/ndb/tools/restore/restore_main.cpp +++ b/storage/ndb/tools/restore/restore_main.cpp @@ -51,6 +51,7 @@ NDB_STD_OPTS_VARS; static bool ga_restore_epoch = false; static bool ga_restore = false; static bool ga_print = false; +static bool ga_skip_table_check = false; static int _print = 0; static int _print_meta = 0; static int _print_data = 0; @@ -92,6 +93,9 @@ static struct my_option my_long_options[] = NDB_REP_DB "." NDB_APPLY_TABLE " with id 0 will be updated/inserted.", (gptr*) &ga_restore_epoch, (gptr*) &ga_restore_epoch, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, + { "skip-table-check", 's', "Skip table structure check during restore of data", + (gptr*) &ga_skip_table_check, (gptr*) &ga_skip_table_check, 0, + GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 }, { "parallelism", 'p', "No of parallel transactions during restore of data." "(parallelism can be 1 to 1024)", @@ -460,6 +464,8 @@ main(int argc, char** argv) g_options.appfmt(" -n %d", ga_nodeId); if (_restore_meta) g_options.appfmt(" -m"); + if (ga_skip_table_check) + g_options.appfmt(" -s"); if (_restore_data) g_options.appfmt(" -r"); if (ga_restore_epoch) @@ -590,6 +596,20 @@ main(int argc, char** argv) { if(_restore_data || _print_data) { + if (!ga_skip_table_check){ + for(i=0; i < metaData.getNoOfTables(); i++){ + if (checkSysTable(metaData, i)) + { + for(Uint32 j= 0; j < g_consumers.size(); j++) + if (!g_consumers[j]->table_equal(* metaData[i])) + { + err << "Restore: Failed to restore data, "; + err << metaData[i]->getTableName() << " table structure doesn't match backup ... Exiting " << endl; + exitHandler(NDBT_FAILED); + } + } + } + } RestoreDataIterator dataIter(metaData, &free_data_callback); // Read data file header From 3f5cac54c20648fb3aedb80e120bcf031fc04973 Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Tue, 6 Feb 2007 20:00:00 +0800 Subject: [PATCH 03/73] BUG#19378 Job Buffer Full error appears for too large MaxNoOfTables --- storage/ndb/src/mgmsrv/ConfigInfo.cpp | 2 +- storage/ndb/src/mgmsrv/ParamInfo.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/storage/ndb/src/mgmsrv/ConfigInfo.cpp b/storage/ndb/src/mgmsrv/ConfigInfo.cpp index 3b71bcea45d..c3c8625051e 100644 --- a/storage/ndb/src/mgmsrv/ConfigInfo.cpp +++ b/storage/ndb/src/mgmsrv/ConfigInfo.cpp @@ -449,7 +449,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = { ConfigInfo::CI_INT, "128", "8", - STR_VALUE(MAX_INT_RNIL) }, + STR_VALUE(MAX_TABLES) }, { CFG_DB_NO_ORDERED_INDEXES, diff --git a/storage/ndb/src/mgmsrv/ParamInfo.cpp b/storage/ndb/src/mgmsrv/ParamInfo.cpp index 4a4e80eb079..888b7948c05 100644 --- a/storage/ndb/src/mgmsrv/ParamInfo.cpp +++ b/storage/ndb/src/mgmsrv/ParamInfo.cpp @@ -275,7 +275,7 @@ const ParamInfo ParamInfoArray[] = { CI_INT, "128", "8", - STR_VALUE(MAX_INT_RNIL) }, + STR_VALUE(MAX_TABLES) }, { CFG_DB_NO_ORDERED_INDEXES, From 2ca730248880ba6354b58c2ee8037a2d4d69ec6e Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Mon, 12 Feb 2007 16:35:32 +0800 Subject: [PATCH 04/73] BUG#19378 Job Buffer Full error appears for too large MaxNoOfTables --- ndb/src/mgmsrv/ConfigInfo.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ndb/src/mgmsrv/ConfigInfo.cpp b/ndb/src/mgmsrv/ConfigInfo.cpp index d4e72a7ff1d..3a8c8f26b09 100644 --- a/ndb/src/mgmsrv/ConfigInfo.cpp +++ b/ndb/src/mgmsrv/ConfigInfo.cpp @@ -459,7 +459,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = { ConfigInfo::CI_INT, "128", "8", - STR_VALUE(MAX_INT_RNIL) }, + STR_VALUE(MAX_TABLES) }, { CFG_DB_NO_ORDERED_INDEXES, From 8761abba0e107de4436e3c8eaf4d88df5fa407ec Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Thu, 15 Feb 2007 16:52:23 +0800 Subject: [PATCH 05/73] BUG#21715 mgm client command status return version(0.0.0.0) --- ndb/src/mgmclient/CommandInterpreter.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/ndb/src/mgmclient/CommandInterpreter.cpp b/ndb/src/mgmclient/CommandInterpreter.cpp index 65d5b038707..e38c1109077 100644 --- a/ndb/src/mgmclient/CommandInterpreter.cpp +++ b/ndb/src/mgmclient/CommandInterpreter.cpp @@ -1627,6 +1627,19 @@ CommandInterpreter::executeStatus(int processId, ndbout << processId << ": Node not found" << endl; return -1; } + if (cl->node_states[i].node_type != NDB_MGM_NODE_TYPE_NDB){ + if (cl->node_states[i].version != 0){ + version = cl->node_states[i].version; + ndbout << "Node "<< cl->node_states[i].node_id <<": connected" ; + ndbout_c(" (Version %d.%d.%d)", + getMajor(version) , + getMinor(version), + getBuild(version)); + + }else + ndbout << "Node "<< cl->node_states[i].node_id <<": not connected" << endl; + return 0; + } status = cl->node_states[i].node_status; startPhase = cl->node_states[i].start_phase; version = cl->node_states[i].version; From 62171d25cf2752696833f29accb14bd1ecda81a2 Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Thu, 22 Feb 2007 09:12:07 +0100 Subject: [PATCH 06/73] Bug#25460 - High concurrency MyISAM access causes severe mysqld crash. Decreased code duplication by calling memory mapping function through mi_extra(). --- storage/myisam/mi_open.c | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/storage/myisam/mi_open.c b/storage/myisam/mi_open.c index 830332fe0c1..a06b21ee5b4 100644 --- a/storage/myisam/mi_open.c +++ b/storage/myisam/mi_open.c @@ -506,22 +506,6 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags) share->data_file_type = DYNAMIC_RECORD; my_afree((gptr) disk_cache); mi_setup_functions(share); - if (open_flags & HA_OPEN_MMAP) - { - info.s= share; - if (mi_dynmap_file(&info, share->state.state.data_file_length)) - { - /* purecov: begin inspected */ - /* Ignore if mmap fails. Use file I/O instead. */ - DBUG_PRINT("warning", ("mmap failed: errno: %d", errno)); - /* purecov: end */ - } - else - { - share->file_read= mi_mmap_pread; - share->file_write= mi_mmap_pwrite; - } - } share->is_log_table= FALSE; #ifdef THREAD thr_lock_init(&share->lock); @@ -552,6 +536,14 @@ MI_INFO *mi_open(const char *name, int mode, uint open_flags) } } #endif + /* + Memory mapping can only be requested after initializing intern_lock. + */ + if (open_flags & HA_OPEN_MMAP) + { + info.s= share; + mi_extra(&info, HA_EXTRA_MMAP, 0); + } } else { From ddb8131207c7b58203ca5b5729827f507323c3c6 Mon Sep 17 00:00:00 2001 From: "svoj@mysql.com/june.mysql.com" <> Date: Wed, 28 Feb 2007 14:27:19 +0400 Subject: [PATCH 07/73] BUG#26080 - Memory Storage engine not working properly Extending varchar column length with ALTER TABLE may result in unusable memory table. The problem is that we use fast ALTER TABLE in this case, which is not supported by now. This is fixed by refusing fast ALTER TABLE when extending varchar column. In other words force copy of a table during ALTER TABLE. Affects MEMORY tables in 5.1 only. --- mysql-test/r/heap.result | 7 +++++++ mysql-test/t/heap.test | 9 +++++++++ storage/heap/ha_heap.cc | 7 ++++--- 3 files changed, 20 insertions(+), 3 deletions(-) diff --git a/mysql-test/r/heap.result b/mysql-test/r/heap.result index 29bdfcbef7a..ddf675e2f73 100644 --- a/mysql-test/r/heap.result +++ b/mysql-test/r/heap.result @@ -731,3 +731,10 @@ SELECT COUNT(*) FROM t1 WHERE c=REPEAT('a',256); COUNT(*) 2 DROP TABLE t1; +CREATE TABLE t1(c1 VARCHAR(100), c2 INT) ENGINE=MEMORY; +INSERT INTO t1 VALUES('', 0); +ALTER TABLE t1 MODIFY c1 VARCHAR(101); +SELECT c2 FROM t1; +c2 +0 +DROP TABLE t1; diff --git a/mysql-test/t/heap.test b/mysql-test/t/heap.test index 624597cd8d7..b47a5fc2033 100644 --- a/mysql-test/t/heap.test +++ b/mysql-test/t/heap.test @@ -471,3 +471,12 @@ SELECT COUNT(*) FROM t1 WHERE c=REPEAT('a',256); DROP TABLE t1; # End of 5.0 tests + +# +# BUG#26080 - Memory Storage engine not working properly +# +CREATE TABLE t1(c1 VARCHAR(100), c2 INT) ENGINE=MEMORY; +INSERT INTO t1 VALUES('', 0); +ALTER TABLE t1 MODIFY c1 VARCHAR(101); +SELECT c2 FROM t1; +DROP TABLE t1; diff --git a/storage/heap/ha_heap.cc b/storage/heap/ha_heap.cc index cf11c9923eb..f2caa7e6d18 100644 --- a/storage/heap/ha_heap.cc +++ b/storage/heap/ha_heap.cc @@ -703,9 +703,10 @@ bool ha_heap::check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes) { /* Check that auto_increment value was not changed */ - if ((table_changes != IS_EQUAL_YES && - info->used_fields & HA_CREATE_USED_AUTO) && - info->auto_increment_value != 0) + if ((info->used_fields & HA_CREATE_USED_AUTO && + info->auto_increment_value != 0) || + table_changes == IS_EQUAL_NO || + table_changes & IS_EQUAL_PACK_LENGTH) // Not implemented yet return COMPATIBLE_DATA_NO; return COMPATIBLE_DATA_YES; } From aae6e1aba44e2d8353ccb111633bc3631eefaf7a Mon Sep 17 00:00:00 2001 From: "svoj@mysql.com/june.mysql.com" <> Date: Wed, 28 Feb 2007 18:34:35 +0400 Subject: [PATCH 08/73] BUG#26238 - inserted delayed always inserts 0 for BIT columns INSERT DELAYED inserts garbage for BIT columns. When delayed thread clones TABLE object, it didn't adjusted bit_ptr to newly created record (though it correctly adjusts ptr and null_ptr). This is fixed by correctly adjusting bit_ptr when performing a clone. With this fix BIT values are stored correctly by INSERT DELAYED. --- mysql-test/r/delayed.result | 7 +++++++ mysql-test/t/delayed.test | 8 ++++++++ sql/field.h | 7 ++++++- 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/delayed.result b/mysql-test/r/delayed.result index 6295fceec2b..82a308c63e7 100644 --- a/mysql-test/r/delayed.result +++ b/mysql-test/r/delayed.result @@ -243,3 +243,10 @@ SET @@session.auto_increment_offset= @bug20830_old_session_auto_increment_offset; SET @@session.auto_increment_increment= @bug20830_old_session_auto_increment_increment; +CREATE TABLE t1(a BIT); +INSERT DELAYED INTO t1 VALUES(1); +FLUSH TABLE t1; +SELECT HEX(a) FROM t1; +HEX(a) +1 +DROP TABLE t1; diff --git a/mysql-test/t/delayed.test b/mysql-test/t/delayed.test index fe8bc167e0f..773927f6015 100644 --- a/mysql-test/t/delayed.test +++ b/mysql-test/t/delayed.test @@ -234,3 +234,11 @@ SET @@session.auto_increment_offset= SET @@session.auto_increment_increment= @bug20830_old_session_auto_increment_increment; +# +# BUG#26238 - inserted delayed always inserts 0 for BIT columns +# +CREATE TABLE t1(a BIT); +INSERT DELAYED INTO t1 VALUES(1); +FLUSH TABLE t1; +SELECT HEX(a) FROM t1; +DROP TABLE t1; diff --git a/sql/field.h b/sql/field.h index fe3c59c89f5..d46f5f699af 100644 --- a/sql/field.h +++ b/sql/field.h @@ -225,7 +225,7 @@ public: ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg; } inline void move_field(char *ptr_arg) { ptr=ptr_arg; } - inline void move_field(my_ptrdiff_t ptr_diff) + virtual inline void move_field(my_ptrdiff_t ptr_diff) { ptr=ADD_TO_PTR(ptr,ptr_diff,char*); if (null_ptr) @@ -1407,6 +1407,11 @@ public: Field *new_key_field(MEM_ROOT *root, struct st_table *new_table, char *new_ptr, uchar *new_null_ptr, uint new_null_bit); + inline void move_field(my_ptrdiff_t ptr_diff) + { + Field::move_field(ptr_diff); + bit_ptr= ADD_TO_PTR(bit_ptr, ptr_diff, uchar*); + } void set_bit_ptr(uchar *bit_ptr_arg, uchar bit_ofs_arg) { bit_ptr= bit_ptr_arg; From 2697c7d5677a7e4c91aebce488305ea973bc1801 Mon Sep 17 00:00:00 2001 From: "Justin.He/justin.he@dev3-240.dev.cn.tlan" <> Date: Thu, 1 Mar 2007 15:13:33 +0800 Subject: [PATCH 09/73] correct NAND/NOR scan operations, and add a test case for it. --- ndb/src/ndbapi/NdbScanFilter.cpp | 46 +- ndb/test/include/NDBT_Test.hpp | 6 + ndb/test/ndbapi/Makefile.am | 2 + ndb/test/ndbapi/testScanFilter.cpp | 851 +++++++++++++++++++++++++++++ ndb/test/src/NDBT_Test.cpp | 57 ++ 5 files changed, 961 insertions(+), 1 deletion(-) create mode 100644 ndb/test/ndbapi/testScanFilter.cpp diff --git a/ndb/src/ndbapi/NdbScanFilter.cpp b/ndb/src/ndbapi/NdbScanFilter.cpp index 2e9e338d5aa..bec039b3eea 100644 --- a/ndb/src/ndbapi/NdbScanFilter.cpp +++ b/ndb/src/ndbapi/NdbScanFilter.cpp @@ -41,7 +41,9 @@ public: int m_label; State m_current; + Uint32 m_negative; //used for translating NAND/NOR to AND/OR, equal 0 or 1 Vector m_stack; + Vector m_stack2; //to store info of m_negative NdbOperation * m_operation; Uint32 m_latestAttrib; @@ -65,6 +67,7 @@ NdbScanFilter::NdbScanFilter(class NdbOperation * op) m_impl.m_label = 0; m_impl.m_latestAttrib = ~0; m_impl.m_operation = op; + m_impl.m_negative = 0; } NdbScanFilter::~NdbScanFilter(){ @@ -74,18 +77,39 @@ NdbScanFilter::~NdbScanFilter(){ int NdbScanFilter::begin(Group group){ + m_impl.m_stack2.push_back(m_impl.m_negative); switch(group){ case NdbScanFilter::AND: INT_DEBUG(("Begin(AND)")); + if(m_impl.m_negative == 1){ + group = NdbScanFilter::OR; + } break; case NdbScanFilter::OR: INT_DEBUG(("Begin(OR)")); + if(m_impl.m_negative == 1){ + group = NdbScanFilter::AND; + } break; case NdbScanFilter::NAND: INT_DEBUG(("Begin(NAND)")); + if(m_impl.m_negative == 0){ + group = NdbScanFilter::OR; + m_impl.m_negative = 1; + }else{ + group = NdbScanFilter::AND; + m_impl.m_negative = 0; + } break; case NdbScanFilter::NOR: INT_DEBUG(("Begin(NOR)")); + if(m_impl.m_negative == 0){ + group = NdbScanFilter::AND; + m_impl.m_negative = 1; + }else{ + group = NdbScanFilter::OR; + m_impl.m_negative = 0; + } break; } @@ -129,6 +153,13 @@ NdbScanFilter::begin(Group group){ int NdbScanFilter::end(){ + if(m_impl.m_stack2.size() == 0){ + m_impl.m_operation->setErrorCodeAbort(4259); + return -1; + } + m_impl.m_negative = m_impl.m_stack2.back(); + m_impl.m_stack2.erase(m_impl.m_stack2.size() - 1); + switch(m_impl.m_current.m_group){ case NdbScanFilter::AND: INT_DEBUG(("End(AND pc=%d)", m_impl.m_current.m_popCount)); @@ -150,6 +181,10 @@ NdbScanFilter::end(){ } NdbScanFilterImpl::State tmp = m_impl.m_current; + if(m_impl.m_stack.size() == 0){ + m_impl.m_operation->setErrorCodeAbort(4259); + return -1; + } m_impl.m_current = m_impl.m_stack.back(); m_impl.m_stack.erase(m_impl.m_stack.size() - 1); @@ -394,8 +429,17 @@ NdbScanFilterImpl::cond_col_const(Interpreter::BinaryCondition op, m_operation->setErrorCodeAbort(4260); return -1; } + + StrBranch2 branch; + if(m_negative == 1){ //change NdbOperation to its negative + if(m_current.m_group == NdbScanFilter::AND) + branch = table3[op].m_branches[(Uint32)(m_current.m_group) + 1]; + if(m_current.m_group == NdbScanFilter::OR) + branch = table3[op].m_branches[(Uint32)(m_current.m_group) - 1]; + }else{ + branch = table3[op].m_branches[(Uint32)(m_current.m_group)]; + } - StrBranch2 branch = table3[op].m_branches[m_current.m_group]; const NdbDictionary::Column * col = m_operation->m_currentTable->getColumn(AttrId); diff --git a/ndb/test/include/NDBT_Test.hpp b/ndb/test/include/NDBT_Test.hpp index c102c569933..e476a1a0759 100644 --- a/ndb/test/include/NDBT_Test.hpp +++ b/ndb/test/include/NDBT_Test.hpp @@ -325,6 +325,12 @@ public: // supply argc and argv as parameters int execute(int, const char**); + // NDBT's test tables are fixed and it always create + // and drop fixed table when execute, add this method + // in order to run CTX only and adapt to some new + // customized testsuite + int executeOneCtx(Ndb_cluster_connection&, + const NdbDictionary::Table* ptab, const char* testname = NULL); // These function can be used from main in the test program // to control the behaviour of the testsuite diff --git a/ndb/test/ndbapi/Makefile.am b/ndb/test/ndbapi/Makefile.am index 4766e6b83b3..9019d71ada2 100644 --- a/ndb/test/ndbapi/Makefile.am +++ b/ndb/test/ndbapi/Makefile.am @@ -39,6 +39,7 @@ testOperations \ testRestartGci \ testScan \ testInterpreter \ +testScanFilter \ testScanInterpreter \ testScanPerf \ testSystemRestart \ @@ -83,6 +84,7 @@ testOperations_SOURCES = testOperations.cpp testRestartGci_SOURCES = testRestartGci.cpp testScan_SOURCES = testScan.cpp ScanFunctions.hpp testInterpreter_SOURCES = testInterpreter.cpp +testScanFilter_SOURCES = testScanFilter.cpp testScanInterpreter_SOURCES = testScanInterpreter.cpp ScanFilter.hpp ScanInterpretTest.hpp testScanPerf_SOURCES = testScanPerf.cpp testSystemRestart_SOURCES = testSystemRestart.cpp diff --git a/ndb/test/ndbapi/testScanFilter.cpp b/ndb/test/ndbapi/testScanFilter.cpp new file mode 100644 index 00000000000..e195c04bd93 --- /dev/null +++ b/ndb/test/ndbapi/testScanFilter.cpp @@ -0,0 +1,851 @@ +/* Copyright (C) 2007, Justin He, MySQL AB + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include +#include + +#define ERR_EXIT(obj, msg) \ +do \ +{ \ +fprintf(stderr, "%s: %s (%d) in %s:%d\n", \ +msg, obj->getNdbError().message, obj->getNdbError().code, __FILE__, __LINE__); \ +exit(-1); \ +} \ +while (0); + +#define PRINT_ERROR(code,msg) \ +do \ +{ \ +fprintf(stderr, "Error in %s, line: %d, code: %d, msg: %s.\n", __FILE__, __LINE__, code, msg); \ +} \ +while (0); + +#define MYSQLERROR(mysql) { \ + PRINT_ERROR(mysql_errno(&mysql),mysql_error(&mysql)); \ + exit(-1); } +#define APIERROR(error) { \ + PRINT_ERROR(error.code,error.message); \ + exit(-1); } + +#define TEST_NAME "TestScanFilter" +#define TABLE_NAME "TABLE_SCAN" + +const char *COL_NAME[] = {"id", "i", "j", "k", "l", "m", "n"}; +const char COL_LEN = 7; +/* +* Not to change TUPLE_NUM, because the column in TABLE_NAME is fixed, +* there are six columns, 'i', 'j', 'k', 'l', 'm', 'n', and each on is equal to 1 or 1, +* Since each tuple should be unique in this case, then TUPLE_NUM = 2 power 6 = 64 +*/ +const int TUPLE_NUM = (int)pow(2, COL_LEN-1); + +/* +* the recursive level of random scan filter, can +* modify this parameter more or less, range from +* 1 to 100, larger num consumes more scan time +*/ +const int RECURSIVE_LEVEL = 10; + +const int MAX_STR_LEN = (RECURSIVE_LEVEL * (COL_LEN+1) * 4); + +/* +* Each time stands for one test, it will produce a random +* filter string, and scan through ndb api and through +* calculation with tuples' data, then compare the result, +* if they are equal, this test passed, or failed. +* Only all TEST_NUM times tests passed, we can believe +* the suite of test cases are okay. +* Change TEST_NUM to larger will need more time to test +*/ +const int TEST_NUM = 5000; + + +/* Table definition*/ +static +const +NDBT_Attribute MYTAB1Attribs[] = { + NDBT_Attribute("id", NdbDictionary::Column::Unsigned, 1, true), + NDBT_Attribute("i", NdbDictionary::Column::Unsigned), + NDBT_Attribute("j", NdbDictionary::Column::Unsigned), + NDBT_Attribute("k", NdbDictionary::Column::Unsigned), + NDBT_Attribute("l", NdbDictionary::Column::Unsigned), + NDBT_Attribute("m", NdbDictionary::Column::Unsigned), + NDBT_Attribute("n", NdbDictionary::Column::Unsigned), +}; +static +const +NDBT_Table MYTAB1(TABLE_NAME, sizeof(MYTAB1Attribs)/sizeof(NDBT_Attribute), MYTAB1Attribs); + + +int createTable(Ndb* pNdb, const NdbDictionary::Table* tab, bool _temp, + bool existsOk, NDBT_CreateTableHook f) +{ + int r = 0; + do{ + NdbDictionary::Table tmpTab(* tab); + tmpTab.setStoredTable(_temp ? 0 : 1); + if(f != 0 && f(pNdb, tmpTab, 0)) + { + ndbout << "Failed to create table" << endl; + return NDBT_FAILED; + } + r = pNdb->getDictionary()->createTable(tmpTab); + if(r == -1){ + if(!existsOk){ + ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl; + break; + } + if(pNdb->getDictionary()->getNdbError().code != 721){ + ndbout << "Error: " << pNdb->getDictionary()->getNdbError() << endl; + break; + } + r = 0; + } + }while(false); + + return r; +} + +/* +* Function to produce the tuples' data +*/ +int runPopulate(NDBT_Context* ctx, NDBT_Step* step) +{ + Ndb *myNdb = GETNDB(step); + const NdbDictionary::Dictionary* myDict= myNdb->getDictionary(); + const NdbDictionary::Table *myTable= myDict->getTable(TABLE_NAME); + if(myTable == NULL) + APIERROR(myDict->getNdbError()); + + NdbTransaction* myTrans = myNdb->startTransaction(); + if (myTrans == NULL) + APIERROR(myNdb->getNdbError()); + + for(int num = 0; num < TUPLE_NUM; num++) + { + NdbOperation* myNdbOperation = myTrans->getNdbOperation(myTable); + if(myNdbOperation == NULL) + { + APIERROR(myTrans->getNdbError()); + } + +/* the tuples' data in TABLE_NAME ++----+---+---+---+---+---+---+ +| id | i | j | k | l | m | n | ++----+---+---+---+---+---+---+ +| 0 | 0 | 0 | 0 | 0 | 0 | 0 | +| 1 | 0 | 0 | 0 | 0 | 0 | 1 | +| 2 | 0 | 0 | 0 | 0 | 1 | 0 | +| 3 | 0 | 0 | 0 | 0 | 1 | 1 | +| 4 | 0 | 0 | 0 | 1 | 0 | 0 | +| 5 | 0 | 0 | 0 | 1 | 0 | 1 | +| 6 | 0 | 0 | 0 | 1 | 1 | 0 | +| 7 | 0 | 0 | 0 | 1 | 1 | 1 | +| 8 | 0 | 0 | 1 | 0 | 0 | 0 | +| 9 | 0 | 0 | 1 | 0 | 0 | 1 | +| 10 | 0 | 0 | 1 | 0 | 1 | 0 | +| 11 | 0 | 0 | 1 | 0 | 1 | 1 | +| 12 | 0 | 0 | 1 | 1 | 0 | 0 | +| 13 | 0 | 0 | 1 | 1 | 0 | 1 | +| 14 | 0 | 0 | 1 | 1 | 1 | 0 | +| 15 | 0 | 0 | 1 | 1 | 1 | 1 | +| 16 | 0 | 1 | 0 | 0 | 0 | 0 | +| 17 | 0 | 1 | 0 | 0 | 0 | 1 | +| 18 | 0 | 1 | 0 | 0 | 1 | 0 | +| 19 | 0 | 1 | 0 | 0 | 1 | 1 | +| 20 | 0 | 1 | 0 | 1 | 0 | 0 | +| 21 | 0 | 1 | 0 | 1 | 0 | 1 | +| 22 | 0 | 1 | 0 | 1 | 1 | 0 | +| 23 | 0 | 1 | 0 | 1 | 1 | 1 | +| 24 | 0 | 1 | 1 | 0 | 0 | 0 | +| 25 | 0 | 1 | 1 | 0 | 0 | 1 | +| 26 | 0 | 1 | 1 | 0 | 1 | 0 | +| 27 | 0 | 1 | 1 | 0 | 1 | 1 | +| 28 | 0 | 1 | 1 | 1 | 0 | 0 | +| 29 | 0 | 1 | 1 | 1 | 0 | 1 | +| 30 | 0 | 1 | 1 | 1 | 1 | 0 | +| 31 | 0 | 1 | 1 | 1 | 1 | 1 | +| 32 | 1 | 0 | 0 | 0 | 0 | 0 | +| 33 | 1 | 0 | 0 | 0 | 0 | 1 | +| 34 | 1 | 0 | 0 | 0 | 1 | 0 | +| 35 | 1 | 0 | 0 | 0 | 1 | 1 | +| 36 | 1 | 0 | 0 | 1 | 0 | 0 | +| 37 | 1 | 0 | 0 | 1 | 0 | 1 | +| 38 | 1 | 0 | 0 | 1 | 1 | 0 | +| 39 | 1 | 0 | 0 | 1 | 1 | 1 | +| 40 | 1 | 0 | 1 | 0 | 0 | 0 | +| 41 | 1 | 0 | 1 | 0 | 0 | 1 | +| 42 | 1 | 0 | 1 | 0 | 1 | 0 | +| 43 | 1 | 0 | 1 | 0 | 1 | 1 | +| 44 | 1 | 0 | 1 | 1 | 0 | 0 | +| 45 | 1 | 0 | 1 | 1 | 0 | 1 | +| 46 | 1 | 0 | 1 | 1 | 1 | 0 | +| 47 | 1 | 0 | 1 | 1 | 1 | 1 | +| 48 | 1 | 1 | 0 | 0 | 0 | 0 | +| 49 | 1 | 1 | 0 | 0 | 0 | 1 | +| 50 | 1 | 1 | 0 | 0 | 1 | 0 | +| 51 | 1 | 1 | 0 | 0 | 1 | 1 | +| 52 | 1 | 1 | 0 | 1 | 0 | 0 | +| 53 | 1 | 1 | 0 | 1 | 0 | 1 | +| 54 | 1 | 1 | 0 | 1 | 1 | 0 | +| 55 | 1 | 1 | 0 | 1 | 1 | 1 | +| 56 | 1 | 1 | 1 | 0 | 0 | 0 | +| 57 | 1 | 1 | 1 | 0 | 0 | 1 | +| 58 | 1 | 1 | 1 | 0 | 1 | 0 | +| 59 | 1 | 1 | 1 | 0 | 1 | 1 | +| 60 | 1 | 1 | 1 | 1 | 0 | 0 | +| 61 | 1 | 1 | 1 | 1 | 0 | 1 | +| 62 | 1 | 1 | 1 | 1 | 1 | 0 | +| 63 | 1 | 1 | 1 | 1 | 1 | 1 | ++----+---+---+---+---+---+---+ +*/ + myNdbOperation->insertTuple(); + myNdbOperation->equal(COL_NAME[0], num); + for(int col = 1; col < COL_LEN; col++) + { + myNdbOperation->setValue(COL_NAME[col], (num>>(COL_LEN-1-col))&1); + } + } + + int check = myTrans->execute(NdbTransaction::Commit); + + myTrans->close(); + + if (check == -1) + return NDBT_FAILED; + else + return NDBT_OK; + +} + + + +/* +* a=AND, o=OR, A=NAND, O=NOR +*/ +char op_string[] = "aoAO"; +/* +* the six columns' name of test table +*/ +char col_string[] = "ijklmn"; +const int op_len = strlen(op_string); +const int col_len = strlen(col_string); + +/* +* get a random op from "aoAO" +*/ +int get_rand_op_ch(char *ch) +{ + static unsigned int num = 0; + if(++num == 0) + num = 1; + srand(num*time(NULL)); + *ch = op_string[rand() % op_len]; + return 1; +} + +/* +* get a random order form of "ijklmn" trough exchanging letter +*/ +void change_col_order() +{ + int pos1,pos2; + char temp; + for (int i = 0; i < 10; i++) //exchange for 10 times + { + srand(time(NULL)/(i+1)); + pos1 = rand() % col_len; + srand((i+1)*time(NULL)); + pos2 = rand() % col_len; + if (pos1 == pos2) + continue; + temp = col_string[pos1]; + col_string[pos1] = col_string[pos2]; + col_string[pos2] = temp; + } +} + +/* +* get a random sub string of "ijklmn" +*/ +int get_rand_col_str(char *str) +{ + int len; + static unsigned int num = 0; + if(++num == 0) + num = 1; + srand(num*time(NULL)); + len = rand() % col_len + 1; + change_col_order(); + snprintf(str, len+1, "%s", col_string); //len+1, including '\0' + return len; +} + +/* +* get a random string including operation and column +* eg, Alnikx +*/ +int get_rand_op_str(char *str) +{ + char temp[256]; + int len1, len2, len; + len1 = get_rand_op_ch(temp); + len2 = get_rand_col_str(temp+len1); + len = len1 + len2; + temp[len] = 'x'; + snprintf(str, len+1+1, "%s", temp); //len+1, including '\0' + return len+1; +} + +/* +* replace a letter of source string with a new string +* e.g., source string: 'Aijkx', replace i with new string 'olmx' +* then source string is changed to 'Aolmxjkx' +* source: its format should be produced from get_rand_op_str() +* pos: range from 1 to strlen(source)-2 +*/ +int replace_a_to_str(char *source, int pos, char *newstr) +{ + char temp[MAX_STR_LEN]; + snprintf(temp, pos+1, "%s", source); + snprintf(temp+pos, strlen(newstr)+1, "%s", newstr); + snprintf(temp+pos+strlen(newstr), strlen(source)-pos, "%s", source+pos+1); + snprintf(source, strlen(temp)+1, "%s", temp); + return strlen(source); +} + +/* +* check whether the inputed char is an operation +*/ +bool check_op(char ch) +{ + if( ch == 'a' || ch == 'A' || ch == 'o' || ch == 'O') + return true; + else + return false; +} + +/* +* check whether the inputed char is end flag +*/ +bool check_end(char ch) +{ + return (ch == 'x'); +} + +/* +* check whether the inputed char is end flag +*/ +bool check_col(char ch) +{ + if( ch == 'i' || ch == 'j' || ch == 'k' + || ch == 'l' || ch == 'm' || ch == 'n' ) + return true; + else + return false; +} + +/* +* To ensure we can get a random string with RECURSIVE_LEVEL, +* we need a position where can replace a letter with a new string. +*/ +int get_rand_replace_pos(char *str, int len) +{ + int pos_op = 0; + int pos_x = 0; + int pos_col = 0; + int span = 0; + static int num = 0; + char temp; + + for(int i = 0; i < len; i++) + { + temp = str[i]; + if(! check_end(temp)) + { + if(check_op(temp)) + pos_op = i; + } + else + { + pos_x = i; + break; + } + } + + if(++num == 0) + num = 1; + + span = pos_x - pos_op - 1; + if(span <= 1) + { + pos_col = pos_op + 1; + } + else + { + srand(num*time(NULL)); + pos_col = pos_op + rand() % span + 1; + } + return pos_col; +} + +/* +* Check whether the given random string is valid +* and applicable for this test case +*/ +bool check_random_str(char *str) +{ + char *p; + int op_num = 0; + int end_num = 0; + + for(p = str; *p; p++) + { + bool tmp1 = false, tmp2 = false; + if(tmp1 = check_op(*p)) + op_num++; + if(tmp2 = check_end(*p)) + end_num++; + if(!(tmp1 || tmp2 || check_col(*p))) //there are illegal letters + return false; + } + + if(op_num != end_num) //begins are not equal to ends + return false; + + return true; +} + +/* +* Get a random string with RECURSIVE_LEVEL +*/ +void get_rand_op_str_compound(char *str) +{ + char small_str[256]; + int pos; + int tmp; + int level; + static int num = 0; + + if(++num == 0) + num = 1; + + srand(num*time(NULL)); + level = 1 + rand() % RECURSIVE_LEVEL; + + get_rand_op_str(str); + + for(int i = 0; i < level; i++) + { + get_rand_op_str(small_str); + tmp = strlen(small_str); + get_rand_op_str(small_str + tmp); //get two operations + pos = get_rand_replace_pos(str, strlen(str)); + replace_a_to_str(str, pos, small_str); + } + + //check the random string + if(!check_random_str(str)) + { + fprintf(stderr, "Error random string! \n"); + exit(-1); + } +} + +/* +* get column id of i,j,k,l,m,n +*/ +int get_column_id(char ch) +{ + return (ch - 'i' + 1); //from 1 to 6 +} + +/* +* check whether column value of the NO. tuple is equal to 1 +* col_id: column id, range from 1 to 6 +* tuple_no: record NO., range from 0 to 63 +*/ +bool check_col_equal_one(int tuple_no, int col_id) +{ + int i = (int)pow(2, 6 - col_id); + int j = tuple_no / i; + if(j % 2) + return true; + else + return false; +} + +/* +* get a result after all elements in the array with AND +* value: pointer to a bool array +* len: length of the bool array +*/ +bool AND_op(bool *value, int len) +{ + for(int i = 0; i < len; i++) + { + if(! value[i]) + return false; + } + return true; +} + +/* +* get a result after all elements in the array with OR +* value: pointer to a bool array +* len: length of the bool array +*/ +bool OR_op(bool *value, int len) +{ + for(int i = 0; i < len; i++) + { + if(value[i]) + return true; + } + return false; +} + +/* +* get a result after all elements in the array with NAND +* value: pointer to a bool array +* len: length of the bool array +*/ +bool NAND_op(bool *value, int len) +{ + return (! AND_op(value, len)); +} + +/* +* get a result after all elements in the array with NOR +* value: pointer to a bool array +* len: length of the bool array +*/ +bool NOR_op(bool *value, int len) +{ + return (! OR_op(value, len)); +} + +/* +* AND/NAND/OR/NOR operation for a bool array +*/ +bool calculate_one_op(char op_type, bool *value, int len) +{ + switch(op_type) + { + case 'a': + return AND_op(value, len); + break; + case 'o': + return OR_op(value, len); + break; + case 'A': + return NAND_op(value, len); + break; + case 'O': + return NOR_op(value, len); + break; + } + return false; //make gcc happy +} + +typedef struct _stack_element +{ + char type; + int num; +}stack_element; + +/* +* stack_op, store info for AND,OR,NAND,NOR +* stack_col, store value of column(i,j,k,l,m,n) and temporary result for an operation +*/ +stack_element stack_op[RECURSIVE_LEVEL * COL_LEN]; +bool stack_col[RECURSIVE_LEVEL * COL_LEN * 2]; + +/* +* check whether the given tuple is chosen by judgement condition +* tuple_no, the NO of tuple in TABLE_NAME, range from 0 to TUPLE_NUM +* str: a random string of scan opearation and condition +* len: length of str +*/ +bool check_one_tuple(int tuple_no, char *str, int len) +{ + int pop_op = 0; + int pop_col = 0; + for(int i = 0; i < len; i++) + { + char letter = *(str + i); + if(check_op(letter)) //push + { + stack_op[pop_op].type = letter; + stack_op[pop_op].num = 0; + pop_op++; + } + if(check_col(letter)) //push + { + stack_col[pop_col] = check_col_equal_one(tuple_no, get_column_id(letter)); + pop_col++; + stack_op[pop_op-1].num += 1; + } + if(check_end(letter)) + { + if(pop_op <= 1) + { + return calculate_one_op(stack_op[pop_op-1].type, + stack_col, + stack_op[pop_op-1].num); + } + else + { + bool tmp1 = calculate_one_op(stack_op[pop_op-1].type, + stack_col + pop_col - stack_op[pop_op-1].num, + stack_op[pop_op-1].num); + pop_col -= stack_op[pop_op-1].num; //pop + pop_op--; + stack_col[pop_col] = tmp1; //push + pop_col++; + stack_op[pop_op-1].num += 1; + } + } + } + return false; //make gcc happy +} + +/* +* get lists of tuples which match the scan condiction through calculating +* str: a random string of scan opearation and condition +*/ +void check_all_tuples(char *str, bool *res) +{ + for (int i = 0; i < TUPLE_NUM; i++) + { + if(check_one_tuple(i, str, strlen(str))) + res[i] = true; + } +} + +/* +* convert a letter to group number what ndbapi need +*/ +NdbScanFilter::Group get_api_group(char op_name) +{ + switch (op_name) { + case 'a': return NdbScanFilter::AND; + case 'o': return NdbScanFilter::OR; + case 'A': return NdbScanFilter::NAND; + case 'O': return NdbScanFilter::NOR; + default: + fprintf(stderr, "Invalid group name %c !\n", op_name); + exit(3); + } +} + +/* +* with ndbapi, call begin, eq/ne/lt/gt/le/ge..., end +*/ +NdbScanFilter * call_ndbapi(char *str, NdbTransaction *transaction, + NdbScanOperation *scan, NdbDictionary::Column const *col[]) +{ + NdbScanFilter *scanfilter = new NdbScanFilter(scan); + char *p; + + for (p = str; *p; p++) + { + if(check_op(*p)) + { + if(scanfilter->begin(get_api_group(*p))) + ERR_EXIT(transaction, "filter begin() failed"); + } + if(check_col(*p)) + { + if(scanfilter->eq(col[*p-'i'+1]->getColumnNo(), (Uint32)1)) + ERR_EXIT(transaction, "filter eq() failed"); + } + if(check_end(*p)) + { + if(scanfilter->end()) + ERR_EXIT(transaction, "filter end() failed"); + } + } + + return scanfilter; +} + +/* +* get the tuples through ndbapi, and save the tuples NO. +* str: a random string of scan opearation and condition +*/ +void ndbapi_tuples(Ndb *ndb, char *str, bool *res) +{ + const NdbDictionary::Dictionary *dict = ndb->getDictionary(); + if (!dict) + ERR_EXIT(ndb, "Can't get dict"); + + const NdbDictionary::Table *table = dict->getTable(TABLE_NAME); + if (!table) + ERR_EXIT(dict, "Can't get table"TABLE_NAME); + + const NdbDictionary::Column *col[COL_LEN]; + for(int i = 0; i < COL_LEN; i++) + { + char tmp[128]; + col[i] = table->getColumn(COL_NAME[i]); + if(!col[i]) + { + snprintf(tmp, 128, "Can't get column %s", COL_NAME[i]); + ERR_EXIT(dict, tmp); + } + } + + NdbTransaction *transaction; + NdbScanOperation *scan; + NdbScanFilter *filter; + + transaction = ndb->startTransaction(); + if (!transaction) + ERR_EXIT(ndb, "Can't start transaction"); + + scan = transaction->getNdbScanOperation(table); + if (!scan) + ERR_EXIT(transaction, "Can't get scan op"); + + if (scan->readTuples(NdbOperation::LM_Exclusive)) + ERR_EXIT(scan, "Can't set up read"); + + NdbRecAttr *rec[COL_LEN]; + for(int i = 0; i < COL_LEN; i++) + { + char tmp[128]; + rec[i] = scan->getValue(COL_NAME[i]); + if(!rec[i]) + { + snprintf(tmp, 128, "Can't get rec of %s", COL_NAME[i]); + ERR_EXIT(scan, tmp); + } + } + + filter = call_ndbapi(str, transaction, scan, col); + + if (transaction->execute(NdbTransaction::NoCommit)) + ERR_EXIT(transaction, "Can't execute"); + + int i,j,k,l,m,n; + while (scan->nextResult(true) == 0) + { + do + { + i = rec[1]->u_32_value(); + j = rec[2]->u_32_value(); + k = rec[3]->u_32_value(); + l = rec[4]->u_32_value(); + m = rec[5]->u_32_value(); + n = rec[6]->u_32_value(); + res[32*i+16*j+8*k+4*l+2*m+n] = true; + } while (scan->nextResult(false) == 0); + } + + delete filter; + transaction->close(); +} + +/* +* compare the result between calculation and NDBAPI +* str: a random string of scan opearation and condition +* return: true stands for ndbapi ok, false stands for ndbapi failed +*/ +bool compare_cal_ndb(char *str, Ndb *ndb) +{ + bool res_cal[TUPLE_NUM], res_ndb[TUPLE_NUM]; + + for(int i = 0; i < TUPLE_NUM; i++) + { + res_cal[i] = false; + res_ndb[i] = false; + } + + check_all_tuples(str, res_cal); + ndbapi_tuples(ndb, str, res_ndb); + + for(int i = 0; i < TUPLE_NUM; i++) + { + if(res_cal[i] != res_ndb[i]) + return false; + } + return true; +} + + +int runCreateTables(NDBT_Context* ctx, NDBT_Step* step) +{ + Ndb *pNdb = GETNDB(step); + pNdb->getDictionary()->dropTable(MYTAB1.getName()); + int ret = createTable(pNdb, &MYTAB1, false, true, 0); + if(ret) + return ret; + return NDBT_OK; +} + + +int runDropTables(NDBT_Context* ctx, NDBT_Step* step) +{ + int ret = GETNDB(step)->getDictionary()->dropTable(MYTAB1.getName()); + if(ret == -1) + return NDBT_FAILED; + + return NDBT_OK; +} + +int runScanRandomFilterTest(NDBT_Context* ctx, NDBT_Step* step) +{ + char random_str[MAX_STR_LEN]; + Ndb *myNdb = GETNDB(step); + bool res = true; + + for(int i = 0; i < TEST_NUM; i++) + { + get_rand_op_str_compound(random_str); + if( !compare_cal_ndb(random_str, myNdb)) + return NDBT_FAILED; + } + + return NDBT_OK; +} + +NDBT_TESTSUITE(testScanFilter); +TESTCASE(TEST_NAME, + "Scan table TABLE_NAME for the records which accord with \ + conditions of logical scan operations: AND/OR/NAND/NOR") +{ + INITIALIZER(runCreateTables); + INITIALIZER(runPopulate); + INITIALIZER(runScanRandomFilterTest); + FINALIZER(runDropTables); +} + +NDBT_TESTSUITE_END(testScanFilter); + + +int main(int argc, const char** argv) +{ + ndb_init(); + + Ndb_cluster_connection con; + if(con.connect(12, 5, 1)) + { + return NDBT_ProgramExit(NDBT_FAILED); + } + + return testScanFilter.executeOneCtx(con, &MYTAB1, TEST_NAME); +} diff --git a/ndb/test/src/NDBT_Test.cpp b/ndb/test/src/NDBT_Test.cpp index 37100732eca..391af3e5d95 100644 --- a/ndb/test/src/NDBT_Test.cpp +++ b/ndb/test/src/NDBT_Test.cpp @@ -817,6 +817,63 @@ NDBT_TestSuite::executeOne(Ndb_cluster_connection& con, } } +int +NDBT_TestSuite::executeOneCtx(Ndb_cluster_connection& con, + const NdbDictionary::Table *ptab, const char* _testname){ + + testSuiteTimer.doStart(); + + do{ + if(tests.size() == 0) + break; + + Ndb ndb(&con, "TEST_DB"); + ndb.init(1024); + + int result = ndb.waitUntilReady(300); // 5 minutes + if (result != 0){ + g_err << name <<": Ndb was not ready" << endl; + break; + } + + ndbout << name << " started [" << getDate() << "]" << endl; + ndbout << "|- " << ptab->getName() << endl; + + for (unsigned t = 0; t < tests.size(); t++){ + + if (_testname != NULL && + strcasecmp(tests[t]->getName(), _testname) != 0) + continue; + + tests[t]->initBeforeTest(); + + ctx = new NDBT_Context(con); + ctx->setTab(ptab); + ctx->setNumRecords(records); + ctx->setNumLoops(loops); + if(remote_mgm != NULL) + ctx->setRemoteMgm(remote_mgm); + ctx->setSuite(this); + + result = tests[t]->execute(ctx); + if (result != NDBT_OK) + numTestsFail++; + else + numTestsOk++; + numTestsExecuted++; + + delete ctx; + } + + if (numTestsFail > 0) + break; + }while(0); + + testSuiteTimer.doStop(); + int res = report(_testname); + return NDBT_ProgramExit(res); +} + void NDBT_TestSuite::execute(Ndb_cluster_connection& con, Ndb* ndb, const NdbDictionary::Table* pTab, const char* _testname){ From 360b063d3f9af7e8a7026a89611b801cca9975f3 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@magare.gmz" <> Date: Thu, 1 Mar 2007 15:28:10 +0200 Subject: [PATCH 10/73] Correctly recognize Intel Core2Duo Extreme in build. --- BUILD/check-cpu | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/BUILD/check-cpu b/BUILD/check-cpu index 55f4e62327b..3fded0a680f 100755 --- a/BUILD/check-cpu +++ b/BUILD/check-cpu @@ -114,6 +114,10 @@ check_cpu () { *i386*i486*) cpu_arg="pentium-m"; ;; + #Core 2 Duo + *Intel*Core\(TM\)2*) + cpu_arg="nocona"; + ;; # Intel ia64 *Itanium*) From 11588e5e4a64f01485fce6d5b566d47ef7d6b824 Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Fri, 2 Mar 2007 00:09:22 +0300 Subject: [PATCH 11/73] Bug#25122: Views based on a self-joined table aren't insertable. When INSERT is done over a view the table being inserted into is checked to be unique among all views tables. But if the view contains self-joined table an error will be thrown even if all tables are used under different aliases. The unique_table() function now also checks tables' aliases when needed. --- sql/mysql_priv.h | 3 ++- sql/sql_base.cc | 9 +++++++-- sql/sql_delete.cc | 4 ++-- sql/sql_insert.cc | 4 ++-- sql/sql_load.cc | 2 +- sql/sql_parse.cc | 4 ++-- sql/sql_update.cc | 6 +++--- 7 files changed, 19 insertions(+), 13 deletions(-) diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 0948487869a..d2f4938c07c 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -1064,7 +1064,8 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table, st_table_list *TABLE_LIST::*link, const char *db_name, const char *table_name); -TABLE_LIST *unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list); +TABLE_LIST *unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list, + bool check_alias); TABLE **find_temporary_table(THD *thd, const char *db, const char *table_name); bool close_temporary_table(THD *thd, const char *db, const char *table_name); void close_temporary(TABLE *table, bool delete_table); diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 239c787eca5..ea937be4e70 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -796,6 +796,7 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table, thd thread handle table table which should be checked table_list list of tables + check_alias whether to check tables' aliases NOTE: to exclude derived tables from check we use following mechanism: a) during derived table processing set THD::derived_tables_processing @@ -823,10 +824,11 @@ TABLE_LIST *find_table_in_list(TABLE_LIST *table, 0 if table is unique */ -TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list) +TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list, + bool check_alias) { TABLE_LIST *res; - const char *d_name, *t_name; + const char *d_name, *t_name, *t_alias; DBUG_ENTER("unique_table"); DBUG_PRINT("enter", ("table alias: %s", table->alias)); @@ -854,6 +856,7 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list) } d_name= table->db; t_name= table->table_name; + t_alias= table->alias; DBUG_PRINT("info", ("real table: %s.%s", d_name, t_name)); for (;;) @@ -861,6 +864,8 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list) if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) && (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) || ((!res->table || res->table != table->table) && + (!check_alias || !(lower_case_table_names ? + strcasecmp(t_alias, res->alias) : strcmp(t_alias, res->alias))) && res->select_lex && !res->select_lex->exclude_from_table_unique_test && !res->prelocking_placeholder)) break; diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc index 94d753eb703..7771a10966d 100644 --- a/sql/sql_delete.cc +++ b/sql/sql_delete.cc @@ -370,7 +370,7 @@ bool mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds) } { TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, table_list, table_list->next_global))) + if ((duplicate= unique_table(thd, table_list, table_list->next_global, 0))) { update_non_unique_table_error(table_list, "DELETE", duplicate); DBUG_RETURN(TRUE); @@ -462,7 +462,7 @@ bool mysql_multi_delete_prepare(THD *thd) { TABLE_LIST *duplicate; if ((duplicate= unique_table(thd, target_tbl->correspondent_table, - lex->query_tables))) + lex->query_tables, 0))) { update_non_unique_table_error(target_tbl->correspondent_table, "DELETE", duplicate); diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc index 332c4c82ba1..55c9d2e6882 100644 --- a/sql/sql_insert.cc +++ b/sql/sql_insert.cc @@ -1044,7 +1044,7 @@ bool mysql_prepare_insert(THD *thd, TABLE_LIST *table_list, { Item *fake_conds= 0; TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, table_list, table_list->next_global))) + if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1))) { update_non_unique_table_error(table_list, "INSERT", duplicate); DBUG_RETURN(TRUE); @@ -2424,7 +2424,7 @@ select_insert::prepare(List &values, SELECT_LEX_UNIT *u) query */ if (!(lex->current_select->options & OPTION_BUFFER_RESULT) && - unique_table(thd, table_list, table_list->next_global)) + unique_table(thd, table_list, table_list->next_global, 0)) { /* Using same table for INSERT and SELECT */ lex->current_select->options|= OPTION_BUFFER_RESULT; diff --git a/sql/sql_load.cc b/sql/sql_load.cc index 0e4057d9ae4..cb156cc51f0 100644 --- a/sql/sql_load.cc +++ b/sql/sql_load.cc @@ -175,7 +175,7 @@ bool mysql_load(THD *thd,sql_exchange *ex,TABLE_LIST *table_list, table is marked to be 'used for insert' in which case we should never mark this table as as 'const table' (ie, one that has only one row). */ - if (unique_table(thd, table_list, table_list->next_global)) + if (unique_table(thd, table_list, table_list->next_global, 0)) { my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name); DBUG_RETURN(TRUE); diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index affa6e130dc..fbe000ac78e 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -2993,7 +2993,7 @@ mysql_execute_command(THD *thd) if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE)) { TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, create_table, select_tables))) + if ((duplicate= unique_table(thd, create_table, select_tables, 0))) { update_non_unique_table_error(create_table, "CREATE", duplicate); res= 1; @@ -3009,7 +3009,7 @@ mysql_execute_command(THD *thd) tab= tab->next_local) { TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, tab, select_tables))) + if ((duplicate= unique_table(thd, tab, select_tables, 0))) { update_non_unique_table_error(tab, "CREATE", duplicate); res= 1; diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 1db77f8704c..b20e3689f64 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -636,7 +636,7 @@ bool mysql_prepare_update(THD *thd, TABLE_LIST *table_list, /* Check that we are not using table that we are updating in a sub select */ { TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, table_list, table_list->next_global))) + if ((duplicate= unique_table(thd, table_list, table_list->next_global, 0))) { update_non_unique_table_error(table_list, "UPDATE", duplicate); my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->table_name); @@ -863,7 +863,7 @@ reopen_tables: tl->lock_type != TL_READ_NO_INSERT) { TABLE_LIST *duplicate; - if ((duplicate= unique_table(thd, tl, table_list))) + if ((duplicate= unique_table(thd, tl, table_list, 0))) { update_non_unique_table_error(table_list, "UPDATE", duplicate); DBUG_RETURN(TRUE); @@ -1082,7 +1082,7 @@ static bool safe_update_on_fly(THD *thd, JOIN_TAB *join_tab, List *fields) { TABLE *table= join_tab->table; - if (unique_table(thd, table_ref, all_tables)) + if (unique_table(thd, table_ref, all_tables, 0)) return 0; switch (join_tab->type) { case JT_SYSTEM: From e1a90408dbef25c186e2e602dcdb960fccc7a477 Mon Sep 17 00:00:00 2001 From: "Justin.He/justin.he@dev3-240.dev.cn.tlan" <> Date: Fri, 2 Mar 2007 09:41:47 +0800 Subject: [PATCH 12/73] bug#24568, NdbScanFilter NAND/NOR operations sometimes do not work as expected, add a new file in 5.0 and rename it in 5.1 because the directory of ndb is changed from 5.0 to 5.1 --- {ndb => storage/ndb}/test/ndbapi/testScanFilter.cpp | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {ndb => storage/ndb}/test/ndbapi/testScanFilter.cpp (100%) diff --git a/ndb/test/ndbapi/testScanFilter.cpp b/storage/ndb/test/ndbapi/testScanFilter.cpp similarity index 100% rename from ndb/test/ndbapi/testScanFilter.cpp rename to storage/ndb/test/ndbapi/testScanFilter.cpp From 2248cd3d3e57fd6ad6e7037826cb32c5af933e00 Mon Sep 17 00:00:00 2001 From: "Justin.He/justin.he@dev3-240.dev.cn.tlan" <> Date: Fri, 2 Mar 2007 11:03:16 +0800 Subject: [PATCH 13/73] bug#24568, NdbScanFilter NAND/NOR operations sometimes do not work as expected when merge from 5.0 to 5.1, update a function call in testScanFilter.cpp beacuase the function's definition is changed from 5.0 to 5.1 --- storage/ndb/test/ndbapi/testScanFilter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/storage/ndb/test/ndbapi/testScanFilter.cpp b/storage/ndb/test/ndbapi/testScanFilter.cpp index e195c04bd93..ba869dc8ce4 100644 --- a/storage/ndb/test/ndbapi/testScanFilter.cpp +++ b/storage/ndb/test/ndbapi/testScanFilter.cpp @@ -97,7 +97,7 @@ int createTable(Ndb* pNdb, const NdbDictionary::Table* tab, bool _temp, do{ NdbDictionary::Table tmpTab(* tab); tmpTab.setStoredTable(_temp ? 0 : 1); - if(f != 0 && f(pNdb, tmpTab, 0)) + if(f != 0 && f(pNdb, tmpTab, 0, NULL)) { ndbout << "Failed to create table" << endl; return NDBT_FAILED; From 4a6efcd664791457ee2793e1d6286705bebcee86 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@magare.gmz" <> Date: Fri, 2 Mar 2007 12:14:50 +0200 Subject: [PATCH 14/73] Bug #26537: item_unhex() was not expected to return NULL for non-NULL arguments. This is not the case as it can return NULL for invalid hexidecimal strings. Fixed by setting the maybe_null flag. --- mysql-test/r/func_str.result | 6 ++++++ mysql-test/t/func_str.test | 6 ++++++ sql/item_strfunc.h | 6 +++++- 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result index 052451f8c54..d09d3aeb529 100644 --- a/mysql-test/r/func_str.result +++ b/mysql-test/r/func_str.result @@ -1940,4 +1940,10 @@ abcxx select lpad('abc', cast(5 as unsigned integer), 'x'); lpad('abc', cast(5 as unsigned integer), 'x') xxabc +SELECT UNHEX('G'); +UNHEX('G') +NULL +SELECT UNHEX('G') IS NULL; +UNHEX('G') IS NULL +1 End of 5.0 tests diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test index 64b59025d44..2e76dc2ca31 100644 --- a/mysql-test/t/func_str.test +++ b/mysql-test/t/func_str.test @@ -1008,4 +1008,10 @@ select repeat('a', cast(2 as unsigned int)); select rpad('abc', cast(5 as unsigned integer), 'x'); select lpad('abc', cast(5 as unsigned integer), 'x'); +# +# Bug #26537: UNHEX() IS NULL comparison fails +# +SELECT UNHEX('G'); +SELECT UNHEX('G') IS NULL; + --echo End of 5.0 tests diff --git a/sql/item_strfunc.h b/sql/item_strfunc.h index 60547d00a5c..778ea6e9496 100644 --- a/sql/item_strfunc.h +++ b/sql/item_strfunc.h @@ -605,7 +605,11 @@ class Item_func_unhex :public Item_str_func { String tmp_value; public: - Item_func_unhex(Item *a) :Item_str_func(a) {} + Item_func_unhex(Item *a) :Item_str_func(a) + { + /* there can be bad hex strings */ + maybe_null= 1; + } const char *func_name() const { return "unhex"; } String *val_str(String *); void fix_length_and_dec() From 629aa8071dca494ea0c4c98d40340d2712934237 Mon Sep 17 00:00:00 2001 From: "evgen@sunlight.local" <> Date: Fri, 2 Mar 2007 13:25:41 +0300 Subject: [PATCH 15/73] sql_base.cc: Post fix for bug#25122. --- sql/sql_base.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 86cb9f77703..9945057cd1b 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -865,7 +865,8 @@ TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list, (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) || ((!res->table || res->table != table->table) && (!check_alias || !(lower_case_table_names ? - strcasecmp(t_alias, res->alias) : strcmp(t_alias, res->alias))) && + my_strcasecmp(files_charset_info, t_alias, res->alias) : + strcmp(t_alias, res->alias))) && res->select_lex && !res->select_lex->exclude_from_table_unique_test && !res->prelocking_placeholder)) break; From be75593165afccdc4dc829b8de5add5f0477b1f3 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@macbook.gmz" <> Date: Fri, 2 Mar 2007 16:25:56 +0200 Subject: [PATCH 16/73] Bug #19342: Several problems here : 1. The conversion to double of an hex string const item was not taking into account the unsigned flag. 2. IN was not behaving in the same was way as comparisons when performed over an INT/DATE/DATETIME/TIMESTAMP column and a constant. The ordinary comparisons in that case convert the constant to an INTEGER value and do int comparisons. Fixed the IN to do the same. 3. IN is not taking into account the unsigned flag when calculating IN (, , ...). Extended the implementation of IN to store and process the unsigned flag for its arguments. --- mysql-test/r/func_in.result | 66 ++++++++++++++++++ mysql-test/t/func_in.test | 58 ++++++++++++++++ sql/item.h | 5 +- sql/item_cmpfunc.cc | 130 ++++++++++++++++++++++++++++++++++-- sql/item_cmpfunc.h | 17 ++++- 5 files changed, 268 insertions(+), 8 deletions(-) diff --git a/mysql-test/r/func_in.result b/mysql-test/r/func_in.result index d9ca9e80e44..36bcc6f1711 100644 --- a/mysql-test/r/func_in.result +++ b/mysql-test/r/func_in.result @@ -398,4 +398,70 @@ WHERE t3.a=t1.a AND t3.a=t2.a; 3 3 DROP TABLE t1,t2,t3,t4; +CREATE TABLE t1(a BIGINT UNSIGNED); +INSERT INTO t1 VALUES (0xFFFFFFFFFFFFFFFF); +SELECT * FROM t1 WHERE a=-1 OR a=-2 ; +a +SELECT * FROM t1 WHERE a IN (-1, -2); +a +CREATE TABLE t2 (a BIGINT UNSIGNED); +insert into t2 values(13491727406643098568), +(0x7fffffefffffffff), +(0x7ffffffeffffffff), +(0x7fffffffefffffff), +(0x7ffffffffeffffff), +(0x7fffffffffefffff), +(0x7ffffffffffeffff), +(0x7fffffffffffefff), +(0x7ffffffffffffeff), +(0x7fffffffffffffef), +(0x7ffffffffffffffe), +(0x7fffffffffffffff), +(0x8000000000000000), +(0x8000000000000001), +(0x8000000000000002), +(0x8000000000000300), +(0x8000000000000400), +(0x8000000000000401), +(0x8000000000004001), +(0x8000000000040001), +(0x8000000000400001), +(0x8000000004000001), +(0x8000000040000001), +(0x8000000400000001), +(0x8000004000000001), +(0x8000040000000001); +SELECT HEX(a) FROM t2 WHERE a IN (0xBB3C3E98175D33C8, 42); +HEX(a) +BB3C3E98175D33C8 +SELECT HEX(a) FROM t2 WHERE a IN +(0xBB3C3E98175D33C8, +0x7fffffffffffffff, +0x8000000000000000, +0x8000000000000400, +0x8000000000000401, +42); +HEX(a) +BB3C3E98175D33C8 +7FFFFFFFFFFFFFFF +8000000000000000 +8000000000000400 +8000000000000401 +SELECT HEX(a) FROM t2 WHERE a IN (0x7fffffffffffffff,0x8000000000000001); +HEX(a) +7FFFFFFFFFFFFFFF +8000000000000001 +SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff); +HEX(a) +7FFFFFFFFFFFFFFE +7FFFFFFFFFFFFFFF +SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff,'abc'); +HEX(a) +7FFFFFFFFFFFFFFE +7FFFFFFFFFFFFFFF +CREATE TABLE t3 (a BIGINT UNSIGNED); +INSERT INTO t3 VALUES (9223372036854775551); +SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42); +HEX(a) +DROP TABLE t1,t2,t3; End of 5.0 tests diff --git a/mysql-test/t/func_in.test b/mysql-test/t/func_in.test index 54b81bed133..7ba54747d4b 100644 --- a/mysql-test/t/func_in.test +++ b/mysql-test/t/func_in.test @@ -298,4 +298,62 @@ SELECT STRAIGHT_JOIN DROP TABLE t1,t2,t3,t4; +# +# BUG#19342: IN works incorrectly for BIGINT UNSIGNED values +# +CREATE TABLE t1(a BIGINT UNSIGNED); +INSERT INTO t1 VALUES (0xFFFFFFFFFFFFFFFF); + +SELECT * FROM t1 WHERE a=-1 OR a=-2 ; +SELECT * FROM t1 WHERE a IN (-1, -2); + +CREATE TABLE t2 (a BIGINT UNSIGNED); +insert into t2 values(13491727406643098568), + (0x7fffffefffffffff), + (0x7ffffffeffffffff), + (0x7fffffffefffffff), + (0x7ffffffffeffffff), + (0x7fffffffffefffff), + (0x7ffffffffffeffff), + (0x7fffffffffffefff), + (0x7ffffffffffffeff), + (0x7fffffffffffffef), + (0x7ffffffffffffffe), + (0x7fffffffffffffff), + (0x8000000000000000), + (0x8000000000000001), + (0x8000000000000002), + (0x8000000000000300), + (0x8000000000000400), + (0x8000000000000401), + (0x8000000000004001), + (0x8000000000040001), + (0x8000000000400001), + (0x8000000004000001), + (0x8000000040000001), + (0x8000000400000001), + (0x8000004000000001), + (0x8000040000000001); + +SELECT HEX(a) FROM t2 WHERE a IN (0xBB3C3E98175D33C8, 42); + +SELECT HEX(a) FROM t2 WHERE a IN +(0xBB3C3E98175D33C8, + 0x7fffffffffffffff, + 0x8000000000000000, + 0x8000000000000400, + 0x8000000000000401, + 42); + +SELECT HEX(a) FROM t2 WHERE a IN (0x7fffffffffffffff,0x8000000000000001); +SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff); +SELECT HEX(a) FROM t2 WHERE a IN (0x7ffffffffffffffe,0x7fffffffffffffff,'abc'); + +CREATE TABLE t3 (a BIGINT UNSIGNED); +INSERT INTO t3 VALUES (9223372036854775551); + +SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42); + +DROP TABLE t1,t2,t3; + --echo End of 5.0 tests diff --git a/sql/item.h b/sql/item.h index 6c41aa09f80..f02d4f0c65d 100644 --- a/sql/item.h +++ b/sql/item.h @@ -1766,7 +1766,10 @@ public: Item_hex_string(const char *str,uint str_length); enum Type type() const { return VARBIN_ITEM; } double val_real() - { DBUG_ASSERT(fixed == 1); return (double) Item_hex_string::val_int(); } + { + DBUG_ASSERT(fixed == 1); + return (double) (ulonglong) Item_hex_string::val_int(); + } longlong val_int(); bool basic_const_item() const { return 1; } String *val_str(String*) { DBUG_ASSERT(fixed == 1); return &str_value; } diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc index 08f9c16384a..f239e3ea18e 100644 --- a/sql/item_cmpfunc.cc +++ b/sql/item_cmpfunc.cc @@ -2034,9 +2034,100 @@ void Item_func_coalesce::fix_length_and_dec() Classes and function for the IN operator ****************************************************************************/ -static int cmp_longlong(void *cmp_arg, longlong *a,longlong *b) +/* + Determine which of the signed longlong arguments is bigger + + SYNOPSIS + cmp_longs() + a_val left argument + b_val right argument + + DESCRIPTION + This function will compare two signed longlong arguments + and will return -1, 0, or 1 if left argument is smaller than, + equal to or greater than the right argument. + + RETURN VALUE + -1 left argument is smaller than the right argument. + 0 left argument is equal to the right argument. + 1 left argument is greater than the right argument. +*/ +static inline int cmp_longs (longlong a_val, longlong b_val) { - return *a < *b ? -1 : *a == *b ? 0 : 1; + return a_val < b_val ? -1 : a_val == b_val ? 0 : 1; +} + + +/* + Determine which of the unsigned longlong arguments is bigger + + SYNOPSIS + cmp_ulongs() + a_val left argument + b_val right argument + + DESCRIPTION + This function will compare two unsigned longlong arguments + and will return -1, 0, or 1 if left argument is smaller than, + equal to or greater than the right argument. + + RETURN VALUE + -1 left argument is smaller than the right argument. + 0 left argument is equal to the right argument. + 1 left argument is greater than the right argument. +*/ +static inline int cmp_ulongs (ulonglong a_val, ulonglong b_val) +{ + return a_val < b_val ? -1 : a_val == b_val ? 0 : 1; +} + + +/* + Compare two integers in IN value list format (packed_longlong) + + SYNOPSIS + cmp_longlong() + cmp_arg an argument passed to the calling function (qsort2) + a left argument + b right argument + + DESCRIPTION + This function will compare two integer arguments in the IN value list + format and will return -1, 0, or 1 if left argument is smaller than, + equal to or greater than the right argument. + It's used in sorting the IN values list and finding an element in it. + Depending on the signedness of the arguments cmp_longlong() will + compare them as either signed (using cmp_longs()) or unsigned (using + cmp_ulongs()). + + RETURN VALUE + -1 left argument is smaller than the right argument. + 0 left argument is equal to the right argument. + 1 left argument is greater than the right argument. +*/ +int cmp_longlong(void *cmp_arg, + in_longlong::packed_longlong *a, + in_longlong::packed_longlong *b) +{ + if (a->unsigned_flag != b->unsigned_flag) + { + /* + One of the args is unsigned and is too big to fit into the + positive signed range. Report no match. + */ + if (a->unsigned_flag && ((ulonglong) a->val) > LONGLONG_MAX || + b->unsigned_flag && ((ulonglong) b->val) > LONGLONG_MAX) + return a->unsigned_flag ? 1 : -1; + /* + Although the signedness differs both args can fit into the signed + positive range. Make them signed and compare as usual. + */ + return cmp_longs (a->val, b->val); + } + if (a->unsigned_flag) + return cmp_ulongs ((ulonglong) a->val, (ulonglong) b->val); + else + return cmp_longs (a->val, b->val); } static int cmp_double(void *cmp_arg, double *a,double *b) @@ -2161,19 +2252,23 @@ void in_row::set(uint pos, Item *item) } in_longlong::in_longlong(uint elements) - :in_vector(elements,sizeof(longlong),(qsort2_cmp) cmp_longlong, 0) + :in_vector(elements,sizeof(packed_longlong),(qsort2_cmp) cmp_longlong, 0) {} void in_longlong::set(uint pos,Item *item) { - ((longlong*) base)[pos]=item->val_int(); + struct packed_longlong *buff= &((packed_longlong*) base)[pos]; + + buff->val= item->val_int(); + buff->unsigned_flag= item->unsigned_flag; } byte *in_longlong::get_value(Item *item) { - tmp= item->val_int(); + tmp.val= item->val_int(); if (item->null_value) return 0; + tmp.unsigned_flag= item->unsigned_flag; return (byte*) &tmp; } @@ -2494,6 +2589,31 @@ void Item_func_in::fix_length_and_dec() */ if (const_itm && !nulls_in_row()) { + /* + IN must compare INT/DATE/DATETIME/TIMESTAMP columns and constants + as int values (the same way as equality does). + So we must check here if the column on the left and all the constant + values on the right can be compared as integers and adjust the + comparison type accordingly. + */ + if (args[0]->real_item()->type() == FIELD_ITEM && + thd->lex->sql_command != SQLCOM_CREATE_VIEW && + thd->lex->sql_command != SQLCOM_SHOW_CREATE && + cmp_type != INT_RESULT) + { + Field *field= ((Item_field*) (args[0]->real_item()))->field; + if (field->can_be_compared_as_longlong()) + { + bool all_converted= TRUE; + for (arg=args+1, arg_end=args+arg_count; arg != arg_end ; arg++) + { + if (!convert_constant_item (thd, field, &arg[0])) + all_converted= FALSE; + } + if (all_converted) + cmp_type= INT_RESULT; + } + } switch (cmp_type) { case STRING_RESULT: array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in, diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index f18728c554b..80115549336 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -731,7 +731,16 @@ public: class in_longlong :public in_vector { - longlong tmp; + /* + Here we declare a temporary variable (tmp) of the same type as the + elements of this vector. tmp is used in finding if a given value is in + the list. + */ + struct packed_longlong + { + longlong val; + longlong unsigned_flag; // Use longlong, not bool, to preserve alignment + } tmp; public: in_longlong(uint elements); void set(uint pos,Item *item); @@ -747,8 +756,12 @@ public: } void value_to_item(uint pos, Item *item) { - ((Item_int*)item)->value= ((longlong*)base)[pos]; + ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val; + ((Item_int*) item)->unsigned_flag= + ((packed_longlong*) base)[pos].unsigned_flag; } + + friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b); }; class in_double :public in_vector From 76995281a3f8b39fe7e9aefaa0d80edc69970764 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@macbook.gmz" <> Date: Fri, 2 Mar 2007 19:27:32 +0200 Subject: [PATCH 17/73] fixed win32 warning --- sql/item_cmpfunc.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index 80115549336..b612553e840 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -757,7 +757,7 @@ public: void value_to_item(uint pos, Item *item) { ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val; - ((Item_int*) item)->unsigned_flag= + ((Item_int*) item)->unsigned_flag= (my_bool) ((packed_longlong*) base)[pos].unsigned_flag; } From 6274ee84b31a364bd7d0c5a8db9d5f49a2e45672 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@magare.gmz" <> Date: Fri, 2 Mar 2007 19:32:46 +0200 Subject: [PATCH 18/73] fixed win32 warnings --- sql/item_cmpfunc.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index b0d85ba92a1..e50e744668a 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -760,7 +760,7 @@ public: void value_to_item(uint pos, Item *item) { ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val; - ((Item_int*) item)->unsigned_flag= + ((Item_int*) item)->unsigned_flag= (my_bool) ((packed_longlong*) base)[pos].unsigned_flag; } From be4db4993bef67cde3b242864324fca903bfae39 Mon Sep 17 00:00:00 2001 From: "lzhou/zhl@dev3-63.(none)" <> Date: Fri, 2 Mar 2007 18:45:09 +0000 Subject: [PATCH 19/73] BUG#26307 correct inconsistant jam() and ljam() use in DBTUP source files. --- storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp | 109 +++++++-- .../src/kernel/blocks/dbtup/DbtupAbort.cpp | 66 +++-- .../src/kernel/blocks/dbtup/DbtupBuffer.cpp | 34 ++- .../src/kernel/blocks/dbtup/DbtupCommit.cpp | 42 ++-- .../src/kernel/blocks/dbtup/DbtupDebug.cpp | 14 +- .../kernel/blocks/dbtup/DbtupDiskAlloc.cpp | 1 + .../src/kernel/blocks/dbtup/DbtupFixAlloc.cpp | 12 +- .../ndb/src/kernel/blocks/dbtup/DbtupGen.cpp | 82 +++---- .../src/kernel/blocks/dbtup/DbtupIndex.cpp | 70 +++--- .../ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp | 96 ++++---- .../src/kernel/blocks/dbtup/DbtupPagMan.cpp | 54 ++--- .../src/kernel/blocks/dbtup/DbtupPageMap.cpp | 78 +++--- .../src/kernel/blocks/dbtup/DbtupRoutines.cpp | 228 +++++++++--------- .../ndb/src/kernel/blocks/dbtup/DbtupScan.cpp | 1 + .../blocks/dbtup/DbtupStoredProcDef.cpp | 26 +- .../kernel/blocks/dbtup/DbtupTabDesMan.cpp | 38 ++- .../src/kernel/blocks/dbtup/DbtupTrigger.cpp | 172 +++++++------ .../src/kernel/blocks/dbtup/DbtupVarAlloc.cpp | 37 ++- 18 files changed, 604 insertions(+), 556 deletions(-) diff --git a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp index 230895c942a..5481cafd4f1 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp +++ b/storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp @@ -32,6 +32,82 @@ #include <../pgman.hpp> #include <../tsman.hpp> +// jams +#undef jam +#undef jamEntry +#ifdef DBTUP_BUFFER_CPP +#define jam() jamLine(10000 + __LINE__) +#define jamEntry() jamEntryLine(10000 + __LINE__) +#endif +#ifdef DBTUP_ROUTINES_CPP +#define jam() jamLine(15000 + __LINE__) +#define jamEntry() jamEntryLine(15000 + __LINE__) +#endif +#ifdef DBTUP_COMMIT_CPP +#define jam() jamLine(20000 + __LINE__) +#define jamEntry() jamEntryLine(20000 + __LINE__) +#endif +#ifdef DBTUP_FIXALLOC_CPP +#define jam() jamLine(25000 + __LINE__) +#define jamEntry() jamEntryLine(25000 + __LINE__) +#endif +#ifdef DBTUP_TRIGGER_CPP +#define jam() jamLine(30000 + __LINE__) +#define jamEntry() jamEntryLine(30000 + __LINE__) +#endif +#ifdef DBTUP_ABORT_CPP +#define jam() jamLine(35000 + __LINE__) +#define jamEntry() jamEntryLine(35000 + __LINE__) +#endif +#ifdef DBTUP_PAGE_MAP_CPP +#define jam() jamLine(40000 + __LINE__) +#define jamEntry() jamEntryLine(40000 + __LINE__) +#endif +#ifdef DBTUP_PAG_MAN_CPP +#define jam() jamLine(45000 + __LINE__) +#define jamEntry() jamEntryLine(45000 + __LINE__) +#endif +#ifdef DBTUP_STORE_PROC_DEF_CPP +#define jam() jamLine(50000 + __LINE__) +#define jamEntry() jamEntryLine(50000 + __LINE__) +#endif +#ifdef DBTUP_META_CPP +#define jam() jamLine(55000 + __LINE__) +#define jamEntry() jamEntryLine(55000 + __LINE__) +#endif +#ifdef DBTUP_TAB_DES_MAN_CPP +#define jam() jamLine(60000 + __LINE__) +#define jamEntry() jamEntryLine(60000 + __LINE__) +#endif +#ifdef DBTUP_GEN_CPP +#define jam() jamLine(65000 + __LINE__) +#define jamEntry() jamEntryLine(65000 + __LINE__) +#endif +#ifdef DBTUP_INDEX_CPP +#define jam() jamLine(70000 + __LINE__) +#define jamEntry() jamEntryLine(70000 + __LINE__) +#endif +#ifdef DBTUP_DEBUG_CPP +#define jam() jamLine(75000 + __LINE__) +#define jamEntry() jamEntryLine(75000 + __LINE__) +#endif +#ifdef DBTUP_VAR_ALLOC_CPP +#define jam() jamLine(80000 + __LINE__) +#define jamEntry() jamEntryLine(80000 + __LINE__) +#endif +#ifdef DBTUP_SCAN_CPP +#define jam() jamLine(85000 + __LINE__) +#define jamEntry() jamEntryLine(85000 + __LINE__) +#endif +#ifdef DBTUP_DISK_ALLOC_CPP +#define jam() jamLine(90000 + __LINE__) +#define jamEntry() jamEntryLine(90000 + __LINE__) +#endif +#ifndef jam +#define jam() jamLine(__LINE__) +#define jamEntry() jamEntryLine(__LINE__) +#endif + #ifdef VM_TRACE inline const char* dbgmask(const Bitmask& bm) { static int i=0; static char buf[5][200]; @@ -70,22 +146,23 @@ inline const Uint32* ALIGN_WORD(const void* ptr) // only reports the line number in the file it currently is located in. // // DbtupExecQuery.cpp 0 -// DbtupBuffer.cpp 2000 -// DbtupRoutines.cpp 3000 -// DbtupCommit.cpp 5000 -// DbtupFixAlloc.cpp 6000 -// DbtupTrigger.cpp 7000 -// DbtupAbort.cpp 9000 -// DbtupPageMap.cpp 14000 -// DbtupPagMan.cpp 16000 -// DbtupStoredProcDef.cpp 18000 -// DbtupMeta.cpp 20000 -// DbtupTabDesMan.cpp 22000 -// DbtupGen.cpp 24000 -// DbtupIndex.cpp 28000 -// DbtupDebug.cpp 30000 -// DbtupVarAlloc.cpp 32000 -// DbtupScan.cpp 33000 +// DbtupBuffer.cpp 10000 +// DbtupRoutines.cpp 15000 +// DbtupCommit.cpp 20000 +// DbtupFixAlloc.cpp 25000 +// DbtupTrigger.cpp 30000 +// DbtupAbort.cpp 35000 +// DbtupPageMap.cpp 40000 +// DbtupPagMan.cpp 45000 +// DbtupStoredProcDef.cpp 50000 +// DbtupMeta.cpp 55000 +// DbtupTabDesMan.cpp 60000 +// DbtupGen.cpp 65000 +// DbtupIndex.cpp 70000 +// DbtupDebug.cpp 75000 +// DbtupVarAlloc.cpp 80000 +// DbtupScan.cpp 85000 +// DbtupDiskAlloc.cpp 90000 //------------------------------------------------------------------ /* diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp index 904629fff77..77cd59dc2e9 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp @@ -14,21 +14,19 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_ABORT_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(9000 + __LINE__); } -#define ljamEntry() { jamEntryLine(9000 + __LINE__); } - void Dbtup::freeAllAttrBuffers(Operationrec* const regOperPtr) { if (regOperPtr->storedProcedureId == RNIL) { - ljam(); + jam(); freeAttrinbufrec(regOperPtr->firstAttrinbufrec); } else { - ljam(); + jam(); StoredProcPtr storedPtr; c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId); ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE); @@ -46,7 +44,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf) Uint32 RnoFree = cnoFreeAttrbufrec; localAttrBufPtr.i = anAttrBuf; while (localAttrBufPtr.i != RNIL) { - ljam(); + jam(); ptrCheckGuard(localAttrBufPtr, cnoOfAttrbufrec, attrbufrec); Ttemp = localAttrBufPtr.p->attrbuf[ZBUF_NEXT]; localAttrBufPtr.p->attrbuf[ZBUF_NEXT] = cfirstfreeAttrbufrec; @@ -62,7 +60,7 @@ void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf) */ void Dbtup::execTUP_ABORTREQ(Signal* signal) { - ljamEntry(); + jamEntry(); do_tup_abortreq(signal, 0); } @@ -80,7 +78,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags) (trans_state == TRANS_ERROR_WAIT_TUPKEYREQ) || (trans_state == TRANS_IDLE)); if (regOperPtr.p->op_struct.op_type == ZREAD) { - ljam(); + jam(); freeAllAttrBuffers(regOperPtr.p); initOpConnection(regOperPtr.p); return; @@ -94,7 +92,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags) if (get_tuple_state(regOperPtr.p) == TUPLE_PREPARED) { - ljam(); + jam(); if (!regTabPtr.p->tuxCustomTriggers.isEmpty() && (flags & ZSKIP_TUX_TRIGGERS) == 0) executeTuxAbortTriggers(signal, @@ -105,12 +103,12 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags) OperationrecPtr loopOpPtr; loopOpPtr.i = regOperPtr.p->nextActiveOp; while (loopOpPtr.i != RNIL) { - ljam(); + jam(); c_operation_pool.getPtr(loopOpPtr); if (get_tuple_state(loopOpPtr.p) != TUPLE_ALREADY_ABORTED && !regTabPtr.p->tuxCustomTriggers.isEmpty() && (flags & ZSKIP_TUX_TRIGGERS) == 0) { - ljam(); + jam(); executeTuxAbortTriggers(signal, loopOpPtr.p, regFragPtr.p, @@ -211,116 +209,116 @@ int Dbtup::TUPKEY_abort(Signal* signal, int error_type) case 1: //tmupdate_alloc_error: terrorCode= ZMEM_NOMEM_ERROR; - ljam(); + jam(); break; case 15: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 16: - ljam(); + jam(); terrorCode = ZTRY_TO_UPDATE_ERROR; break; case 17: - ljam(); + jam(); terrorCode = ZNO_ILLEGAL_NULL_ATTR; break; case 19: - ljam(); + jam(); terrorCode = ZTRY_TO_UPDATE_ERROR; break; case 20: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 22: - ljam(); + jam(); terrorCode = ZTOTAL_LEN_ERROR; break; case 23: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 24: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 26: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 27: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 28: - ljam(); + jam(); terrorCode = ZREGISTER_INIT_ERROR; break; case 29: - ljam(); + jam(); break; case 30: - ljam(); + jam(); terrorCode = ZCALL_ERROR; break; case 31: - ljam(); + jam(); terrorCode = ZSTACK_OVERFLOW_ERROR; break; case 32: - ljam(); + jam(); terrorCode = ZSTACK_UNDERFLOW_ERROR; break; case 33: - ljam(); + jam(); terrorCode = ZNO_INSTRUCTION_ERROR; break; case 34: - ljam(); + jam(); terrorCode = ZOUTSIDE_OF_PROGRAM_ERROR; break; case 35: - ljam(); + jam(); terrorCode = ZTOO_MANY_INSTRUCTIONS_ERROR; break; case 38: - ljam(); + jam(); terrorCode = ZTEMPORARY_RESOURCE_FAILURE; break; case 39: if (get_trans_state(operPtr.p) == TRANS_TOO_MUCH_AI) { - ljam(); + jam(); terrorCode = ZTOO_MUCH_ATTRINFO_ERROR; } else if (get_trans_state(operPtr.p) == TRANS_ERROR_WAIT_TUPKEYREQ) { - ljam(); + jam(); terrorCode = ZSEIZE_ATTRINBUFREC_ERROR; } else { ndbrequire(false); }//if break; case 40: - ljam(); + jam(); terrorCode = ZUNSUPPORTED_BRANCH; break; default: diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp index 60c0c22ae6c..adac4d3d460 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupBuffer.cpp @@ -14,28 +14,26 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_BUFFER_CPP #include "Dbtup.hpp" #include #include #include #include -#define ljam() { jamLine(2000 + __LINE__); } -#define ljamEntry() { jamEntryLine(2000 + __LINE__); } - void Dbtup::execSEND_PACKED(Signal* signal) { Uint16 hostId; Uint32 i; Uint32 TpackedListIndex= cpackedListIndex; - ljamEntry(); + jamEntry(); for (i= 0; i < TpackedListIndex; i++) { - ljam(); + jam(); hostId= cpackedList[i]; ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero Uint32 TpacketTA= hostBuffer[hostId].noOfPacketsTA; if (TpacketTA != 0) { - ljam(); + jam(); BlockReference TBref= numberToRef(API_PACKED, hostId); Uint32 TpacketLen= hostBuffer[hostId].packetLenTA; MEMCOPY_NO_WORDS(&signal->theData[0], @@ -73,7 +71,7 @@ void Dbtup::bufferTRANSID_AI(Signal* signal, BlockReference aRef, // There is still space in the buffer. We will copy it into the // buffer. // ---------------------------------------------------------------- - ljam(); + jam(); updatePackedList(signal, hostId); } else if (false && TnoOfPackets == 1) { // ---------------------------------------------------------------- @@ -118,7 +116,7 @@ void Dbtup::updatePackedList(Signal* signal, Uint16 hostId) { if (hostBuffer[hostId].inPackedList == false) { Uint32 TpackedListIndex= cpackedListIndex; - ljam(); + jam(); hostBuffer[hostId].inPackedList= true; cpackedList[TpackedListIndex]= hostId; cpackedListIndex= TpackedListIndex + 1; @@ -149,7 +147,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal, if (ERROR_INSERTED(4006) && (nodeId != getOwnNodeId())){ // Use error insert to turn routing on - ljam(); + jam(); connectedToNode= false; } @@ -167,18 +165,18 @@ void Dbtup::sendReadAttrinfo(Signal* signal, * Own node -> execute direct */ if(nodeId != getOwnNodeId()){ - ljam(); + jam(); /** * Send long sig */ if (ToutBufIndex >= 22 && is_api && !old_dest) { - ljam(); + jam(); /** * Flush buffer so that order is maintained */ if (TpacketTA != 0) { - ljam(); + jam(); BlockReference TBref = numberToRef(API_PACKED, nodeId); MEMCOPY_NO_WORDS(&signal->theData[0], &hostBuffer[nodeId].packetBufferTA[0], @@ -202,7 +200,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal, */ #ifndef NDB_NO_DROPPED_SIGNAL if (ToutBufIndex < 22 && is_api){ - ljam(); + jam(); bufferTRANSID_AI(signal, recBlockref, 3+ToutBufIndex); return; } @@ -214,7 +212,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal, Uint32 * src= signal->theData+25; if (ToutBufIndex >= 22){ do { - ljam(); + jam(); MEMCOPY_NO_WORDS(&signal->theData[3], src, 22); sendSignal(recBlockref, GSN_TRANSID_AI, signal, 25, JBB); ToutBufIndex -= 22; @@ -223,14 +221,14 @@ void Dbtup::sendReadAttrinfo(Signal* signal, } if (ToutBufIndex > 0){ - ljam(); + jam(); MEMCOPY_NO_WORDS(&signal->theData[3], src, ToutBufIndex); sendSignal(recBlockref, GSN_TRANSID_AI, signal, 3+ToutBufIndex, JBB); } return; } EXECUTE_DIRECT(block, GSN_TRANSID_AI, signal, 3 + ToutBufIndex); - ljamEntry(); + jamEntry(); return; } @@ -242,7 +240,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal, Uint32 routeBlockref= req_struct->TC_ref; if (true){ // TODO is_api && !old_dest){ - ljam(); + jam(); transIdAI->attrData[0]= recBlockref; LinearSectionPtr ptr[3]; ptr[0].p= &signal->theData[25]; @@ -260,7 +258,7 @@ void Dbtup::sendReadAttrinfo(Signal* signal, Uint32 sent= 0; Uint32 maxLen= TransIdAI::DataLength - 1; while (sent < tot) { - ljam(); + jam(); Uint32 dataLen= (tot - sent > maxLen) ? maxLen : tot - sent; Uint32 sigLen= dataLen + TransIdAI::HeaderLength + 1; MEMCOPY_NO_WORDS(&transIdAI->attrData, diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp index 1f703599cf5..75b4832aafe 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp @@ -14,6 +14,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_COMMIT_CPP #include "Dbtup.hpp" #include #include @@ -21,16 +22,13 @@ #include #include "../dblqh/Dblqh.hpp" -#define ljam() { jamLine(5000 + __LINE__); } -#define ljamEntry() { jamEntryLine(5000 + __LINE__); } - void Dbtup::execTUP_DEALLOCREQ(Signal* signal) { TablerecPtr regTabPtr; FragrecordPtr regFragPtr; Uint32 frag_page_id, frag_id; - ljamEntry(); + jamEntry(); frag_id= signal->theData[0]; regTabPtr.i= signal->theData[1]; @@ -62,7 +60,7 @@ void Dbtup::execTUP_DEALLOCREQ(Signal* signal) if (regTabPtr.p->m_attributes[MM].m_no_of_varsize) { - ljam(); + jam(); free_var_rec(regFragPtr.p, regTabPtr.p, &tmp, pagePtr); } else { free_fix_rec(regFragPtr.p, regTabPtr.p, &tmp, (Fix_page*)pagePtr.p); @@ -78,7 +76,7 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal) Uint32 gci= signal->theData[1]; c_operation_pool.getPtr(loopOpPtr); while (loopOpPtr.p->prevActiveOp != RNIL) { - ljam(); + jam(); loopOpPtr.i= loopOpPtr.p->prevActiveOp; c_operation_pool.getPtr(loopOpPtr); } @@ -87,11 +85,11 @@ void Dbtup::execTUP_WRITELOG_REQ(Signal* signal) signal->theData[0]= loopOpPtr.p->userpointer; signal->theData[1]= gci; if (loopOpPtr.p->nextActiveOp == RNIL) { - ljam(); + jam(); EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2); return; } - ljam(); + jam(); EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 2); jamEntry(); loopOpPtr.i= loopOpPtr.p->nextActiveOp; @@ -114,16 +112,16 @@ void Dbtup::removeActiveOpList(Operationrec* const regOperPtr, if (regOperPtr->op_struct.in_active_list) { regOperPtr->op_struct.in_active_list= false; if (regOperPtr->nextActiveOp != RNIL) { - ljam(); + jam(); raoOperPtr.i= regOperPtr->nextActiveOp; c_operation_pool.getPtr(raoOperPtr); raoOperPtr.p->prevActiveOp= regOperPtr->prevActiveOp; } else { - ljam(); + jam(); tuple_ptr->m_operation_ptr_i = regOperPtr->prevActiveOp; } if (regOperPtr->prevActiveOp != RNIL) { - ljam(); + jam(); raoOperPtr.i= regOperPtr->prevActiveOp; c_operation_pool.getPtr(raoOperPtr); raoOperPtr.p->nextActiveOp= regOperPtr->nextActiveOp; @@ -343,7 +341,7 @@ Dbtup::disk_page_commit_callback(Signal* signal, Uint32 gci; OperationrecPtr regOperPtr; - ljamEntry(); + jamEntry(); c_operation_pool.getPtr(regOperPtr, opPtrI); c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci); @@ -379,7 +377,7 @@ Dbtup::disk_page_log_buffer_callback(Signal* signal, Uint32 gci; OperationrecPtr regOperPtr; - ljamEntry(); + jamEntry(); c_operation_pool.getPtr(regOperPtr, opPtrI); c_lqh->get_op_info(regOperPtr.p->userpointer, &hash_value, &gci); @@ -447,7 +445,7 @@ void Dbtup::execTUP_COMMITREQ(Signal* signal) TupCommitReq * const tupCommitReq= (TupCommitReq *)signal->getDataPtr(); regOperPtr.i= tupCommitReq->opPtr; - ljamEntry(); + jamEntry(); c_operation_pool.getPtr(regOperPtr); if(!regOperPtr.p->is_first_operation()) @@ -603,7 +601,7 @@ skip_disk: * why can't we instead remove "own version" (when approriate ofcourse) */ if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) { - ljam(); + jam(); OperationrecPtr loopPtr= regOperPtr; while(loopPtr.i != RNIL) { @@ -656,18 +654,18 @@ Dbtup::set_change_mask_info(KeyReqStruct * const req_struct, { ChangeMaskState state = get_change_mask_state(regOperPtr); if (state == USE_SAVED_CHANGE_MASK) { - ljam(); + jam(); req_struct->changeMask.setWord(0, regOperPtr->saved_change_mask[0]); req_struct->changeMask.setWord(1, regOperPtr->saved_change_mask[1]); } else if (state == RECALCULATE_CHANGE_MASK) { - ljam(); + jam(); // Recompute change mask, for now set all bits req_struct->changeMask.set(); } else if (state == SET_ALL_MASK) { - ljam(); + jam(); req_struct->changeMask.set(); } else { - ljam(); + jam(); ndbrequire(state == DELETE_CHANGES); req_struct->changeMask.set(); } @@ -687,17 +685,17 @@ Dbtup::calculateChangeMask(Page* const pagePtr, ndbrequire(loopOpPtr.p->op_struct.op_type == ZUPDATE); ChangeMaskState change_mask= get_change_mask_state(loopOpPtr.p); if (change_mask == USE_SAVED_CHANGE_MASK) { - ljam(); + jam(); saved_word1|= loopOpPtr.p->saved_change_mask[0]; saved_word2|= loopOpPtr.p->saved_change_mask[1]; } else if (change_mask == RECALCULATE_CHANGE_MASK) { - ljam(); + jam(); //Recompute change mask, for now set all bits req_struct->changeMask.set(); return; } else { ndbrequire(change_mask == SET_ALL_MASK); - ljam(); + jam(); req_struct->changeMask.set(); return; } diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp index ccb0bdcb537..708b4e0e8d7 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp @@ -15,6 +15,7 @@ #define DBTUP_C +#define DBTUP_DEBUG_CPP #include "Dbtup.hpp" #include #include @@ -24,9 +25,6 @@ #include #include -#define ljam() { jamLine(30000 + __LINE__); } -#define ljamEntry() { jamEntryLine(30000 + __LINE__); } - /* **************************************************************** */ /* ---------------------------------------------------------------- */ /* ------------------------ DEBUG MODULE -------------------------- */ @@ -35,7 +33,7 @@ void Dbtup::execDEBUG_SIG(Signal* signal) { PagePtr regPagePtr; - ljamEntry(); + jamEntry(); regPagePtr.i = signal->theData[0]; c_page_pool.getPtr(regPagePtr); }//Dbtup::execDEBUG_SIG() @@ -248,18 +246,18 @@ void Dbtup::execMEMCHECKREQ(Signal* signal) PagePtr regPagePtr; Uint32* data = &signal->theData[0]; - ljamEntry(); + jamEntry(); BlockReference blockref = signal->theData[0]; Uint32 i; for (i = 0; i < 25; i++) { - ljam(); + jam(); data[i] = 0; }//for for (i = 0; i < 16; i++) { regPagePtr.i = cfreepageList[i]; - ljam(); + jam(); while (regPagePtr.i != RNIL) { - ljam(); + jam(); ptrCheckGuard(regPagePtr, cnoOfPage, cpage); regPagePtr.i = regPagePtr.p->next_page; data[0]++; diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp index 54abbf18664..496936a4e9e 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupDiskAlloc.cpp @@ -14,6 +14,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_DISK_ALLOC_CPP #include "Dbtup.hpp" static bool f_undo_done = true; diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp index 88a818e6fd7..84421962290 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupFixAlloc.cpp @@ -14,14 +14,12 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_FIXALLOC_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(6000 + __LINE__); } -#define ljamEntry() { jamEntryLine(6000 + __LINE__); } - // // Fixed Allocator // This module is used to allocate and free fixed size tuples from the @@ -79,7 +77,7 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr, /* ---------------------------------------------------------------- */ pagePtr.i = getEmptyPage(regFragPtr); if (pagePtr.i != RNIL) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ // We found empty pages on the fragment. Allocate an empty page and // convert it into a tuple header page and put it in thFreeFirst-list. @@ -95,14 +93,14 @@ Dbtup::alloc_fix_rec(Fragrecord* const regFragPtr, LocalDLList free_pages(c_page_pool, regFragPtr->thFreeFirst); free_pages.add(pagePtr); } else { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* THERE ARE NO EMPTY PAGES. MEMORY CAN NOT BE ALLOCATED. */ /* ---------------------------------------------------------------- */ return 0; } } else { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* THIS SHOULD BE THE COMMON PATH THROUGH THE CODE, FREE */ /* COPY PAGE EXISTED. */ @@ -194,7 +192,7 @@ void Dbtup::free_fix_rec(Fragrecord* regFragPtr, if(free == 1) { - ljam(); + jam(); PagePtr pagePtr = { (Page*)regPagePtr, key->m_page_no }; LocalDLList free_pages(c_page_pool, regFragPtr->thFreeFirst); ndbrequire(regPagePtr->page_state == ZTH_MM_FULL); diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp index 3e9469c4edf..bdcefffd2e7 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp @@ -15,6 +15,7 @@ #define DBTUP_C +#define DBTUP_GEN_CPP #include "Dbtup.hpp" #include #include @@ -34,9 +35,6 @@ #define DEBUG(x) { ndbout << "TUP::" << x << endl; } -#define ljam() { jamLine(24000 + __LINE__); } -#define ljamEntry() { jamEntryLine(24000 + __LINE__); } - void Dbtup::initData() { cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC; @@ -152,21 +150,21 @@ BLOCK_FUNCTIONS(Dbtup) void Dbtup::execCONTINUEB(Signal* signal) { - ljamEntry(); + jamEntry(); Uint32 actionType = signal->theData[0]; Uint32 dataPtr = signal->theData[1]; switch (actionType) { case ZINITIALISE_RECORDS: - ljam(); + jam(); initialiseRecordsLab(signal, dataPtr, signal->theData[2], signal->theData[3]); break; case ZREL_FRAG: - ljam(); + jam(); releaseFragment(signal, dataPtr, signal->theData[2]); break; case ZREPORT_MEMORY_USAGE:{ - ljam(); + jam(); static int c_currentMemUsed = 0; Uint32 cnt = signal->theData[1]; Uint32 tmp = c_page_pool.getSize(); @@ -201,11 +199,11 @@ void Dbtup::execCONTINUEB(Signal* signal) return; } case ZBUILD_INDEX: - ljam(); + jam(); buildIndex(signal, dataPtr); break; case ZTUP_SCAN: - ljam(); + jam(); { ScanOpPtr scanPtr; c_scanOpPool.getPtr(scanPtr, dataPtr); @@ -214,7 +212,7 @@ void Dbtup::execCONTINUEB(Signal* signal) return; case ZFREE_EXTENT: { - ljam(); + jam(); TablerecPtr tabPtr; tabPtr.i= dataPtr; @@ -227,7 +225,7 @@ void Dbtup::execCONTINUEB(Signal* signal) } case ZUNMAP_PAGES: { - ljam(); + jam(); TablerecPtr tabPtr; tabPtr.i= dataPtr; @@ -240,7 +238,7 @@ void Dbtup::execCONTINUEB(Signal* signal) } case ZFREE_VAR_PAGES: { - ljam(); + jam(); drop_fragment_free_var_pages(signal); return; } @@ -257,12 +255,12 @@ void Dbtup::execCONTINUEB(Signal* signal) /* **************************************************************** */ void Dbtup::execSTTOR(Signal* signal) { - ljamEntry(); + jamEntry(); Uint32 startPhase = signal->theData[1]; Uint32 sigKey = signal->theData[6]; switch (startPhase) { case ZSTARTPHASE1: - ljam(); + jam(); CLEAR_ERROR_INSERT_VALUE; ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0); ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0); @@ -270,7 +268,7 @@ void Dbtup::execSTTOR(Signal* signal) cownref = calcTupBlockRef(0); break; default: - ljam(); + jam(); break; }//switch signal->theData[0] = sigKey; @@ -293,7 +291,7 @@ void Dbtup::execREAD_CONFIG_REQ(Signal* signal) Uint32 senderData = req->senderData; ndbrequire(req->noOfParameters == 0); - ljamEntry(); + jamEntry(); const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); @@ -413,58 +411,58 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData, { switch (switchData) { case 0: - ljam(); + jam(); initializeHostBuffer(); break; case 1: - ljam(); + jam(); initializeOperationrec(); break; case 2: - ljam(); + jam(); initializePage(); break; case 3: - ljam(); + jam(); break; case 4: - ljam(); + jam(); initializeTablerec(); break; case 5: - ljam(); + jam(); break; case 6: - ljam(); + jam(); initializeFragrecord(); break; case 7: - ljam(); + jam(); initializeFragoperrec(); break; case 8: - ljam(); + jam(); initializePageRange(); break; case 9: - ljam(); + jam(); initializeTabDescr(); break; case 10: - ljam(); + jam(); break; case 11: - ljam(); + jam(); break; case 12: - ljam(); + jam(); initializeAttrbufrec(); break; case 13: - ljam(); + jam(); break; case 14: - ljam(); + jam(); { ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend(); @@ -488,28 +486,28 @@ void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData, void Dbtup::execNDB_STTOR(Signal* signal) { - ljamEntry(); + jamEntry(); cndbcntrRef = signal->theData[0]; Uint32 ownNodeId = signal->theData[1]; Uint32 startPhase = signal->theData[2]; switch (startPhase) { case ZSTARTPHASE1: - ljam(); + jam(); cownNodeId = ownNodeId; cownref = calcTupBlockRef(ownNodeId); break; case ZSTARTPHASE2: - ljam(); + jam(); break; case ZSTARTPHASE3: - ljam(); + jam(); startphase3Lab(signal, ~0, ~0); break; case ZSTARTPHASE4: - ljam(); + jam(); break; case ZSTARTPHASE6: - ljam(); + jam(); /*****************************************/ /* NOW SET THE DISK WRITE SPEED TO */ /* PAGES PER TICK AFTER SYSTEM */ @@ -520,7 +518,7 @@ void Dbtup::execNDB_STTOR(Signal* signal) sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1); break; default: - ljam(); + jam(); break; }//switch signal->theData[0] = cownref; @@ -597,7 +595,7 @@ void Dbtup::initializeTablerec() { TablerecPtr regTabPtr; for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) { - ljam(); + jam(); refresh_watch_dog(); ptrAss(regTabPtr, tablerec); initTab(regTabPtr.p); @@ -668,12 +666,12 @@ void Dbtup::initializeTabDescr() void Dbtup::execTUPSEIZEREQ(Signal* signal) { OperationrecPtr regOperPtr; - ljamEntry(); + jamEntry(); Uint32 userPtr = signal->theData[0]; BlockReference userRef = signal->theData[1]; if (!c_operation_pool.seize(regOperPtr)) { - ljam(); + jam(); signal->theData[0] = userPtr; signal->theData[1] = ZGET_OPREC_ERROR; sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB); @@ -707,7 +705,7 @@ void Dbtup::execTUPSEIZEREQ(Signal* signal) void Dbtup::execTUPRELEASEREQ(Signal* signal) { OperationrecPtr regOperPtr; - ljamEntry(); + jamEntry(); regOperPtr.i = signal->theData[0]; c_operation_pool.getPtr(regOperPtr); set_trans_state(regOperPtr.p, TRANS_DISCONNECTED); diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp index 3f42f0151e6..e4a26f8ccd0 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp @@ -14,6 +14,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_INDEX_CPP #include "Dbtup.hpp" #include #include @@ -23,9 +24,6 @@ #include #include -#define ljam() { jamLine(28000 + __LINE__); } -#define ljamEntry() { jamEntryLine(28000 + __LINE__); } - // methods used by ordered index void @@ -34,7 +32,7 @@ Dbtup::tuxGetTupAddr(Uint32 fragPtrI, Uint32 pageIndex, Uint32& tupAddr) { - ljamEntry(); + jamEntry(); PagePtr pagePtr; c_page_pool.getPtr(pagePtr, pageId); Uint32 fragPageId= pagePtr.p->frag_page_id; @@ -48,7 +46,7 @@ Dbtup::tuxAllocNode(Signal* signal, Uint32& pageOffset, Uint32*& node) { - ljamEntry(); + jamEntry(); FragrecordPtr fragPtr; fragPtr.i= fragPtrI; ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); @@ -61,7 +59,7 @@ Dbtup::tuxAllocNode(Signal* signal, Uint32* ptr, frag_page_id; if ((ptr= alloc_fix_rec(fragPtr.p, tablePtr.p, &key, &frag_page_id)) == 0) { - ljam(); + jam(); terrorCode = ZMEM_NOMEM_ERROR; // caller sets error return terrorCode; } @@ -82,7 +80,7 @@ Dbtup::tuxFreeNode(Signal* signal, Uint32 pageOffset, Uint32* node) { - ljamEntry(); + jamEntry(); FragrecordPtr fragPtr; fragPtr.i= fragPtrI; ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); @@ -105,7 +103,7 @@ Dbtup::tuxGetNode(Uint32 fragPtrI, Uint32 pageOffset, Uint32*& node) { - ljamEntry(); + jamEntry(); FragrecordPtr fragPtr; fragPtr.i= fragPtrI; ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); @@ -130,7 +128,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI, Uint32 numAttrs, Uint32* dataOut) { - ljamEntry(); + jamEntry(); // use own variables instead of globals FragrecordPtr fragPtr; fragPtr.i= fragPtrI; @@ -150,21 +148,21 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI, Tuple_header *tuple_ptr= req_struct.m_tuple_ptr; if (tuple_ptr->get_tuple_version() != tupVersion) { - ljam(); + jam(); OperationrecPtr opPtr; opPtr.i= tuple_ptr->m_operation_ptr_i; Uint32 loopGuard= 0; while (opPtr.i != RNIL) { c_operation_pool.getPtr(opPtr); if (opPtr.p->tupVersion == tupVersion) { - ljam(); + jam(); if (!opPtr.p->m_copy_tuple_location.isNull()) { req_struct.m_tuple_ptr= (Tuple_header*) c_undo_buffer.get_ptr(&opPtr.p->m_copy_tuple_location); } break; } - ljam(); + jam(); opPtr.i= opPtr.p->prevActiveOp; ndbrequire(++loopGuard < (1 << ZTUP_VERSION_BITS)); } @@ -202,7 +200,7 @@ Dbtup::tuxReadAttrs(Uint32 fragPtrI, int Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag) { - ljamEntry(); + jamEntry(); // use own variables instead of globals FragrecordPtr fragPtr; fragPtr.i= fragPtrI; @@ -305,7 +303,7 @@ Dbtup::tuxReadPk(Uint32 fragPtrI, Uint32 pageId, Uint32 pageIndex, Uint32* dataO int Dbtup::accReadPk(Uint32 tableId, Uint32 fragId, Uint32 fragPageId, Uint32 pageIndex, Uint32* dataOut, bool xfrmFlag) { - ljamEntry(); + jamEntry(); // get table TablerecPtr tablePtr; tablePtr.i = tableId; @@ -329,7 +327,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI, Uint32 transId2, Uint32 savePointId) { - ljamEntry(); + jamEntry(); FragrecordPtr fragPtr; fragPtr.i= fragPtrI; ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord); @@ -358,9 +356,9 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI, * for this transaction and savepoint id. If its tuple version * equals the requested then we have a visible tuple otherwise not. */ - ljam(); + jam(); if (req_struct.m_tuple_ptr->get_tuple_version() == tupVersion) { - ljam(); + jam(); return true; } } @@ -378,7 +376,7 @@ Dbtup::tuxQueryTh(Uint32 fragPtrI, void Dbtup::execBUILDINDXREQ(Signal* signal) { - ljamEntry(); + jamEntry(); #ifdef TIME_MEASUREMENT time_events= 0; tot_time_passed= 0; @@ -387,7 +385,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal) // get new operation BuildIndexPtr buildPtr; if (! c_buildIndexList.seize(buildPtr)) { - ljam(); + jam(); BuildIndexRec buildRec; memcpy(buildRec.m_request, signal->theData, sizeof(buildRec.m_request)); buildRec.m_errorCode= BuildIndxRef::Busy; @@ -402,7 +400,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal) do { const BuildIndxReq* buildReq= (const BuildIndxReq*)buildPtr.p->m_request; if (buildReq->getTableId() >= cnoOfTablerec) { - ljam(); + jam(); buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable; break; } @@ -410,7 +408,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal) tablePtr.i= buildReq->getTableId(); ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec); if (tablePtr.p->tableStatus != DEFINED) { - ljam(); + jam(); buildPtr.p->m_errorCode= BuildIndxRef::InvalidPrimaryTable; break; } @@ -418,7 +416,7 @@ Dbtup::execBUILDINDXREQ(Signal* signal) buildPtr.p->m_build_vs = tablePtr.p->m_attributes[MM].m_no_of_varsize > 0; if (DictTabInfo::isOrderedIndex(buildReq->getIndexType())) { - ljam(); + jam(); const DLList& triggerList = tablePtr.p->tuxCustomTriggers; @@ -426,13 +424,13 @@ Dbtup::execBUILDINDXREQ(Signal* signal) triggerList.first(triggerPtr); while (triggerPtr.i != RNIL) { if (triggerPtr.p->indexId == buildReq->getIndexId()) { - ljam(); + jam(); break; } triggerList.next(triggerPtr); } if (triggerPtr.i == RNIL) { - ljam(); + jam(); // trigger was not created buildPtr.p->m_errorCode = BuildIndxRef::InternalError; break; @@ -440,12 +438,12 @@ Dbtup::execBUILDINDXREQ(Signal* signal) buildPtr.p->m_indexId = buildReq->getIndexId(); buildPtr.p->m_buildRef = DBTUX; } else if(buildReq->getIndexId() == RNIL) { - ljam(); + jam(); // REBUILD of acc buildPtr.p->m_indexId = RNIL; buildPtr.p->m_buildRef = DBACC; } else { - ljam(); + jam(); buildPtr.p->m_errorCode = BuildIndxRef::InvalidIndexType; break; } @@ -490,7 +488,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) // get fragment FragrecordPtr fragPtr; if (buildPtr.p->m_fragNo == MAX_FRAG_PER_NODE) { - ljam(); + jam(); // build ready buildIndexReply(signal, buildPtr.p); c_buildIndexList.release(buildPtr); @@ -499,7 +497,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) ndbrequire(buildPtr.p->m_fragNo < MAX_FRAG_PER_NODE); fragPtr.i= tablePtr.p->fragrec[buildPtr.p->m_fragNo]; if (fragPtr.i == RNIL) { - ljam(); + jam(); buildPtr.p->m_fragNo++; buildPtr.p->m_pageId= 0; buildPtr.p->m_tupleNo= firstTupleNo; @@ -509,7 +507,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) // get page PagePtr pagePtr; if (buildPtr.p->m_pageId >= fragPtr.p->noOfPages) { - ljam(); + jam(); buildPtr.p->m_fragNo++; buildPtr.p->m_pageId= 0; buildPtr.p->m_tupleNo= firstTupleNo; @@ -520,7 +518,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) Uint32 pageState= pagePtr.p->page_state; // skip empty page if (pageState == ZEMPTY_MM) { - ljam(); + jam(); buildPtr.p->m_pageId++; buildPtr.p->m_tupleNo= firstTupleNo; break; @@ -530,7 +528,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) const Tuple_header* tuple_ptr = 0; pageIndex = buildPtr.p->m_tupleNo * tupheadsize; if (pageIndex + tupheadsize > Fix_page::DATA_WORDS) { - ljam(); + jam(); buildPtr.p->m_pageId++; buildPtr.p->m_tupleNo= firstTupleNo; break; @@ -538,7 +536,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) tuple_ptr = (Tuple_header*)&pagePtr.p->m_data[pageIndex]; // skip over free tuple if (tuple_ptr->m_header_bits & Tuple_header::FREE) { - ljam(); + jam(); buildPtr.p->m_tupleNo++; break; } @@ -581,7 +579,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) tuple as a copy tuple. The original tuple is stable and is thus preferrable to store in TUX. */ - ljam(); + jam(); /** * Since copy tuples now can't be found on real pages. @@ -610,11 +608,11 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI) } while(req->errorCode == 0 && pageOperPtr.i != RNIL); } - ljamEntry(); + jamEntry(); if (req->errorCode != 0) { switch (req->errorCode) { case TuxMaintReq::NoMemError: - ljam(); + jam(); buildPtr.p->m_errorCode= BuildIndxRef::AllocationFailure; break; default: @@ -666,7 +664,7 @@ Dbtup::buildIndexReply(Signal* signal, const BuildIndexRec* buildPtrP) rep->setIndexId(buildReq->getIndexId()); // conf if (buildPtrP->m_errorCode == BuildIndxRef::NoError) { - ljam(); + jam(); sendSignal(rep->getUserRef(), GSN_BUILDINDXCONF, signal, BuildIndxConf::SignalLength, JBB); return; diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp index b5010205880..aa1b1b546ac 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp @@ -15,6 +15,7 @@ #define DBTUP_C +#define DBTUP_META_CPP #include "Dbtup.hpp" #include #include @@ -29,16 +30,13 @@ #include "AttributeOffset.hpp" #include -#define ljam() { jamLine(20000 + __LINE__); } -#define ljamEntry() { jamEntryLine(20000 + __LINE__); } - void Dbtup::execTUPFRAGREQ(Signal* signal) { - ljamEntry(); + jamEntry(); TupFragReq* tupFragReq = (TupFragReq*)signal->getDataPtr(); if (tupFragReq->userPtr == (Uint32)-1) { - ljam(); + jam(); abortAddFragOp(signal); return; } @@ -70,7 +68,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) #ifndef VM_TRACE // config mismatch - do not crash if release compiled if (regTabPtr.i >= cnoOfTablerec) { - ljam(); + jam(); tupFragReq->userPtr = userptr; tupFragReq->userRef = 800; sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB); @@ -80,7 +78,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec); if (cfirstfreeFragopr == RNIL) { - ljam(); + jam(); tupFragReq->userPtr = userptr; tupFragReq->userRef = ZNOFREE_FRAGOP_ERROR; sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB); @@ -109,29 +107,29 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) getFragmentrec(regFragPtr, fragId, regTabPtr.p); if (regFragPtr.i != RNIL) { - ljam(); + jam(); terrorCode= ZEXIST_FRAG_ERROR; fragrefuse1Lab(signal, fragOperPtr); return; } if (cfirstfreefrag != RNIL) { - ljam(); + jam(); seizeFragrecord(regFragPtr); } else { - ljam(); + jam(); terrorCode= ZFULL_FRAGRECORD_ERROR; fragrefuse1Lab(signal, fragOperPtr); return; } initFragRange(regFragPtr.p); if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) { - ljam(); + jam(); terrorCode= ZNO_FREE_TAB_ENTRY_ERROR; fragrefuse2Lab(signal, fragOperPtr, regFragPtr); return; } if (cfirstfreerange == RNIL) { - ljam(); + jam(); terrorCode= ZNO_FREE_PAGE_RANGE_ERROR; fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); return; @@ -147,7 +145,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId || ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) { - ljam(); + jam(); terrorCode = 1; fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); CLEAR_ERROR_INSERT_VALUE; @@ -155,7 +153,7 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) } if (regTabPtr.p->tableStatus == NOT_DEFINED) { - ljam(); + jam(); //----------------------------------------------------------------------------- // We are setting up references to the header of the tuple. // Active operation This word contains a reference to the operation active @@ -201,13 +199,13 @@ void Dbtup::execTUPFRAGREQ(Signal* signal) Uint32 offset[10]; Uint32 tableDescriptorRef= allocTabDescr(regTabPtr.p, offset); if (tableDescriptorRef == RNIL) { - ljam(); + jam(); fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId); return; } setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset); } else { - ljam(); + jam(); fragOperPtr.p->definingFragment= false; } signal->theData[0]= fragOperPtr.p->lqhPtrFrag; @@ -223,9 +221,9 @@ bool Dbtup::addfragtotab(Tablerec* const regTabPtr, Uint32 fragIndex) { for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) { - ljam(); + jam(); if (regTabPtr->fragid[i] == RNIL) { - ljam(); + jam(); regTabPtr->fragid[i]= fragId; regTabPtr->fragrec[i]= fragIndex; return true; @@ -239,9 +237,9 @@ void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr, Tablerec* const regTabPtr) { for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) { - ljam(); + jam(); if (regTabPtr->fragid[i] == fragId) { - ljam(); + jam(); regFragPtr.i= regTabPtr->fragrec[i]; ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); return; @@ -277,7 +275,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) FragoperrecPtr fragOperPtr; TablerecPtr regTabPtr; - ljamEntry(); + jamEntry(); fragOperPtr.i= signal->theData[0]; ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec); Uint32 attrId = signal->theData[2]; @@ -338,7 +336,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) Uint32 attrDes2= 0; if (!AttributeDescriptor::getDynamic(attrDescriptor)) { - ljam(); + jam(); Uint32 pos= 0, null_pos; Uint32 bytes= AttributeDescriptor::getSizeInBytes(attrDescriptor); Uint32 words= (bytes + 3) / 4; @@ -348,7 +346,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) if (AttributeDescriptor::getNullable(attrDescriptor)) { - ljam(); + jam(); fragOperPtr.p->m_null_bits[ind]++; } else @@ -363,17 +361,17 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) switch (AttributeDescriptor::getArrayType(attrDescriptor)) { case NDB_ARRAYTYPE_FIXED: { - ljam(); + jam(); regTabPtr.p->m_attributes[ind].m_no_of_fixsize++; if(attrLen != 0) { - ljam(); + jam(); pos= fragOperPtr.p->m_fix_attributes_size[ind]; fragOperPtr.p->m_fix_attributes_size[ind] += words; } else { - ljam(); + jam(); Uint32 bitCount = AttributeDescriptor::getArraySize(attrDescriptor); fragOperPtr.p->m_null_bits[ind] += bitCount; } @@ -381,7 +379,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) } default: { - ljam(); + jam(); fragOperPtr.p->m_var_attributes_size[ind] += bytes; pos= regTabPtr.p->m_attributes[ind].m_no_of_varsize++; break; @@ -398,13 +396,13 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) ndbrequire(cs != NULL); Uint32 i = 0; while (i < fragOperPtr.p->charsetIndex) { - ljam(); + jam(); if (regTabPtr.p->charsetArray[i] == cs) break; i++; } if (i == fragOperPtr.p->charsetIndex) { - ljam(); + jam(); fragOperPtr.p->charsetIndex++; } ndbrequire(i < regTabPtr.p->noOfCharsets); @@ -417,7 +415,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId && lastAttr || ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0|| ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId && lastAttr) { - ljam(); + jam(); terrorCode = 1; addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId); CLEAR_ERROR_INSERT_VALUE; @@ -428,7 +426,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) /* ************** TUP_ADD_ATTCONF ****************** */ /* **************************************************************** */ if (! lastAttr) { - ljam(); + jam(); signal->theData[0] = fragOperPtr.p->lqhPtrFrag; signal->theData[1] = lastAttr; sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, @@ -554,7 +552,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages); if (noAllocatedPages == 0) { - ljam(); + jam(); terrorCode = ZNO_PAGES_ALLOCATED_ERROR; addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId); return; @@ -564,7 +562,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) CreateFilegroupImplReq rep; if(regTabPtr.p->m_no_of_disk_attributes) { - ljam(); + jam(); Tablespace_client tsman(0, c_tsman, 0, 0, regFragPtr.p->m_tablespace_id); ndbrequire(tsman.get_tablespace_info(&rep) == 0); @@ -581,12 +579,12 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) if (regTabPtr.p->m_no_of_disk_attributes) { - ljam(); + jam(); if(!(getNodeState().startLevel == NodeState::SL_STARTING && getNodeState().starting.startPhase <= 4)) { Callback cb; - ljam(); + jam(); cb.m_callbackData= fragOperPtr.i; cb.m_callbackFunction = @@ -600,7 +598,7 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal) int res= lgman.get_log_buffer(signal, sz, &cb); switch(res){ case 0: - ljam(); + jam(); signal->theData[0] = 1; return; case -1: @@ -719,11 +717,11 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr) Uint32* keyArray= &tableDescriptor[regTabPtr->readKeyArray].tabDescr; Uint32 countKeyAttr= 0; for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) { - ljam(); + jam(); Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE); Uint32 attrDescriptor= getTabDescrWord(refAttr); if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) { - ljam(); + jam(); AttributeHeader::init(&keyArray[countKeyAttr], i, 0); countKeyAttr++; } @@ -743,7 +741,7 @@ void Dbtup::setUpKeyArray(Tablerec* const regTabPtr) { for (Uint32 i= 0; i < regTabPtr->m_no_of_attributes; i++) { - ljam(); + jam(); Uint32 refAttr= regTabPtr->tabDescriptor + (i * ZAD_SIZE); Uint32 desc = getTabDescrWord(refAttr); Uint32 t = 0; @@ -838,9 +836,9 @@ void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr) void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) { for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) { - ljam(); + jam(); if (regTabPtr->fragid[i] == fragId) { - ljam(); + jam(); regTabPtr->fragid[i]= RNIL; regTabPtr->fragrec[i]= RNIL; return; @@ -866,7 +864,7 @@ void Dbtup::abortAddFragOp(Signal* signal) void Dbtup::execDROP_TAB_REQ(Signal* signal) { - ljamEntry(); + jamEntry(); if (ERROR_INSERTED(4013)) { #ifdef VM_TRACE verifytabdes(); @@ -892,7 +890,7 @@ void Dbtup::releaseTabDescr(Tablerec* const regTabPtr) { Uint32 descriptor= regTabPtr->readKeyArray; if (descriptor != RNIL) { - ljam(); + jam(); Uint32 offset[10]; getTabDescrOffsets(regTabPtr, offset); @@ -923,16 +921,16 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId, Uint32 fragId = RNIL; Uint32 i = 0; for (i = 0; i < MAX_FRAG_PER_NODE; i++) { - ljam(); + jam(); if (tabPtr.p->fragid[i] != RNIL) { - ljam(); + jam(); fragIndex= tabPtr.p->fragrec[i]; fragId= tabPtr.p->fragid[i]; break; } } if (fragIndex != RNIL) { - ljam(); + jam(); signal->theData[0] = ZUNMAP_PAGES; signal->theData[1] = tabPtr.i; @@ -957,7 +955,7 @@ void Dbtup::releaseFragment(Signal* signal, Uint32 tableId, int res= lgman.get_log_buffer(signal, sz, &cb); switch(res){ case 0: - ljam(); + jam(); return; case -1: ndbrequire("NOT YET IMPLEMENTED" == 0); @@ -1088,7 +1086,7 @@ Dbtup::drop_fragment_free_extent(Signal *signal, int res= lgman.get_log_buffer(signal, sz, &cb); switch(res){ case 0: - ljam(); + jam(); return; case -1: ndbrequire("NOT YET IMPLEMENTED" == 0); @@ -1239,7 +1237,7 @@ Dbtup::drop_fragment_free_extent_log_buffer_callback(Signal* signal, void Dbtup::drop_fragment_free_var_pages(Signal* signal) { - ljam(); + jam(); Uint32 tableId = signal->theData[1]; Uint32 fragPtrI = signal->theData[2]; diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp index 73755494207..d10fabf42da 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPagMan.cpp @@ -14,14 +14,12 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_PAG_MAN_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(16000 + __LINE__); } -#define ljamEntry() { jamEntryLine(16000 + __LINE__); } - /* ---------------------------------------------------------------- */ // 4) Page Memory Manager (buddy algorithm) // @@ -121,7 +119,7 @@ void Dbtup::initializePage() }//for PagePtr pagePtr; for (pagePtr.i = 0; pagePtr.i < c_page_pool.getSize(); pagePtr.i++) { - ljam(); + jam(); refresh_watch_dog(); c_page_pool.getPtr(pagePtr); pagePtr.p->physical_page_id= RNIL; @@ -153,16 +151,16 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate, Uint32& allocPageRef) { if (noOfPagesToAllocate == 0){ - ljam(); + jam(); noOfPagesAllocated = 0; return; }//if Uint32 firstListToCheck = nextHigherTwoLog(noOfPagesToAllocate - 1); for (Uint32 i = firstListToCheck; i < 16; i++) { - ljam(); + jam(); if (cfreepageList[i] != RNIL) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* PROPER AMOUNT OF PAGES WERE FOUND. NOW SPLIT THE FOUND */ /* AREA AND RETURN THE PART NOT NEEDED. */ @@ -182,11 +180,11 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate, /* ---------------------------------------------------------------- */ if (firstListToCheck) { - ljam(); + jam(); for (Uint32 j = firstListToCheck - 1; (Uint32)~j; j--) { - ljam(); + jam(); if (cfreepageList[j] != RNIL) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* SOME AREA WAS FOUND, ALLOCATE ALL OF IT. */ /* ---------------------------------------------------------------- */ @@ -212,9 +210,9 @@ void Dbtup::allocConsPages(Uint32 noOfPagesToAllocate, void Dbtup::returnCommonArea(Uint32 retPageRef, Uint32 retNo) { do { - ljam(); + jam(); if (retNo == 0) { - ljam(); + jam(); return; }//if Uint32 list = nextHigherTwoLog(retNo) - 1; @@ -231,28 +229,28 @@ void Dbtup::findFreeLeftNeighbours(Uint32& allocPageRef, PagePtr pageFirstPtr, pageLastPtr; Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated; while (allocPageRef > 0) { - ljam(); + jam(); pageLastPtr.i = allocPageRef - 1; c_page_pool.getPtr(pageLastPtr); if (pageLastPtr.p->page_state != ZFREE_COMMON) { - ljam(); + jam(); return; } else { - ljam(); + jam(); pageFirstPtr.i = pageLastPtr.p->first_cluster_page; ndbrequire(pageFirstPtr.i != RNIL); Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i); removeCommonArea(pageFirstPtr.i, list); Uint32 listSize = 1 << list; if (listSize > remainAllocate) { - ljam(); + jam(); Uint32 retNo = listSize - remainAllocate; returnCommonArea(pageFirstPtr.i, retNo); allocPageRef = pageFirstPtr.i + retNo; noPagesAllocated = noOfPagesToAllocate; return; } else { - ljam(); + jam(); allocPageRef = pageFirstPtr.i; noPagesAllocated += listSize; remainAllocate -= listSize; @@ -268,32 +266,32 @@ void Dbtup::findFreeRightNeighbours(Uint32& allocPageRef, PagePtr pageFirstPtr, pageLastPtr; Uint32 remainAllocate = noOfPagesToAllocate - noPagesAllocated; if (remainAllocate == 0) { - ljam(); + jam(); return; }//if while ((allocPageRef + noPagesAllocated) < c_page_pool.getSize()) { - ljam(); + jam(); pageFirstPtr.i = allocPageRef + noPagesAllocated; c_page_pool.getPtr(pageFirstPtr); if (pageFirstPtr.p->page_state != ZFREE_COMMON) { - ljam(); + jam(); return; } else { - ljam(); + jam(); pageLastPtr.i = pageFirstPtr.p->last_cluster_page; ndbrequire(pageLastPtr.i != RNIL); Uint32 list = nextHigherTwoLog(pageLastPtr.i - pageFirstPtr.i); removeCommonArea(pageFirstPtr.i, list); Uint32 listSize = 1 << list; if (listSize > remainAllocate) { - ljam(); + jam(); Uint32 retPageRef = pageFirstPtr.i + remainAllocate; Uint32 retNo = listSize - remainAllocate; returnCommonArea(retPageRef, retNo); noPagesAllocated += remainAllocate; return; } else { - ljam(); + jam(); noPagesAllocated += listSize; remainAllocate -= listSize; }//if @@ -328,30 +326,30 @@ void Dbtup::removeCommonArea(Uint32 remPageRef, Uint32 list) c_page_pool.getPtr(remPagePtr, remPageRef); ndbrequire(list < 16); if (cfreepageList[list] == remPagePtr.i) { - ljam(); + jam(); cfreepageList[list] = remPagePtr.p->next_cluster_page; pageNextPtr.i = cfreepageList[list]; if (pageNextPtr.i != RNIL) { - ljam(); + jam(); c_page_pool.getPtr(pageNextPtr); pageNextPtr.p->prev_cluster_page = RNIL; }//if } else { pageSearchPtr.i = cfreepageList[list]; while (true) { - ljam(); + jam(); c_page_pool.getPtr(pageSearchPtr); pagePrevPtr = pageSearchPtr; pageSearchPtr.i = pageSearchPtr.p->next_cluster_page; if (pageSearchPtr.i == remPagePtr.i) { - ljam(); + jam(); break; }//if }//while pageNextPtr.i = remPagePtr.p->next_cluster_page; pagePrevPtr.p->next_cluster_page = pageNextPtr.i; if (pageNextPtr.i != RNIL) { - ljam(); + jam(); c_page_pool.getPtr(pageNextPtr); pageNextPtr.p->prev_cluster_page = pagePrevPtr.i; }//if diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp index 26373708b66..cbbbc1fa56c 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupPageMap.cpp @@ -15,14 +15,12 @@ #define DBTUP_C +#define DBTUP_PAGE_MAP_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(14000 + __LINE__); } -#define ljamEntry() { jamEntryLine(14000 + __LINE__); } - // // PageMap is a service used by Dbtup to map logical page id's to physical // page id's. The mapping is needs the fragment and the logical page id to @@ -92,11 +90,11 @@ Uint32 Dbtup::getEmptyPage(Fragrecord* regFragPtr) { Uint32 pageId = regFragPtr->emptyPrimPage.firstItem; if (pageId == RNIL) { - ljam(); + jam(); allocMoreFragPages(regFragPtr); pageId = regFragPtr->emptyPrimPage.firstItem; if (pageId == RNIL) { - ljam(); + jam(); return RNIL; }//if }//if @@ -122,11 +120,11 @@ Uint32 Dbtup::getRealpid(Fragrecord* regFragPtr, Uint32 logicalPageId) loopLimit = grpPageRangePtr.p->currentIndexPos; ndbrequire(loopLimit <= 3); for (Uint32 i = 0; i <= loopLimit; i++) { - ljam(); + jam(); if (grpPageRangePtr.p->startRange[i] <= logicalPageId) { if (grpPageRangePtr.p->endRange[i] >= logicalPageId) { if (grpPageRangePtr.p->type[i] == ZLEAF) { - ljam(); + jam(); Uint32 realPageId = (logicalPageId - grpPageRangePtr.p->startRange[i]) + grpPageRangePtr.p->basePageId[i]; return realPageId; @@ -167,12 +165,12 @@ bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, { PageRangePtr currPageRangePtr; if (cfirstfreerange == RNIL) { - ljam(); + jam(); return false; }//if currPageRangePtr.i = regFragPtr->currentPageRange; if (currPageRangePtr.i == RNIL) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* THE FIRST PAGE RANGE IS HANDLED WITH SPECIAL CODE */ /* ---------------------------------------------------------------- */ @@ -181,10 +179,10 @@ bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, currPageRangePtr.p->currentIndexPos = 0; currPageRangePtr.p->parentPtr = RNIL; } else { - ljam(); + jam(); ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange); if (currPageRangePtr.p->currentIndexPos < 3) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* THE SIMPLE CASE WHEN IT IS ONLY NECESSARY TO FILL IN THE */ /* NEXT EMPTY POSITION IN THE PAGE RANGE RECORD IS TREATED */ @@ -192,7 +190,7 @@ bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, /* ---------------------------------------------------------------- */ currPageRangePtr.p->currentIndexPos++; } else { - ljam(); + jam(); ndbrequire(currPageRangePtr.p->currentIndexPos == 3); currPageRangePtr.i = leafPageRangeFull(regFragPtr, currPageRangePtr); if (currPageRangePtr.i == RNIL) { @@ -223,15 +221,15 @@ bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, PageRangePtr loopPageRangePtr; loopPageRangePtr = currPageRangePtr; while (true) { - ljam(); + jam(); loopPageRangePtr.i = loopPageRangePtr.p->parentPtr; if (loopPageRangePtr.i != RNIL) { - ljam(); + jam(); ptrCheckGuard(loopPageRangePtr, cnoOfPageRangeRec, pageRange); ndbrequire(loopPageRangePtr.p->currentIndexPos < 4); loopPageRangePtr.p->endRange[loopPageRangePtr.p->currentIndexPos] += noPages; } else { - ljam(); + jam(); break; }//if }//while @@ -243,26 +241,26 @@ bool Dbtup::insertPageRangeTab(Fragrecord* const regFragPtr, void Dbtup::releaseFragPages(Fragrecord* regFragPtr) { if (regFragPtr->rootPageRange == RNIL) { - ljam(); + jam(); return; }//if PageRangePtr regPRPtr; regPRPtr.i = regFragPtr->rootPageRange; ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange); while (true) { - ljam(); + jam(); const Uint32 indexPos = regPRPtr.p->currentIndexPos; ndbrequire(indexPos < 4); const Uint32 basePageId = regPRPtr.p->basePageId[indexPos]; regPRPtr.p->basePageId[indexPos] = RNIL; if (basePageId == RNIL) { - ljam(); + jam(); /** * Finished with indexPos continue with next */ if (indexPos > 0) { - ljam(); + jam(); regPRPtr.p->currentIndexPos--; continue; }//if @@ -274,13 +272,13 @@ void Dbtup::releaseFragPages(Fragrecord* regFragPtr) releasePagerange(regPRPtr); if (parentPtr != RNIL) { - ljam(); + jam(); regPRPtr.i = parentPtr; ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange); continue; }//if - ljam(); + jam(); ndbrequire(regPRPtr.i == regFragPtr->rootPageRange); initFragRange(regFragPtr); for (Uint32 i = 0; inextStartRange; if (!insertPageRangeTab(regFragPtr, retPageRef, noOfPagesAllocated)) { - ljam(); + jam(); returnCommonArea(retPageRef, noOfPagesAllocated); return tafpPagesAllocated; }//if @@ -388,7 +386,7 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested /* ---------------------------------------------------------------- */ Uint32 prev = RNIL; for (loopPagePtr.i = retPageRef; loopPagePtr.i < loopLimit; loopPagePtr.i++) { - ljam(); + jam(); c_page_pool.getPtr(loopPagePtr); loopPagePtr.p->page_state = ZEMPTY_MM; loopPagePtr.p->frag_page_id = startRange + @@ -416,10 +414,10 @@ Uint32 Dbtup::allocFragPages(Fragrecord* regFragPtr, Uint32 tafpNoAllocRequested /* WAS ENOUGH PAGES ALLOCATED OR ARE MORE NEEDED. */ /* ---------------------------------------------------------------- */ if (tafpPagesAllocated < tafpNoAllocRequested) { - ljam(); + jam(); } else { ndbrequire(tafpPagesAllocated == tafpNoAllocRequested); - ljam(); + jam(); return tafpNoAllocRequested; }//if }//while @@ -451,15 +449,15 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr parentPageRangePtr = currPageRangePtr; Uint32 tiprNoLevels = 1; while (true) { - ljam(); + jam(); parentPageRangePtr.i = parentPageRangePtr.p->parentPtr; if (parentPageRangePtr.i == RNIL) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* WE HAVE REACHED THE ROOT. A NEW ROOT MUST BE ALLOCATED. */ /* ---------------------------------------------------------------- */ if (c_noOfFreePageRanges < tiprNoLevels) { - ljam(); + jam(); return RNIL; }//if PageRangePtr oldRootPRPtr; @@ -482,10 +480,10 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr foundPageRangePtr = newRootPRPtr; break; } else { - ljam(); + jam(); ptrCheckGuard(parentPageRangePtr, cnoOfPageRangeRec, pageRange); if (parentPageRangePtr.p->currentIndexPos < 3) { - ljam(); + jam(); /* ---------------------------------------------------------------- */ /* WE HAVE FOUND AN EMPTY ENTRY IN A PAGE RANGE RECORD. */ /* ALLOCATE A NEW PAGE RANGE RECORD, FILL IN THE START RANGE, */ @@ -498,7 +496,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr foundPageRangePtr = parentPageRangePtr; break; } else { - ljam(); + jam(); ndbrequire(parentPageRangePtr.p->currentIndexPos == 3); /* ---------------------------------------------------------------- */ /* THE PAGE RANGE RECORD WAS FULL. FIND THE PARENT RECORD */ @@ -516,7 +514,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr PageRangePtr prevPageRangePtr; prevPageRangePtr = foundPageRangePtr; if (c_noOfFreePageRanges < tiprNoLevels) { - ljam(); + jam(); return RNIL; }//if /* ---------------------------------------------------------------- */ @@ -527,7 +525,7 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr /* ARE ALSO PROPERLY UPDATED ON THE PATH TO THE LEAF LEVEL. */ /* ---------------------------------------------------------------- */ while (true) { - ljam(); + jam(); seizePagerange(newPageRangePtr); tiprNoLevels--; ndbrequire(prevPageRangePtr.p->currentIndexPos < 4); @@ -535,13 +533,13 @@ Uint32 Dbtup::leafPageRangeFull(Fragrecord* const regFragPtr, PageRangePtr curr newPageRangePtr.p->parentPtr = prevPageRangePtr.i; newPageRangePtr.p->currentIndexPos = 0; if (tiprNoLevels > 0) { - ljam(); + jam(); newPageRangePtr.p->startRange[0] = regFragPtr->nextStartRange; newPageRangePtr.p->endRange[0] = regFragPtr->nextStartRange - 1; newPageRangePtr.p->type[0] = ZNON_LEAF; prevPageRangePtr = newPageRangePtr; } else { - ljam(); + jam(); break; }//if }//while @@ -576,16 +574,16 @@ void Dbtup::errorHandler(Uint32 errorCode) { switch (errorCode) { case 0: - ljam(); + jam(); break; case 1: - ljam(); + jam(); break; case 2: - ljam(); + jam(); break; default: - ljam(); + jam(); } ndbrequire(false); }//Dbtup::errorHandler() diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp index c8546209f94..44c0092811c 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupRoutines.cpp @@ -15,6 +15,7 @@ #define DBTUP_C +#define DBTUP_ROUTINES_CPP #include "Dbtup.hpp" #include #include @@ -23,9 +24,6 @@ #include "AttributeOffset.hpp" #include -#define ljam() { jamLine(3000 + __LINE__); } -#define ljamEntry() { jamEntryLine(3000 + __LINE__); } - void Dbtup::setUpQueryRoutines(Tablerec *regTabPtr) { @@ -40,23 +38,23 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr) if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){ if (!AttributeDescriptor::getNullable(attrDescr)) { if (AttributeDescriptor::getSize(attrDescr) == 0){ - ljam(); + jam(); regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNotNULL; regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNotNULL; } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4) { - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readFixedSizeTHOneWordNotNULL; regTabPtr->updateFunctionArray[i]= &Dbtup::updateFixedSizeTHOneWordNotNULL; } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) { - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readFixedSizeTHTwoWordNotNULL; regTabPtr->updateFunctionArray[i]= &Dbtup::updateFixedSizeTHTwoWordNotNULL; } else { - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readFixedSizeTHManyWordNotNULL; regTabPtr->updateFunctionArray[i]= @@ -64,27 +62,27 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr) } // replace functions for char attribute if (AttributeOffset::getCharsetFlag(attrOffset)) { - ljam(); + jam(); regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNotNULL; regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNotNULL; } } else { if (AttributeDescriptor::getSize(attrDescr) == 0){ - ljam(); + jam(); regTabPtr->readFunctionArray[i] = &Dbtup::readBitsNULLable; regTabPtr->updateFunctionArray[i] = &Dbtup::updateBitsNULLable; } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 4){ - ljam(); + jam(); regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNULLable; regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; } else if (AttributeDescriptor::getSizeInBytes(attrDescr) == 8) { - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readFixedSizeTHTwoWordNULLable; regTabPtr->updateFunctionArray[i]= &Dbtup::updateFixedSizeTHManyWordNULLable; } else { - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readFixedSizeTHManyWordNULLable; regTabPtr->updateFunctionArray[i]= @@ -92,7 +90,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr) } // replace functions for char attribute if (AttributeOffset::getCharsetFlag(attrOffset)) { - ljam(); + jam(); regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNULLable; regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable; } @@ -144,7 +142,7 @@ Dbtup::setUpQueryRoutines(Tablerec *regTabPtr) } } else { if (AttributeDescriptor::getArrayType(attrDescr) == NDB_ARRAYTYPE_FIXED){ - ljam(); + jam(); regTabPtr->readFunctionArray[i]= &Dbtup::readDynFixedSize; regTabPtr->updateFunctionArray[i]= &Dbtup::updateDynFixedSize; } else { @@ -204,7 +202,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct, inBufIndex++; attributeId= ahIn.getAttributeId(); descr_index= attributeId << ZAD_LOG_SIZE; - ljam(); + jam(); AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, 0); ahOut= (AttributeHeader*)&outBuffer[tmpAttrBufIndex]; @@ -223,7 +221,7 @@ int Dbtup::readAttributes(KeyReqStruct *req_struct, return -1; } } else if(attributeId & AttributeHeader::PSEUDO) { - ljam(); + jam(); Uint32 sz= read_pseudo(attributeId, req_struct, outBuffer+tmpAttrBufIndex+1); @@ -252,13 +250,13 @@ Dbtup::readFixedSizeTHOneWordNotNULL(Uint32* outBuffer, ndbrequire(readOffset < req_struct->check_offset[MM]); if (newIndexBuf <= maxRead) { - ljam(); + jam(); outBuffer[indexBuf]= wordRead; ahOut->setDataSize(1); req_struct->out_buf_index= newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR; return false; } @@ -280,14 +278,14 @@ Dbtup::readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer, ndbrequire(readOffset + 1 < req_struct->check_offset[MM]); if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setDataSize(2); outBuffer[indexBuf]= wordReadFirst; outBuffer[indexBuf + 1]= wordReadSecond; req_struct->out_buf_index= newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR; return false; } @@ -311,7 +309,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, if (! charsetFlag || ! req_struct->xfrm_flag) { Uint32 newIndexBuf = indexBuf + attrNoOfWords; if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor)); MEMCOPY_NO_WORDS(&outBuffer[indexBuf], &tuple_header[readOffset], @@ -319,11 +317,11 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, req_struct->out_buf_index = newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; }//if } else { - ljam(); + jam(); Tablerec* regTabPtr = tabptr.p; Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor); uchar* dstPtr = (uchar*)&outBuffer[indexBuf]; @@ -340,7 +338,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, Uint32 dstLen = xmul * (srcBytes - lb); Uint32 maxIndexBuf = indexBuf + (dstLen >> 2); if (maxIndexBuf <= maxRead && ok) { - ljam(); + jam(); const char* ssrcPtr = (const char*)srcPtr; int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len); ndbrequire(n != -1); @@ -354,7 +352,7 @@ Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer, req_struct->out_buf_index = newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; } } @@ -368,13 +366,13 @@ Dbtup::readFixedSizeTHOneWordNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readFixedSizeTHOneWordNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -387,13 +385,13 @@ Dbtup::readFixedSizeTHTwoWordNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readFixedSizeTHTwoWordNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -406,13 +404,13 @@ Dbtup::readFixedSizeTHManyWordNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readFixedSizeTHManyWordNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -424,9 +422,9 @@ Dbtup::readFixedSizeTHZeroWordNULLable(Uint32* outBuffer, AttributeHeader* ahOut, Uint32 attrDes2) { - ljam(); + jam(); if (nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); ahOut->setNULL(); } return true; @@ -478,7 +476,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer, if (! charsetFlag || ! req_struct->xfrm_flag) { if (new_index <= max_read) { - ljam(); + jam(); ah_out->setByteSize(vsize_in_bytes); out_buffer[index_buf + (vsize_in_bytes >> 2)] = 0; memcpy(out_buffer+index_buf, @@ -490,7 +488,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer, } else { - ljam(); + jam(); Tablerec* regTabPtr = tabptr.p; Uint32 maxBytes = AttributeDescriptor::getSizeInBytes(attr_descriptor); Uint32 srcBytes = vsize_in_bytes; @@ -509,7 +507,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer, Uint32 dstLen = xmul * (maxBytes - lb); Uint32 maxIndexBuf = index_buf + (dstLen >> 2); if (maxIndexBuf <= max_read && ok) { - ljam(); + jam(); const char* ssrcPtr = (const char*)srcPtr; int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len); ndbrequire(n != -1); @@ -524,7 +522,7 @@ Dbtup::readVarSizeNotNULL(Uint32* out_buffer, return true; } } - ljam(); + jam(); terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR; return false; } @@ -536,13 +534,13 @@ Dbtup::readVarSizeNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readVarSizeNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -554,7 +552,7 @@ Dbtup::readDynFixedSize(Uint32* outBuffer, AttributeHeader* ahOut, Uint32 attrDes2) { - ljam(); + jam(); terrorCode= ZVAR_SIZED_NOT_SUPPORTED; return false; } @@ -565,7 +563,7 @@ Dbtup::readDynVarSize(Uint32* outBuffer, AttributeHeader* ahOut, Uint32 attrDes2) { - ljam(); + jam(); terrorCode= ZVAR_SIZED_NOT_SUPPORTED; return false; }//Dbtup::readDynBigVarSize() @@ -588,7 +586,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer, if (! charsetFlag || ! req_struct->xfrm_flag) { Uint32 newIndexBuf = indexBuf + attrNoOfWords; if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setByteSize(AttributeDescriptor::getSizeInBytes(attrDescriptor)); MEMCOPY_NO_WORDS(&outBuffer[indexBuf], &tuple_header[readOffset], @@ -596,11 +594,11 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer, req_struct->out_buf_index = newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; }//if } else { - ljam(); + jam(); Tablerec* regTabPtr = tabptr.p; Uint32 srcBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor); uchar* dstPtr = (uchar*)&outBuffer[indexBuf]; @@ -617,7 +615,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer, Uint32 dstLen = xmul * (srcBytes - lb); Uint32 maxIndexBuf = indexBuf + (dstLen >> 2); if (maxIndexBuf <= maxRead && ok) { - ljam(); + jam(); const char* ssrcPtr = (const char*)srcPtr; int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len); ndbrequire(n != -1); @@ -631,7 +629,7 @@ Dbtup::readDiskFixedSizeNotNULL(Uint32* outBuffer, req_struct->out_buf_index = newIndexBuf; return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; } } @@ -645,13 +643,13 @@ Dbtup::readDiskFixedSizeNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!disk_nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readDiskFixedSizeNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -680,7 +678,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer, ndbrequire(vsize_in_words <= max_var_size); if (new_index <= max_read) { - ljam(); + jam(); ah_out->setByteSize(vsize_in_bytes); memcpy(out_buffer+index_buf, req_struct->m_var_data[DD].m_data_ptr+var_attr_pos, @@ -688,7 +686,7 @@ Dbtup::readDiskVarSizeNotNULL(Uint32* out_buffer, req_struct->out_buf_index= new_index; return true; } else { - ljam(); + jam(); terrorCode= ZTRY_TO_READ_TOO_MUCH_ERROR; return false; } @@ -701,13 +699,13 @@ Dbtup::readDiskVarSizeNULLable(Uint32* outBuffer, Uint32 attrDes2) { if (!disk_nullFlagCheck(req_struct, attrDes2)) { - ljam(); + jam(); return readDiskVarSizeNotNULL(outBuffer, req_struct, ahOut, attrDes2); } else { - ljam(); + jam(); ahOut->setNULL(); return true; } @@ -749,13 +747,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct, if (checkUpdateOfPrimaryKey(req_struct, &inBuffer[inBufIndex], regTabPtr)) { - ljam(); + jam(); terrorCode= ZTRY_UPDATE_PRIMARY_KEY; return -1; } } UpdateFunction f= regTabPtr->updateFunctionArray[attributeId]; - ljam(); + jam(); req_struct->attr_descriptor= attrDescriptor; req_struct->changeMask.set(attributeId); if (attributeId >= 64) { @@ -771,13 +769,13 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct, inBufIndex= req_struct->in_buf_index; continue; } else { - ljam(); + jam(); return -1; } } else if(attributeId == AttributeHeader::DISK_REF) { - ljam(); + jam(); Uint32 sz= ahIn.getDataSize(); ndbrequire(sz == 2); req_struct->m_tuple_ptr->m_header_bits |= Tuple_header::DISK_PART; @@ -788,7 +786,7 @@ int Dbtup::updateAttributes(KeyReqStruct *req_struct, } else { - ljam(); + jam(); terrorCode= ZATTRIBUTE_ID_ERROR; return -1; } @@ -842,13 +840,13 @@ Dbtup::checkUpdateOfPrimaryKey(KeyReqStruct* req_struct, ndbrequire(req_struct->out_buf_index == ahOut->getDataSize()); if (ahIn.getDataSize() != ahOut->getDataSize()) { - ljam(); + jam(); return true; } if (memcmp(&keyReadBuffer[0], &updateBuffer[1], req_struct->out_buf_index << 2) != 0) { - ljam(); + jam(); return true; } return false; @@ -871,17 +869,17 @@ Dbtup::updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer, if (newIndex <= inBufLen) { Uint32 updateWord= inBuffer[indexBuf + 1]; if (!nullIndicator) { - ljam(); + jam(); req_struct->in_buf_index= newIndex; tuple_header[updateOffset]= updateWord; return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -906,18 +904,18 @@ Dbtup::updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer, Uint32 updateWord1= inBuffer[indexBuf + 1]; Uint32 updateWord2= inBuffer[indexBuf + 2]; if (!nullIndicator) { - ljam(); + jam(); req_struct->in_buf_index= newIndex; tuple_header[updateOffset]= updateWord1; tuple_header[updateOffset + 1]= updateWord2; return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -943,9 +941,9 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer, if (newIndex <= inBufLen) { if (!nullIndicator) { - ljam(); + jam(); if (charsetFlag) { - ljam(); + jam(); Tablerec* regTabPtr = tabptr.p; Uint32 typeId = AttributeDescriptor::getType(attrDescriptor); Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor); @@ -957,14 +955,14 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer, const char* ssrc = (const char*)&inBuffer[indexBuf + 1]; Uint32 lb, len; if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) { - ljam(); + jam(); terrorCode = ZINVALID_CHAR_FORMAT; return false; } // fast fix bug#7340 if (typeId != NDB_TYPE_TEXT && (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, ¬_used) != len) { - ljam(); + jam(); terrorCode = ZINVALID_CHAR_FORMAT; return false; } @@ -976,12 +974,12 @@ Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer, return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -999,7 +997,7 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer, Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr); if (!nullIndicator) { - ljam(); + jam(); BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos); return updateFixedSizeTHManyWordNotNULL(inBuffer, req_struct, @@ -1008,11 +1006,11 @@ Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer, Uint32 newIndex= req_struct->in_buf_index + 1; if (newIndex <= req_struct->in_buf_len) { BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos); - ljam(); + jam(); req_struct->in_buf_index= newIndex; return true; } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1046,7 +1044,7 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer, if (new_index <= in_buf_len && vsize_in_words <= max_var_size) { if (!null_ind) { - ljam(); + jam(); var_attr_pos= vpos_array[var_index]; var_data_start= req_struct->m_var_data[MM].m_data_ptr; vpos_array[var_index+idx]= var_attr_pos+size_in_bytes; @@ -1057,12 +1055,12 @@ Dbtup::updateVarSizeNotNULL(Uint32* in_buffer, size_in_bytes); return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1082,7 +1080,7 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer, Uint32 idx= req_struct->m_var_data[MM].m_var_len_offset; if (!nullIndicator) { - ljam(); + jam(); BitmaskImpl::clear(regTabPtr->m_offsets[MM].m_null_words, bits, pos); return updateVarSizeNotNULL(inBuffer, req_struct, @@ -1092,13 +1090,13 @@ Dbtup::updateVarSizeNULLable(Uint32* inBuffer, Uint32 var_index= AttributeOffset::getOffset(attrDes2); Uint32 var_pos= req_struct->var_pos_array[var_index]; if (newIndex <= req_struct->in_buf_len) { - ljam(); + jam(); BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos); req_struct->var_pos_array[var_index+idx]= var_pos; req_struct->in_buf_index= newIndex; return true; } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1110,7 +1108,7 @@ Dbtup::updateDynFixedSize(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32 attrDes2) { - ljam(); + jam(); terrorCode= ZVAR_SIZED_NOT_SUPPORTED; return false; } @@ -1120,7 +1118,7 @@ Dbtup::updateDynVarSize(Uint32* inBuffer, KeyReqStruct *req_struct, Uint32 attrDes2) { - ljam(); + jam(); terrorCode= ZVAR_SIZED_NOT_SUPPORTED; return false; } @@ -1218,7 +1216,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer, Uint32 maxRead = req_struct->max_read; Uint32 *bits= req_struct->m_tuple_ptr->get_null_bits(regTabPtr); if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setDataSize((bitCount + 31) >> 5); req_struct->out_buf_index = newIndexBuf; @@ -1227,7 +1225,7 @@ Dbtup::readBitsNotNULL(Uint32* outBuffer, return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; return false; }//if @@ -1251,20 +1249,20 @@ Dbtup::readBitsNULLable(Uint32* outBuffer, if(BitmaskImpl::get(regTabPtr->m_offsets[MM].m_null_words, bits, pos)) { - ljam(); + jam(); ahOut->setNULL(); return true; } if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setDataSize((bitCount + 31) >> 5); req_struct->out_buf_index = newIndexBuf; BitmaskImpl::getField(regTabPtr->m_offsets[MM].m_null_words, bits, pos+1, bitCount, outBuffer+indexBuf); return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; return false; }//if @@ -1293,12 +1291,12 @@ Dbtup::updateBitsNotNULL(Uint32* inBuffer, req_struct->in_buf_index = newIndex; return true; } else { - ljam(); + jam(); terrorCode = ZNOT_NULL_ATTR; return false; }//if } else { - ljam(); + jam(); terrorCode = ZAI_INCONSISTENCY_ERROR; return false; }//if @@ -1331,13 +1329,13 @@ Dbtup::updateBitsNULLable(Uint32* inBuffer, Uint32 newIndex = indexBuf + 1; if (newIndex <= req_struct->in_buf_len) { - ljam(); + jam(); BitmaskImpl::set(regTabPtr->m_offsets[MM].m_null_words, bits, pos); req_struct->in_buf_index = newIndex; return true; } else { - ljam(); + jam(); terrorCode = ZAI_INCONSISTENCY_ERROR; return false; }//if @@ -1364,9 +1362,9 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer, if (newIndex <= inBufLen) { if (!nullIndicator) { - ljam(); + jam(); if (charsetFlag) { - ljam(); + jam(); Tablerec* regTabPtr = tabptr.p; Uint32 typeId = AttributeDescriptor::getType(attrDescriptor); Uint32 bytes = AttributeDescriptor::getSizeInBytes(attrDescriptor); @@ -1378,14 +1376,14 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer, const char* ssrc = (const char*)&inBuffer[indexBuf + 1]; Uint32 lb, len; if (! NdbSqlUtil::get_var_length(typeId, ssrc, bytes, lb, len)) { - ljam(); + jam(); terrorCode = ZINVALID_CHAR_FORMAT; return false; } // fast fix bug#7340 if (typeId != NDB_TYPE_TEXT && (*cs->cset->well_formed_len)(cs, ssrc + lb, ssrc + lb + len, ZNIL, ¬_used) != len) { - ljam(); + jam(); terrorCode = ZINVALID_CHAR_FORMAT; return false; } @@ -1396,12 +1394,12 @@ Dbtup::updateDiskFixedSizeNotNULL(Uint32* inBuffer, noOfWords); return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1419,7 +1417,7 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer, Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD); if (!nullIndicator) { - ljam(); + jam(); BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos); return updateDiskFixedSizeNotNULL(inBuffer, req_struct, @@ -1428,11 +1426,11 @@ Dbtup::updateDiskFixedSizeNULLable(Uint32* inBuffer, Uint32 newIndex= req_struct->in_buf_index + 1; if (newIndex <= req_struct->in_buf_len) { BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos); - ljam(); + jam(); req_struct->in_buf_index= newIndex; return true; } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1466,7 +1464,7 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer, if (new_index <= in_buf_len && vsize_in_words <= max_var_size) { if (!null_ind) { - ljam(); + jam(); var_attr_pos= vpos_array[var_index]; var_data_start= req_struct->m_var_data[DD].m_data_ptr; vpos_array[var_index+idx]= var_attr_pos+size_in_bytes; @@ -1477,12 +1475,12 @@ Dbtup::updateDiskVarSizeNotNULL(Uint32* in_buffer, size_in_bytes); return true; } else { - ljam(); + jam(); terrorCode= ZNOT_NULL_ATTR; return false; } } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1502,7 +1500,7 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer, Uint32 idx= req_struct->m_var_data[DD].m_var_len_offset; if (!nullIndicator) { - ljam(); + jam(); BitmaskImpl::clear(regTabPtr->m_offsets[DD].m_null_words, bits, pos); return updateDiskVarSizeNotNULL(inBuffer, req_struct, @@ -1512,13 +1510,13 @@ Dbtup::updateDiskVarSizeNULLable(Uint32* inBuffer, Uint32 var_index= AttributeOffset::getOffset(attrDes2); Uint32 var_pos= req_struct->var_pos_array[var_index]; if (newIndex <= req_struct->in_buf_len) { - ljam(); + jam(); BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos); req_struct->var_pos_array[var_index+idx]= var_pos; req_struct->in_buf_index= newIndex; return true; } else { - ljam(); + jam(); terrorCode= ZAI_INCONSISTENCY_ERROR; return false; } @@ -1540,7 +1538,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer, Uint32 maxRead = req_struct->max_read; Uint32 *bits= req_struct->m_disk_ptr->get_null_bits(regTabPtr, DD); if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setDataSize((bitCount + 31) >> 5); req_struct->out_buf_index = newIndexBuf; @@ -1549,7 +1547,7 @@ Dbtup::readDiskBitsNotNULL(Uint32* outBuffer, return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; return false; }//if @@ -1573,20 +1571,20 @@ Dbtup::readDiskBitsNULLable(Uint32* outBuffer, if(BitmaskImpl::get(regTabPtr->m_offsets[DD].m_null_words, bits, pos)) { - ljam(); + jam(); ahOut->setNULL(); return true; } if (newIndexBuf <= maxRead) { - ljam(); + jam(); ahOut->setDataSize((bitCount + 31) >> 5); req_struct->out_buf_index = newIndexBuf; BitmaskImpl::getField(regTabPtr->m_offsets[DD].m_null_words, bits, pos+1, bitCount, outBuffer+indexBuf); return true; } else { - ljam(); + jam(); terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR; return false; }//if @@ -1615,12 +1613,12 @@ Dbtup::updateDiskBitsNotNULL(Uint32* inBuffer, req_struct->in_buf_index = newIndex; return true; } else { - ljam(); + jam(); terrorCode = ZNOT_NULL_ATTR; return false; }//if } else { - ljam(); + jam(); terrorCode = ZAI_INCONSISTENCY_ERROR; return false; }//if @@ -1653,13 +1651,13 @@ Dbtup::updateDiskBitsNULLable(Uint32* inBuffer, Uint32 newIndex = indexBuf + 1; if (newIndex <= req_struct->in_buf_len) { - ljam(); + jam(); BitmaskImpl::set(regTabPtr->m_offsets[DD].m_null_words, bits, pos); req_struct->in_buf_index = newIndex; return true; } else { - ljam(); + jam(); terrorCode = ZAI_INCONSISTENCY_ERROR; return false; }//if diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp index 653a24ba6a1..b1627ca7652 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp @@ -14,6 +14,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_SCAN_CPP #include "Dbtup.hpp" #include #include diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp index b2c42418418..c1ccf5952da 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupStoredProcDef.cpp @@ -15,14 +15,12 @@ #define DBTUP_C +#define DBTUP_STORE_PROC_DEF_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(18000 + __LINE__); } -#define ljamEntry() { jamEntryLine(18000 + __LINE__); } - /* ---------------------------------------------------------------- */ /* ---------------------------------------------------------------- */ /* ------------ADD/DROP STORED PROCEDURE MODULE ------------------- */ @@ -32,7 +30,7 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal) { OperationrecPtr regOperPtr; TablerecPtr regTabPtr; - ljamEntry(); + jamEntry(); regOperPtr.i = signal->theData[0]; c_operation_pool.getPtr(regOperPtr); regTabPtr.i = signal->theData[1]; @@ -46,17 +44,17 @@ void Dbtup::execSTORED_PROCREQ(Signal* signal) ndbrequire(regTabPtr.p->tableStatus == DEFINED); switch (requestInfo) { case ZSCAN_PROCEDURE: - ljam(); + jam(); scanProcedure(signal, regOperPtr.p, signal->theData[4]); break; case ZCOPY_PROCEDURE: - ljam(); + jam(); copyProcedure(signal, regTabPtr, regOperPtr.p); break; case ZSTORED_PROCEDURE_DELETE: - ljam(); + jam(); deleteScanProcedure(signal, regOperPtr.p); break; default: @@ -124,14 +122,14 @@ void Dbtup::copyProcedure(Signal* signal, AttributeHeader::init(&signal->theData[length + 1], Ti, 0); length++; if (length == 24) { - ljam(); + jam(); ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, signal->theData+1, length, true)); length = 0; }//if }//for if (length != 0) { - ljam(); + jam(); ndbrequire(storedProcedureAttrInfo(signal, regOperPtr, signal->theData+1, length, true)); }//if @@ -155,7 +153,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal, ndbrequire(regOperPtr->currentAttrinbufLen <= regOperPtr->attrinbufLen); if ((RnoFree > MIN_ATTRBUF) || (copyProcedure)) { - ljam(); + jam(); regAttrPtr.i = cfirstfreeAttrbufrec; ptrCheckGuard(regAttrPtr, cnoOfAttrbufrec, attrbufrec); regAttrPtr.p->attrbuf[ZBUF_DATA_LEN] = 0; @@ -163,18 +161,18 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal, cnoFreeAttrbufrec = RnoFree - 1; regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL; } else { - ljam(); + jam(); storedSeizeAttrinbufrecErrorLab(signal, regOperPtr); return false; }//if if (regOperPtr->firstAttrinbufrec == RNIL) { - ljam(); + jam(); regOperPtr->firstAttrinbufrec = regAttrPtr.i; }//if regAttrPtr.p->attrbuf[ZBUF_NEXT] = RNIL; if (regOperPtr->lastAttrinbufrec != RNIL) { AttrbufrecPtr tempAttrinbufptr; - ljam(); + jam(); tempAttrinbufptr.i = regOperPtr->lastAttrinbufrec; ptrCheckGuard(tempAttrinbufptr, cnoOfAttrbufrec, attrbufrec); tempAttrinbufptr.p->attrbuf[ZBUF_NEXT] = regAttrPtr.i; @@ -187,7 +185,7 @@ bool Dbtup::storedProcedureAttrInfo(Signal* signal, length); if (regOperPtr->currentAttrinbufLen < regOperPtr->attrinbufLen) { - ljam(); + jam(); return true; }//if if (ERROR_INSERTED(4005) && !copyProcedure) { diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp index b85a2a8394d..6406bdefe1e 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp @@ -15,14 +15,12 @@ #define DBTUP_C +#define DBTUP_TAB_DES_MAN_CPP #include "Dbtup.hpp" #include #include #include -#define ljam() { jamLine(22000 + __LINE__); } -#define ljamEntry() { jamEntryLine(22000 + __LINE__); } - /* * TABLE DESCRIPTOR MEMORY MANAGER * @@ -65,30 +63,30 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset) allocSize = (((allocSize - 1) >> 4) + 1) << 4; Uint32 list = nextHigherTwoLog(allocSize - 1); /* CALCULATE WHICH LIST IT BELONGS TO */ for (Uint32 i = list; i < 16; i++) { - ljam(); + jam(); if (cfreeTdList[i] != RNIL) { - ljam(); + jam(); reference = cfreeTdList[i]; removeTdArea(reference, i); /* REMOVE THE AREA FROM THE FREELIST */ Uint32 retNo = (1 << i) - allocSize; /* CALCULATE THE DIFFERENCE */ if (retNo >= ZTD_FREE_SIZE) { - ljam(); + jam(); // return unused words, of course without attempting left merge Uint32 retRef = reference + allocSize; freeTabDescr(retRef, retNo, false); } else { - ljam(); + jam(); allocSize = 1 << i; }//if break; }//if }//for if (reference == RNIL) { - ljam(); + jam(); terrorCode = ZMEM_NOTABDESCR_ERROR; return RNIL; } else { - ljam(); + jam(); setTabDescrWord((reference + allocSize) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL); setTabDescrWord(reference + ZTD_DATASIZE, allocSize); @@ -105,7 +103,7 @@ void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal) { itdaMergeTabDescr(retRef, retNo, normal); /* MERGE WITH POSSIBLE NEIGHBOURS */ while (retNo >= ZTD_FREE_SIZE) { - ljam(); + jam(); Uint32 list = nextHigherTwoLog(retNo); list--; /* RETURN TO NEXT LOWER LIST */ Uint32 sizeOfChunk = 1 << list; @@ -136,7 +134,7 @@ void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list) setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE); setTabDescrWord(tabDesRef + ZTD_FL_NEXT, cfreeTdList[list]); if (cfreeTdList[list] != RNIL) { - ljam(); /* PREVIOUSLY EMPTY SLOT */ + jam(); /* PREVIOUSLY EMPTY SLOT */ setTabDescrWord(cfreeTdList[list] + ZTD_FL_PREV, tabDesRef); }//if cfreeTdList[list] = tabDesRef; /* RELINK THE LIST */ @@ -156,28 +154,28 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal) { // merge right while ((retRef + retNo) < cnoOfTabDescrRec) { - ljam(); + jam(); Uint32 tabDesRef = retRef + retNo; Uint32 headerWord = getTabDescrWord(tabDesRef + ZTD_FL_HEADER); if (headerWord == ZTD_TYPE_FREE) { - ljam(); + jam(); Uint32 sizeOfMergedPart = getTabDescrWord(tabDesRef + ZTD_FL_SIZE); retNo += sizeOfMergedPart; Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1); removeTdArea(tabDesRef, list); } else { - ljam(); + jam(); break; } } // merge left const bool mergeLeft = normal; while (mergeLeft && retRef > 0) { - ljam(); + jam(); Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE); if (trailerWord == ZTD_TYPE_FREE) { - ljam(); + jam(); Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE); ndbrequire(retRef >= sizeOfMergedPart); retRef -= sizeOfMergedPart; @@ -185,7 +183,7 @@ void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal) Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1); removeTdArea(retRef, list); } else { - ljam(); + jam(); break; } } @@ -213,15 +211,15 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list) setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_TYPE, ZTD_TYPE_NORMAL); if (tabDesRef == cfreeTdList[list]) { - ljam(); + jam(); cfreeTdList[list] = tabDescrNextPtr; /* RELINK THE LIST */ }//if if (tabDescrNextPtr != RNIL) { - ljam(); + jam(); setTabDescrWord(tabDescrNextPtr + ZTD_FL_PREV, tabDescrPrevPtr); }//if if (tabDescrPrevPtr != RNIL) { - ljam(); + jam(); setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr); }//if }//Dbtup::removeTdArea() diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp index 9615047540b..0c6a1491543 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp @@ -15,6 +15,7 @@ #define DBTUP_C +#define DBTUP_TRIGGER_CPP #include "Dbtup.hpp" #include #include @@ -26,9 +27,6 @@ #include #include -#define ljam() { jamLine(7000 + __LINE__); } -#define ljamEntry() { jamEntryLine(7000 + __LINE__); } - /* **************************************************************** */ /* ---------------------------------------------------------------- */ /* ----------------------- TRIGGER HANDLING ----------------------- */ @@ -47,17 +45,17 @@ Dbtup::findTriggerList(Tablerec* table, case TriggerType::SUBSCRIPTION_BEFORE: switch (tevent) { case TriggerEvent::TE_INSERT: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_DETACHED) tlist = &table->subscriptionInsertTriggers; break; case TriggerEvent::TE_UPDATE: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_DETACHED) tlist = &table->subscriptionUpdateTriggers; break; case TriggerEvent::TE_DELETE: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_DETACHED) tlist = &table->subscriptionDeleteTriggers; break; @@ -68,17 +66,17 @@ Dbtup::findTriggerList(Tablerec* table, case TriggerType::SECONDARY_INDEX: switch (tevent) { case TriggerEvent::TE_INSERT: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_AFTER) tlist = &table->afterInsertTriggers; break; case TriggerEvent::TE_UPDATE: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_AFTER) tlist = &table->afterUpdateTriggers; break; case TriggerEvent::TE_DELETE: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_AFTER) tlist = &table->afterDeleteTriggers; break; @@ -89,7 +87,7 @@ Dbtup::findTriggerList(Tablerec* table, case TriggerType::ORDERED_INDEX: switch (tevent) { case TriggerEvent::TE_CUSTOM: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_CUSTOM) tlist = &table->tuxCustomTriggers; break; @@ -100,7 +98,7 @@ Dbtup::findTriggerList(Tablerec* table, case TriggerType::READ_ONLY_CONSTRAINT: switch (tevent) { case TriggerEvent::TE_UPDATE: - ljam(); + jam(); if (ttime == TriggerActionTime::TA_AFTER) tlist = &table->constraintUpdateTriggers; break; @@ -118,7 +116,7 @@ Dbtup::findTriggerList(Tablerec* table, void Dbtup::execCREATE_TRIG_REQ(Signal* signal) { - ljamEntry(); + jamEntry(); BlockReference senderRef = signal->getSendersBlockRef(); const CreateTrigReq reqCopy = *(const CreateTrigReq*)signal->getDataPtr(); const CreateTrigReq* const req = &reqCopy; @@ -131,13 +129,13 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal) if (tabPtr.p->tableStatus != DEFINED ) { - ljam(); + jam(); error= CreateTrigRef::InvalidTable; } // Create trigger and associate it with the table else if (createTrigger(tabPtr.p, req)) { - ljam(); + jam(); // Send conf CreateTrigConf* const conf = (CreateTrigConf*)signal->getDataPtrSend(); conf->setUserRef(reference()); @@ -153,7 +151,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal) } else { - ljam(); + jam(); error= CreateTrigRef::TooManyTriggers; } ndbassert(error != CreateTrigRef::NoError); @@ -174,7 +172,7 @@ Dbtup::execCREATE_TRIG_REQ(Signal* signal) void Dbtup::execDROP_TRIG_REQ(Signal* signal) { - ljamEntry(); + jamEntry(); BlockReference senderRef = signal->getSendersBlockRef(); const DropTrigReq reqCopy = *(const DropTrigReq*)signal->getDataPtr(); const DropTrigReq* const req = &reqCopy; @@ -262,7 +260,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req) if ((tptr.p->triggerType == TriggerType::SUBSCRIPTION) && ((tptr.p->triggerEvent == TriggerEvent::TE_UPDATE) || (tptr.p->triggerEvent == TriggerEvent::TE_DELETE))) { - ljam(); + jam(); tptr.p->sendBeforeValues = false; } /* @@ -270,7 +268,7 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req) if (((tptr.p->triggerType == TriggerType::SUBSCRIPTION) || (tptr.p->triggerType == TriggerType::SUBSCRIPTION_BEFORE)) && (tptr.p->triggerEvent == TriggerEvent::TE_UPDATE)) { - ljam(); + jam(); tptr.p->sendOnlyChangedAttributes = true; } */ @@ -282,16 +280,16 @@ Dbtup::createTrigger(Tablerec* table, const CreateTrigReq* req) tptr.p->attributeMask.clear(); if (tptr.p->monitorAllAttributes) { - ljam(); + jam(); for(Uint32 i = 0; i < table->m_no_of_attributes; i++) { if (!primaryKey(table, i)) { - ljam(); + jam(); tptr.p->attributeMask.set(i); } } } else { // Set attribute mask - ljam(); + jam(); tptr.p->attributeMask = req->getAttributeMask(); } return true; @@ -336,7 +334,7 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender) Ptr ptr; for (tlist->first(ptr); !ptr.isNull(); tlist->next(ptr)) { - ljam(); + jam(); if (ptr.p->triggerId == triggerId) { if(ttype==TriggerType::SUBSCRIPTION && sender != ptr.p->m_receiverBlock) { @@ -348,10 +346,10 @@ Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req, BlockNumber sender) * * Backup doesn't really care about the Ids though. */ - ljam(); + jam(); continue; } - ljam(); + jam(); tlist->release(ptr.i); return 0; } @@ -379,7 +377,7 @@ Dbtup::checkImmediateTriggersAfterInsert(KeyReqStruct *req_struct, if ((regOperPtr->op_struct.primary_replica) && (!(regTablePtr->afterInsertTriggers.isEmpty()))) { - ljam(); + jam(); fireImmediateTriggers(req_struct, regTablePtr->afterInsertTriggers, regOperPtr); @@ -397,14 +395,14 @@ Dbtup::checkImmediateTriggersAfterUpdate(KeyReqStruct *req_struct, if ((regOperPtr->op_struct.primary_replica) && (!(regTablePtr->afterUpdateTriggers.isEmpty()))) { - ljam(); + jam(); fireImmediateTriggers(req_struct, regTablePtr->afterUpdateTriggers, regOperPtr); } if ((regOperPtr->op_struct.primary_replica) && (!(regTablePtr->constraintUpdateTriggers.isEmpty()))) { - ljam(); + jam(); fireImmediateTriggers(req_struct, regTablePtr->constraintUpdateTriggers, regOperPtr); @@ -422,7 +420,7 @@ Dbtup::checkImmediateTriggersAfterDelete(KeyReqStruct *req_struct, if ((regOperPtr->op_struct.primary_replica) && (!(regTablePtr->afterDeleteTriggers.isEmpty()))) { - ljam(); + jam(); executeTriggers(req_struct, regTablePtr->afterDeleteTriggers, regOperPtr); @@ -443,7 +441,7 @@ void Dbtup::checkDeferredTriggers(Signal* signal, Operationrec* const regOperPtr, Tablerec* const regTablePtr) { - ljam(); + jam(); // NYI }//Dbtup::checkDeferredTriggers() #endif @@ -479,7 +477,7 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct, if (save_ptr->m_header_bits & Tuple_header::ALLOC) { if (save_type == ZDELETE) { // insert + delete = nothing - ljam(); + jam(); return; goto end; } @@ -495,10 +493,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct, switch(regOperPtr->op_struct.op_type) { case(ZINSERT): - ljam(); + jam(); if (regTablePtr->subscriptionInsertTriggers.isEmpty()) { // Table has no active triggers monitoring inserts at commit - ljam(); + jam(); goto end; } @@ -508,10 +506,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct, regOperPtr); break; case(ZDELETE): - ljam(); + jam(); if (regTablePtr->subscriptionDeleteTriggers.isEmpty()) { // Table has no active triggers monitoring deletes at commit - ljam(); + jam(); goto end; } @@ -522,10 +520,10 @@ void Dbtup::checkDetachedTriggers(KeyReqStruct *req_struct, regOperPtr); break; case(ZUPDATE): - ljam(); + jam(); if (regTablePtr->subscriptionUpdateTriggers.isEmpty()) { // Table has no active triggers monitoring updates at commit - ljam(); + jam(); goto end; } @@ -553,10 +551,10 @@ Dbtup::fireImmediateTriggers(KeyReqStruct *req_struct, TriggerPtr trigPtr; triggerList.first(trigPtr); while (trigPtr.i != RNIL) { - ljam(); + jam(); if (trigPtr.p->monitorAllAttributes || trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) { - ljam(); + jam(); executeTrigger(req_struct, trigPtr.p, regOperPtr); @@ -575,10 +573,10 @@ Dbtup::fireDeferredTriggers(Signal* signal, TriggerPtr trigPtr; triggerList.first(trigPtr); while (trigPtr.i != RNIL) { - ljam(); + jam(); if (trigPtr.p->monitorAllAttributes || trigPtr.p->attributeMask.overlaps(req_struct->changeMask)) { - ljam(); + jam(); executeTrigger(req_struct, trigPtr, regOperPtr); @@ -604,12 +602,12 @@ Dbtup::fireDetachedTriggers(KeyReqStruct *req_struct, ndbrequire(regOperPtr->is_first_operation()); triggerList.first(trigPtr); while (trigPtr.i != RNIL) { - ljam(); + jam(); if ((trigPtr.p->monitorReplicas || regOperPtr->op_struct.primary_replica) && (trigPtr.p->monitorAllAttributes || trigPtr.p->attributeMask.overlaps(req_struct->changeMask))) { - ljam(); + jam(); executeTrigger(req_struct, trigPtr.p, regOperPtr); @@ -625,7 +623,7 @@ void Dbtup::executeTriggers(KeyReqStruct *req_struct, TriggerPtr trigPtr; triggerList.first(trigPtr); while (trigPtr.i != RNIL) { - ljam(); + jam(); executeTrigger(req_struct, trigPtr.p, regOperPtr); @@ -675,7 +673,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct, ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord); if (ref == BACKUP) { - ljam(); + jam(); /* In order for the implementation of BACKUP to work even when changing primaries in the middle of the backup we need to set the trigger on @@ -688,9 +686,9 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct, signal->theData[0] = trigPtr->triggerId; signal->theData[1] = regFragPtr.p->fragmentId; EXECUTE_DIRECT(BACKUP, GSN_BACKUP_TRIG_REQ, signal, 2); - ljamEntry(); + jamEntry(); if (signal->theData[0] == 0) { - ljam(); + jam(); return; } } @@ -704,7 +702,7 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct, noAfterWords, beforeBuffer, noBeforeWords)) { - ljam(); + jam(); return; } //-------------------------------------------------------------------- @@ -720,13 +718,13 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct, switch(trigPtr->triggerType) { case (TriggerType::SECONDARY_INDEX): - ljam(); + jam(); ref = req_struct->TC_ref; executeDirect = false; break; case (TriggerType::SUBSCRIPTION): case (TriggerType::SUBSCRIPTION_BEFORE): - ljam(); + jam(); // Since only backup uses subscription triggers we send to backup directly for now ref = trigPtr->m_receiverBlock; executeDirect = true; @@ -747,22 +745,22 @@ void Dbtup::executeTrigger(KeyReqStruct *req_struct, switch(regOperPtr->op_struct.op_type) { case(ZINSERT): - ljam(); + jam(); // Send AttrInfo signals with new attribute values trigAttrInfo->setAttrInfoType(TrigAttrInfo::AFTER_VALUES); sendTrigAttrInfo(signal, afterBuffer, noAfterWords, executeDirect, ref); break; case(ZDELETE): if (trigPtr->sendBeforeValues) { - ljam(); + jam(); trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES); sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref); } break; case(ZUPDATE): - ljam(); + jam(); if (trigPtr->sendBeforeValues) { - ljam(); + jam(); trigAttrInfo->setAttrInfoType(TrigAttrInfo::BEFORE_VALUES); sendTrigAttrInfo(signal, beforeBuffer, noBeforeWords, executeDirect,ref); } @@ -788,9 +786,9 @@ Uint32 Dbtup::setAttrIds(Bitmask& attributeMask, { Uint32 bufIndx = 0; for (Uint32 i = 0; i < m_no_of_attributesibutes; i++) { - ljam(); + jam(); if (attributeMask.get(i)) { - ljam(); + jam(); AttributeHeader::init(&inBuffer[bufIndx++], i, 0); } } @@ -858,7 +856,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, Uint32 numAttrsToRead; if ((regOperPtr->op_struct.op_type == ZUPDATE) && (trigPtr->sendOnlyChangedAttributes)) { - ljam(); + jam(); //-------------------------------------------------------------------- // Update that sends only changed information //-------------------------------------------------------------------- @@ -870,13 +868,13 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, } else if ((regOperPtr->op_struct.op_type == ZDELETE) && (!trigPtr->sendBeforeValues)) { - ljam(); + jam(); //-------------------------------------------------------------------- // Delete without sending before values only read Primary Key //-------------------------------------------------------------------- return true; } else { - ljam(); + jam(); //-------------------------------------------------------------------- // All others send all attributes that are monitored, except: // Omit unchanged blob inlines on update i.e. @@ -898,7 +896,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, //-------------------------------------------------------------------- if (regOperPtr->op_struct.op_type != ZDELETE) { - ljam(); + jam(); int ret = readAttributes(req_struct, &readBuffer[0], numAttrsToRead, @@ -908,7 +906,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, ndbrequire(ret != -1); noAfterWords= ret; } else { - ljam(); + jam(); noAfterWords = 0; } @@ -920,7 +918,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, if ((regOperPtr->op_struct.op_type == ZUPDATE || regOperPtr->op_struct.op_type == ZDELETE) && (trigPtr->sendBeforeValues)) { - ljam(); + jam(); Tuple_header *save= req_struct->m_tuple_ptr; PagePtr tmp; @@ -956,7 +954,7 @@ bool Dbtup::readTriggerInfo(TupTriggerData* const trigPtr, // Although a trigger was fired it was not necessary since the old // value and the new value was exactly the same //-------------------------------------------------------------------- - ljam(); + jam(); //XXX does this work with collations? return false; } @@ -976,21 +974,21 @@ void Dbtup::sendTrigAttrInfo(Signal* signal, do { sigLen = dataLen - dataIndex; if (sigLen > TrigAttrInfo::DataLength) { - ljam(); + jam(); sigLen = TrigAttrInfo::DataLength; } MEMCOPY_NO_WORDS(trigAttrInfo->getData(), data + dataIndex, sigLen); if (executeDirect) { - ljam(); + jam(); EXECUTE_DIRECT(receiverReference, GSN_TRIG_ATTRINFO, signal, TrigAttrInfo::StaticLength + sigLen); - ljamEntry(); + jamEntry(); } else { - ljam(); + jam(); sendSignal(receiverReference, GSN_TRIG_ATTRINFO, signal, @@ -1018,15 +1016,15 @@ void Dbtup::sendFireTrigOrd(Signal* signal, switch(regOperPtr->op_struct.op_type) { case(ZINSERT): - ljam(); + jam(); fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT); break; case(ZDELETE): - ljam(); + jam(); fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE); break; case(ZUPDATE): - ljam(); + jam(); fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE); break; default: @@ -1040,12 +1038,12 @@ void Dbtup::sendFireTrigOrd(Signal* signal, switch(trigPtr->triggerType) { case (TriggerType::SECONDARY_INDEX): - ljam(); + jam(); sendSignal(req_struct->TC_ref, GSN_FIRE_TRIG_ORD, signal, FireTrigOrd::SignalLength, JBB); break; case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma - ljam(); + jam(); // Since only backup uses subscription triggers we // send to backup directly for now fireTrigOrd->setGCI(req_struct->gci); @@ -1056,7 +1054,7 @@ void Dbtup::sendFireTrigOrd(Signal* signal, FireTrigOrd::SignalWithHashValueLength); break; case (TriggerType::SUBSCRIPTION): - ljam(); + jam(); // Since only backup uses subscription triggers we // send to backup directly for now fireTrigOrd->setGCI(req_struct->gci); @@ -1123,7 +1121,7 @@ Dbtup::addTuxEntries(Signal* signal, Tablerec* regTabPtr) { if (ERROR_INSERTED(4022)) { - ljam(); + jam(); CLEAR_ERROR_INSERT_VALUE; terrorCode = 9999; return -1; @@ -1134,12 +1132,12 @@ Dbtup::addTuxEntries(Signal* signal, Uint32 failPtrI; triggerList.first(triggerPtr); while (triggerPtr.i != RNIL) { - ljam(); + jam(); req->indexId = triggerPtr.p->indexId; req->errorCode = RNIL; if (ERROR_INSERTED(4023) && ! triggerList.hasNext(triggerPtr)) { - ljam(); + jam(); CLEAR_ERROR_INSERT_VALUE; terrorCode = 9999; failPtrI = triggerPtr.i; @@ -1147,9 +1145,9 @@ Dbtup::addTuxEntries(Signal* signal, } EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, signal, TuxMaintReq::SignalLength); - ljamEntry(); + jamEntry(); if (req->errorCode != 0) { - ljam(); + jam(); terrorCode = req->errorCode; failPtrI = triggerPtr.i; goto fail; @@ -1161,12 +1159,12 @@ fail: req->opInfo = TuxMaintReq::OpRemove; triggerList.first(triggerPtr); while (triggerPtr.i != failPtrI) { - ljam(); + jam(); req->indexId = triggerPtr.p->indexId; req->errorCode = RNIL; EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, signal, TuxMaintReq::SignalLength); - ljamEntry(); + jamEntry(); ndbrequire(req->errorCode == 0); triggerList.next(triggerPtr); } @@ -1197,15 +1195,15 @@ Dbtup::executeTuxCommitTriggers(Signal* signal, if (regOperPtr->op_struct.op_type == ZINSERT) { if (! regOperPtr->op_struct.delete_insert_flag) return; - ljam(); + jam(); tupVersion= decr_tup_version(regOperPtr->tupVersion); } else if (regOperPtr->op_struct.op_type == ZUPDATE) { - ljam(); + jam(); tupVersion= decr_tup_version(regOperPtr->tupVersion); } else if (regOperPtr->op_struct.op_type == ZDELETE) { if (regOperPtr->op_struct.delete_insert_flag) return; - ljam(); + jam(); tupVersion= regOperPtr->tupVersion; } else { ndbrequire(false); @@ -1231,13 +1229,13 @@ Dbtup::executeTuxAbortTriggers(Signal* signal, // get version Uint32 tupVersion; if (regOperPtr->op_struct.op_type == ZINSERT) { - ljam(); + jam(); tupVersion = regOperPtr->tupVersion; } else if (regOperPtr->op_struct.op_type == ZUPDATE) { - ljam(); + jam(); tupVersion = regOperPtr->tupVersion; } else if (regOperPtr->op_struct.op_type == ZDELETE) { - ljam(); + jam(); return; } else { ndbrequire(false); @@ -1262,12 +1260,12 @@ Dbtup::removeTuxEntries(Signal* signal, TriggerPtr triggerPtr; triggerList.first(triggerPtr); while (triggerPtr.i != RNIL) { - ljam(); + jam(); req->indexId = triggerPtr.p->indexId; req->errorCode = RNIL, EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ, signal, TuxMaintReq::SignalLength); - ljamEntry(); + jamEntry(); // must succeed ndbrequire(req->errorCode == 0); triggerList.next(triggerPtr); diff --git a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp index 28543882255..a32fae16790 100644 --- a/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp +++ b/storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp @@ -14,12 +14,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #define DBTUP_C +#define DBTUP_VAR_ALLOC_CPP #include "Dbtup.hpp" -#define ljam() { jamLine(32000 + __LINE__); } -#define ljamEntry() { jamEntryLine(32000 + __LINE__); } - - void Dbtup::init_list_sizes(void) { c_min_list_size[0]= 200; @@ -109,9 +106,9 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr, PagePtr pagePtr; pagePtr.i= get_alloc_page(fragPtr, (alloc_size + 1)); if (pagePtr.i == RNIL) { - ljam(); + jam(); if ((pagePtr.i= get_empty_var_page(fragPtr)) == RNIL) { - ljam(); + jam(); return 0; } c_page_pool.getPtr(pagePtr); @@ -127,7 +124,7 @@ Dbtup::alloc_var_part(Fragrecord* fragPtr, pagePtr.p->page_state = ZTH_MM_FREE; } else { c_page_pool.getPtr(pagePtr); - ljam(); + jam(); } Uint32 idx= ((Var_page*)pagePtr.p) ->alloc_record(alloc_size, (Var_page*)ctemp_page, Var_page::CHAIN); @@ -178,7 +175,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr, ndbassert(pagePtr.p->free_space <= Var_page::DATA_WORDS); if (pagePtr.p->free_space == Var_page::DATA_WORDS - 1) { - ljam(); + jam(); /* This code could be used when we release pages. remove_free_page(signal,fragPtr,page_header,page_header->list_index); @@ -186,7 +183,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr, */ update_free_page_list(fragPtr, pagePtr); } else { - ljam(); + jam(); update_free_page_list(fragPtr, pagePtr); } return; @@ -260,16 +257,16 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size) start_index= calculate_free_list_impl(alloc_size); if (start_index == (MAX_FREE_LIST - 1)) { - ljam(); + jam(); } else { - ljam(); + jam(); ndbrequire(start_index < (MAX_FREE_LIST - 1)); start_index++; } for (i= start_index; i < MAX_FREE_LIST; i++) { - ljam(); + jam(); if (!fragPtr->free_var_page_array[i].isEmpty()) { - ljam(); + jam(); return fragPtr->free_var_page_array[i].firstItem; } } @@ -278,9 +275,9 @@ Dbtup::get_alloc_page(Fragrecord* fragPtr, Uint32 alloc_size) LocalDLList list(c_page_pool, fragPtr->free_var_page_array[i]); for(list.first(pagePtr); !pagePtr.isNull() && loop < 16; ) { - ljam(); + jam(); if (pagePtr.p->free_space >= alloc_size) { - ljam(); + jam(); return pagePtr.i; } loop++; @@ -347,7 +344,7 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr, (free_space > c_max_list_size[list_index])) { Uint32 new_list_index= calculate_free_list_impl(free_space); if (list_index != MAX_FREE_LIST) { - ljam(); + jam(); /* * Only remove it from its list if it is in a list */ @@ -362,11 +359,11 @@ void Dbtup::update_free_page_list(Fragrecord* fragPtr, This can only happen for the free list with least guaranteed free space. */ - ljam(); + jam(); ndbrequire(new_list_index == 0); pagePtr.p->list_index= MAX_FREE_LIST; } else { - ljam(); + jam(); LocalDLList list(c_page_pool, fragPtr->free_var_page_array[new_list_index]); list.add(pagePtr); @@ -382,9 +379,9 @@ Uint32 Dbtup::calculate_free_list_impl(Uint32 free_space_size) const { Uint32 i; for (i = 0; i < MAX_FREE_LIST; i++) { - ljam(); + jam(); if (free_space_size <= c_max_list_size[i]) { - ljam(); + jam(); return i; } } From 629c12316dbf363b2bc8f63e567cb8131896bba5 Mon Sep 17 00:00:00 2001 From: "evgen@sunlight.local" <> Date: Sun, 4 Mar 2007 00:47:42 +0300 Subject: [PATCH 20/73] Bug#25126: Wrongly resolved field leads to a crash. When the ORDER BY clause gets fixed it's allowed to search in the current item_list in order to find aliased fields and expressions. This is ok for a SELECT but wrong for an UPDATE statement. If the ORDER BY clause will contain a non-existing field which is mentioned in the UPDATE set list then the server will crash due to using of non-existing (0x0) field. When an Item_field is getting fixed it's allowed to search item list for aliased expressions and fields only for selects. --- mysql-test/r/update.result | 4 ++++ mysql-test/t/update.test | 8 ++++++++ sql/sql_base.cc | 31 ++++++++++++++++++++++++++++++- sql/sql_select.cc | 7 ++----- 4 files changed, 44 insertions(+), 6 deletions(-) diff --git a/mysql-test/r/update.result b/mysql-test/r/update.result index 0f86a959250..186e0955e61 100644 --- a/mysql-test/r/update.result +++ b/mysql-test/r/update.result @@ -377,3 +377,7 @@ create table t1(f1 int, `*f2` int); insert into t1 values (1,1); update t1 set `*f2`=1; drop table t1; +create table t1(f1 int); +update t1 set f2=1 order by f2; +ERROR 42S22: Unknown column 'f2' in 'order clause' +drop table t1; diff --git a/mysql-test/t/update.test b/mysql-test/t/update.test index c69c56f0331..e5287eacbc8 100644 --- a/mysql-test/t/update.test +++ b/mysql-test/t/update.test @@ -306,4 +306,12 @@ create table t1(f1 int, `*f2` int); insert into t1 values (1,1); update t1 set `*f2`=1; drop table t1; + +# +# Bug#25126: Wrongly resolved field leads to a crash +# +create table t1(f1 int); +--error 1054 +update t1 set f2=1 order by f2; +drop table t1; # End of 4.1 tests diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 05ecfe9b484..2f7661182a6 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -2518,11 +2518,14 @@ int setup_fields(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, { reg2 Item *item; List_iterator it(fields); + bool save_is_item_list_lookup; DBUG_ENTER("setup_fields"); thd->set_query_id=set_query_id; thd->allow_sum_func= allow_sum_func; thd->where="field list"; + save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup; + thd->lex->current_select->is_item_list_lookup= 0; /* To prevent fail on forward lookup we fill it with zerows, @@ -2543,7 +2546,10 @@ int setup_fields(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, { if (!item->fixed && item->fix_fields(thd, tables, it.ref()) || (item= *(it.ref()))->check_cols(1)) + { + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; DBUG_RETURN(-1); /* purecov: inspected */ + } if (ref) *(ref++)= item; if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM && @@ -2551,6 +2557,7 @@ int setup_fields(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, item->split_sum_func(thd, ref_pointer_array, *sum_func_list); thd->used_tables|=item->used_tables(); } + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; DBUG_RETURN(test(thd->net.report_error)); } @@ -2747,6 +2754,8 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) { table_map not_null_tables= 0; Item_arena *arena= 0, backup; + bool save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup; + thd->lex->current_select->is_item_list_lookup= 0; DBUG_ENTER("setup_conds"); thd->set_query_id=1; @@ -2756,7 +2765,10 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) thd->where="where clause"; if (!(*conds)->fixed && (*conds)->fix_fields(thd, tables, conds) || (*conds)->check_cols(1)) + { + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; DBUG_RETURN(1); + } not_null_tables= (*conds)->not_null_tables(); } @@ -2772,7 +2784,10 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) if (!table->on_expr->fixed && table->on_expr->fix_fields(thd, tables, &table->on_expr) || table->on_expr->check_cols(1)) + { + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; DBUG_RETURN(1); + } thd->lex->current_select->cond_count++; /* @@ -2794,7 +2809,11 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) } if ((*conds) && !(*conds)->fixed && (*conds)->fix_fields(thd, tables, conds)) + { + thd->lex->current_select->is_item_list_lookup= + save_is_item_list_lookup; DBUG_RETURN(1); + } } } if (table->natural_join) @@ -2846,7 +2865,11 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) { if (!(*conds)->fixed && (*conds)->fix_fields(thd, tables, conds)) + { + thd->lex->current_select->is_item_list_lookup= + save_is_item_list_lookup; DBUG_RETURN(1); + } } } else @@ -2859,7 +2882,11 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) { if (!table->on_expr->fixed && table->on_expr->fix_fields(thd, tables, &table->on_expr)) - DBUG_RETURN(1); + { + thd->lex->current_select->is_item_list_lookup= + save_is_item_list_lookup; + DBUG_RETURN(1); + } } } } @@ -2881,9 +2908,11 @@ int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds) */ thd->lex->current_select->where= *conds; } + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; DBUG_RETURN(test(thd->net.report_error)); err: + thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup; if (arena) thd->restore_backup_item_arena(arena, &backup); DBUG_RETURN(1); diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 9eb9d2640e9..af3ad782ee3 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -265,6 +265,7 @@ JOIN::prepare(Item ***rref_pointer_array, select_lex->join= this; union_part= (unit_arg->first_select()->next_select() != 0); + thd->lex->current_select->is_item_list_lookup= 1; /* Check that all tables, fields, conds and order are ok */ if (setup_tables(tables_list) || @@ -8702,16 +8703,12 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, 'it' reassigned in if condition because fix_field can change it. */ - thd->lex->current_select->is_item_list_lookup= 1; if (!it->fixed && (it->fix_fields(thd, tables, order->item) || (it= *order->item)->check_cols(1) || thd->is_fatal_error)) - { - thd->lex->current_select->is_item_list_lookup= 0; return 1; // Wrong field - } - thd->lex->current_select->is_item_list_lookup= 0; + uint el= all_fields.elements; all_fields.push_front(it); // Add new field to field list ref_pointer_array[el]= it; From e851d788605eca73b95c3c9154241e4c376fbff7 Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Mon, 5 Mar 2007 11:25:44 +0800 Subject: [PATCH 21/73] BUG#25992 Data nodes died during creating many tables based on different tablespaces. --- storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp index 00a984e591b..f020d012023 100644 --- a/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp +++ b/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp @@ -1090,7 +1090,6 @@ Dbdict::updateSchemaState(Signal* signal, Uint32 tableId, SchemaFile::TableEntry* te, Callback* callback, bool savetodisk){ jam(); - ndbrequire(tableId < c_tableRecordPool.getSize()); XSchemaFile * xsf = &c_schemaFile[c_schemaRecord.schemaPage != 0]; SchemaFile::TableEntry * tableEntry = getTableEntry(xsf, tableId); From 08efa4e0ea99255dd9136b19222feff1165605ff Mon Sep 17 00:00:00 2001 From: "igor@olga.mysql.com" <> Date: Sun, 4 Mar 2007 19:54:35 -0800 Subject: [PATCH 22/73] Fixed bug #26560. The flag alias_name_used was not set on for the outer references in subqueries. It resulted in replacement of any outer reference resolved against an alias for a full field name when the frm representation of a view with a subquery was generated. If the subquery and the outer query referenced the same table in their from lists this replacement effectively changed the meaning of the view and led to wrong results for selects from this view. Modified several functions to ensure setting the right value of the alias_name_used flag for outer references resolved against aliases. --- mysql-test/r/view.result | 37 ++++++++++++ mysql-test/t/view.test | 40 +++++++++++++ sql/item.cc | 26 ++++++--- sql/item.h | 10 +++- sql/mysql_priv.h | 22 ++++++- sql/sql_base.cc | 121 ++++++++++++++++++++++----------------- sql/sql_select.cc | 8 +-- 7 files changed, 195 insertions(+), 69 deletions(-) diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result index 50b41e1352f..cfa4f7cbba5 100644 --- a/mysql-test/r/view.result +++ b/mysql-test/r/view.result @@ -3135,4 +3135,41 @@ code COUNT(DISTINCT country) 100 2 DROP VIEW v1; DROP TABLE t1; +CREATE TABLE t1 ( +lid int NOT NULL PRIMARY KEY, +name char(10) NOT NULL +); +INSERT INTO t1 (lid, name) VALUES +(1, 'YES'), (2, 'NO'); +CREATE TABLE t2 ( +id int NOT NULL PRIMARY KEY, +gid int NOT NULL, +lid int NOT NULL, +dt date +); +INSERT INTO t2 (id, gid, lid, dt) VALUES +(1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'), +(3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02'); +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +lgid clid +1 NO +2 YES +CREATE VIEW v1 AS +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +SELECT * FROM v1; +lgid clid +1 NO +2 YES +DROP VIEW v1; +DROP table t1,t2; End of 5.0 tests. diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test index 33e381af476..32776e85e85 100644 --- a/mysql-test/t/view.test +++ b/mysql-test/t/view.test @@ -3058,4 +3058,44 @@ SELECT code, COUNT(DISTINCT country) FROM v1 GROUP BY code ORDER BY MAX(id); DROP VIEW v1; DROP TABLE t1; +# +# Bug#26560: view using subquery with a reference to an outer alias +# + +CREATE TABLE t1 ( + lid int NOT NULL PRIMARY KEY, + name char(10) NOT NULL +); +INSERT INTO t1 (lid, name) VALUES + (1, 'YES'), (2, 'NO'); + +CREATE TABLE t2 ( + id int NOT NULL PRIMARY KEY, + gid int NOT NULL, + lid int NOT NULL, + dt date +); +INSERT INTO t2 (id, gid, lid, dt) VALUES + (1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'), + (3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02'); + +SELECT DISTINCT t2.gid AS lgid, + (SELECT t1.name FROM t1, t2 + WHERE t1.lid = t2.lid AND t2.gid = lgid + ORDER BY t2.dt DESC LIMIT 1 + ) as clid + FROM t2; + +CREATE VIEW v1 AS +SELECT DISTINCT t2.gid AS lgid, + (SELECT t1.name FROM t1, t2 + WHERE t1.lid = t2.lid AND t2.gid = lgid + ORDER BY t2.dt DESC LIMIT 1 + ) as clid + FROM t2; +SELECT * FROM v1; + +DROP VIEW v1; +DROP table t1,t2; + --echo End of 5.0 tests. diff --git a/sql/item.cc b/sql/item.cc index 257687ebaaf..c5d8a62761c 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -3320,7 +3320,7 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select) ORDER *group_list= (ORDER*) select->group_list.first; bool ambiguous_fields= FALSE; uint counter; - bool not_used; + enum_resolution_type resolution; /* Search for a column or derived column named as 'ref' in the SELECT @@ -3328,8 +3328,10 @@ resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select) */ if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()), &counter, REPORT_EXCEPT_NOT_FOUND, - ¬_used))) + &resolution))) return NULL; /* Some error occurred. */ + if (resolution == RESOLVED_AGAINST_ALIAS) + ref->alias_name_used= TRUE; /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */ if (select->having_fix_field && !ref->with_sum_func && group_list) @@ -3630,9 +3632,9 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference) *ref= NULL; // Don't call set_properties() rf= (place == IN_HAVING ? new Item_ref(context, ref, (char*) table_name, - (char*) field_name) : + (char*) field_name, alias_name_used) : new Item_direct_ref(context, ref, (char*) table_name, - (char*) field_name)); + (char*) field_name, alias_name_used)); *ref= save; if (!rf) return -1; @@ -3750,12 +3752,14 @@ bool Item_field::fix_fields(THD *thd, Item **reference) if (thd->lex->current_select->is_item_list_lookup) { uint counter; - bool not_used; + enum_resolution_type resolution; Item** res= find_item_in_list(this, thd->lex->current_select->item_list, &counter, REPORT_EXCEPT_NOT_FOUND, - ¬_used); + &resolution); if (!res) return 1; + if (resolution == RESOLVED_AGAINST_ALIAS) + alias_name_used= TRUE; if (res != (Item **)not_found_item) { if ((*res)->type() == Item::FIELD_ITEM) @@ -4898,10 +4902,12 @@ Item *Item_field::update_value_transformer(byte *select_arg) Item_ref::Item_ref(Name_resolution_context *context_arg, Item **item, const char *table_name_arg, - const char *field_name_arg) + const char *field_name_arg, + bool alias_name_used_arg) :Item_ident(context_arg, NullS, table_name_arg, field_name_arg), result_field(0), ref(item) { + alias_name_used= alias_name_used_arg; /* This constructor used to create some internals references over fixed items */ @@ -5184,11 +5190,13 @@ void Item_ref::set_properties() */ with_sum_func= (*ref)->with_sum_func; unsigned_flag= (*ref)->unsigned_flag; + fixed= 1; + if (alias_name_used) + return; if ((*ref)->type() == FIELD_ITEM) alias_name_used= ((Item_ident *) (*ref))->alias_name_used; else alias_name_used= TRUE; // it is not field, so it is was resolved by alias - fixed= 1; } @@ -5206,7 +5214,7 @@ void Item_ref::print(String *str) if (ref) { if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF && - ref_type() != OUTER_REF && name && alias_name_used) + !table_name && name && alias_name_used) { THD *thd= current_thd; append_identifier(thd, str, name, (uint) strlen(name)); diff --git a/sql/item.h b/sql/item.h index d792f95055d..2a121523423 100644 --- a/sql/item.h +++ b/sql/item.h @@ -1851,7 +1851,8 @@ public: with Bar, and if we have a more broader set of problems like this. */ Item_ref(Name_resolution_context *context_arg, Item **item, - const char *table_name_arg, const char *field_name_arg); + const char *table_name_arg, const char *field_name_arg, + bool alias_name_used_arg= FALSE); /* Constructor need to process subselect with temporary tables (see Item) */ Item_ref(THD *thd, Item_ref *item) @@ -1926,8 +1927,11 @@ class Item_direct_ref :public Item_ref public: Item_direct_ref(Name_resolution_context *context_arg, Item **item, const char *table_name_arg, - const char *field_name_arg) - :Item_ref(context_arg, item, table_name_arg, field_name_arg) {} + const char *field_name_arg, + bool alias_name_used_arg= FALSE) + :Item_ref(context_arg, item, table_name_arg, + field_name_arg, alias_name_used_arg) + {} /* Constructor need to process subselect with temporary tables (see Item) */ Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {} diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h index 7c9b43f23b9..cf5e9799fae 100644 --- a/sql/mysql_priv.h +++ b/sql/mysql_priv.h @@ -1008,9 +1008,29 @@ SQL_SELECT *make_select(TABLE *head, table_map const_tables, table_map read_tables, COND *conds, bool allow_null_cond, int *error); extern Item **not_found_item; + +/* + This enumeration type is used only by the function find_item_in_list + to return the info on how an item has been resolved against a list + of possibly aliased items. + The item can be resolved: + - against an alias name of the list's element (RESOLVED_AGAINST_ALIAS) + - against non-aliased field name of the list (RESOLVED_WITH_NO_ALIAS) + - against an aliased field name of the list (RESOLVED_BEHIND_ALIAS) + - ignoring the alias name in cases when SQL requires to ignore aliases + (e.g. when the resolved field reference contains a table name or + when the resolved item is an expression) (RESOLVED_IGNORING_ALIAS) +*/ +enum enum_resolution_type { + NOT_RESOLVED=0, + RESOLVED_IGNORING_ALIAS, + RESOLVED_BEHIND_ALIAS, + RESOLVED_WITH_NO_ALIAS, + RESOLVED_AGAINST_ALIAS +}; Item ** find_item_in_list(Item *item, List &items, uint *counter, find_item_error_report_type report_error, - bool *unaliased); + enum_resolution_type *resolution); bool get_key_map_from_key_list(key_map *map, TABLE *table, List *index_list); bool insert_fields(THD *thd, Name_resolution_context *context, diff --git a/sql/sql_base.cc b/sql/sql_base.cc index 9945057cd1b..0ebfd2b1044 100644 --- a/sql/sql_base.cc +++ b/sql/sql_base.cc @@ -3468,10 +3468,13 @@ find_field_in_tables(THD *thd, Item_ident *item, return not_found_item, report other errors, return 0 IGNORE_ERRORS Do not report errors, return 0 if error - unaliased Set to true if item is field which was found - by original field name and not by its alias - in item list. Set to false otherwise. - + resolution Set to the resolution type if the item is found + (it says whether the item is resolved + against an alias name, + or as a field name without alias, + or as a field hidden by alias, + or ignoring alias) + RETURN VALUES 0 Item is not found or item is not unique, error message is reported @@ -3487,7 +3490,8 @@ Item **not_found_item= (Item**) 0x1; Item ** find_item_in_list(Item *find, List &items, uint *counter, - find_item_error_report_type report_error, bool *unaliased) + find_item_error_report_type report_error, + enum_resolution_type *resolution) { List_iterator li(items); Item **found=0, **found_unaliased= 0, *item; @@ -3501,10 +3505,9 @@ find_item_in_list(Item *find, List &items, uint *counter, */ bool is_ref_by_name= 0; uint unaliased_counter; - LINT_INIT(unaliased_counter); // Dependent on found_unaliased - *unaliased= FALSE; + *resolution= NOT_RESOLVED; is_ref_by_name= (find->type() == Item::FIELD_ITEM || find->type() == Item::REF_ITEM); @@ -3571,63 +3574,77 @@ find_item_in_list(Item *find, List &items, uint *counter, } found_unaliased= li.ref(); unaliased_counter= i; + *resolution= RESOLVED_IGNORING_ALIAS; if (db_name) break; // Perfect match } } - else if (!my_strcasecmp(system_charset_info, item_field->name, - field_name)) + else { - /* - If table name was not given we should scan through aliases - (or non-aliased fields) first. We are also checking unaliased - name of the field in then next else-if, to be able to find - instantly field (hidden by alias) if no suitable alias (or - non-aliased field) was found. - */ - if (found) + int fname_cmp= my_strcasecmp(system_charset_info, + item_field->field_name, + field_name); + if (!my_strcasecmp(system_charset_info, + item_field->name,field_name)) { - if ((*found)->eq(item, 0)) - continue; // Same field twice - if (report_error != IGNORE_ERRORS) - my_error(ER_NON_UNIQ_ERROR, MYF(0), - find->full_name(), current_thd->where); - return (Item**) 0; + /* + If table name was not given we should scan through aliases + and non-aliased fields first. We are also checking unaliased + name of the field in then next else-if, to be able to find + instantly field (hidden by alias) if no suitable alias or + non-aliased field was found. + */ + if (found) + { + if ((*found)->eq(item, 0)) + continue; // Same field twice + if (report_error != IGNORE_ERRORS) + my_error(ER_NON_UNIQ_ERROR, MYF(0), + find->full_name(), current_thd->where); + return (Item**) 0; + } + found= li.ref(); + *counter= i; + *resolution= fname_cmp ? RESOLVED_AGAINST_ALIAS: + RESOLVED_WITH_NO_ALIAS; } - found= li.ref(); - *counter= i; - } - else if (!my_strcasecmp(system_charset_info, item_field->field_name, - field_name)) - { - /* - We will use un-aliased field or react on such ambiguities only if - we won't be able to find aliased field. - Again if we have ambiguity with field outside of select list - we should prefer fields from select list. - */ - if (found_unaliased) - { - if ((*found_unaliased)->eq(item, 0)) - continue; // Same field twice - found_unaliased_non_uniq= 1; - } - else + else if (!fname_cmp) { + /* + We will use non-aliased field or react on such ambiguities only if + we won't be able to find aliased field. + Again if we have ambiguity with field outside of select list + we should prefer fields from select list. + */ + if (found_unaliased) + { + if ((*found_unaliased)->eq(item, 0)) + continue; // Same field twice + found_unaliased_non_uniq= 1; + } found_unaliased= li.ref(); unaliased_counter= i; } } } - else if (!table_name && (find->eq(item,0) || - is_ref_by_name && find->name && item->name && - !my_strcasecmp(system_charset_info, - item->name,find->name))) - { - found= li.ref(); - *counter= i; - break; - } + else if (!table_name) + { + if (is_ref_by_name && find->name && item->name && + !my_strcasecmp(system_charset_info,item->name,find->name)) + { + found= li.ref(); + *counter= i; + *resolution= RESOLVED_AGAINST_ALIAS; + break; + } + else if (find->eq(item,0)) + { + found= li.ref(); + *counter= i; + *resolution= RESOLVED_IGNORING_ALIAS; + break; + } + } } if (!found) { @@ -3642,7 +3659,7 @@ find_item_in_list(Item *find, List &items, uint *counter, { found= found_unaliased; *counter= unaliased_counter; - *unaliased= TRUE; + *resolution= RESOLVED_BEHIND_ALIAS; } } if (found) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 5202f35f4de..7538d3bf599 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -13158,7 +13158,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, Item **select_item; /* The corresponding item from the SELECT clause. */ Field *from_field; /* The corresponding field from the FROM clause. */ uint counter; - bool unaliased; + enum_resolution_type resolution; /* Local SP variables may be int but are expressions, not positions. @@ -13181,7 +13181,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, } /* Lookup the current GROUP/ORDER field in the SELECT clause. */ select_item= find_item_in_list(order_item, fields, &counter, - REPORT_EXCEPT_NOT_FOUND, &unaliased); + REPORT_EXCEPT_NOT_FOUND, &resolution); if (!select_item) return TRUE; /* The item is not unique, or some other error occured. */ @@ -13195,7 +13195,7 @@ find_order_in_list(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables, original field name, we should additionaly check if we have conflict for this name (in case if we would perform lookup in all tables). */ - if (unaliased && !order_item->fixed && + if (resolution == RESOLVED_BEHIND_ALIAS && !order_item->fixed && order_item->fix_fields(thd, order->item)) return TRUE; @@ -13429,7 +13429,7 @@ setup_new_fields(THD *thd, List &fields, thd->set_query_id=1; // Not really needed, but... uint counter; - bool not_used; + enum_resolution_type not_used; for (; new_field ; new_field= new_field->next) { if ((item= find_item_in_list(*new_field->item, fields, &counter, From 629fed6c4d2dcb8e062de7bee959e38d434d5c67 Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Mon, 5 Mar 2007 11:52:28 +0100 Subject: [PATCH 23/73] Bug#26464 - insert delayed + update + merge = corruption Using INSERT DELAYED on MERGE tables could lead to table corruptions. The manual lists a couple of storage engines, which can be used with INSERT DELAYED. MERGE is not in this list. The attempt to try it anyway has not been rejected yet. This bug was not detected earlier as it can work under special circumstances. Most notable is low concurrency. To be safe, this patch rejects any attempt to use INSERT DELAYED on MERGE tables. --- mysql-test/r/merge.result | 5 +++++ mysql-test/t/merge.test | 9 +++++++++ sql/ha_myisammrg.h | 2 +- 3 files changed, 15 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/merge.result b/mysql-test/r/merge.result index eb333cdadb7..33de735d714 100644 --- a/mysql-test/r/merge.result +++ b/mysql-test/r/merge.result @@ -801,3 +801,8 @@ CREATE TABLE tm1(a SMALLINT, b SMALLINT, KEY(a)) ENGINE=MERGE UNION=(t1); SELECT * FROM tm1; ERROR HY000: Unable to open underlying table which is differently defined or of non-MyISAM type or doesn't exist DROP TABLE t1, tm1; +CREATE TABLE t1(c1 INT) ENGINE=MyISAM; +CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1); +INSERT DELAYED INTO t2 VALUES(1); +ERROR HY000: Table storage engine for 't2' doesn't have this option +DROP TABLE t1, t2; diff --git a/mysql-test/t/merge.test b/mysql-test/t/merge.test index 700a807e62c..f759d20dd80 100644 --- a/mysql-test/t/merge.test +++ b/mysql-test/t/merge.test @@ -428,4 +428,13 @@ CREATE TABLE tm1(a SMALLINT, b SMALLINT, KEY(a)) ENGINE=MERGE UNION=(t1); SELECT * FROM tm1; DROP TABLE t1, tm1; +# +# Bug#26464 - insert delayed + update + merge = corruption +# +CREATE TABLE t1(c1 INT) ENGINE=MyISAM; +CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1); +--error 1031 +INSERT DELAYED INTO t2 VALUES(1); +DROP TABLE t1, t2; + # End of 4.1 tests diff --git a/sql/ha_myisammrg.h b/sql/ha_myisammrg.h index 84eaae04590..84af55b262e 100644 --- a/sql/ha_myisammrg.h +++ b/sql/ha_myisammrg.h @@ -37,7 +37,7 @@ class ha_myisammrg: public handler { return (HA_REC_NOT_IN_SEQ | HA_AUTO_PART_KEY | HA_READ_RND_SAME | HA_NULL_IN_KEY | HA_CAN_INDEX_BLOBS | HA_FILE_BASED | - HA_CAN_INSERT_DELAYED | HA_ANY_INDEX_MAY_BE_UNIQUE); + HA_ANY_INDEX_MAY_BE_UNIQUE); } ulong index_flags(uint inx, uint part, bool all_parts) const { From 0bdb2a0c06d576bf5749ccd0b442eb1ab43b4667 Mon Sep 17 00:00:00 2001 From: "Justin.He/justin.he@dev3-240.dev.cn.tlan" <> Date: Mon, 5 Mar 2007 19:14:56 +0800 Subject: [PATCH 24/73] BUG#25877, After DROP INDEX non-indexed data isn't moved from memory into tablespace --- sql/ha_ndbcluster.cc | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 86a2f9d8544..3394962b141 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -10606,10 +10606,23 @@ bool ha_ndbcluster::check_if_incompatible_data(HA_CREATE_INFO *create_info, int pk= 0; int ai= 0; + + if (create_info->tablespace) + create_info->storage_media = HA_SM_DISK; + else + create_info->storage_media = HA_SM_MEMORY; + for (i= 0; i < table->s->fields; i++) { Field *field= table->field[i]; const NDBCOL *col= tab->getColumn(i); + if (col->getStorageType() == NDB_STORAGETYPE_MEMORY && create_info->storage_media != HA_SM_MEMORY || + col->getStorageType() == NDB_STORAGETYPE_DISK && create_info->storage_media != HA_SM_DISK) + { + DBUG_PRINT("info", ("Column storage media is changed")); + DBUG_RETURN(COMPATIBLE_DATA_NO); + } + if (field->flags & FIELD_IS_RENAMED) { DBUG_PRINT("info", ("Field has been renamed, copy table")); From f5e9c10d58f747f103a7adc29e0bf647e2ea170e Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@macbook.gmz" <> Date: Tue, 6 Mar 2007 18:52:00 +0200 Subject: [PATCH 25/73] Bug#19342: additional test case for code coverage --- mysql-test/r/func_in.result | 8 +++++++- mysql-test/t/func_in.test | 6 +++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/mysql-test/r/func_in.result b/mysql-test/r/func_in.result index 36bcc6f1711..fad9a7157e1 100644 --- a/mysql-test/r/func_in.result +++ b/mysql-test/r/func_in.result @@ -463,5 +463,11 @@ CREATE TABLE t3 (a BIGINT UNSIGNED); INSERT INTO t3 VALUES (9223372036854775551); SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42); HEX(a) -DROP TABLE t1,t2,t3; +CREATE TABLE t4 (a DATE); +INSERT INTO t4 VALUES ('1972-02-06'), ('1972-07-29'); +SELECT * FROM t4 WHERE a IN ('1972-02-06','19772-07-29'); +a +Warnings: +Warning 1292 Incorrect date value: '19772-07-29' for column 'a' at row 1 +DROP TABLE t1,t2,t3,t4; End of 5.0 tests diff --git a/mysql-test/t/func_in.test b/mysql-test/t/func_in.test index 7ba54747d4b..f9749662ec1 100644 --- a/mysql-test/t/func_in.test +++ b/mysql-test/t/func_in.test @@ -354,6 +354,10 @@ INSERT INTO t3 VALUES (9223372036854775551); SELECT HEX(a) FROM t3 WHERE a IN (9223372036854775807, 42); -DROP TABLE t1,t2,t3; +CREATE TABLE t4 (a DATE); +INSERT INTO t4 VALUES ('1972-02-06'), ('1972-07-29'); +SELECT * FROM t4 WHERE a IN ('1972-02-06','19772-07-29'); + +DROP TABLE t1,t2,t3,t4; --echo End of 5.0 tests From 6552d3064ddbe6e3846e9fb0b8e848dcef0ae008 Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Tue, 6 Mar 2007 23:58:10 +0300 Subject: [PATCH 26/73] Bug#25376: Incomplete setup of ORDER BY clause results in a wrong result. Functions over sum functions wasn't set up correctly for the ORDER BY clause which leads to a wrong order of the result set. The split_sum_func() function is called now for each ORDER BY item that contains a sum function to set it up correctly. --- mysql-test/r/order_by.result | 8 ++++++++ mysql-test/t/order_by.test | 8 ++++++++ sql/sql_select.cc | 11 +++++++++++ 3 files changed, 27 insertions(+) diff --git a/mysql-test/r/order_by.result b/mysql-test/r/order_by.result index e81d46c9199..0b1edfd3e8f 100644 --- a/mysql-test/r/order_by.result +++ b/mysql-test/r/order_by.result @@ -926,3 +926,11 @@ NULL 2 3 DROP TABLE t1,t2,t3,t4; +create table t1 (a int, b int, c int); +insert into t1 values (1,2,3), (9,8,3), (19,4,3), (1,4,9); +select a,(sum(b)/sum(c)) as ratio from t1 group by a order by sum(b)/sum(c) asc; +a ratio +1 0.5000 +19 1.3333 +9 2.6667 +drop table t1; diff --git a/mysql-test/t/order_by.test b/mysql-test/t/order_by.test index 012b38ff8b7..a3aa2c0081d 100644 --- a/mysql-test/t/order_by.test +++ b/mysql-test/t/order_by.test @@ -640,3 +640,11 @@ SELECT t2.b FROM t1 LEFT JOIN (t2, t3 LEFT JOIN t4 ON t3.a=t4.a) ON (t1.a=t2.a AND t1.b=t3.b) order by t2.b; DROP TABLE t1,t2,t3,t4; + +# +# Bug#25376: Incomplete setup of ORDER BY clause results in a wrong result. +# +create table t1 (a int, b int, c int); +insert into t1 values (1,2,3), (9,8,3), (19,4,3), (1,4,9); +select a,(sum(b)/sum(c)) as ratio from t1 group by a order by sum(b)/sum(c) asc; +drop table t1; diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 5202f35f4de..fae4a0ce4aa 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -455,6 +455,17 @@ JOIN::prepare(Item ***rref_pointer_array, select_lex->fix_prepare_information(thd, &conds, &having); + if (order) + { + ORDER *ord; + for (ord= order; ord; ord= ord->next) + { + Item *item= *ord->item; + if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM) + item->split_sum_func(thd, ref_pointer_array, all_fields); + } + } + if (having && having->with_sum_func) having->split_sum_func2(thd, ref_pointer_array, all_fields, &having, TRUE); From 7afa5f1c5af3b78ff1db21c191e36258d6f478e7 Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Wed, 7 Mar 2007 21:44:58 +0300 Subject: [PATCH 27/73] Bug#22331: Wrong WHERE in EXPLAIN EXTENDED when all expressions were optimized away. During optimization stage the WHERE conditions can be changed or even be removed at all if they know for sure to be true of false. Thus they aren't showed in the EXPLAIN EXTENDED which prints conditions after optimization. Now if all elements of an Item_cond were removed this Item_cond is substituted for an Item_int with the int value of the Item_cond. If there were conditions that were totally optimized away then values of the saved cond_value and having_value will be printed instead. --- mysql-test/r/explain.result | 29 +++++++++++++++++++++++++++++ mysql-test/r/func_test.result | 2 +- mysql-test/r/subselect.result | 16 ++++++++-------- mysql-test/t/explain.test | 14 ++++++++++++++ sql/sql_lex.cc | 1 + sql/sql_lex.h | 2 ++ sql/sql_select.cc | 23 ++++++++++++++++++----- sql/sql_select.h | 2 +- 8 files changed, 74 insertions(+), 15 deletions(-) diff --git a/mysql-test/r/explain.result b/mysql-test/r/explain.result index 3bd7b2ccc15..221a8695f60 100644 --- a/mysql-test/r/explain.result +++ b/mysql-test/r/explain.result @@ -57,3 +57,32 @@ select 3 into @v1; explain select 3 into @v1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE NULL NULL NULL NULL NULL NULL NULL No tables used +create table t1(f1 int, f2 int); +insert into t1 values (1,1); +create view v1 as select * from t1 where f1=1; +explain extended select * from v1 where f2=1; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 +Warnings: +Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 +explain extended select * from t1 where 0; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE +Warnings: +Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 0 +explain extended select * from t1 where 1; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 +Warnings: +Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 +explain extended select * from t1 having 0; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible HAVING +Warnings: +Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 0 +explain extended select * from t1 having 1; +id select_type table type possible_keys key key_len ref rows Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 +Warnings: +Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 1 +drop table t1; diff --git a/mysql-test/r/func_test.result b/mysql-test/r/func_test.result index 43832bdbccc..c3fbdb3b3bf 100644 --- a/mysql-test/r/func_test.result +++ b/mysql-test/r/func_test.result @@ -79,7 +79,7 @@ explain extended select * from t1 where 1 xor 1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE Warnings: -Note 1003 select `test`.`t1`.`a` AS `a` from `test`.`t1` +Note 1003 select `test`.`t1`.`a` AS `a` from `test`.`t1` where 0 select - a from t1; - a -1 diff --git a/mysql-test/r/subselect.result b/mysql-test/r/subselect.result index 06f8c019265..1f29497f662 100644 --- a/mysql-test/r/subselect.result +++ b/mysql-test/r/subselect.result @@ -421,7 +421,7 @@ id select_type table type possible_keys key key_len ref rows Extra 3 UNION NULL NULL NULL NULL NULL NULL NULL No tables used NULL UNION RESULT ALL NULL NULL NULL NULL NULL Warnings: -Note 1003 select 1 AS `1` from `test`.`t1` +Note 1003 select 1 AS `1` from `test`.`t1` where 1 drop table t1; CREATE TABLE `t1` ( `numeropost` mediumint(8) unsigned NOT NULL auto_increment, @@ -1180,7 +1180,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL No tables used 2 DEPENDENT SUBQUERY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE Warnings: -Note 1003 select (0,(select 1 AS `Not_used` from `test`.`t1` `a`)) AS `0 IN (SELECT 1 FROM t1 a)` +Note 1003 select (0,(select 1 AS `Not_used` from `test`.`t1` `a` where 0)) AS `0 IN (SELECT 1 FROM t1 a)` INSERT INTO t1 (pseudo) VALUES ('test1'); SELECT 0 IN (SELECT 1 FROM t1 a); 0 IN (SELECT 1 FROM t1 a) @@ -1190,7 +1190,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL No tables used 2 DEPENDENT SUBQUERY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE Warnings: -Note 1003 select (0,(select 1 AS `Not_used` from `test`.`t1` `a`)) AS `0 IN (SELECT 1 FROM t1 a)` +Note 1003 select (0,(select 1 AS `Not_used` from `test`.`t1` `a` where 0)) AS `0 IN (SELECT 1 FROM t1 a)` drop table t1; CREATE TABLE `t1` ( `i` int(11) NOT NULL default '0', @@ -1532,7 +1532,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0 select * from t3 where NULL >= any (select b from t2 group by 1); a explain extended select * from t3 where NULL >= any (select b from t2 group by 1); @@ -1540,7 +1540,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0 select * from t3 where NULL >= some (select b from t2); a explain extended select * from t3 where NULL >= some (select b from t2); @@ -1548,7 +1548,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0 select * from t3 where NULL >= some (select b from t2 group by 1); a explain extended select * from t3 where NULL >= some (select b from t2 group by 1); @@ -1556,7 +1556,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY NULL NULL NULL NULL NULL NULL NULL Impossible WHERE 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where 0 insert into t2 values (2,2), (2,1), (3,3), (3,1); select * from t3 where a > all (select max(b) from t2 group by a); a @@ -1618,7 +1618,7 @@ id select_type table type possible_keys key key_len ref rows Extra 3 UNION t1 system NULL NULL NULL NULL 1 NULL UNION RESULT ALL NULL NULL NULL NULL NULL Warnings: -Note 1003 select `test`.`t1`.`s1` AS `s1` from `test`.`t1` +Note 1003 select `test`.`t1`.`s1` AS `s1` from `test`.`t1` where 1 drop table t1; CREATE TABLE t1 (number char(11) NOT NULL default '') ENGINE=MyISAM CHARSET=latin1; INSERT INTO t1 VALUES ('69294728265'),('18621828126'),('89356874041'),('95895001874'); diff --git a/mysql-test/t/explain.test b/mysql-test/t/explain.test index efce0cdf3b5..85bbbfea154 100644 --- a/mysql-test/t/explain.test +++ b/mysql-test/t/explain.test @@ -51,4 +51,18 @@ set names latin1; select 3 into @v1; explain select 3 into @v1; +# +# Bug#22331: Wrong WHERE in EXPLAIN EXTENDED when all expressions were +# optimized away. +# +create table t1(f1 int, f2 int); +insert into t1 values (1,1); +create view v1 as select * from t1 where f1=1; +explain extended select * from v1 where f2=1; +explain extended select * from t1 where 0; +explain extended select * from t1 where 1; +explain extended select * from t1 having 0; +explain extended select * from t1 having 1; +drop table t1; + # End of 5.0 tests. diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc index ce76c35b33c..86590e10535 100644 --- a/sql/sql_lex.cc +++ b/sql/sql_lex.cc @@ -1192,6 +1192,7 @@ void st_select_lex::init_select() is_correlated= 0; cur_pos_in_select_list= UNDEF_POS; non_agg_fields.empty(); + cond_value= having_value= Item::COND_UNDEF; } /* diff --git a/sql/sql_lex.h b/sql/sql_lex.h index ae2b0d30a9c..4400c94e7f5 100644 --- a/sql/sql_lex.h +++ b/sql/sql_lex.h @@ -487,6 +487,8 @@ public: Item *where, *having; /* WHERE & HAVING clauses */ Item *prep_where; /* saved WHERE clause for prepared statement processing */ Item *prep_having;/* saved HAVING clause for prepared statement processing */ + /* Saved values of the WHERE and HAVING clauses*/ + Item::cond_result cond_value, having_value; /* point on lex in which it was created, used in view subquery detection */ st_lex *parent_lex; enum olap_type olap; diff --git a/sql/sql_select.cc b/sql/sql_select.cc index e7b18201a0a..6adb26ade29 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -681,7 +681,6 @@ JOIN::optimize() } { - Item::cond_result having_value; having= optimize_cond(this, having, join_list, &having_value); if (thd->net.report_error) { @@ -689,6 +688,10 @@ JOIN::optimize() DBUG_PRINT("error",("Error from optimize_cond")); DBUG_RETURN(1); } + if (select_lex->where) + select_lex->cond_value= cond_value; + if (select_lex->having) + select_lex->having_value= having_value; if (cond_value == Item::COND_FALSE || having_value == Item::COND_FALSE || (!unit->select_limit_cnt && !(select_options & OPTION_FOUND_ROWS))) @@ -829,6 +832,7 @@ JOIN::optimize() conds->update_used_tables(); DBUG_EXECUTE("where", print_where(conds, "after substitute_best_equal");); } + /* Permorm the the optimization on fields evaluation mentioned above for all on expressions. @@ -7535,6 +7539,9 @@ static COND* substitute_for_best_equal_field(COND *cond, break; } } + if (!((Item_cond*)cond)->argument_list()->elements) + cond= new Item_int(cond->val_bool()); + } else if (cond->type() == Item::FUNC_ITEM && ((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC) @@ -15259,10 +15266,13 @@ void st_select_lex::print(THD *thd, String *str) Item *cur_where= where; if (join) cur_where= join->conds; - if (cur_where) + if (cur_where || cond_value != Item::COND_UNDEF) { str->append(STRING_WITH_LEN(" where ")); - cur_where->print(str); + if (cur_where) + cur_where->print(str); + else + str->append(cond_value != Item::COND_FALSE ? "1" : "0"); } // group by & olap @@ -15288,10 +15298,13 @@ void st_select_lex::print(THD *thd, String *str) if (join) cur_having= join->having; - if (cur_having) + if (cur_having || having_value != Item::COND_UNDEF) { str->append(STRING_WITH_LEN(" having ")); - cur_having->print(str); + if (cur_having) + cur_having->print(str); + else + str->append(having_value != Item::COND_FALSE ? "1" : "0"); } if (order_list.elements) diff --git a/sql/sql_select.h b/sql/sql_select.h index a17d7fcb362..27ca633fdb5 100644 --- a/sql/sql_select.h +++ b/sql/sql_select.h @@ -292,7 +292,7 @@ public: bool need_tmp, hidden_group_fields; DYNAMIC_ARRAY keyuse; - Item::cond_result cond_value; + Item::cond_result cond_value, having_value; List all_fields; // to store all fields that used in query //Above list changed to use temporary table List tmp_all_fields1, tmp_all_fields2, tmp_all_fields3; From b81b814cd180d4d1963a57201758e47b04c21bcf Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Wed, 7 Mar 2007 22:11:57 +0300 Subject: [PATCH 28/73] Bug#25373: Stored functions wasn't compared correctly which leads to a wrong result. For built-in functions like sqrt() function names are hard-coded and can be compared by pointer. But this isn't the case for a used-defined stored functions - names there are dynamical and should be compared as strings. Now the Item_func::eq() function employs my_strcasecmp() function to compare used-defined stored functions names. --- mysql-test/r/sp.result | 13 +++++++++++++ mysql-test/t/sp.test | 15 +++++++++++++++ sql/item_func.cc | 9 +++++++-- 3 files changed, 35 insertions(+), 2 deletions(-) diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index 8e3c057cc62..81e2db70357 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -5741,4 +5741,17 @@ END| CALL bug24117()| DROP PROCEDURE bug24117| DROP TABLE t3| +DROP FUNCTION IF EXISTS bug25373| +CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER +LANGUAGE SQL DETERMINISTIC +RETURN p1;| +CREATE TABLE t3 (f1 INT, f2 FLOAT)| +INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)| +SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP| +SUM(f2) bug25373(f1) +6.3000000715256 1 +15 2 +21.300000071526 NULL +DROP FUNCTION bug25373| +DROP TABLE t3| drop table t1,t2; diff --git a/mysql-test/t/sp.test b/mysql-test/t/sp.test index cfa4937e050..5da29454b08 100644 --- a/mysql-test/t/sp.test +++ b/mysql-test/t/sp.test @@ -6714,6 +6714,21 @@ CALL bug24117()| DROP PROCEDURE bug24117| DROP TABLE t3| +# +# Bug#25373: Stored functions wasn't compared correctly which leads to a wrong +# result. +# +--disable_warnings +DROP FUNCTION IF EXISTS bug25373| +--disable_warnings +CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER +LANGUAGE SQL DETERMINISTIC +RETURN p1;| +CREATE TABLE t3 (f1 INT, f2 FLOAT)| +INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)| +SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP| +DROP FUNCTION bug25373| +DROP TABLE t3| # # NOTE: The delimiter is `|`, and not `;`. It is changed to `;` # at the end of the file! diff --git a/sql/item_func.cc b/sql/item_func.cc index 638d8903dcb..c8c0671ae1d 100644 --- a/sql/item_func.cc +++ b/sql/item_func.cc @@ -409,8 +409,13 @@ bool Item_func::eq(const Item *item, bool binary_cmp) const if (item->type() != FUNC_ITEM) return 0; Item_func *item_func=(Item_func*) item; - if (arg_count != item_func->arg_count || - func_name() != item_func->func_name()) + Item_func::Functype func_type; + if ((func_type= functype()) != item_func->functype() || + arg_count != item_func->arg_count || + (func_type != Item_func::FUNC_SP && + func_name() != item_func->func_name()) || + (func_type == Item_func::FUNC_SP && + my_strcasecmp(system_charset_info, func_name(), item_func->func_name()))) return 0; for (uint i=0; i < arg_count ; i++) if (!args[i]->eq(item_func->args[i], binary_cmp)) From 999c1cdcc1a6c82b69ea75d6661f75ed55f405f1 Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Thu, 8 Mar 2007 00:27:42 +0300 Subject: [PATCH 29/73] sql_select.cc: Postfix for bug#22331 for windows platform. explain.test, explain.result: Cleanup after bugfix#22331. --- mysql-test/r/explain.result | 1 + mysql-test/t/explain.test | 1 + sql/sql_select.cc | 2 +- 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/explain.result b/mysql-test/r/explain.result index 221a8695f60..e0afaaef201 100644 --- a/mysql-test/r/explain.result +++ b/mysql-test/r/explain.result @@ -85,4 +85,5 @@ id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 1 +drop view v1; drop table t1; diff --git a/mysql-test/t/explain.test b/mysql-test/t/explain.test index 85bbbfea154..04cf37f457a 100644 --- a/mysql-test/t/explain.test +++ b/mysql-test/t/explain.test @@ -63,6 +63,7 @@ explain extended select * from t1 where 0; explain extended select * from t1 where 1; explain extended select * from t1 having 0; explain extended select * from t1 having 1; +drop view v1; drop table t1; # End of 5.0 tests. diff --git a/sql/sql_select.cc b/sql/sql_select.cc index fc67ffac2fb..06352d48154 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -7622,7 +7622,7 @@ static COND* substitute_for_best_equal_field(COND *cond, } } if (!((Item_cond*)cond)->argument_list()->elements) - cond= new Item_int(cond->val_bool()); + cond= new Item_int((int32)cond->val_bool()); } else if (cond->type() == Item::FUNC_ITEM && From 2d6ad76abd1948f977da202258a463a6d888bf3c Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Thu, 8 Mar 2007 09:54:37 +0100 Subject: [PATCH 30/73] Bug#25673 - spatial index corruption, error 126 incorrect key file for table In certain cases it could happen that deleting a row could corrupt an RTREE index. According to Guttman's algorithm, page underflow is handled by storing the page in a list for later re-insertion. The keys from the stored pages have to be inserted into the remaining pages of the same level of the tree. Hence the level number is stored in the re-insertion list together with the page. In the MySQL RTree implementation the level counts from zero at the root page, increasing numbers for levels down the tree. If during re-insertion of the keys the tree height grows, all level numbers become invalid. The remaining keys will be inserted at the wrong level. The fix is to increment the level numbers stored in the reinsert list after a split of the root block during reinsertion. --- myisam/rt_index.c | 100 ++++-- myisam/rt_key.c | 17 +- myisam/rt_split.c | 7 +- mysql-test/r/gis-rtree.result | 552 +++++++++++++++++++++++++++++++++ mysql-test/t/gis-rtree.test | 556 ++++++++++++++++++++++++++++++++++ 5 files changed, 1200 insertions(+), 32 deletions(-) diff --git a/myisam/rt_index.c b/myisam/rt_index.c index 1806476dc39..9c58f4ba5d2 100644 --- a/myisam/rt_index.c +++ b/myisam/rt_index.c @@ -186,6 +186,7 @@ int rtree_find_first(MI_INFO *info, uint keynr, uchar *key, uint key_length, /* Save searched key, include data pointer. The data pointer is required if the search_flag contains MBR_DATA. + (minimum bounding rectangle) */ memcpy(info->first_mbr_key, key, keyinfo->keylength); info->last_rkey_length = key_length; @@ -540,16 +541,19 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, uint nod_flag; uchar *page_buf; int res; + DBUG_ENTER("rtree_insert_req"); if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length + MI_MAX_KEY_BUFF))) { my_errno = HA_ERR_OUT_OF_MEM; - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0)) goto err1; nod_flag = mi_test_if_nod(page_buf); + DBUG_PRINT("rtree", ("page: %lu level: %d ins_level: %d nod_flag: %u", + (ulong) page, level, ins_level, nod_flag)); if ((ins_level == -1 && nod_flag) || /* key: go down to leaf */ (ins_level > -1 && ins_level > level)) /* branch: go down to ins_level */ @@ -601,11 +605,11 @@ static int rtree_insert_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, ok: my_afree((byte*)page_buf); - return res; + DBUG_RETURN(res); err1: my_afree((byte*)page_buf); - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } @@ -625,7 +629,8 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key, MI_KEYDEF *keyinfo = info->s->keyinfo + keynr; int res; my_off_t new_page; - + DBUG_ENTER("rtree_insert_level"); + if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR) { int res; @@ -655,11 +660,12 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key, uchar *new_key; uint nod_flag = info->s->base.key_reflength; + DBUG_PRINT("rtree", ("root was split, grow a new root")); if (!(new_root_buf = (uchar*)my_alloca((uint)keyinfo->block_length + MI_MAX_KEY_BUFF))) { my_errno = HA_ERR_OUT_OF_MEM; - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } mi_putint(new_root_buf, 2, nod_flag); @@ -685,12 +691,14 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key, DFLT_INIT_HITS, new_root_buf)) goto err1; info->s->state.key_root[keynr] = new_root; + DBUG_PRINT("rtree", ("new root page: %lu level: %d nod_flag: %u", + (ulong) new_root, 0, mi_test_if_nod(new_root_buf))); my_afree((byte*)new_root_buf); break; err1: my_afree((byte*)new_root_buf); - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } default: case -1: /* error */ @@ -698,7 +706,7 @@ err1: break; } } - return res; + DBUG_RETURN(res); } @@ -712,8 +720,10 @@ err1: int rtree_insert(MI_INFO *info, uint keynr, uchar *key, uint key_length) { - return (!key_length || - (rtree_insert_level(info, keynr, key, key_length, -1) == -1)) ? -1 : 0; + DBUG_ENTER("rtree_insert"); + DBUG_RETURN((!key_length || + (rtree_insert_level(info, keynr, key, key_length, -1) == -1)) ? + -1 : 0); } @@ -728,6 +738,8 @@ int rtree_insert(MI_INFO *info, uint keynr, uchar *key, uint key_length) static int rtree_fill_reinsert_list(stPageList *ReinsertList, my_off_t page, int level) { + DBUG_ENTER("rtree_fill_reinsert_list"); + DBUG_PRINT("rtree", ("page: %lu level: %d", (ulong) page, level)); if (ReinsertList->n_pages == ReinsertList->m_pages) { ReinsertList->m_pages += REINSERT_BUFFER_INC; @@ -739,10 +751,10 @@ static int rtree_fill_reinsert_list(stPageList *ReinsertList, my_off_t page, ReinsertList->pages[ReinsertList->n_pages].offs = page; ReinsertList->pages[ReinsertList->n_pages].level = level; ReinsertList->n_pages++; - return 0; + DBUG_RETURN(0); err1: - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } @@ -766,15 +778,18 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, uint nod_flag; uchar *page_buf; int res; + DBUG_ENTER("rtree_delete_req"); if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length))) { my_errno = HA_ERR_OUT_OF_MEM; - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0)) goto err1; nod_flag = mi_test_if_nod(page_buf); + DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u", + (ulong) page, level, nod_flag)); k = rt_PAGE_FIRST_KEY(page_buf, nod_flag); last = rt_PAGE_END(page_buf); @@ -795,6 +810,7 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, if (*page_size + key_length >= rt_PAGE_MIN_SIZE(keyinfo->block_length)) { /* OK */ + /* Calculate a new key value (MBR) for the shrinked block. */ if (rtree_set_key_mbr(info, keyinfo, k, key_length, _mi_kpos(nod_flag, k))) goto err1; @@ -804,10 +820,23 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, } else { - /* too small: delete key & add it descendant to reinsert list */ + /* + Too small: delete key & add it descendant to reinsert list. + Store position and level of the block so that it can be + accessed later for inserting the remaining keys. + */ + DBUG_PRINT("rtree", ("too small. move block to reinsert list")); if (rtree_fill_reinsert_list(ReinsertList, _mi_kpos(nod_flag, k), level + 1)) goto err1; + /* + Delete the key that references the block. This makes the + block disappear from the index. Hence we need to insert + its remaining keys later. Note: if the block is a branch + block, we do not only remove this block, but the whole + subtree. So we need to re-insert its keys on the same + level later to reintegrate the subtrees. + */ rtree_delete_key(info, page_buf, k, key_length, nod_flag); if (_mi_write_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf)) @@ -867,11 +896,11 @@ static int rtree_delete_req(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, ok: my_afree((byte*)page_buf); - return res; + DBUG_RETURN(res); err1: my_afree((byte*)page_buf); - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } @@ -889,12 +918,15 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length) stPageList ReinsertList; my_off_t old_root; MI_KEYDEF *keyinfo = info->s->keyinfo + keynr; + DBUG_ENTER("rtree_delete"); if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR) { my_errno= HA_ERR_END_OF_FILE; - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } + DBUG_PRINT("rtree", ("starting deletion at root page: %lu", + (ulong) old_root)); ReinsertList.pages = NULL; ReinsertList.n_pages = 0; @@ -903,12 +935,12 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length) switch (rtree_delete_req(info, keyinfo, key, key_length, old_root, &page_size, &ReinsertList, 0)) { - case 2: + case 2: /* empty */ { info->s->state.key_root[keynr] = HA_OFFSET_ERROR; - return 0; + DBUG_RETURN(0); } - case 0: + case 0: /* deleted */ { uint nod_flag; ulong i; @@ -928,16 +960,34 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length) DFLT_INIT_HITS, page_buf, 0)) goto err1; nod_flag = mi_test_if_nod(page_buf); + DBUG_PRINT("rtree", ("reinserting keys from " + "page: %lu level: %d nod_flag: %u", + (ulong) ReinsertList.pages[i].offs, + ReinsertList.pages[i].level, nod_flag)); + k = rt_PAGE_FIRST_KEY(page_buf, nod_flag); last = rt_PAGE_END(page_buf); for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag)) { - if (rtree_insert_level(info, keynr, k, key_length, - ReinsertList.pages[i].level) == -1) + int res; + if ((res= rtree_insert_level(info, keynr, k, key_length, + ReinsertList.pages[i].level)) == -1) { my_afree((byte*)page_buf); goto err1; } + if (res) + { + int j; + DBUG_PRINT("rtree", ("root has been split, adjust levels")); + for (j= i; j < ReinsertList.n_pages; j++) + { + ReinsertList.pages[j].level++; + DBUG_PRINT("rtree", ("keys from page: %lu now level: %d", + (ulong) ReinsertList.pages[i].offs, + ReinsertList.pages[i].level)); + } + } } my_afree((byte*)page_buf); if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs, @@ -964,20 +1014,20 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length) info->s->state.key_root[keynr] = new_root; } info->update= HA_STATE_DELETED; - return 0; + DBUG_RETURN(0); err1: - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } case 1: /* not found */ { my_errno = HA_ERR_KEY_NOT_FOUND; - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } default: case -1: /* error */ { - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ } } } diff --git a/myisam/rt_key.c b/myisam/rt_key.c index e2a402fbefd..b969ac30569 100644 --- a/myisam/rt_key.c +++ b/myisam/rt_key.c @@ -35,6 +35,7 @@ int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, { uint page_size = mi_getint(page_buf); uint nod_flag = mi_test_if_nod(page_buf); + DBUG_ENTER("rtree_add_key"); if (page_size + key_length + info->s->base.rec_reflength <= keyinfo->block_length) @@ -43,22 +44,26 @@ int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, if (nod_flag) { /* save key */ + DBUG_ASSERT(_mi_kpos(nod_flag, key) < info->state->key_file_length); memcpy(rt_PAGE_END(page_buf), key - nod_flag, key_length + nod_flag); page_size += key_length + nod_flag; } else { /* save key */ + DBUG_ASSERT(_mi_dpos(info, nod_flag, key + key_length + + info->s->base.rec_reflength) < + info->state->data_file_length + info->s->base.pack_reclength); memcpy(rt_PAGE_END(page_buf), key, key_length + info->s->base.rec_reflength); page_size += key_length + info->s->base.rec_reflength; } mi_putint(page_buf, page_size, nod_flag); - return 0; + DBUG_RETURN(0); } - return (rtree_split_page(info, keyinfo, page_buf, key, key_length, - new_page) ? -1 : 1); + DBUG_RETURN((rtree_split_page(info, keyinfo, page_buf, key, key_length, + new_page) ? -1 : 1)); } /* @@ -90,11 +95,13 @@ int rtree_delete_key(MI_INFO *info, uchar *page_buf, uchar *key, int rtree_set_key_mbr(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key, uint key_length, my_off_t child_page) { + DBUG_ENTER("rtree_set_key_mbr"); + if (!_mi_fetch_keypage(info, keyinfo, child_page, DFLT_INIT_HITS, info->buff, 0)) - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ - return rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length); + DBUG_RETURN(rtree_page_mbr(info, keyinfo->seg, info->buff, key, key_length)); } #endif /*HAVE_RTREE_KEYS*/ diff --git a/myisam/rt_split.c b/myisam/rt_split.c index 87da22a93c7..d400274064b 100644 --- a/myisam/rt_split.c +++ b/myisam/rt_split.c @@ -268,13 +268,15 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key, info->s->base.rec_reflength); int max_keys = (mi_getint(page)-2) / (full_length); + DBUG_ENTER("rtree_split_page"); + DBUG_PRINT("rtree", ("splitting block")); n_dim = keyinfo->keysegs / 2; if (!(coord_buf= (double*) my_alloca(n_dim * 2 * sizeof(double) * (max_keys + 1 + 4) + sizeof(SplitStruct) * (max_keys + 1)))) - return -1; + DBUG_RETURN(-1); /* purecov: inspected */ task= (SplitStruct *)(coord_buf + n_dim * 2 * (max_keys + 1 + 4)); @@ -346,12 +348,13 @@ int rtree_split_page(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page, uchar *key, else err_code= _mi_write_keypage(info, keyinfo, *new_page_offs, DFLT_INIT_HITS, new_page); + DBUG_PRINT("rtree", ("split new block: %lu", (ulong) *new_page_offs)); my_afree((byte*)new_page); split_err: my_afree((byte*) coord_buf); - return err_code; + DBUG_RETURN(err_code); } #endif /*HAVE_RTREE_KEYS*/ diff --git a/mysql-test/r/gis-rtree.result b/mysql-test/r/gis-rtree.result index bdb3de4de75..762dda4e501 100644 --- a/mysql-test/r/gis-rtree.result +++ b/mysql-test/r/gis-rtree.result @@ -868,3 +868,555 @@ SELECT 1 FROM t1 WHERE foo != PointFromWKB(POINT(0,0)); 1 1 DROP TABLE t1; +CREATE TABLE t1 (id bigint(12) unsigned NOT NULL auto_increment, +c2 varchar(15) collate utf8_bin default NULL, +c1 varchar(15) collate utf8_bin default NULL, +c3 varchar(10) collate utf8_bin default NULL, +spatial_point point NOT NULL, +PRIMARY KEY(id), +SPATIAL KEY (spatial_point(32)) +)ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES +('y', 's', 'j', GeomFromText('POINT(167 74)')), +('r', 'n', 'd', GeomFromText('POINT(215 118)')), +('g', 'n', 'e', GeomFromText('POINT(203 98)')), +('h', 'd', 'd', GeomFromText('POINT(54 193)')), +('r', 'x', 'y', GeomFromText('POINT(47 69)')), +('t', 'q', 'r', GeomFromText('POINT(109 42)')), +('a', 'z', 'd', GeomFromText('POINT(0 154)')), +('x', 'v', 'o', GeomFromText('POINT(174 131)')), +('b', 'r', 'a', GeomFromText('POINT(114 253)')), +('x', 'z', 'i', GeomFromText('POINT(163 21)')), +('w', 'p', 'i', GeomFromText('POINT(42 102)')), +('g', 'j', 'j', GeomFromText('POINT(170 133)')), +('m', 'g', 'n', GeomFromText('POINT(28 22)')), +('b', 'z', 'h', GeomFromText('POINT(174 28)')), +('q', 'k', 'f', GeomFromText('POINT(233 73)')), +('w', 'w', 'a', GeomFromText('POINT(124 200)')), +('t', 'j', 'w', GeomFromText('POINT(252 101)')), +('d', 'r', 'd', GeomFromText('POINT(98 18)')), +('w', 'o', 'y', GeomFromText('POINT(165 31)')), +('y', 'h', 't', GeomFromText('POINT(14 220)')), +('d', 'p', 'u', GeomFromText('POINT(223 196)')), +('g', 'y', 'g', GeomFromText('POINT(207 96)')), +('x', 'm', 'n', GeomFromText('POINT(214 3)')), +('g', 'v', 'e', GeomFromText('POINT(140 205)')), +('g', 'm', 'm', GeomFromText('POINT(10 236)')), +('i', 'r', 'j', GeomFromText('POINT(137 228)')), +('w', 's', 'p', GeomFromText('POINT(115 6)')), +('o', 'n', 'k', GeomFromText('POINT(158 129)')), +('j', 'h', 'l', GeomFromText('POINT(129 72)')), +('f', 'x', 'l', GeomFromText('POINT(139 207)')), +('u', 'd', 'n', GeomFromText('POINT(125 109)')), +('b', 'a', 'z', GeomFromText('POINT(30 32)')), +('m', 'h', 'o', GeomFromText('POINT(251 251)')), +('f', 'r', 'd', GeomFromText('POINT(243 211)')), +('b', 'd', 'r', GeomFromText('POINT(232 80)')), +('g', 'k', 'v', GeomFromText('POINT(15 100)')), +('i', 'f', 'c', GeomFromText('POINT(109 66)')), +('r', 't', 'j', GeomFromText('POINT(178 6)')), +('y', 'n', 'f', GeomFromText('POINT(233 211)')), +('f', 'y', 'm', GeomFromText('POINT(99 16)')), +('z', 'q', 'l', GeomFromText('POINT(39 49)')), +('j', 'c', 'r', GeomFromText('POINT(75 187)')), +('c', 'y', 'y', GeomFromText('POINT(246 253)')), +('w', 'u', 'd', GeomFromText('POINT(56 190)')), +('n', 'q', 'm', GeomFromText('POINT(73 149)')), +('d', 'y', 'a', GeomFromText('POINT(134 6)')), +('z', 's', 'w', GeomFromText('POINT(216 225)')), +('d', 'u', 'k', GeomFromText('POINT(132 70)')), +('f', 'v', 't', GeomFromText('POINT(187 141)')), +('r', 'r', 'a', GeomFromText('POINT(152 39)')), +('y', 'p', 'o', GeomFromText('POINT(45 27)')), +('p', 'n', 'm', GeomFromText('POINT(228 148)')), +('e', 'g', 'e', GeomFromText('POINT(88 81)')), +('m', 'a', 'h', GeomFromText('POINT(35 29)')), +('m', 'h', 'f', GeomFromText('POINT(30 71)')), +('h', 'k', 'i', GeomFromText('POINT(244 78)')), +('z', 'v', 'd', GeomFromText('POINT(241 38)')), +('q', 'l', 'j', GeomFromText('POINT(13 71)')), +('s', 'p', 'g', GeomFromText('POINT(108 38)')), +('q', 's', 'j', GeomFromText('POINT(92 101)')), +('l', 'h', 'g', GeomFromText('POINT(120 78)')), +('w', 't', 'b', GeomFromText('POINT(193 109)')), +('b', 's', 's', GeomFromText('POINT(223 211)')), +('w', 'w', 'y', GeomFromText('POINT(122 42)')), +('q', 'c', 'c', GeomFromText('POINT(104 102)')), +('w', 'g', 'n', GeomFromText('POINT(213 120)')), +('p', 'q', 'a', GeomFromText('POINT(247 148)')), +('c', 'z', 'e', GeomFromText('POINT(18 106)')), +('z', 'u', 'n', GeomFromText('POINT(70 133)')), +('j', 'n', 'x', GeomFromText('POINT(232 13)')), +('e', 'h', 'f', GeomFromText('POINT(22 135)')), +('w', 'l', 'f', GeomFromText('POINT(9 180)')), +('a', 'v', 'q', GeomFromText('POINT(163 228)')), +('i', 'z', 'o', GeomFromText('POINT(180 100)')), +('e', 'c', 'l', GeomFromText('POINT(182 231)')), +('c', 'k', 'o', GeomFromText('POINT(19 60)')), +('q', 'f', 'p', GeomFromText('POINT(79 95)')), +('m', 'd', 'r', GeomFromText('POINT(3 127)')), +('m', 'e', 't', GeomFromText('POINT(136 154)')), +('w', 'w', 'w', GeomFromText('POINT(102 15)')), +('l', 'n', 'q', GeomFromText('POINT(71 196)')), +('p', 'k', 'c', GeomFromText('POINT(47 139)')), +('j', 'o', 'r', GeomFromText('POINT(177 128)')), +('j', 'q', 'a', GeomFromText('POINT(170 6)')), +('b', 'a', 'o', GeomFromText('POINT(63 211)')), +('g', 's', 'o', GeomFromText('POINT(144 251)')), +('w', 'u', 'w', GeomFromText('POINT(221 214)')), +('g', 'a', 'm', GeomFromText('POINT(14 102)')), +('u', 'q', 'z', GeomFromText('POINT(86 200)')), +('k', 'a', 'm', GeomFromText('POINT(144 222)')), +('j', 'u', 'r', GeomFromText('POINT(216 142)')), +('q', 'k', 'v', GeomFromText('POINT(121 236)')), +('p', 'o', 'r', GeomFromText('POINT(108 102)')), +('b', 'd', 'x', GeomFromText('POINT(127 198)')), +('k', 's', 'a', GeomFromText('POINT(2 150)')), +('f', 'm', 'f', GeomFromText('POINT(160 191)')), +('q', 'y', 'x', GeomFromText('POINT(98 111)')), +('o', 'f', 'm', GeomFromText('POINT(232 218)')), +('c', 'w', 'j', GeomFromText('POINT(156 165)')), +('s', 'q', 'v', GeomFromText('POINT(98 161)')); +SET @@RAND_SEED1=692635050, @@RAND_SEED2=297339954; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=159925977, @@RAND_SEED2=942570618; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=328169745, @@RAND_SEED2=410451954; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=178507359, @@RAND_SEED2=332493072; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=1034033013, @@RAND_SEED2=558966507; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +UPDATE t1 set spatial_point=GeomFromText('POINT(230 9)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(95 35)') where c1 like 'j%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(93 99)') where c1 like 'a%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(19 81)') where c1 like 'r%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(20 177)') where c1 like 'h%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(221 193)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(195 205)') where c1 like 'd%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(15 213)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(214 63)') where c1 like 'n%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(243 171)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(198 82)') where c1 like 'y%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES +('f', 'y', 'p', GeomFromText('POINT(109 235)')), +('b', 'e', 'v', GeomFromText('POINT(20 48)')), +('i', 'u', 'f', GeomFromText('POINT(15 55)')), +('o', 'r', 'z', GeomFromText('POINT(105 64)')), +('a', 'p', 'a', GeomFromText('POINT(142 236)')), +('g', 'i', 'k', GeomFromText('POINT(10 49)')), +('x', 'z', 'x', GeomFromText('POINT(192 200)')), +('c', 'v', 'r', GeomFromText('POINT(94 168)')), +('y', 'z', 'e', GeomFromText('POINT(141 51)')), +('h', 'm', 'd', GeomFromText('POINT(35 251)')), +('v', 'm', 'q', GeomFromText('POINT(44 90)')), +('j', 'l', 'z', GeomFromText('POINT(67 237)')), +('i', 'v', 'a', GeomFromText('POINT(75 14)')), +('b', 'q', 't', GeomFromText('POINT(153 33)')), +('e', 'm', 'a', GeomFromText('POINT(247 49)')), +('l', 'y', 'g', GeomFromText('POINT(56 203)')), +('v', 'o', 'r', GeomFromText('POINT(90 54)')), +('r', 'n', 'd', GeomFromText('POINT(135 83)')), +('j', 't', 'u', GeomFromText('POINT(174 239)')), +('u', 'n', 'g', GeomFromText('POINT(104 191)')), +('p', 'q', 'y', GeomFromText('POINT(63 171)')), +('o', 'q', 'p', GeomFromText('POINT(192 103)')), +('f', 'x', 'e', GeomFromText('POINT(244 30)')), +('n', 'x', 'c', GeomFromText('POINT(92 103)')), +('r', 'q', 'z', GeomFromText('POINT(166 20)')), +('s', 'a', 'j', GeomFromText('POINT(137 205)')), +('z', 't', 't', GeomFromText('POINT(99 134)')), +('o', 'm', 'j', GeomFromText('POINT(217 3)')), +('n', 'h', 'j', GeomFromText('POINT(211 17)')), +('v', 'v', 'a', GeomFromText('POINT(41 137)')), +('q', 'o', 'j', GeomFromText('POINT(5 92)')), +('z', 'y', 'e', GeomFromText('POINT(175 212)')), +('j', 'z', 'h', GeomFromText('POINT(224 194)')), +('a', 'g', 'm', GeomFromText('POINT(31 119)')), +('p', 'c', 'f', GeomFromText('POINT(17 221)')), +('t', 'h', 'k', GeomFromText('POINT(26 203)')), +('u', 'w', 'p', GeomFromText('POINT(47 185)')), +('z', 'a', 'c', GeomFromText('POINT(61 133)')), +('u', 'k', 'a', GeomFromText('POINT(210 115)')), +('k', 'f', 'h', GeomFromText('POINT(125 113)')), +('t', 'v', 'y', GeomFromText('POINT(12 239)')), +('u', 'v', 'd', GeomFromText('POINT(90 24)')), +('m', 'y', 'w', GeomFromText('POINT(25 243)')), +('d', 'n', 'g', GeomFromText('POINT(122 92)')), +('z', 'm', 'f', GeomFromText('POINT(235 110)')), +('q', 'd', 'f', GeomFromText('POINT(233 217)')), +('a', 'v', 'u', GeomFromText('POINT(69 59)')), +('x', 'k', 'p', GeomFromText('POINT(240 14)')), +('i', 'v', 'r', GeomFromText('POINT(154 42)')), +('w', 'h', 'l', GeomFromText('POINT(178 156)')), +('d', 'h', 'n', GeomFromText('POINT(65 157)')), +('c', 'k', 'z', GeomFromText('POINT(62 33)')), +('e', 'l', 'w', GeomFromText('POINT(162 1)')), +('r', 'f', 'i', GeomFromText('POINT(127 71)')), +('q', 'm', 'c', GeomFromText('POINT(63 118)')), +('c', 'h', 'u', GeomFromText('POINT(205 203)')), +('d', 't', 'p', GeomFromText('POINT(234 87)')), +('s', 'g', 'h', GeomFromText('POINT(149 34)')), +('o', 'b', 'q', GeomFromText('POINT(159 179)')), +('k', 'u', 'f', GeomFromText('POINT(202 254)')), +('u', 'f', 'g', GeomFromText('POINT(70 15)')), +('x', 's', 'b', GeomFromText('POINT(25 181)')), +('s', 'c', 'g', GeomFromText('POINT(252 17)')), +('a', 'c', 'f', GeomFromText('POINT(89 67)')), +('r', 'e', 'q', GeomFromText('POINT(55 54)')), +('f', 'i', 'k', GeomFromText('POINT(178 230)')), +('p', 'e', 'l', GeomFromText('POINT(198 28)')), +('w', 'o', 'd', GeomFromText('POINT(204 189)')), +('c', 'a', 'g', GeomFromText('POINT(230 178)')), +('r', 'o', 'e', GeomFromText('POINT(61 116)')), +('w', 'a', 'a', GeomFromText('POINT(178 237)')), +('v', 'd', 'e', GeomFromText('POINT(70 85)')), +('k', 'c', 'e', GeomFromText('POINT(147 118)')), +('d', 'q', 't', GeomFromText('POINT(218 77)')), +('k', 'g', 'f', GeomFromText('POINT(192 113)')), +('w', 'n', 'e', GeomFromText('POINT(92 124)')), +('r', 'm', 'q', GeomFromText('POINT(130 65)')), +('o', 'r', 'r', GeomFromText('POINT(174 233)')), +('k', 'n', 't', GeomFromText('POINT(175 147)')), +('q', 'm', 'r', GeomFromText('POINT(18 208)')), +('l', 'd', 'i', GeomFromText('POINT(13 104)')), +('w', 'o', 'y', GeomFromText('POINT(207 39)')), +('p', 'u', 'o', GeomFromText('POINT(114 31)')), +('y', 'a', 'p', GeomFromText('POINT(106 59)')), +('a', 'x', 'z', GeomFromText('POINT(17 57)')), +('v', 'h', 'x', GeomFromText('POINT(170 13)')), +('t', 's', 'u', GeomFromText('POINT(84 18)')), +('z', 'z', 'f', GeomFromText('POINT(250 197)')), +('l', 'z', 't', GeomFromText('POINT(59 80)')), +('j', 'g', 's', GeomFromText('POINT(54 26)')), +('g', 'v', 'm', GeomFromText('POINT(89 98)')), +('q', 'v', 'b', GeomFromText('POINT(39 240)')), +('x', 'k', 'v', GeomFromText('POINT(246 207)')), +('k', 'u', 'i', GeomFromText('POINT(105 111)')), +('w', 'z', 's', GeomFromText('POINT(235 8)')), +('d', 'd', 'd', GeomFromText('POINT(105 4)')), +('c', 'z', 'q', GeomFromText('POINT(13 140)')), +('m', 'k', 'i', GeomFromText('POINT(208 120)')), +('g', 'a', 'g', GeomFromText('POINT(9 182)')), +('z', 'j', 'r', GeomFromText('POINT(149 153)')), +('h', 'f', 'g', GeomFromText('POINT(81 236)')), +('m', 'e', 'q', GeomFromText('POINT(209 215)')), +('c', 'h', 'y', GeomFromText('POINT(235 70)')), +('i', 'e', 'g', GeomFromText('POINT(138 26)')), +('m', 't', 'u', GeomFromText('POINT(119 237)')), +('o', 'w', 's', GeomFromText('POINT(193 166)')), +('f', 'm', 'q', GeomFromText('POINT(85 96)')), +('x', 'l', 'x', GeomFromText('POINT(58 115)')), +('x', 'q', 'u', GeomFromText('POINT(108 210)')), +('b', 'h', 'i', GeomFromText('POINT(250 139)')), +('y', 'd', 'x', GeomFromText('POINT(199 135)')), +('w', 'h', 'p', GeomFromText('POINT(247 233)')), +('p', 'z', 't', GeomFromText('POINT(148 249)')), +('q', 'a', 'u', GeomFromText('POINT(174 78)')), +('v', 't', 'm', GeomFromText('POINT(70 228)')), +('t', 'n', 'f', GeomFromText('POINT(123 2)')), +('x', 't', 'b', GeomFromText('POINT(35 50)')), +('r', 'j', 'f', GeomFromText('POINT(200 51)')), +('s', 'q', 'o', GeomFromText('POINT(23 184)')), +('u', 'v', 'z', GeomFromText('POINT(7 113)')), +('v', 'u', 'l', GeomFromText('POINT(145 190)')), +('o', 'k', 'i', GeomFromText('POINT(161 122)')), +('l', 'y', 'e', GeomFromText('POINT(17 232)')), +('t', 'b', 'e', GeomFromText('POINT(120 50)')), +('e', 's', 'u', GeomFromText('POINT(254 1)')), +('d', 'd', 'u', GeomFromText('POINT(167 140)')), +('o', 'b', 'x', GeomFromText('POINT(186 237)')), +('m', 's', 's', GeomFromText('POINT(172 149)')), +('t', 'y', 'a', GeomFromText('POINT(149 85)')), +('x', 't', 'r', GeomFromText('POINT(10 165)')), +('g', 'c', 'e', GeomFromText('POINT(95 165)')), +('e', 'e', 'z', GeomFromText('POINT(98 65)')), +('f', 'v', 'i', GeomFromText('POINT(149 144)')), +('o', 'p', 'm', GeomFromText('POINT(233 67)')), +('t', 'u', 'b', GeomFromText('POINT(109 215)')), +('o', 'o', 'b', GeomFromText('POINT(130 48)')), +('e', 'm', 'h', GeomFromText('POINT(88 189)')), +('e', 'v', 'y', GeomFromText('POINT(55 29)')), +('e', 't', 'm', GeomFromText('POINT(129 55)')), +('p', 'p', 'i', GeomFromText('POINT(126 222)')), +('c', 'i', 'c', GeomFromText('POINT(19 158)')), +('c', 'b', 's', GeomFromText('POINT(13 19)')), +('u', 'y', 'a', GeomFromText('POINT(114 5)')), +('a', 'o', 'f', GeomFromText('POINT(227 232)')), +('t', 'c', 'z', GeomFromText('POINT(63 62)')), +('d', 'o', 'k', GeomFromText('POINT(48 228)')), +('x', 'c', 'e', GeomFromText('POINT(204 2)')), +('e', 'e', 'g', GeomFromText('POINT(125 43)')), +('o', 'r', 'f', GeomFromText('POINT(171 140)')); +UPDATE t1 set spatial_point=GeomFromText('POINT(163 157)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(53 151)') where c1 like 'd%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(96 183)') where c1 like 'r%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(57 91)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(202 110)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(120 137)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(207 147)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(31 125)') where c1 like 'e%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(27 36)') where c1 like 'r%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES +('b', 'c', 'e', GeomFromText('POINT(41 137)')), +('p', 'y', 'k', GeomFromText('POINT(50 22)')), +('s', 'c', 'h', GeomFromText('POINT(208 173)')), +('x', 'u', 'l', GeomFromText('POINT(199 175)')), +('s', 'r', 'h', GeomFromText('POINT(85 192)')), +('j', 'k', 'u', GeomFromText('POINT(18 25)')), +('p', 'w', 'h', GeomFromText('POINT(152 197)')), +('e', 'd', 'c', GeomFromText('POINT(229 3)')), +('o', 'x', 'k', GeomFromText('POINT(187 155)')), +('o', 'b', 'k', GeomFromText('POINT(208 150)')), +('d', 'a', 'j', GeomFromText('POINT(70 87)')), +('f', 'e', 'k', GeomFromText('POINT(156 96)')), +('u', 'y', 'p', GeomFromText('POINT(239 193)')), +('n', 'v', 'p', GeomFromText('POINT(223 98)')), +('z', 'j', 'r', GeomFromText('POINT(87 89)')), +('h', 'x', 'x', GeomFromText('POINT(92 0)')), +('r', 'v', 'r', GeomFromText('POINT(159 139)')), +('v', 'g', 'g', GeomFromText('POINT(16 229)')), +('z', 'k', 'u', GeomFromText('POINT(99 52)')), +('p', 'p', 'o', GeomFromText('POINT(105 125)')), +('w', 'h', 'y', GeomFromText('POINT(105 154)')), +('v', 'y', 'z', GeomFromText('POINT(134 238)')), +('x', 'o', 'o', GeomFromText('POINT(178 88)')), +('z', 'w', 'd', GeomFromText('POINT(123 60)')), +('q', 'f', 'u', GeomFromText('POINT(64 90)')), +('s', 'n', 't', GeomFromText('POINT(50 138)')), +('v', 'p', 't', GeomFromText('POINT(114 91)')), +('a', 'o', 'n', GeomFromText('POINT(78 43)')), +('k', 'u', 'd', GeomFromText('POINT(185 161)')), +('w', 'd', 'n', GeomFromText('POINT(25 92)')), +('k', 'w', 'a', GeomFromText('POINT(59 238)')), +('t', 'c', 'f', GeomFromText('POINT(65 87)')), +('g', 's', 'p', GeomFromText('POINT(238 126)')), +('d', 'n', 'y', GeomFromText('POINT(107 173)')), +('l', 'a', 'w', GeomFromText('POINT(125 152)')), +('m', 'd', 'j', GeomFromText('POINT(146 53)')), +('q', 'm', 'c', GeomFromText('POINT(217 187)')), +('i', 'r', 'r', GeomFromText('POINT(6 113)')), +('e', 'j', 'b', GeomFromText('POINT(37 83)')), +('w', 'w', 'h', GeomFromText('POINT(83 199)')), +('k', 'b', 's', GeomFromText('POINT(170 64)')), +('s', 'b', 'c', GeomFromText('POINT(163 130)')), +('c', 'h', 'a', GeomFromText('POINT(141 3)')), +('k', 'j', 'u', GeomFromText('POINT(143 76)')), +('r', 'h', 'o', GeomFromText('POINT(243 92)')), +('i', 'd', 'b', GeomFromText('POINT(205 13)')), +('r', 'y', 'q', GeomFromText('POINT(138 8)')), +('m', 'o', 'i', GeomFromText('POINT(36 45)')), +('v', 'g', 'm', GeomFromText('POINT(0 40)')), +('f', 'e', 'i', GeomFromText('POINT(76 6)')), +('c', 'q', 'q', GeomFromText('POINT(115 248)')), +('x', 'c', 'i', GeomFromText('POINT(29 74)')), +('l', 's', 't', GeomFromText('POINT(83 18)')), +('t', 't', 'a', GeomFromText('POINT(26 168)')), +('u', 'n', 'x', GeomFromText('POINT(200 110)')), +('j', 'b', 'd', GeomFromText('POINT(216 136)')), +('s', 'p', 'w', GeomFromText('POINT(38 156)')), +('f', 'b', 'v', GeomFromText('POINT(29 186)')), +('v', 'e', 'r', GeomFromText('POINT(149 40)')), +('v', 't', 'm', GeomFromText('POINT(184 24)')), +('y', 'g', 'a', GeomFromText('POINT(219 105)')), +('s', 'f', 'i', GeomFromText('POINT(114 130)')), +('e', 'q', 'h', GeomFromText('POINT(203 135)')), +('h', 'g', 'b', GeomFromText('POINT(9 208)')), +('o', 'l', 'r', GeomFromText('POINT(245 79)')), +('s', 's', 'v', GeomFromText('POINT(238 198)')), +('w', 'w', 'z', GeomFromText('POINT(209 232)')), +('v', 'd', 'n', GeomFromText('POINT(30 193)')), +('q', 'w', 'k', GeomFromText('POINT(133 18)')), +('o', 'h', 'o', GeomFromText('POINT(42 140)')), +('f', 'f', 'h', GeomFromText('POINT(145 1)')), +('u', 's', 'r', GeomFromText('POINT(70 62)')), +('x', 'n', 'q', GeomFromText('POINT(33 86)')), +('u', 'p', 'v', GeomFromText('POINT(232 220)')), +('z', 'e', 'a', GeomFromText('POINT(130 69)')), +('r', 'u', 'z', GeomFromText('POINT(243 241)')), +('b', 'n', 't', GeomFromText('POINT(120 12)')), +('u', 'f', 's', GeomFromText('POINT(190 212)')), +('a', 'd', 'q', GeomFromText('POINT(235 191)')), +('f', 'q', 'm', GeomFromText('POINT(176 2)')), +('n', 'c', 's', GeomFromText('POINT(218 163)')), +('e', 'm', 'h', GeomFromText('POINT(163 108)')), +('c', 'f', 'l', GeomFromText('POINT(220 115)')), +('c', 'v', 'q', GeomFromText('POINT(66 45)')), +('w', 'v', 'x', GeomFromText('POINT(251 220)')), +('f', 'w', 'z', GeomFromText('POINT(146 149)')), +('h', 'n', 'h', GeomFromText('POINT(148 128)')), +('y', 'k', 'v', GeomFromText('POINT(28 110)')), +('c', 'x', 'q', GeomFromText('POINT(13 13)')), +('e', 'd', 's', GeomFromText('POINT(91 190)')), +('c', 'w', 'c', GeomFromText('POINT(10 231)')), +('u', 'j', 'n', GeomFromText('POINT(250 21)')), +('w', 'n', 'x', GeomFromText('POINT(141 69)')), +('f', 'p', 'y', GeomFromText('POINT(228 246)')), +('d', 'q', 'f', GeomFromText('POINT(194 22)')), +('d', 'z', 'l', GeomFromText('POINT(233 181)')), +('c', 'a', 'q', GeomFromText('POINT(183 96)')), +('m', 'i', 'd', GeomFromText('POINT(117 226)')), +('z', 'y', 'y', GeomFromText('POINT(62 81)')), +('g', 'v', 'm', GeomFromText('POINT(66 158)')); +SET @@RAND_SEED1=481064922, @@RAND_SEED2=438133497; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=280535103, @@RAND_SEED2=444518646; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=1072017234, @@RAND_SEED2=484203885; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=358851897, @@RAND_SEED2=358495224; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=509031459, @@RAND_SEED2=675962925; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +UPDATE t1 set spatial_point=GeomFromText('POINT(61 203)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(202 194)') where c1 like 'f%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(228 18)') where c1 like 'h%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(88 18)') where c1 like 'l%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(176 94)') where c1 like 'e%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(44 47)') where c1 like 'g%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(95 191)') where c1 like 'b%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(179 218)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(239 40)') where c1 like 'g%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(248 41)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(167 82)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(13 104)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(139 84)') where c1 like 'a%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(145 108)') where c1 like 'p%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(147 57)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(217 144)') where c1 like 'n%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(160 224)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(38 28)') where c1 like 'j%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(104 114)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(88 19)') where c1 like 'c%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES +('f', 'x', 'p', GeomFromText('POINT(92 181)')), +('s', 'i', 'c', GeomFromText('POINT(49 60)')), +('c', 'c', 'i', GeomFromText('POINT(7 57)')), +('n', 'g', 'k', GeomFromText('POINT(252 105)')), +('g', 'b', 'm', GeomFromText('POINT(180 11)')), +('u', 'l', 'r', GeomFromText('POINT(32 90)')), +('c', 'x', 'e', GeomFromText('POINT(143 24)')), +('x', 'u', 'a', GeomFromText('POINT(123 92)')), +('s', 'b', 'h', GeomFromText('POINT(190 108)')), +('c', 'x', 'b', GeomFromText('POINT(104 100)')), +('i', 'd', 't', GeomFromText('POINT(214 104)')), +('r', 'w', 'g', GeomFromText('POINT(29 67)')), +('b', 'f', 'g', GeomFromText('POINT(149 46)')), +('r', 'r', 'd', GeomFromText('POINT(242 196)')), +('j', 'l', 'a', GeomFromText('POINT(90 196)')), +('e', 't', 'b', GeomFromText('POINT(190 64)')), +('l', 'x', 'w', GeomFromText('POINT(250 73)')), +('q', 'y', 'r', GeomFromText('POINT(120 182)')), +('s', 'j', 'a', GeomFromText('POINT(180 175)')), +('n', 'i', 'y', GeomFromText('POINT(124 136)')), +('s', 'x', 's', GeomFromText('POINT(176 209)')), +('u', 'f', 's', GeomFromText('POINT(215 173)')), +('m', 'j', 'x', GeomFromText('POINT(44 140)')), +('v', 'g', 'x', GeomFromText('POINT(177 233)')), +('u', 't', 'b', GeomFromText('POINT(136 197)')), +('f', 'g', 'b', GeomFromText('POINT(10 8)')), +('v', 'c', 'j', GeomFromText('POINT(13 81)')), +('d', 's', 'q', GeomFromText('POINT(200 100)')), +('a', 'p', 'j', GeomFromText('POINT(33 40)')), +('i', 'c', 'g', GeomFromText('POINT(168 204)')), +('k', 'h', 'i', GeomFromText('POINT(93 243)')), +('s', 'b', 's', GeomFromText('POINT(157 13)')), +('v', 'l', 'l', GeomFromText('POINT(103 6)')), +('r', 'b', 'k', GeomFromText('POINT(244 137)')), +('l', 'd', 'r', GeomFromText('POINT(162 254)')), +('q', 'b', 'z', GeomFromText('POINT(136 246)')), +('x', 'x', 'p', GeomFromText('POINT(120 37)')), +('m', 'e', 'z', GeomFromText('POINT(203 167)')), +('q', 'n', 'p', GeomFromText('POINT(94 119)')), +('b', 'g', 'u', GeomFromText('POINT(93 248)')), +('r', 'v', 'v', GeomFromText('POINT(53 88)')), +('y', 'a', 'i', GeomFromText('POINT(98 219)')), +('a', 's', 'g', GeomFromText('POINT(173 138)')), +('c', 'a', 't', GeomFromText('POINT(235 135)')), +('q', 'm', 'd', GeomFromText('POINT(224 208)')), +('e', 'p', 'k', GeomFromText('POINT(161 238)')), +('n', 'g', 'q', GeomFromText('POINT(35 204)')), +('t', 't', 'x', GeomFromText('POINT(230 178)')), +('w', 'f', 'a', GeomFromText('POINT(150 221)')), +('z', 'm', 'z', GeomFromText('POINT(119 42)')), +('l', 'j', 's', GeomFromText('POINT(97 96)')), +('f', 'z', 'x', GeomFromText('POINT(208 65)')), +('i', 'v', 'c', GeomFromText('POINT(145 79)')), +('l', 'f', 'k', GeomFromText('POINT(83 234)')), +('u', 'a', 's', GeomFromText('POINT(250 49)')), +('o', 'k', 'p', GeomFromText('POINT(46 50)')), +('d', 'e', 'z', GeomFromText('POINT(30 198)')), +('r', 'r', 'l', GeomFromText('POINT(78 189)')), +('y', 'l', 'f', GeomFromText('POINT(188 132)')), +('d', 'q', 'm', GeomFromText('POINT(247 107)')), +('p', 'j', 'n', GeomFromText('POINT(148 227)')), +('b', 'o', 'i', GeomFromText('POINT(172 25)')), +('e', 'v', 'd', GeomFromText('POINT(94 248)')), +('q', 'd', 'f', GeomFromText('POINT(15 29)')), +('w', 'b', 'b', GeomFromText('POINT(74 111)')), +('g', 'q', 'f', GeomFromText('POINT(107 215)')), +('o', 'h', 'r', GeomFromText('POINT(25 168)')), +('u', 't', 'w', GeomFromText('POINT(251 188)')), +('h', 's', 'w', GeomFromText('POINT(254 247)')), +('f', 'f', 'b', GeomFromText('POINT(166 103)')); +SET @@RAND_SEED1=866613816, @@RAND_SEED2=92289615; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES +('l', 'c', 'l', GeomFromText('POINT(202 98)')), +('k', 'c', 'b', GeomFromText('POINT(46 206)')), +('r', 'y', 'm', GeomFromText('POINT(74 140)')), +('y', 'z', 'd', GeomFromText('POINT(200 160)')), +('s', 'y', 's', GeomFromText('POINT(156 205)')), +('u', 'v', 'p', GeomFromText('POINT(86 82)')), +('j', 's', 's', GeomFromText('POINT(91 233)')), +('x', 'j', 'f', GeomFromText('POINT(3 14)')), +('l', 'z', 'v', GeomFromText('POINT(123 156)')), +('h', 'i', 'o', GeomFromText('POINT(145 229)')), +('o', 'r', 'd', GeomFromText('POINT(15 22)')), +('f', 'x', 't', GeomFromText('POINT(21 60)')), +('t', 'g', 'h', GeomFromText('POINT(50 153)')), +('g', 'u', 'b', GeomFromText('POINT(82 85)')), +('v', 'a', 'p', GeomFromText('POINT(231 178)')), +('n', 'v', 'o', GeomFromText('POINT(183 25)')), +('j', 'n', 'm', GeomFromText('POINT(50 144)')), +('e', 'f', 'i', GeomFromText('POINT(46 16)')), +('d', 'w', 'a', GeomFromText('POINT(66 6)')), +('f', 'x', 'a', GeomFromText('POINT(107 197)')), +('m', 'o', 'a', GeomFromText('POINT(142 80)')), +('q', 'l', 'g', GeomFromText('POINT(251 23)')), +('c', 's', 's', GeomFromText('POINT(158 43)')), +('y', 'd', 'o', GeomFromText('POINT(196 228)')), +('d', 'p', 'l', GeomFromText('POINT(107 5)')), +('h', 'a', 'b', GeomFromText('POINT(183 166)')), +('m', 'w', 'p', GeomFromText('POINT(19 59)')), +('b', 'y', 'o', GeomFromText('POINT(178 30)')), +('x', 'w', 'i', GeomFromText('POINT(168 94)')), +('t', 'k', 'z', GeomFromText('POINT(171 5)')), +('r', 'm', 'a', GeomFromText('POINT(222 19)')), +('u', 'v', 'e', GeomFromText('POINT(224 80)')), +('q', 'r', 'k', GeomFromText('POINT(212 218)')), +('d', 'p', 'j', GeomFromText('POINT(169 7)')), +('d', 'r', 'v', GeomFromText('POINT(193 23)')), +('n', 'y', 'y', GeomFromText('POINT(130 178)')), +('m', 'z', 'r', GeomFromText('POINT(81 200)')), +('j', 'e', 'w', GeomFromText('POINT(145 239)')), +('v', 'h', 'x', GeomFromText('POINT(24 105)')), +('z', 'm', 'a', GeomFromText('POINT(175 129)')), +('b', 'c', 'v', GeomFromText('POINT(213 10)')), +('t', 't', 'u', GeomFromText('POINT(2 129)')), +('r', 's', 'v', GeomFromText('POINT(209 192)')), +('x', 'p', 'g', GeomFromText('POINT(43 63)')), +('t', 'e', 'u', GeomFromText('POINT(139 210)')), +('l', 'e', 't', GeomFromText('POINT(245 148)')), +('a', 'i', 'k', GeomFromText('POINT(167 195)')), +('m', 'o', 'h', GeomFromText('POINT(206 120)')), +('g', 'z', 's', GeomFromText('POINT(169 240)')), +('z', 'u', 's', GeomFromText('POINT(202 120)')), +('i', 'b', 'a', GeomFromText('POINT(216 18)')), +('w', 'y', 'g', GeomFromText('POINT(119 236)')), +('h', 'y', 'p', GeomFromText('POINT(161 24)')); +UPDATE t1 set spatial_point=GeomFromText('POINT(33 100)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(41 46)') where c1 like 'f%'; +CHECK TABLE t1 EXTENDED; +Table Op Msg_type Msg_text +test.t1 check status OK +DROP TABLE t1; diff --git a/mysql-test/t/gis-rtree.test b/mysql-test/t/gis-rtree.test index cdd8d1f3f0f..f28a718cc11 100644 --- a/mysql-test/t/gis-rtree.test +++ b/mysql-test/t/gis-rtree.test @@ -242,4 +242,560 @@ INSERT INTO t1 (foo) VALUES (PointFromWKB(POINT(0,1))); INSERT INTO t1 (foo) VALUES (PointFromWKB(POINT(0,0))); SELECT 1 FROM t1 WHERE foo != PointFromWKB(POINT(0,0)); DROP TABLE t1; + +# +# Bug#25673 - spatial index corruption, error 126 incorrect key file for table +# +CREATE TABLE t1 (id bigint(12) unsigned NOT NULL auto_increment, + c2 varchar(15) collate utf8_bin default NULL, + c1 varchar(15) collate utf8_bin default NULL, + c3 varchar(10) collate utf8_bin default NULL, + spatial_point point NOT NULL, + PRIMARY KEY(id), + SPATIAL KEY (spatial_point(32)) + )ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_bin; +# +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES + ('y', 's', 'j', GeomFromText('POINT(167 74)')), + ('r', 'n', 'd', GeomFromText('POINT(215 118)')), + ('g', 'n', 'e', GeomFromText('POINT(203 98)')), + ('h', 'd', 'd', GeomFromText('POINT(54 193)')), + ('r', 'x', 'y', GeomFromText('POINT(47 69)')), + ('t', 'q', 'r', GeomFromText('POINT(109 42)')), + ('a', 'z', 'd', GeomFromText('POINT(0 154)')), + ('x', 'v', 'o', GeomFromText('POINT(174 131)')), + ('b', 'r', 'a', GeomFromText('POINT(114 253)')), + ('x', 'z', 'i', GeomFromText('POINT(163 21)')), + ('w', 'p', 'i', GeomFromText('POINT(42 102)')), + ('g', 'j', 'j', GeomFromText('POINT(170 133)')), + ('m', 'g', 'n', GeomFromText('POINT(28 22)')), + ('b', 'z', 'h', GeomFromText('POINT(174 28)')), + ('q', 'k', 'f', GeomFromText('POINT(233 73)')), + ('w', 'w', 'a', GeomFromText('POINT(124 200)')), + ('t', 'j', 'w', GeomFromText('POINT(252 101)')), + ('d', 'r', 'd', GeomFromText('POINT(98 18)')), + ('w', 'o', 'y', GeomFromText('POINT(165 31)')), + ('y', 'h', 't', GeomFromText('POINT(14 220)')), + ('d', 'p', 'u', GeomFromText('POINT(223 196)')), + ('g', 'y', 'g', GeomFromText('POINT(207 96)')), + ('x', 'm', 'n', GeomFromText('POINT(214 3)')), + ('g', 'v', 'e', GeomFromText('POINT(140 205)')), + ('g', 'm', 'm', GeomFromText('POINT(10 236)')), + ('i', 'r', 'j', GeomFromText('POINT(137 228)')), + ('w', 's', 'p', GeomFromText('POINT(115 6)')), + ('o', 'n', 'k', GeomFromText('POINT(158 129)')), + ('j', 'h', 'l', GeomFromText('POINT(129 72)')), + ('f', 'x', 'l', GeomFromText('POINT(139 207)')), + ('u', 'd', 'n', GeomFromText('POINT(125 109)')), + ('b', 'a', 'z', GeomFromText('POINT(30 32)')), + ('m', 'h', 'o', GeomFromText('POINT(251 251)')), + ('f', 'r', 'd', GeomFromText('POINT(243 211)')), + ('b', 'd', 'r', GeomFromText('POINT(232 80)')), + ('g', 'k', 'v', GeomFromText('POINT(15 100)')), + ('i', 'f', 'c', GeomFromText('POINT(109 66)')), + ('r', 't', 'j', GeomFromText('POINT(178 6)')), + ('y', 'n', 'f', GeomFromText('POINT(233 211)')), + ('f', 'y', 'm', GeomFromText('POINT(99 16)')), + ('z', 'q', 'l', GeomFromText('POINT(39 49)')), + ('j', 'c', 'r', GeomFromText('POINT(75 187)')), + ('c', 'y', 'y', GeomFromText('POINT(246 253)')), + ('w', 'u', 'd', GeomFromText('POINT(56 190)')), + ('n', 'q', 'm', GeomFromText('POINT(73 149)')), + ('d', 'y', 'a', GeomFromText('POINT(134 6)')), + ('z', 's', 'w', GeomFromText('POINT(216 225)')), + ('d', 'u', 'k', GeomFromText('POINT(132 70)')), + ('f', 'v', 't', GeomFromText('POINT(187 141)')), + ('r', 'r', 'a', GeomFromText('POINT(152 39)')), + ('y', 'p', 'o', GeomFromText('POINT(45 27)')), + ('p', 'n', 'm', GeomFromText('POINT(228 148)')), + ('e', 'g', 'e', GeomFromText('POINT(88 81)')), + ('m', 'a', 'h', GeomFromText('POINT(35 29)')), + ('m', 'h', 'f', GeomFromText('POINT(30 71)')), + ('h', 'k', 'i', GeomFromText('POINT(244 78)')), + ('z', 'v', 'd', GeomFromText('POINT(241 38)')), + ('q', 'l', 'j', GeomFromText('POINT(13 71)')), + ('s', 'p', 'g', GeomFromText('POINT(108 38)')), + ('q', 's', 'j', GeomFromText('POINT(92 101)')), + ('l', 'h', 'g', GeomFromText('POINT(120 78)')), + ('w', 't', 'b', GeomFromText('POINT(193 109)')), + ('b', 's', 's', GeomFromText('POINT(223 211)')), + ('w', 'w', 'y', GeomFromText('POINT(122 42)')), + ('q', 'c', 'c', GeomFromText('POINT(104 102)')), + ('w', 'g', 'n', GeomFromText('POINT(213 120)')), + ('p', 'q', 'a', GeomFromText('POINT(247 148)')), + ('c', 'z', 'e', GeomFromText('POINT(18 106)')), + ('z', 'u', 'n', GeomFromText('POINT(70 133)')), + ('j', 'n', 'x', GeomFromText('POINT(232 13)')), + ('e', 'h', 'f', GeomFromText('POINT(22 135)')), + ('w', 'l', 'f', GeomFromText('POINT(9 180)')), + ('a', 'v', 'q', GeomFromText('POINT(163 228)')), + ('i', 'z', 'o', GeomFromText('POINT(180 100)')), + ('e', 'c', 'l', GeomFromText('POINT(182 231)')), + ('c', 'k', 'o', GeomFromText('POINT(19 60)')), + ('q', 'f', 'p', GeomFromText('POINT(79 95)')), + ('m', 'd', 'r', GeomFromText('POINT(3 127)')), + ('m', 'e', 't', GeomFromText('POINT(136 154)')), + ('w', 'w', 'w', GeomFromText('POINT(102 15)')), + ('l', 'n', 'q', GeomFromText('POINT(71 196)')), + ('p', 'k', 'c', GeomFromText('POINT(47 139)')), + ('j', 'o', 'r', GeomFromText('POINT(177 128)')), + ('j', 'q', 'a', GeomFromText('POINT(170 6)')), + ('b', 'a', 'o', GeomFromText('POINT(63 211)')), + ('g', 's', 'o', GeomFromText('POINT(144 251)')), + ('w', 'u', 'w', GeomFromText('POINT(221 214)')), + ('g', 'a', 'm', GeomFromText('POINT(14 102)')), + ('u', 'q', 'z', GeomFromText('POINT(86 200)')), + ('k', 'a', 'm', GeomFromText('POINT(144 222)')), + ('j', 'u', 'r', GeomFromText('POINT(216 142)')), + ('q', 'k', 'v', GeomFromText('POINT(121 236)')), + ('p', 'o', 'r', GeomFromText('POINT(108 102)')), + ('b', 'd', 'x', GeomFromText('POINT(127 198)')), + ('k', 's', 'a', GeomFromText('POINT(2 150)')), + ('f', 'm', 'f', GeomFromText('POINT(160 191)')), + ('q', 'y', 'x', GeomFromText('POINT(98 111)')), + ('o', 'f', 'm', GeomFromText('POINT(232 218)')), + ('c', 'w', 'j', GeomFromText('POINT(156 165)')), + ('s', 'q', 'v', GeomFromText('POINT(98 161)')); +SET @@RAND_SEED1=692635050, @@RAND_SEED2=297339954; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=159925977, @@RAND_SEED2=942570618; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=328169745, @@RAND_SEED2=410451954; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=178507359, @@RAND_SEED2=332493072; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=1034033013, @@RAND_SEED2=558966507; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +UPDATE t1 set spatial_point=GeomFromText('POINT(230 9)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(95 35)') where c1 like 'j%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(93 99)') where c1 like 'a%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(19 81)') where c1 like 'r%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(20 177)') where c1 like 'h%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(221 193)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(195 205)') where c1 like 'd%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(15 213)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(214 63)') where c1 like 'n%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(243 171)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(198 82)') where c1 like 'y%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES + ('f', 'y', 'p', GeomFromText('POINT(109 235)')), + ('b', 'e', 'v', GeomFromText('POINT(20 48)')), + ('i', 'u', 'f', GeomFromText('POINT(15 55)')), + ('o', 'r', 'z', GeomFromText('POINT(105 64)')), + ('a', 'p', 'a', GeomFromText('POINT(142 236)')), + ('g', 'i', 'k', GeomFromText('POINT(10 49)')), + ('x', 'z', 'x', GeomFromText('POINT(192 200)')), + ('c', 'v', 'r', GeomFromText('POINT(94 168)')), + ('y', 'z', 'e', GeomFromText('POINT(141 51)')), + ('h', 'm', 'd', GeomFromText('POINT(35 251)')), + ('v', 'm', 'q', GeomFromText('POINT(44 90)')), + ('j', 'l', 'z', GeomFromText('POINT(67 237)')), + ('i', 'v', 'a', GeomFromText('POINT(75 14)')), + ('b', 'q', 't', GeomFromText('POINT(153 33)')), + ('e', 'm', 'a', GeomFromText('POINT(247 49)')), + ('l', 'y', 'g', GeomFromText('POINT(56 203)')), + ('v', 'o', 'r', GeomFromText('POINT(90 54)')), + ('r', 'n', 'd', GeomFromText('POINT(135 83)')), + ('j', 't', 'u', GeomFromText('POINT(174 239)')), + ('u', 'n', 'g', GeomFromText('POINT(104 191)')), + ('p', 'q', 'y', GeomFromText('POINT(63 171)')), + ('o', 'q', 'p', GeomFromText('POINT(192 103)')), + ('f', 'x', 'e', GeomFromText('POINT(244 30)')), + ('n', 'x', 'c', GeomFromText('POINT(92 103)')), + ('r', 'q', 'z', GeomFromText('POINT(166 20)')), + ('s', 'a', 'j', GeomFromText('POINT(137 205)')), + ('z', 't', 't', GeomFromText('POINT(99 134)')), + ('o', 'm', 'j', GeomFromText('POINT(217 3)')), + ('n', 'h', 'j', GeomFromText('POINT(211 17)')), + ('v', 'v', 'a', GeomFromText('POINT(41 137)')), + ('q', 'o', 'j', GeomFromText('POINT(5 92)')), + ('z', 'y', 'e', GeomFromText('POINT(175 212)')), + ('j', 'z', 'h', GeomFromText('POINT(224 194)')), + ('a', 'g', 'm', GeomFromText('POINT(31 119)')), + ('p', 'c', 'f', GeomFromText('POINT(17 221)')), + ('t', 'h', 'k', GeomFromText('POINT(26 203)')), + ('u', 'w', 'p', GeomFromText('POINT(47 185)')), + ('z', 'a', 'c', GeomFromText('POINT(61 133)')), + ('u', 'k', 'a', GeomFromText('POINT(210 115)')), + ('k', 'f', 'h', GeomFromText('POINT(125 113)')), + ('t', 'v', 'y', GeomFromText('POINT(12 239)')), + ('u', 'v', 'd', GeomFromText('POINT(90 24)')), + ('m', 'y', 'w', GeomFromText('POINT(25 243)')), + ('d', 'n', 'g', GeomFromText('POINT(122 92)')), + ('z', 'm', 'f', GeomFromText('POINT(235 110)')), + ('q', 'd', 'f', GeomFromText('POINT(233 217)')), + ('a', 'v', 'u', GeomFromText('POINT(69 59)')), + ('x', 'k', 'p', GeomFromText('POINT(240 14)')), + ('i', 'v', 'r', GeomFromText('POINT(154 42)')), + ('w', 'h', 'l', GeomFromText('POINT(178 156)')), + ('d', 'h', 'n', GeomFromText('POINT(65 157)')), + ('c', 'k', 'z', GeomFromText('POINT(62 33)')), + ('e', 'l', 'w', GeomFromText('POINT(162 1)')), + ('r', 'f', 'i', GeomFromText('POINT(127 71)')), + ('q', 'm', 'c', GeomFromText('POINT(63 118)')), + ('c', 'h', 'u', GeomFromText('POINT(205 203)')), + ('d', 't', 'p', GeomFromText('POINT(234 87)')), + ('s', 'g', 'h', GeomFromText('POINT(149 34)')), + ('o', 'b', 'q', GeomFromText('POINT(159 179)')), + ('k', 'u', 'f', GeomFromText('POINT(202 254)')), + ('u', 'f', 'g', GeomFromText('POINT(70 15)')), + ('x', 's', 'b', GeomFromText('POINT(25 181)')), + ('s', 'c', 'g', GeomFromText('POINT(252 17)')), + ('a', 'c', 'f', GeomFromText('POINT(89 67)')), + ('r', 'e', 'q', GeomFromText('POINT(55 54)')), + ('f', 'i', 'k', GeomFromText('POINT(178 230)')), + ('p', 'e', 'l', GeomFromText('POINT(198 28)')), + ('w', 'o', 'd', GeomFromText('POINT(204 189)')), + ('c', 'a', 'g', GeomFromText('POINT(230 178)')), + ('r', 'o', 'e', GeomFromText('POINT(61 116)')), + ('w', 'a', 'a', GeomFromText('POINT(178 237)')), + ('v', 'd', 'e', GeomFromText('POINT(70 85)')), + ('k', 'c', 'e', GeomFromText('POINT(147 118)')), + ('d', 'q', 't', GeomFromText('POINT(218 77)')), + ('k', 'g', 'f', GeomFromText('POINT(192 113)')), + ('w', 'n', 'e', GeomFromText('POINT(92 124)')), + ('r', 'm', 'q', GeomFromText('POINT(130 65)')), + ('o', 'r', 'r', GeomFromText('POINT(174 233)')), + ('k', 'n', 't', GeomFromText('POINT(175 147)')), + ('q', 'm', 'r', GeomFromText('POINT(18 208)')), + ('l', 'd', 'i', GeomFromText('POINT(13 104)')), + ('w', 'o', 'y', GeomFromText('POINT(207 39)')), + ('p', 'u', 'o', GeomFromText('POINT(114 31)')), + ('y', 'a', 'p', GeomFromText('POINT(106 59)')), + ('a', 'x', 'z', GeomFromText('POINT(17 57)')), + ('v', 'h', 'x', GeomFromText('POINT(170 13)')), + ('t', 's', 'u', GeomFromText('POINT(84 18)')), + ('z', 'z', 'f', GeomFromText('POINT(250 197)')), + ('l', 'z', 't', GeomFromText('POINT(59 80)')), + ('j', 'g', 's', GeomFromText('POINT(54 26)')), + ('g', 'v', 'm', GeomFromText('POINT(89 98)')), + ('q', 'v', 'b', GeomFromText('POINT(39 240)')), + ('x', 'k', 'v', GeomFromText('POINT(246 207)')), + ('k', 'u', 'i', GeomFromText('POINT(105 111)')), + ('w', 'z', 's', GeomFromText('POINT(235 8)')), + ('d', 'd', 'd', GeomFromText('POINT(105 4)')), + ('c', 'z', 'q', GeomFromText('POINT(13 140)')), + ('m', 'k', 'i', GeomFromText('POINT(208 120)')), + ('g', 'a', 'g', GeomFromText('POINT(9 182)')), + ('z', 'j', 'r', GeomFromText('POINT(149 153)')), + ('h', 'f', 'g', GeomFromText('POINT(81 236)')), + ('m', 'e', 'q', GeomFromText('POINT(209 215)')), + ('c', 'h', 'y', GeomFromText('POINT(235 70)')), + ('i', 'e', 'g', GeomFromText('POINT(138 26)')), + ('m', 't', 'u', GeomFromText('POINT(119 237)')), + ('o', 'w', 's', GeomFromText('POINT(193 166)')), + ('f', 'm', 'q', GeomFromText('POINT(85 96)')), + ('x', 'l', 'x', GeomFromText('POINT(58 115)')), + ('x', 'q', 'u', GeomFromText('POINT(108 210)')), + ('b', 'h', 'i', GeomFromText('POINT(250 139)')), + ('y', 'd', 'x', GeomFromText('POINT(199 135)')), + ('w', 'h', 'p', GeomFromText('POINT(247 233)')), + ('p', 'z', 't', GeomFromText('POINT(148 249)')), + ('q', 'a', 'u', GeomFromText('POINT(174 78)')), + ('v', 't', 'm', GeomFromText('POINT(70 228)')), + ('t', 'n', 'f', GeomFromText('POINT(123 2)')), + ('x', 't', 'b', GeomFromText('POINT(35 50)')), + ('r', 'j', 'f', GeomFromText('POINT(200 51)')), + ('s', 'q', 'o', GeomFromText('POINT(23 184)')), + ('u', 'v', 'z', GeomFromText('POINT(7 113)')), + ('v', 'u', 'l', GeomFromText('POINT(145 190)')), + ('o', 'k', 'i', GeomFromText('POINT(161 122)')), + ('l', 'y', 'e', GeomFromText('POINT(17 232)')), + ('t', 'b', 'e', GeomFromText('POINT(120 50)')), + ('e', 's', 'u', GeomFromText('POINT(254 1)')), + ('d', 'd', 'u', GeomFromText('POINT(167 140)')), + ('o', 'b', 'x', GeomFromText('POINT(186 237)')), + ('m', 's', 's', GeomFromText('POINT(172 149)')), + ('t', 'y', 'a', GeomFromText('POINT(149 85)')), + ('x', 't', 'r', GeomFromText('POINT(10 165)')), + ('g', 'c', 'e', GeomFromText('POINT(95 165)')), + ('e', 'e', 'z', GeomFromText('POINT(98 65)')), + ('f', 'v', 'i', GeomFromText('POINT(149 144)')), + ('o', 'p', 'm', GeomFromText('POINT(233 67)')), + ('t', 'u', 'b', GeomFromText('POINT(109 215)')), + ('o', 'o', 'b', GeomFromText('POINT(130 48)')), + ('e', 'm', 'h', GeomFromText('POINT(88 189)')), + ('e', 'v', 'y', GeomFromText('POINT(55 29)')), + ('e', 't', 'm', GeomFromText('POINT(129 55)')), + ('p', 'p', 'i', GeomFromText('POINT(126 222)')), + ('c', 'i', 'c', GeomFromText('POINT(19 158)')), + ('c', 'b', 's', GeomFromText('POINT(13 19)')), + ('u', 'y', 'a', GeomFromText('POINT(114 5)')), + ('a', 'o', 'f', GeomFromText('POINT(227 232)')), + ('t', 'c', 'z', GeomFromText('POINT(63 62)')), + ('d', 'o', 'k', GeomFromText('POINT(48 228)')), + ('x', 'c', 'e', GeomFromText('POINT(204 2)')), + ('e', 'e', 'g', GeomFromText('POINT(125 43)')), + ('o', 'r', 'f', GeomFromText('POINT(171 140)')); +UPDATE t1 set spatial_point=GeomFromText('POINT(163 157)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(53 151)') where c1 like 'd%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(96 183)') where c1 like 'r%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(57 91)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(202 110)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(120 137)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(207 147)') where c1 like 'c%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(31 125)') where c1 like 'e%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(27 36)') where c1 like 'r%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES + ('b', 'c', 'e', GeomFromText('POINT(41 137)')), + ('p', 'y', 'k', GeomFromText('POINT(50 22)')), + ('s', 'c', 'h', GeomFromText('POINT(208 173)')), + ('x', 'u', 'l', GeomFromText('POINT(199 175)')), + ('s', 'r', 'h', GeomFromText('POINT(85 192)')), + ('j', 'k', 'u', GeomFromText('POINT(18 25)')), + ('p', 'w', 'h', GeomFromText('POINT(152 197)')), + ('e', 'd', 'c', GeomFromText('POINT(229 3)')), + ('o', 'x', 'k', GeomFromText('POINT(187 155)')), + ('o', 'b', 'k', GeomFromText('POINT(208 150)')), + ('d', 'a', 'j', GeomFromText('POINT(70 87)')), + ('f', 'e', 'k', GeomFromText('POINT(156 96)')), + ('u', 'y', 'p', GeomFromText('POINT(239 193)')), + ('n', 'v', 'p', GeomFromText('POINT(223 98)')), + ('z', 'j', 'r', GeomFromText('POINT(87 89)')), + ('h', 'x', 'x', GeomFromText('POINT(92 0)')), + ('r', 'v', 'r', GeomFromText('POINT(159 139)')), + ('v', 'g', 'g', GeomFromText('POINT(16 229)')), + ('z', 'k', 'u', GeomFromText('POINT(99 52)')), + ('p', 'p', 'o', GeomFromText('POINT(105 125)')), + ('w', 'h', 'y', GeomFromText('POINT(105 154)')), + ('v', 'y', 'z', GeomFromText('POINT(134 238)')), + ('x', 'o', 'o', GeomFromText('POINT(178 88)')), + ('z', 'w', 'd', GeomFromText('POINT(123 60)')), + ('q', 'f', 'u', GeomFromText('POINT(64 90)')), + ('s', 'n', 't', GeomFromText('POINT(50 138)')), + ('v', 'p', 't', GeomFromText('POINT(114 91)')), + ('a', 'o', 'n', GeomFromText('POINT(78 43)')), + ('k', 'u', 'd', GeomFromText('POINT(185 161)')), + ('w', 'd', 'n', GeomFromText('POINT(25 92)')), + ('k', 'w', 'a', GeomFromText('POINT(59 238)')), + ('t', 'c', 'f', GeomFromText('POINT(65 87)')), + ('g', 's', 'p', GeomFromText('POINT(238 126)')), + ('d', 'n', 'y', GeomFromText('POINT(107 173)')), + ('l', 'a', 'w', GeomFromText('POINT(125 152)')), + ('m', 'd', 'j', GeomFromText('POINT(146 53)')), + ('q', 'm', 'c', GeomFromText('POINT(217 187)')), + ('i', 'r', 'r', GeomFromText('POINT(6 113)')), + ('e', 'j', 'b', GeomFromText('POINT(37 83)')), + ('w', 'w', 'h', GeomFromText('POINT(83 199)')), + ('k', 'b', 's', GeomFromText('POINT(170 64)')), + ('s', 'b', 'c', GeomFromText('POINT(163 130)')), + ('c', 'h', 'a', GeomFromText('POINT(141 3)')), + ('k', 'j', 'u', GeomFromText('POINT(143 76)')), + ('r', 'h', 'o', GeomFromText('POINT(243 92)')), + ('i', 'd', 'b', GeomFromText('POINT(205 13)')), + ('r', 'y', 'q', GeomFromText('POINT(138 8)')), + ('m', 'o', 'i', GeomFromText('POINT(36 45)')), + ('v', 'g', 'm', GeomFromText('POINT(0 40)')), + ('f', 'e', 'i', GeomFromText('POINT(76 6)')), + ('c', 'q', 'q', GeomFromText('POINT(115 248)')), + ('x', 'c', 'i', GeomFromText('POINT(29 74)')), + ('l', 's', 't', GeomFromText('POINT(83 18)')), + ('t', 't', 'a', GeomFromText('POINT(26 168)')), + ('u', 'n', 'x', GeomFromText('POINT(200 110)')), + ('j', 'b', 'd', GeomFromText('POINT(216 136)')), + ('s', 'p', 'w', GeomFromText('POINT(38 156)')), + ('f', 'b', 'v', GeomFromText('POINT(29 186)')), + ('v', 'e', 'r', GeomFromText('POINT(149 40)')), + ('v', 't', 'm', GeomFromText('POINT(184 24)')), + ('y', 'g', 'a', GeomFromText('POINT(219 105)')), + ('s', 'f', 'i', GeomFromText('POINT(114 130)')), + ('e', 'q', 'h', GeomFromText('POINT(203 135)')), + ('h', 'g', 'b', GeomFromText('POINT(9 208)')), + ('o', 'l', 'r', GeomFromText('POINT(245 79)')), + ('s', 's', 'v', GeomFromText('POINT(238 198)')), + ('w', 'w', 'z', GeomFromText('POINT(209 232)')), + ('v', 'd', 'n', GeomFromText('POINT(30 193)')), + ('q', 'w', 'k', GeomFromText('POINT(133 18)')), + ('o', 'h', 'o', GeomFromText('POINT(42 140)')), + ('f', 'f', 'h', GeomFromText('POINT(145 1)')), + ('u', 's', 'r', GeomFromText('POINT(70 62)')), + ('x', 'n', 'q', GeomFromText('POINT(33 86)')), + ('u', 'p', 'v', GeomFromText('POINT(232 220)')), + ('z', 'e', 'a', GeomFromText('POINT(130 69)')), + ('r', 'u', 'z', GeomFromText('POINT(243 241)')), + ('b', 'n', 't', GeomFromText('POINT(120 12)')), + ('u', 'f', 's', GeomFromText('POINT(190 212)')), + ('a', 'd', 'q', GeomFromText('POINT(235 191)')), + ('f', 'q', 'm', GeomFromText('POINT(176 2)')), + ('n', 'c', 's', GeomFromText('POINT(218 163)')), + ('e', 'm', 'h', GeomFromText('POINT(163 108)')), + ('c', 'f', 'l', GeomFromText('POINT(220 115)')), + ('c', 'v', 'q', GeomFromText('POINT(66 45)')), + ('w', 'v', 'x', GeomFromText('POINT(251 220)')), + ('f', 'w', 'z', GeomFromText('POINT(146 149)')), + ('h', 'n', 'h', GeomFromText('POINT(148 128)')), + ('y', 'k', 'v', GeomFromText('POINT(28 110)')), + ('c', 'x', 'q', GeomFromText('POINT(13 13)')), + ('e', 'd', 's', GeomFromText('POINT(91 190)')), + ('c', 'w', 'c', GeomFromText('POINT(10 231)')), + ('u', 'j', 'n', GeomFromText('POINT(250 21)')), + ('w', 'n', 'x', GeomFromText('POINT(141 69)')), + ('f', 'p', 'y', GeomFromText('POINT(228 246)')), + ('d', 'q', 'f', GeomFromText('POINT(194 22)')), + ('d', 'z', 'l', GeomFromText('POINT(233 181)')), + ('c', 'a', 'q', GeomFromText('POINT(183 96)')), + ('m', 'i', 'd', GeomFromText('POINT(117 226)')), + ('z', 'y', 'y', GeomFromText('POINT(62 81)')), + ('g', 'v', 'm', GeomFromText('POINT(66 158)')); +SET @@RAND_SEED1=481064922, @@RAND_SEED2=438133497; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=280535103, @@RAND_SEED2=444518646; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=1072017234, @@RAND_SEED2=484203885; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=358851897, @@RAND_SEED2=358495224; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +SET @@RAND_SEED1=509031459, @@RAND_SEED2=675962925; +DELETE FROM t1 ORDER BY RAND() LIMIT 10; +UPDATE t1 set spatial_point=GeomFromText('POINT(61 203)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(202 194)') where c1 like 'f%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(228 18)') where c1 like 'h%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(88 18)') where c1 like 'l%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(176 94)') where c1 like 'e%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(44 47)') where c1 like 'g%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(95 191)') where c1 like 'b%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(179 218)') where c1 like 'y%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(239 40)') where c1 like 'g%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(248 41)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(167 82)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(13 104)') where c1 like 'u%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(139 84)') where c1 like 'a%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(145 108)') where c1 like 'p%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(147 57)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(217 144)') where c1 like 'n%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(160 224)') where c1 like 'w%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(38 28)') where c1 like 'j%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(104 114)') where c1 like 'q%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(88 19)') where c1 like 'c%'; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES + ('f', 'x', 'p', GeomFromText('POINT(92 181)')), + ('s', 'i', 'c', GeomFromText('POINT(49 60)')), + ('c', 'c', 'i', GeomFromText('POINT(7 57)')), + ('n', 'g', 'k', GeomFromText('POINT(252 105)')), + ('g', 'b', 'm', GeomFromText('POINT(180 11)')), + ('u', 'l', 'r', GeomFromText('POINT(32 90)')), + ('c', 'x', 'e', GeomFromText('POINT(143 24)')), + ('x', 'u', 'a', GeomFromText('POINT(123 92)')), + ('s', 'b', 'h', GeomFromText('POINT(190 108)')), + ('c', 'x', 'b', GeomFromText('POINT(104 100)')), + ('i', 'd', 't', GeomFromText('POINT(214 104)')), + ('r', 'w', 'g', GeomFromText('POINT(29 67)')), + ('b', 'f', 'g', GeomFromText('POINT(149 46)')), + ('r', 'r', 'd', GeomFromText('POINT(242 196)')), + ('j', 'l', 'a', GeomFromText('POINT(90 196)')), + ('e', 't', 'b', GeomFromText('POINT(190 64)')), + ('l', 'x', 'w', GeomFromText('POINT(250 73)')), + ('q', 'y', 'r', GeomFromText('POINT(120 182)')), + ('s', 'j', 'a', GeomFromText('POINT(180 175)')), + ('n', 'i', 'y', GeomFromText('POINT(124 136)')), + ('s', 'x', 's', GeomFromText('POINT(176 209)')), + ('u', 'f', 's', GeomFromText('POINT(215 173)')), + ('m', 'j', 'x', GeomFromText('POINT(44 140)')), + ('v', 'g', 'x', GeomFromText('POINT(177 233)')), + ('u', 't', 'b', GeomFromText('POINT(136 197)')), + ('f', 'g', 'b', GeomFromText('POINT(10 8)')), + ('v', 'c', 'j', GeomFromText('POINT(13 81)')), + ('d', 's', 'q', GeomFromText('POINT(200 100)')), + ('a', 'p', 'j', GeomFromText('POINT(33 40)')), + ('i', 'c', 'g', GeomFromText('POINT(168 204)')), + ('k', 'h', 'i', GeomFromText('POINT(93 243)')), + ('s', 'b', 's', GeomFromText('POINT(157 13)')), + ('v', 'l', 'l', GeomFromText('POINT(103 6)')), + ('r', 'b', 'k', GeomFromText('POINT(244 137)')), + ('l', 'd', 'r', GeomFromText('POINT(162 254)')), + ('q', 'b', 'z', GeomFromText('POINT(136 246)')), + ('x', 'x', 'p', GeomFromText('POINT(120 37)')), + ('m', 'e', 'z', GeomFromText('POINT(203 167)')), + ('q', 'n', 'p', GeomFromText('POINT(94 119)')), + ('b', 'g', 'u', GeomFromText('POINT(93 248)')), + ('r', 'v', 'v', GeomFromText('POINT(53 88)')), + ('y', 'a', 'i', GeomFromText('POINT(98 219)')), + ('a', 's', 'g', GeomFromText('POINT(173 138)')), + ('c', 'a', 't', GeomFromText('POINT(235 135)')), + ('q', 'm', 'd', GeomFromText('POINT(224 208)')), + ('e', 'p', 'k', GeomFromText('POINT(161 238)')), + ('n', 'g', 'q', GeomFromText('POINT(35 204)')), + ('t', 't', 'x', GeomFromText('POINT(230 178)')), + ('w', 'f', 'a', GeomFromText('POINT(150 221)')), + ('z', 'm', 'z', GeomFromText('POINT(119 42)')), + ('l', 'j', 's', GeomFromText('POINT(97 96)')), + ('f', 'z', 'x', GeomFromText('POINT(208 65)')), + ('i', 'v', 'c', GeomFromText('POINT(145 79)')), + ('l', 'f', 'k', GeomFromText('POINT(83 234)')), + ('u', 'a', 's', GeomFromText('POINT(250 49)')), + ('o', 'k', 'p', GeomFromText('POINT(46 50)')), + ('d', 'e', 'z', GeomFromText('POINT(30 198)')), + ('r', 'r', 'l', GeomFromText('POINT(78 189)')), + ('y', 'l', 'f', GeomFromText('POINT(188 132)')), + ('d', 'q', 'm', GeomFromText('POINT(247 107)')), + ('p', 'j', 'n', GeomFromText('POINT(148 227)')), + ('b', 'o', 'i', GeomFromText('POINT(172 25)')), + ('e', 'v', 'd', GeomFromText('POINT(94 248)')), + ('q', 'd', 'f', GeomFromText('POINT(15 29)')), + ('w', 'b', 'b', GeomFromText('POINT(74 111)')), + ('g', 'q', 'f', GeomFromText('POINT(107 215)')), + ('o', 'h', 'r', GeomFromText('POINT(25 168)')), + ('u', 't', 'w', GeomFromText('POINT(251 188)')), + ('h', 's', 'w', GeomFromText('POINT(254 247)')), + ('f', 'f', 'b', GeomFromText('POINT(166 103)')); +SET @@RAND_SEED1=866613816, @@RAND_SEED2=92289615; +INSERT INTO t1 (c2, c1, c3, spatial_point) VALUES + ('l', 'c', 'l', GeomFromText('POINT(202 98)')), + ('k', 'c', 'b', GeomFromText('POINT(46 206)')), + ('r', 'y', 'm', GeomFromText('POINT(74 140)')), + ('y', 'z', 'd', GeomFromText('POINT(200 160)')), + ('s', 'y', 's', GeomFromText('POINT(156 205)')), + ('u', 'v', 'p', GeomFromText('POINT(86 82)')), + ('j', 's', 's', GeomFromText('POINT(91 233)')), + ('x', 'j', 'f', GeomFromText('POINT(3 14)')), + ('l', 'z', 'v', GeomFromText('POINT(123 156)')), + ('h', 'i', 'o', GeomFromText('POINT(145 229)')), + ('o', 'r', 'd', GeomFromText('POINT(15 22)')), + ('f', 'x', 't', GeomFromText('POINT(21 60)')), + ('t', 'g', 'h', GeomFromText('POINT(50 153)')), + ('g', 'u', 'b', GeomFromText('POINT(82 85)')), + ('v', 'a', 'p', GeomFromText('POINT(231 178)')), + ('n', 'v', 'o', GeomFromText('POINT(183 25)')), + ('j', 'n', 'm', GeomFromText('POINT(50 144)')), + ('e', 'f', 'i', GeomFromText('POINT(46 16)')), + ('d', 'w', 'a', GeomFromText('POINT(66 6)')), + ('f', 'x', 'a', GeomFromText('POINT(107 197)')), + ('m', 'o', 'a', GeomFromText('POINT(142 80)')), + ('q', 'l', 'g', GeomFromText('POINT(251 23)')), + ('c', 's', 's', GeomFromText('POINT(158 43)')), + ('y', 'd', 'o', GeomFromText('POINT(196 228)')), + ('d', 'p', 'l', GeomFromText('POINT(107 5)')), + ('h', 'a', 'b', GeomFromText('POINT(183 166)')), + ('m', 'w', 'p', GeomFromText('POINT(19 59)')), + ('b', 'y', 'o', GeomFromText('POINT(178 30)')), + ('x', 'w', 'i', GeomFromText('POINT(168 94)')), + ('t', 'k', 'z', GeomFromText('POINT(171 5)')), + ('r', 'm', 'a', GeomFromText('POINT(222 19)')), + ('u', 'v', 'e', GeomFromText('POINT(224 80)')), + ('q', 'r', 'k', GeomFromText('POINT(212 218)')), + ('d', 'p', 'j', GeomFromText('POINT(169 7)')), + ('d', 'r', 'v', GeomFromText('POINT(193 23)')), + ('n', 'y', 'y', GeomFromText('POINT(130 178)')), + ('m', 'z', 'r', GeomFromText('POINT(81 200)')), + ('j', 'e', 'w', GeomFromText('POINT(145 239)')), + ('v', 'h', 'x', GeomFromText('POINT(24 105)')), + ('z', 'm', 'a', GeomFromText('POINT(175 129)')), + ('b', 'c', 'v', GeomFromText('POINT(213 10)')), + ('t', 't', 'u', GeomFromText('POINT(2 129)')), + ('r', 's', 'v', GeomFromText('POINT(209 192)')), + ('x', 'p', 'g', GeomFromText('POINT(43 63)')), + ('t', 'e', 'u', GeomFromText('POINT(139 210)')), + ('l', 'e', 't', GeomFromText('POINT(245 148)')), + ('a', 'i', 'k', GeomFromText('POINT(167 195)')), + ('m', 'o', 'h', GeomFromText('POINT(206 120)')), + ('g', 'z', 's', GeomFromText('POINT(169 240)')), + ('z', 'u', 's', GeomFromText('POINT(202 120)')), + ('i', 'b', 'a', GeomFromText('POINT(216 18)')), + ('w', 'y', 'g', GeomFromText('POINT(119 236)')), + ('h', 'y', 'p', GeomFromText('POINT(161 24)')); +UPDATE t1 set spatial_point=GeomFromText('POINT(33 100)') where c1 like 't%'; +UPDATE t1 set spatial_point=GeomFromText('POINT(41 46)') where c1 like 'f%'; +CHECK TABLE t1 EXTENDED; +DROP TABLE t1; + # End of 4.1 tests From f1b05f294b1205bddb7dd0eef078c0e61089e5d0 Mon Sep 17 00:00:00 2001 From: "gni/root@dev3-221.dev.cn.tlan" <> Date: Thu, 8 Mar 2007 17:47:13 +0800 Subject: [PATCH 31/73] BUG#25743 If undo_buffer_size (for LG) greater than the inital shared memory (default 20M), ndbd nodes are crashed --- storage/ndb/src/kernel/vm/Pool.hpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/storage/ndb/src/kernel/vm/Pool.hpp b/storage/ndb/src/kernel/vm/Pool.hpp index b585af57684..a4e062078fb 100644 --- a/storage/ndb/src/kernel/vm/Pool.hpp +++ b/storage/ndb/src/kernel/vm/Pool.hpp @@ -307,8 +307,11 @@ RecordPool::seize(Ptr & ptr) { Ptr tmp; bool ret = m_pool.seize(tmp); - ptr.i = tmp.i; - ptr.p = static_cast(tmp.p); + if(likely(ret)) + { + ptr.i = tmp.i; + ptr.p = static_cast(tmp.p); + } return ret; } From f1bbbcce220dd273f7aca9688092c5d5c559332e Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Thu, 8 Mar 2007 12:08:59 +0100 Subject: [PATCH 32/73] Bug#25673 - spatial index corruption, error 126 incorrect key file for table After merge fix --- mysql-test/r/gis-rtree.result | 1 + 1 file changed, 1 insertion(+) diff --git a/mysql-test/r/gis-rtree.result b/mysql-test/r/gis-rtree.result index 03423fed78e..92de2abcdcb 100644 --- a/mysql-test/r/gis-rtree.result +++ b/mysql-test/r/gis-rtree.result @@ -1424,6 +1424,7 @@ UPDATE t1 set spatial_point=GeomFromText('POINT(41 46)') where c1 like 'f%'; CHECK TABLE t1 EXTENDED; Table Op Msg_type Msg_text test.t1 check status OK +DROP TABLE t1; CREATE TABLE t1(foo GEOMETRY NOT NULL, SPATIAL INDEX(foo) ); INSERT INTO t1(foo) VALUES (NULL); ERROR 23000: Column 'foo' cannot be null From 35e5925673af86c1ccd61ef22af3b462c62cb5af Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Thu, 8 Mar 2007 19:38:21 +0300 Subject: [PATCH 33/73] sql_select.cc: Postfix for bug#22331. --- sql/sql_select.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/sql_select.cc b/sql/sql_select.cc index 06352d48154..9fe92d63da3 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -7621,7 +7621,8 @@ static COND* substitute_for_best_equal_field(COND *cond, break; } } - if (!((Item_cond*)cond)->argument_list()->elements) + if (cond->type() == Item::COND_ITEM && + !((Item_cond*)cond)->argument_list()->elements) cond= new Item_int((int32)cond->val_bool()); } From 48d3e2c1bba6ea60d73fdf8241fea4770b18d09b Mon Sep 17 00:00:00 2001 From: "holyfoot/hf@mysql.com/hfmain.(none)" <> Date: Thu, 8 Mar 2007 20:57:12 +0400 Subject: [PATCH 34/73] merging --- mysql-test/r/explain.result | 20 ++++++++++---------- mysql-test/r/func_in.result | 6 ++++++ mysql-test/r/sp.result | 13 +++++++++++++ 3 files changed, 29 insertions(+), 10 deletions(-) diff --git a/mysql-test/r/explain.result b/mysql-test/r/explain.result index 13d63cdcdc3..8d5d6adefa5 100644 --- a/mysql-test/r/explain.result +++ b/mysql-test/r/explain.result @@ -61,28 +61,28 @@ create table t1(f1 int, f2 int); insert into t1 values (1,1); create view v1 as select * from t1 where f1=1; explain extended select * from v1 where f2=1; -id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 system NULL NULL NULL NULL 1 +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 100.00 Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 explain extended select * from t1 where 0; -id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL NULL Impossible WHERE Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 0 explain extended select * from t1 where 1; -id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 system NULL NULL NULL NULL 1 +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 100.00 Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 explain extended select * from t1 having 0; -id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible HAVING +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE NULL NULL NULL NULL NULL NULL NULL NULL Impossible HAVING Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 0 explain extended select * from t1 having 1; -id select_type table type possible_keys key key_len ref rows Extra -1 SIMPLE t1 system NULL NULL NULL NULL 1 +id select_type table type possible_keys key key_len ref rows filtered Extra +1 SIMPLE t1 system NULL NULL NULL NULL 1 100.00 Warnings: Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 1 drop view v1; diff --git a/mysql-test/r/func_in.result b/mysql-test/r/func_in.result index dab44fa3dab..7a8f59c65f4 100644 --- a/mysql-test/r/func_in.result +++ b/mysql-test/r/func_in.result @@ -444,8 +444,14 @@ SELECT HEX(a) FROM t2 WHERE a IN 42); HEX(a) BB3C3E98175D33C8 +7FFFFFFFFFFFFEFF +7FFFFFFFFFFFFFEF +7FFFFFFFFFFFFFFE 7FFFFFFFFFFFFFFF 8000000000000000 +8000000000000001 +8000000000000002 +8000000000000300 8000000000000400 8000000000000401 SELECT HEX(a) FROM t2 WHERE a IN (0x7fffffffffffffff,0x8000000000000001); diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index 51ab8d5e139..2b6131cdf90 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -5832,4 +5832,17 @@ END| CALL bug24117()| DROP PROCEDURE bug24117| DROP TABLE t3| +DROP FUNCTION IF EXISTS bug25373| +CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER +LANGUAGE SQL DETERMINISTIC +RETURN p1;| +CREATE TABLE t3 (f1 INT, f2 FLOAT)| +INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)| +SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP| +SUM(f2) bug25373(f1) +6.3000000715256 1 +15 2 +21.300000071526 NULL +DROP FUNCTION bug25373| +DROP TABLE t3| drop table t1,t2; From 7665f50e9c27fef825d0acf3d639478633311615 Mon Sep 17 00:00:00 2001 From: "df@pippilotta.erinye.com" <> Date: Thu, 8 Mar 2007 18:12:16 +0100 Subject: [PATCH 35/73] add comment to compiler_warnings.supp --- support-files/compiler_warnings.supp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/support-files/compiler_warnings.supp b/support-files/compiler_warnings.supp index a147255f9a4..d6c4bcee52a 100644 --- a/support-files/compiler_warnings.supp +++ b/support-files/compiler_warnings.supp @@ -1,3 +1,8 @@ +# +# This file contains compiler warnings that can +# be ignored for various reasons. +# + integer.cpp: .*control reaches end of non-void function.*: 1288-1427 DictTabInfo.cpp : .*invalid access to non-static.* DictTabInfo.cpp : .*macro was used incorrectly.* From 90f23116e226eb842588cb8f639ac8ed52aa29d7 Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Thu, 8 Mar 2007 19:22:43 +0100 Subject: [PATCH 36/73] Bug#25673 - spatial index corruption, error 126 incorrect key file for table After backport fix. Added forgotten DBUG_RETURNs, which was detected in 5.1 only. --- myisam/rt_index.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/myisam/rt_index.c b/myisam/rt_index.c index 9c58f4ba5d2..fd988f320ff 100644 --- a/myisam/rt_index.c +++ b/myisam/rt_index.c @@ -636,14 +636,14 @@ static int rtree_insert_level(MI_INFO *info, uint keynr, uchar *key, int res; if ((old_root = _mi_new(info, keyinfo, DFLT_INIT_HITS)) == HA_OFFSET_ERROR) - return -1; + DBUG_RETURN(-1); info->buff_used = 1; mi_putint(info->buff, 2, 0); res = rtree_add_key(info, keyinfo, key, key_length, info->buff, NULL); if (_mi_write_keypage(info, keyinfo, old_root, DFLT_INIT_HITS, info->buff)) - return 1; + DBUG_RETURN(1); info->s->state.key_root[keynr] = old_root; - return res; + DBUG_RETURN(res); } switch ((res = rtree_insert_req(info, keyinfo, key, key_length, From 4752db40e8cd9e0d1dbd0ee6cd7d40cb60db562d Mon Sep 17 00:00:00 2001 From: "holyfoot/hf@mysql.com/hfmain.(none)" <> Date: Fri, 9 Mar 2007 13:37:06 +0400 Subject: [PATCH 37/73] aftermerge fix --- mysql-test/r/view.result | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result index 7f9353d56fe..dc87f97b322 100644 --- a/mysql-test/r/view.result +++ b/mysql-test/r/view.result @@ -3272,4 +3272,41 @@ a IS TRUE old_istrue a IS NOT TRUE old_isnottrue a IS FALSE old_isfalse a IS NOT drop view view_24532_a; drop view view_24532_b; drop table table_24532; +CREATE TABLE t1 ( +lid int NOT NULL PRIMARY KEY, +name char(10) NOT NULL +); +INSERT INTO t1 (lid, name) VALUES +(1, 'YES'), (2, 'NO'); +CREATE TABLE t2 ( +id int NOT NULL PRIMARY KEY, +gid int NOT NULL, +lid int NOT NULL, +dt date +); +INSERT INTO t2 (id, gid, lid, dt) VALUES +(1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'), +(3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02'); +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +lgid clid +1 NO +2 YES +CREATE VIEW v1 AS +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +SELECT * FROM v1; +lgid clid +1 NO +2 YES +DROP VIEW v1; +DROP table t1,t2; End of 5.0 tests. From 4ab2b8d7825783375a29b847be06e76fb9f0adde Mon Sep 17 00:00:00 2001 From: "holyfoot/hf@mysql.com/hfmain.(none)" <> Date: Fri, 9 Mar 2007 13:38:40 +0400 Subject: [PATCH 38/73] aftermerge fix --- mysql-test/r/sp.result | 13 +++++++++++++ mysql-test/r/view.result | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/mysql-test/r/sp.result b/mysql-test/r/sp.result index c73a44042c3..c46558fb08f 100644 --- a/mysql-test/r/sp.result +++ b/mysql-test/r/sp.result @@ -5857,4 +5857,17 @@ func_8407_b() 1500 drop function func_8407_a| drop function func_8407_b| +DROP FUNCTION IF EXISTS bug25373| +CREATE FUNCTION bug25373(p1 INTEGER) RETURNS INTEGER +LANGUAGE SQL DETERMINISTIC +RETURN p1;| +CREATE TABLE t3 (f1 INT, f2 FLOAT)| +INSERT INTO t3 VALUES (1, 3.4), (1, 2), (1, 0.9), (2, 8), (2, 7)| +SELECT SUM(f2), bug25373(f1) FROM t3 GROUP BY bug25373(f1) WITH ROLLUP| +SUM(f2) bug25373(f1) +6.3000000715256 1 +15 2 +21.300000071526 NULL +DROP FUNCTION bug25373| +DROP TABLE t3| drop table t1,t2; diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result index 30043e066db..bc0906b07f3 100644 --- a/mysql-test/r/view.result +++ b/mysql-test/r/view.result @@ -3263,6 +3263,43 @@ a IS TRUE old_istrue a IS NOT TRUE old_isnottrue a IS FALSE old_isfalse a IS NOT drop view view_24532_a; drop view view_24532_b; drop table table_24532; +CREATE TABLE t1 ( +lid int NOT NULL PRIMARY KEY, +name char(10) NOT NULL +); +INSERT INTO t1 (lid, name) VALUES +(1, 'YES'), (2, 'NO'); +CREATE TABLE t2 ( +id int NOT NULL PRIMARY KEY, +gid int NOT NULL, +lid int NOT NULL, +dt date +); +INSERT INTO t2 (id, gid, lid, dt) VALUES +(1, 1, 1, '2007-01-01'),(2, 1, 2, '2007-01-02'), +(3, 2, 2, '2007-02-01'),(4, 2, 1, '2007-02-02'); +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +lgid clid +1 NO +2 YES +CREATE VIEW v1 AS +SELECT DISTINCT t2.gid AS lgid, +(SELECT t1.name FROM t1, t2 +WHERE t1.lid = t2.lid AND t2.gid = lgid +ORDER BY t2.dt DESC LIMIT 1 +) as clid +FROM t2; +SELECT * FROM v1; +lgid clid +1 NO +2 YES +DROP VIEW v1; +DROP table t1,t2; End of 5.0 tests. DROP DATABASE IF EXISTS `d-1`; CREATE DATABASE `d-1`; From 96cfd5ab91d36ea225305cd997f661045686d5ff Mon Sep 17 00:00:00 2001 From: "igor@olga.mysql.com" <> Date: Fri, 9 Mar 2007 01:45:32 -0800 Subject: [PATCH 39/73] Fixed bug #26661: crash when order by clause in a union construct references invalid name. Derived tables currently cannot use outer references. Thus there is no outer context for them. The 4.1 code takes this fact into account while the Item_field::fix_outer_field code of 5.0 lost the check that blocks any attempts to resolve names in outer context for derived tables. --- mysql-test/r/union.result | 11 +++++++++++ mysql-test/t/union.test | 13 +++++++++++++ sql/item.cc | 7 ++++++- 3 files changed, 30 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/union.result b/mysql-test/r/union.result index dc174e35c8f..d7e222f845e 100644 --- a/mysql-test/r/union.result +++ b/mysql-test/r/union.result @@ -1370,4 +1370,15 @@ select _utf8'12' union select _latin1'12345'; 12 12 12345 +CREATE TABLE t1 (a int); +INSERT INTO t1 VALUES (3),(1),(2),(4),(1); +SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a) AS test; +a +1 +2 +3 +4 +SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY c) AS test; +ERROR 42S22: Unknown column 'c' in 'order clause' +DROP TABLE t1; End of 5.0 tests diff --git a/mysql-test/t/union.test b/mysql-test/t/union.test index bf5c5e066f0..29a9ee36481 100644 --- a/mysql-test/t/union.test +++ b/mysql-test/t/union.test @@ -855,4 +855,17 @@ drop table t1, t2; # select _utf8'12' union select _latin1'12345'; +# +# Bug #26661: UNION with ORDER BY undefined column in FROM list +# + +CREATE TABLE t1 (a int); +INSERT INTO t1 VALUES (3),(1),(2),(4),(1); + +SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY a) AS test; +--error 1054 +SELECT a FROM (SELECT a FROM t1 UNION SELECT a FROM t1 ORDER BY c) AS test; + +DROP TABLE t1; + --echo End of 5.0 tests diff --git a/sql/item.cc b/sql/item.cc index c5d8a62761c..80c3311b2a7 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -3441,7 +3441,12 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference) */ Name_resolution_context *last_checked_context= context; Item **ref= (Item **) not_found_item; - Name_resolution_context *outer_context= context->outer_context; + SELECT_LEX *current_sel= (SELECT_LEX *) thd->lex->current_select; + Name_resolution_context *outer_context= 0; + /* Currently derived tables cannot be correlated */ + if (current_sel->master_unit()->first_select()->linkage != + DERIVED_TABLE_TYPE) + outer_context= context->outer_context; for (; outer_context; outer_context= outer_context->outer_context) From 740a5fd7fe47f89d11d30d09e851b9ac4d28c2f5 Mon Sep 17 00:00:00 2001 From: "gkodinov/kgeorge@magare.gmz" <> Date: Fri, 9 Mar 2007 12:47:12 +0200 Subject: [PATCH 40/73] Bug #26281: Fixed boundry checks in the INSERT() function: were one off. --- mysql-test/r/func_str.result | 12 ++++++++++++ mysql-test/t/func_str.test | 8 ++++++++ sql/item_strfunc.cc | 10 +++++----- 3 files changed, 25 insertions(+), 5 deletions(-) diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result index d09d3aeb529..5e78e2572c1 100644 --- a/mysql-test/r/func_str.result +++ b/mysql-test/r/func_str.result @@ -1946,4 +1946,16 @@ NULL SELECT UNHEX('G') IS NULL; UNHEX('G') IS NULL 1 +SELECT INSERT('abc', 3, 3, '1234'); +INSERT('abc', 3, 3, '1234') +ab1234 +SELECT INSERT('abc', 4, 3, '1234'); +INSERT('abc', 4, 3, '1234') +abc1234 +SELECT INSERT('abc', 5, 3, '1234'); +INSERT('abc', 5, 3, '1234') +abc +SELECT INSERT('abc', 6, 3, '1234'); +INSERT('abc', 6, 3, '1234') +abc End of 5.0 tests diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test index 2e76dc2ca31..775e273b384 100644 --- a/mysql-test/t/func_str.test +++ b/mysql-test/t/func_str.test @@ -1014,4 +1014,12 @@ select lpad('abc', cast(5 as unsigned integer), 'x'); SELECT UNHEX('G'); SELECT UNHEX('G') IS NULL; +# +# Bug #26281: INSERT() function mishandles NUL on boundary condition +# +SELECT INSERT('abc', 3, 3, '1234'); +SELECT INSERT('abc', 4, 3, '1234'); +SELECT INSERT('abc', 5, 3, '1234'); +SELECT INSERT('abc', 6, 3, '1234'); + --echo End of 5.0 tests diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc index 385f4ad9770..8a2574bd248 100644 --- a/sql/item_strfunc.cc +++ b/sql/item_strfunc.cc @@ -967,18 +967,18 @@ String *Item_func_insert::val_str(String *str) args[3]->null_value) goto null; /* purecov: inspected */ - if ((start < 0) || (start > res->length() + 1)) + if ((start < 0) || (start > res->length())) return res; // Wrong param; skip insert - if ((length < 0) || (length > res->length() + 1)) - length= res->length() + 1; + if ((length < 0) || (length > res->length())) + length= res->length(); /* start and length are now sufficiently valid to pass to charpos function */ start= res->charpos((int) start); length= res->charpos((int) length, (uint32) start); /* Re-testing with corrected params */ - if (start > res->length() + 1) - return res; // Wrong param; skip insert + if (start > res->length()) + return res; /* purecov: inspected */ // Wrong param; skip insert if (length > res->length() - start) length= res->length() - start; From a8cd78dd051fdf0c3adee6742ddf99228fbd2be7 Mon Sep 17 00:00:00 2001 From: "tomas@poseidon.mysql.com" <> Date: Fri, 9 Mar 2007 20:29:46 +0700 Subject: [PATCH 41/73] Bug #26825 MySQL Server Crashes in high load Bug #26997 mysqld segfault when in single user mode --- sql/ha_ndbcluster.cc | 7 +++++++ storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp | 2 ++ storage/ndb/src/ndbapi/ndberror.c | 2 ++ 3 files changed, 11 insertions(+) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 0a7dc2ec32e..221d47a0da0 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -6093,9 +6093,16 @@ int ndbcluster_discover(handlerton *hton, THD* thd, const char *db, { const NdbError err= dict->getNdbError(); if (err.code == 709 || err.code == 723) + { error= -1; + DBUG_PRINT("info", ("ndb_error.code: %u", ndb_error.code)); + } else + { + error= -1; ndb_error= err; + DBUG_PRINT("info", ("ndb_error.code: %u", ndb_error.code)); + } goto err; } DBUG_PRINT("info", ("Found table %s", tab->getName())); diff --git a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp index ba2329888d2..c999c7ed919 100644 --- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp +++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp @@ -1753,6 +1753,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* sig, m_transporter->sendSignal(sig, node)); if(res != 0){ DBUG_PRINT("info", ("dictSignal failed to send signal")); + m_error.code = 4007; continue; } @@ -1770,6 +1771,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* sig, */ if(ret_val == -2) //WAIT_NODE_FAILURE { + m_error.code = 4013; continue; } if(m_waiter.m_state == WST_WAIT_TIMEOUT) diff --git a/storage/ndb/src/ndbapi/ndberror.c b/storage/ndb/src/ndbapi/ndberror.c index 8ed8727dd9e..85ec0db50a5 100644 --- a/storage/ndb/src/ndbapi/ndberror.c +++ b/storage/ndb/src/ndbapi/ndberror.c @@ -149,10 +149,12 @@ ErrorBundle ErrorCodes[] = { /** * Unknown result */ + { 4007, DMEC, UR, "Send to ndbd failed" }, { 4008, DMEC, UR, "Receive from NDB failed" }, { 4009, DMEC, UR, "Cluster Failure" }, { 4012, DMEC, UR, "Request ndbd time-out, maybe due to high load or communication problems"}, + { 4013, DMEC, UR, "Request timed out in waiting for node faiulure"}, { 4024, DMEC, UR, "Time-out, most likely caused by simple read or cluster failure" }, From 839f582969d649b88f00c2e9b59aad1e3b1c7877 Mon Sep 17 00:00:00 2001 From: "tomas@poseidon.mysql.com" <> Date: Fri, 9 Mar 2007 20:34:00 +0700 Subject: [PATCH 42/73] added error code for failing send signal and timeout waiting for node failure added error code for failing send signal and timeout waiting for node failure --- ndb/src/ndbapi/NdbDictionaryImpl.cpp | 4 ++++ ndb/src/ndbapi/ndberror.c | 2 ++ 2 files changed, 6 insertions(+) diff --git a/ndb/src/ndbapi/NdbDictionaryImpl.cpp b/ndb/src/ndbapi/NdbDictionaryImpl.cpp index c622332f11f..b3258d4d143 100644 --- a/ndb/src/ndbapi/NdbDictionaryImpl.cpp +++ b/ndb/src/ndbapi/NdbDictionaryImpl.cpp @@ -880,6 +880,7 @@ NdbDictInterface::dictSignal(NdbApiSignal* signal, r = m_transporter->sendSignal(signal, aNodeId); } if(r != 0){ + m_error.code= 4007; m_transporter->unlock_mutex(); continue; } @@ -903,7 +904,10 @@ NdbDictInterface::dictSignal(NdbApiSignal* signal, * Handle error codes */ if(m_waiter.m_state == WAIT_NODE_FAILURE) + { + m_error.code = 4013; continue; + } if(m_waiter.m_state == WST_WAIT_TIMEOUT) { diff --git a/ndb/src/ndbapi/ndberror.c b/ndb/src/ndbapi/ndberror.c index 15445620ce9..328b0688857 100644 --- a/ndb/src/ndbapi/ndberror.c +++ b/ndb/src/ndbapi/ndberror.c @@ -137,10 +137,12 @@ ErrorBundle ErrorCodes[] = { /** * Unknown result */ + { 4007, UR, "Send to ndbd node failed" }, { 4008, UR, "Receive from NDB failed" }, { 4009, UR, "Cluster Failure" }, { 4012, UR, "Request ndbd time-out, maybe due to high load or communication problems"}, + { 4013, UR, "Request timed out in waiting for node failure"}, { 4024, UR, "Time-out, most likely caused by simple read or cluster failure" }, From 1a07a15cb6b828148940e6c0de68ea991db78ecc Mon Sep 17 00:00:00 2001 From: "tomas@poseidon.mysql.com" <> Date: Fri, 9 Mar 2007 21:01:19 +0700 Subject: [PATCH 43/73] corrected returned error code --- mysql-test/r/ndb_single_user.result | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mysql-test/r/ndb_single_user.result b/mysql-test/r/ndb_single_user.result index 711d343fffb..771a02ecc84 100644 --- a/mysql-test/r/ndb_single_user.result +++ b/mysql-test/r/ndb_single_user.result @@ -1,7 +1,7 @@ use test; drop table if exists t1,t2,t3,t4,t5,t6,t7,t8,t9,t10; create table t1 (a int key, b int unique, c int) engine ndb; -ERROR HY000: Can't create table './test/t1.frm' (errno: 155) +ERROR HY000: Can't create table 'test.t1' (errno: 4007) create table t1 (a int key, b int unique, c int) engine ndb; insert into t1 values (1,1,0),(2,2,0),(3,3,0),(4,4,0),(5,5,0),(6,6,0),(7,7,0),(8,8,0),(9,9,0),(10,10,0); create table t2 as select * from t1; From af17853d5ece63376f5380fd07af1fee56b84117 Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Fri, 9 Mar 2007 16:19:42 +0100 Subject: [PATCH 44/73] Bug#25673 - spatial index corruption, error 126 incorrect key file for table Fixed a compiler warning, deteced by pushbuild only. --- myisam/rt_index.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/myisam/rt_index.c b/myisam/rt_index.c index fd988f320ff..238432006a4 100644 --- a/myisam/rt_index.c +++ b/myisam/rt_index.c @@ -978,7 +978,7 @@ int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length) } if (res) { - int j; + ulong j; DBUG_PRINT("rtree", ("root has been split, adjust levels")); for (j= i; j < ReinsertList.n_pages; j++) { From 04f5c46d5dd9911811bce2683b90e2acc711f94e Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Sat, 10 Mar 2007 00:29:02 +0300 Subject: [PATCH 45/73] Bug#22331: Wrong WHERE in EXPLAIN EXTENDED when all expressions were optimized away. Additional fix for bug#22331. Now Item_field prints its value in the case of the const field. --- mysql-test/r/explain.result | 6 +++--- mysql-test/r/func_default.result | 2 +- mysql-test/r/func_regexp.result | 2 +- mysql-test/r/func_str.result | 6 +++--- mysql-test/r/func_test.result | 2 +- mysql-test/r/having.result | 2 +- mysql-test/r/subselect.result | 22 +++++++++++----------- mysql-test/r/union.result | 2 +- mysql-test/r/varbinary.result | 2 +- sql/item.cc | 21 +++++++++++++++++++-- sql/item.h | 1 + sql/sql_union.cc | 6 ++++++ 12 files changed, 49 insertions(+), 25 deletions(-) diff --git a/mysql-test/r/explain.result b/mysql-test/r/explain.result index e0afaaef201..24ff44945bf 100644 --- a/mysql-test/r/explain.result +++ b/mysql-test/r/explain.result @@ -64,7 +64,7 @@ explain extended select * from v1 where f2=1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 +Note 1003 select '1' AS `f1`,'1' AS `f2` from `test`.`t1` where 1 explain extended select * from t1 where 0; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE @@ -74,7 +74,7 @@ explain extended select * from t1 where 1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` where 1 +Note 1003 select '1' AS `f1`,'1' AS `f2` from `test`.`t1` where 1 explain extended select * from t1 having 0; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible HAVING @@ -84,6 +84,6 @@ explain extended select * from t1 having 1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select `test`.`t1`.`f1` AS `f1`,`test`.`t1`.`f2` AS `f2` from `test`.`t1` having 1 +Note 1003 select '1' AS `f1`,'1' AS `f2` from `test`.`t1` having 1 drop view v1; drop table t1; diff --git a/mysql-test/r/func_default.result b/mysql-test/r/func_default.result index 5742ddd102b..84ead3b73c7 100644 --- a/mysql-test/r/func_default.result +++ b/mysql-test/r/func_default.result @@ -8,7 +8,7 @@ explain extended select default(str), default(strnull), default(intg), default(r id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select default(`test`.`t1`.`str`) AS `default(str)`,default(`test`.`t1`.`strnull`) AS `default(strnull)`,default(`test`.`t1`.`intg`) AS `default(intg)`,default(`test`.`t1`.`rel`) AS `default(rel)` from `test`.`t1` +Note 1003 select default('') AS `default(str)`,default('') AS `default(strnull)`,default('0') AS `default(intg)`,default('0') AS `default(rel)` from `test`.`t1` select * from t1 where str <> default(str); str strnull intg rel 0 0 diff --git a/mysql-test/r/func_regexp.result b/mysql-test/r/func_regexp.result index 787463c6aa3..584c8a9b820 100644 --- a/mysql-test/r/func_regexp.result +++ b/mysql-test/r/func_regexp.result @@ -40,7 +40,7 @@ explain extended select * from t1 where xxx regexp('is a test of some long text id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select `test`.`t1`.`xxx` AS `xxx` from `test`.`t1` where (`test`.`t1`.`xxx` regexp _latin1'is a test of some long text to') +Note 1003 select 'this is a test of some long text to see what happens' AS `xxx` from `test`.`t1` where ('this is a test of some long text to see what happens' regexp _latin1'is a test of some long text to') select * from t1 where xxx regexp('is a test of some long text to '); xxx this is a test of some long text to see what happens diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result index d09d3aeb529..02f883d8b43 100644 --- a/mysql-test/r/func_str.result +++ b/mysql-test/r/func_str.result @@ -1089,12 +1089,12 @@ explain extended select encode(f1,'zxcv') as 'enc' from t1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select encode(`test`.`t1`.`f1`,'zxcv') AS `enc` from `test`.`t1` +Note 1003 select encode('','zxcv') AS `enc` from `test`.`t1` explain extended select decode(f1,'zxcv') as 'enc' from t1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select decode(`test`.`t1`.`f1`,'zxcv') AS `enc` from `test`.`t1` +Note 1003 select decode('','zxcv') AS `enc` from `test`.`t1` drop table t1; End of 4.1 tests create table t1 (d decimal default null); @@ -1158,7 +1158,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t2 const PRIMARY PRIMARY 12 const 1 Using index 1 SIMPLE t1 ref code code 13 const 3 Using where; Using index Warnings: -Note 1003 select `test`.`t1`.`code` AS `code`,`test`.`t2`.`id` AS `id` from `test`.`t1` join `test`.`t2` where ((`test`.`t1`.`code` = _latin1'a12') and (length(`test`.`t1`.`code`) = 5)) +Note 1003 select `test`.`t1`.`code` AS `code`,'a12' AS `id` from `test`.`t1` join `test`.`t2` where ((`test`.`t1`.`code` = _latin1'a12') and (length(`test`.`t1`.`code`) = 5)) DROP TABLE t1,t2; select locate('he','hello',-2); locate('he','hello',-2) diff --git a/mysql-test/r/func_test.result b/mysql-test/r/func_test.result index c3fbdb3b3bf..65293398155 100644 --- a/mysql-test/r/func_test.result +++ b/mysql-test/r/func_test.result @@ -87,7 +87,7 @@ explain extended select - a from t1; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 select -(`test`.`t1`.`a`) AS `- a` from `test`.`t1` +Note 1003 select -('1') AS `- a` from `test`.`t1` drop table t1; select 5 between 0 and 10 between 0 and 1,(5 between 0 and 10) between 0 and 1; 5 between 0 and 10 between 0 and 1 (5 between 0 and 10) between 0 and 1 diff --git a/mysql-test/r/having.result b/mysql-test/r/having.result index 68b13b5fc0a..9b131109809 100644 --- a/mysql-test/r/having.result +++ b/mysql-test/r/having.result @@ -12,7 +12,7 @@ explain extended select count(a) as b from t1 where a=0 having b >=0; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE NULL NULL NULL NULL NULL NULL NULL Impossible WHERE noticed after reading const tables Warnings: -Note 1003 select count(`test`.`t1`.`a`) AS `b` from `test`.`t1` where 0 having (`b` >= 0) +Note 1003 select count('0') AS `b` from `test`.`t1` where 0 having (`b` >= 0) drop table t1; CREATE TABLE t1 ( raw_id int(10) NOT NULL default '0', diff --git a/mysql-test/r/subselect.result b/mysql-test/r/subselect.result index 373d49c29d2..79d29a90b2b 100644 --- a/mysql-test/r/subselect.result +++ b/mysql-test/r/subselect.result @@ -50,7 +50,7 @@ id select_type table type possible_keys key key_len ref rows Extra Warnings: Note 1276 Field or reference 'a' of SELECT #3 was resolved in SELECT #1 Note 1276 Field or reference 'b.a' of SELECT #3 was resolved in SELECT #1 -Note 1003 select 1 AS `1` from (select 1 AS `a`) `b` having ((select `b`.`a` AS `a`) = 1) +Note 1003 select 1 AS `1` from (select 1 AS `a`) `b` having ((select '1' AS `a`) = 1) SELECT 1 FROM (SELECT 1 as a) as b HAVING (SELECT a)=1; 1 1 @@ -204,7 +204,7 @@ id select_type table type possible_keys key key_len ref rows Extra 3 DERIVED t2 ALL NULL NULL NULL NULL 2 Using where 2 SUBQUERY t3 ALL NULL NULL NULL NULL 3 Using where; Using filesort Warnings: -Note 1003 select (select `test`.`t3`.`a` AS `a` from `test`.`t3` where (`test`.`t3`.`a` < 8) order by 1 desc limit 1) AS `(select t3.a from t3 where a<8 order by 1 desc limit 1)`,`tt`.`a` AS `a` from (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` > 1)) `tt` +Note 1003 select (select `test`.`t3`.`a` AS `a` from `test`.`t3` where (`test`.`t3`.`a` < 8) order by 1 desc limit 1) AS `(select t3.a from t3 where a<8 order by 1 desc limit 1)`,'2' AS `a` from (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` > 1)) `tt` select * from t1 where t1.a=(select t2.a from t2 where t2.b=(select max(a) from t3) order by 1 desc limit 1); a 2 @@ -315,7 +315,7 @@ NULL UNION RESULT ALL NULL NULL NULL NULL NULL Warnings: Note 1276 Field or reference 'test.t2.a' of SELECT #2 was resolved in SELECT #1 Note 1276 Field or reference 'test.t2.a' of SELECT #3 was resolved in SELECT #1 -Note 1003 select (select `test`.`t1`.`a` AS `a` from `test`.`t1` where (`test`.`t1`.`a` = `test`.`t2`.`a`) union select `test`.`t5`.`a` AS `a` from `test`.`t5` where (`test`.`t5`.`a` = `test`.`t2`.`a`)) AS `(select a from t1 where t1.a=t2.a union select a from t5 where t5.a=t2.a)`,`test`.`t2`.`a` AS `a` from `test`.`t2` +Note 1003 select (select '2' AS `a` from `test`.`t1` where ('2' = `test`.`t2`.`a`) union select `test`.`t5`.`a` AS `a` from `test`.`t5` where (`test`.`t5`.`a` = `test`.`t2`.`a`)) AS `(select a from t1 where t1.a=t2.a union select a from t5 where t5.a=t2.a)`,`test`.`t2`.`a` AS `a` from `test`.`t2` select (select a from t1 where t1.a=t2.a union all select a from t5 where t5.a=t2.a), a from t2; ERROR 21000: Subquery returns more than 1 row create table t6 (patient_uq int, clinic_uq int, index i1 (clinic_uq)); @@ -368,7 +368,7 @@ id select_type table type possible_keys key key_len ref rows Extra 2 SUBQUERY t8 const PRIMARY PRIMARY 37 const 1 3 SUBQUERY t8 const PRIMARY PRIMARY 37 1 Using index Warnings: -Note 1003 select `test`.`t8`.`pseudo` AS `pseudo`,(select `test`.`t8`.`email` AS `email` from `test`.`t8` where 1) AS `(SELECT email FROM t8 WHERE pseudo=(SELECT pseudo FROM t8 WHERE pseudo='joce'))` from `test`.`t8` where 1 +Note 1003 select 'joce' AS `pseudo`,(select 'test' AS `email` from `test`.`t8` where 1) AS `(SELECT email FROM t8 WHERE pseudo=(SELECT pseudo FROM t8 WHERE pseudo='joce'))` from `test`.`t8` where 1 SELECT pseudo FROM t8 WHERE pseudo=(SELECT pseudo,email FROM t8 WHERE pseudo='joce'); ERROR 21000: Operand should contain 1 column(s) @@ -547,7 +547,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t1 const PRIMARY,numreponse PRIMARY 7 const,const 1 Using index 2 SUBQUERY NULL NULL NULL NULL NULL NULL NULL Select tables optimized away Warnings: -Note 1003 select `test`.`t1`.`numreponse` AS `numreponse` from `test`.`t1` where ((`test`.`t1`.`numeropost` = _latin1'1')) +Note 1003 select '3' AS `numreponse` from `test`.`t1` where (('1' = _latin1'1')) drop table t1; CREATE TABLE t1 (a int(1)); INSERT INTO t1 VALUES (1); @@ -1430,7 +1430,7 @@ explain extended (select * from t1); id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 system NULL NULL NULL NULL 1 Warnings: -Note 1003 (select `test`.`t1`.`s1` AS `s1` from `test`.`t1`) +Note 1003 (select 'tttt' AS `s1` from `test`.`t1`) (select * from t1); s1 tttt @@ -1497,7 +1497,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t3 ALL NULL NULL NULL NULL 3 Using where 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` < (select max(`test`.`t2`.`b`) from `test`.`t2`))) +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` < (select max('0') from `test`.`t2`))) select * from t3 where a >= some (select b from t2); a explain extended select * from t3 where a >= some (select b from t2); @@ -1505,7 +1505,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t3 ALL NULL NULL NULL NULL 3 Using where 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` >= (select min(`test`.`t2`.`b`) from `test`.`t2`))) +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` >= (select min('0') from `test`.`t2`))) select * from t3 where a >= all (select b from t2 group by 1); a 6 @@ -1516,7 +1516,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t3 ALL NULL NULL NULL NULL 3 Using where 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` < (select `test`.`t2`.`b` AS `b` from `test`.`t2` group by 1))) +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` < (select '0' AS `b` from `test`.`t2` group by 1))) select * from t3 where a >= some (select b from t2 group by 1); a explain extended select * from t3 where a >= some (select b from t2 group by 1); @@ -1524,7 +1524,7 @@ id select_type table type possible_keys key key_len ref rows Extra 1 PRIMARY t3 ALL NULL NULL NULL NULL 3 Using where 2 SUBQUERY t2 system NULL NULL NULL NULL 0 const row not found Warnings: -Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` >= (select `test`.`t2`.`b` AS `b` from `test`.`t2` group by 1))) +Note 1003 select `test`.`t3`.`a` AS `a` from `test`.`t3` where ((`test`.`t3`.`a` >= (select '0' AS `b` from `test`.`t2` group by 1))) select * from t3 where NULL >= any (select b from t2); a explain extended select * from t3 where NULL >= any (select b from t2); @@ -1618,7 +1618,7 @@ id select_type table type possible_keys key key_len ref rows Extra 3 UNION t1 system NULL NULL NULL NULL 1 NULL UNION RESULT ALL NULL NULL NULL NULL NULL Warnings: -Note 1003 select `test`.`t1`.`s1` AS `s1` from `test`.`t1` where 1 +Note 1003 select 'e' AS `s1` from `test`.`t1` where 1 drop table t1; CREATE TABLE t1 (number char(11) NOT NULL default '') ENGINE=MyISAM CHARSET=latin1; INSERT INTO t1 VALUES ('69294728265'),('18621828126'),('89356874041'),('95895001874'); diff --git a/mysql-test/r/union.result b/mysql-test/r/union.result index dc174e35c8f..602fc08e9fd 100644 --- a/mysql-test/r/union.result +++ b/mysql-test/r/union.result @@ -480,7 +480,7 @@ id select_type table type possible_keys key key_len ref rows Extra 2 UNION t2 const PRIMARY PRIMARY 4 const 1 NULL UNION RESULT ALL NULL NULL NULL NULL NULL Warnings: -Note 1003 (select `test`.`t1`.`a` AS `a`,`test`.`t1`.`b` AS `b` from `test`.`t1` where (`test`.`t1`.`a` = 1)) union (select `test`.`t2`.`a` AS `a`,`test`.`t2`.`b` AS `b` from `test`.`t2` where (`test`.`t2`.`a` = 1)) +Note 1003 (select '1' AS `a`,'1' AS `b` from `test`.`t1` where ('1' = 1)) union (select '1' AS `a`,'10' AS `b` from `test`.`t2` where ('1' = 1)) (select * from t1 where a=5) union (select * from t2 where a=1); a b 1 10 diff --git a/mysql-test/r/varbinary.result b/mysql-test/r/varbinary.result index 2b8a9c625a5..a41885a257d 100644 --- a/mysql-test/r/varbinary.result +++ b/mysql-test/r/varbinary.result @@ -15,7 +15,7 @@ explain extended select * from t1 where UNIQ=0x38afba1d73e6a18a; id select_type table type possible_keys key key_len ref rows Extra 1 SIMPLE t1 const UNIQ UNIQ 8 const 1 Warnings: -Note 1003 select `test`.`t1`.`ID` AS `ID`,`test`.`t1`.`UNIQ` AS `UNIQ` from `test`.`t1` where 1 +Note 1003 select '00000001' AS `ID`,'004084688022709641610' AS `UNIQ` from `test`.`t1` where 1 drop table t1; select x'hello'; ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'x'hello'' at line 1 diff --git a/sql/item.cc b/sql/item.cc index c5d8a62761c..d7faa5f598e 100644 --- a/sql/item.cc +++ b/sql/item.cc @@ -1758,9 +1758,10 @@ void Item_ident::print(String *str) } } - if (!table_name || !field_name) + if (!table_name || !field_name || !field_name[0]) { - const char *nm= field_name ? field_name : name ? name : "tmp_field"; + const char *nm= (field_name && field_name[0]) ? + field_name : name ? name : "tmp_field"; append_identifier(thd, str, nm, (uint) strlen(nm)); return; } @@ -4900,6 +4901,22 @@ Item *Item_field::update_value_transformer(byte *select_arg) } +void Item_field::print(String *str) +{ + if (field && field->table->const_table) + { + char buff[MAX_FIELD_WIDTH]; + String tmp(buff,sizeof(buff),str->charset()); + field->val_str(&tmp); + str->append('\''); + str->append(tmp); + str->append('\''); + return; + } + Item_ident::print(str); +} + + Item_ref::Item_ref(Name_resolution_context *context_arg, Item **item, const char *table_name_arg, const char *field_name_arg, diff --git a/sql/item.h b/sql/item.h index 2a121523423..fb1a87d54fa 100644 --- a/sql/item.h +++ b/sql/item.h @@ -1303,6 +1303,7 @@ public: Item *safe_charset_converter(CHARSET_INFO *tocs); int fix_outer_field(THD *thd, Field **field, Item **reference); virtual Item *update_value_transformer(byte *select_arg); + void print(String *str); friend class Item_default_value; friend class Item_insert_value; friend class st_select_lex_unit; diff --git a/sql/sql_union.cc b/sql/sql_union.cc index 16df0059217..1ec724a6338 100644 --- a/sql/sql_union.cc +++ b/sql/sql_union.cc @@ -621,6 +621,12 @@ bool st_select_lex_unit::cleanup() join->tables= 0; } error|= fake_select_lex->cleanup(); + if (fake_select_lex->order_list.elements) + { + ORDER *ord; + for (ord= (ORDER*)fake_select_lex->order_list.first; ord; ord= ord->next) + (*ord->item)->cleanup(); + } } DBUG_RETURN(error); From 24a816e8134e8a96eccb7371d835e4ddf4c3462a Mon Sep 17 00:00:00 2001 From: "knielsen@ymer.(none)" <> Date: Fri, 9 Mar 2007 23:37:33 +0100 Subject: [PATCH 46/73] BUG#27018: Partial blob write inside blob clobbers data after the write. When doing partial blob update with NdbBlob::writeData(), zero-padding after the write was wrongly done, causing part of the old blob value to be overwritten with zeros (or spaces for text field). Fixed by only padding when needed (when writing at end of the blob). --- ndb/src/ndbapi/NdbBlob.cpp | 4 ++- ndb/test/ndbapi/testBlobs.cpp | 54 ++++++++++++++++++++++++++++++++++- 2 files changed, 56 insertions(+), 2 deletions(-) diff --git a/ndb/src/ndbapi/NdbBlob.cpp b/ndb/src/ndbapi/NdbBlob.cpp index 00b7441a37c..f0e6bf2e720 100644 --- a/ndb/src/ndbapi/NdbBlob.cpp +++ b/ndb/src/ndbapi/NdbBlob.cpp @@ -800,7 +800,9 @@ NdbBlob::writeDataPrivate(const char* buf, Uint32 bytes) DBUG_RETURN(-1); Uint32 n = thePartSize - off; if (n > len) { - memset(thePartBuf.data + off + len, theFillChar, n - len); + /* If we are adding data at the end, fill rest of part. */ + if (pos + len >= theLength) + memset(thePartBuf.data + off + len, theFillChar, n - len); n = len; } memcpy(thePartBuf.data + off, buf, n); diff --git a/ndb/test/ndbapi/testBlobs.cpp b/ndb/test/ndbapi/testBlobs.cpp index 81072f6a12a..bc703d64f21 100644 --- a/ndb/test/ndbapi/testBlobs.cpp +++ b/ndb/test/ndbapi/testBlobs.cpp @@ -138,6 +138,7 @@ printusage() << " 2 readData / writeData" << endl << "bug tests (no blob test)" << endl << " -bug 4088 ndb api hang with mixed ops on index table" << endl + << " -bug 27018 middle partial part write clobbers rest of part" << endl << " -bug nnnn delete + write gives 626" << endl << " -bug nnnn acc crash on delete and long key" << endl ; @@ -1806,6 +1807,56 @@ bugtest_4088() return 0; } +static int +bugtest_27018() +{ + DBG("bug test 27018 - middle partial part write clobbers rest of part"); + + // insert rows + calcTups(false); + CHK(insertPk(false) == 0); + // new trans + for (unsigned k= 0; k < g_opt.m_rows; k++) + { + Tup& tup= g_tups[k]; + + CHK((g_con= g_ndb->startTransaction()) != 0); + CHK((g_opr= g_con->getNdbOperation(g_opt.m_tname)) != 0); + CHK(g_opr->updateTuple() == 0); + CHK(g_opr->equal("PK1", tup.m_pk1) == 0); + if (g_opt.m_pk2len != 0) + CHK(g_opr->equal("PK2", tup.m_pk2) == 0); + CHK(getBlobHandles(g_opr) == 0); + CHK(g_con->execute(NoCommit) == 0); + + /* Update one byte in random position. */ + Uint32 offset= urandom(tup.m_blob1.m_len); + tup.m_blob1.m_buf[0]= 0xff ^ tup.m_blob1.m_val[offset]; + CHK(g_bh1->setPos(offset) == 0); + CHK(g_bh1->writeData(&(tup.m_blob1.m_buf[0]), 1) == 0); + CHK(g_con->execute(Commit) == 0); + g_ndb->closeTransaction(g_con); + + CHK((g_con= g_ndb->startTransaction()) != 0); + CHK((g_opr= g_con->getNdbOperation(g_opt.m_tname)) != 0); + CHK(g_opr->readTuple() == 0); + CHK(g_opr->equal("PK1", tup.m_pk1) == 0); + if (g_opt.m_pk2len != 0) + CHK(g_opr->equal("PK2", tup.m_pk2) == 0); + CHK(getBlobHandles(g_opr) == 0); + + CHK(g_bh1->getValue(tup.m_blob1.m_buf, tup.m_blob1.m_len) == 0); + CHK(g_con->execute(Commit) == 0); + Uint64 len= ~0; + CHK(g_bh1->getLength(len) == 0 && len == tup.m_blob1.m_len); + tup.m_blob1.m_buf[offset]^= 0xff; + CHK(memcmp(tup.m_blob1.m_buf, tup.m_blob1.m_val, tup.m_blob1.m_len) == 0); + g_ndb->closeTransaction(g_con); + } + + return 0; +} + static int bugtest_2222() { @@ -1822,7 +1873,8 @@ static struct { int m_bug; int (*m_test)(); } g_bugtest[] = { - { 4088, bugtest_4088 } + { 4088, bugtest_4088 }, + { 27018, bugtest_27018 } }; NDB_COMMAND(testOdbcDriver, "testBlobs", "testBlobs", "testBlobs", 65535) From 9ef9bfddd468782682e53dd0892a460bb7e316b6 Mon Sep 17 00:00:00 2001 From: "tomas@poseidon.mysql.com" <> Date: Sat, 10 Mar 2007 11:46:20 +0700 Subject: [PATCH 47/73] disabling _new_ unstable test case --- mysql-test/t/disabled.def | 1 + 1 file changed, 1 insertion(+) diff --git a/mysql-test/t/disabled.def b/mysql-test/t/disabled.def index df56165950f..2116e9f51e0 100644 --- a/mysql-test/t/disabled.def +++ b/mysql-test/t/disabled.def @@ -12,3 +12,4 @@ ndb_load : Bug#17233 user_limits : Bug#23921 random failure of user_limits.test +ndb_single_user : Bug#27021 Error codes in mysqld in single user mode varies From ec4593f59a6fabd69fdea20c2f77bb5c4c775eb6 Mon Sep 17 00:00:00 2001 From: "igor@olga.mysql.com" <> Date: Sat, 10 Mar 2007 02:47:47 -0800 Subject: [PATCH 48/73] Fixed bug #26830: a crash for the query with a subselect containing ROLLUP. Crash happened because the function get_best_group_min_max detected joins with ROLLUP incorrectly. --- mysql-test/r/olap.result | 9 +++++++++ mysql-test/t/olap.test | 15 +++++++++++++++ sql/opt_range.cc | 2 +- 3 files changed, 25 insertions(+), 1 deletion(-) diff --git a/mysql-test/r/olap.result b/mysql-test/r/olap.result index a392de613f8..91cd15295c3 100644 --- a/mysql-test/r/olap.result +++ b/mysql-test/r/olap.result @@ -645,3 +645,12 @@ a LENGTH(a) COUNT(*) NULL NULL 2 DROP VIEW v1; DROP TABLE t1; +CREATE TABLE t1 (a int, KEY (a)); +INSERT INTO t1 VALUES (3), (1), (4), (1), (3), (1), (1); +SELECT * FROM (SELECT a, SUM(a) FROM t1 GROUP BY a WITH ROLLUP) as t; +a SUM(a) +1 4 +3 6 +4 4 +NULL 14 +DROP TABLE t1; diff --git a/mysql-test/t/olap.test b/mysql-test/t/olap.test index 4e5e7b72fc8..e6cbfe3166c 100644 --- a/mysql-test/t/olap.test +++ b/mysql-test/t/olap.test @@ -327,3 +327,18 @@ SELECT * FROM v1; DROP VIEW v1; DROP TABLE t1; + +# +# Bug #26830: derived table with ROLLUP +# + +CREATE TABLE t1 (a int, KEY (a)); +INSERT INTO t1 VALUES (3), (1), (4), (1), (3), (1), (1); + +SELECT * FROM (SELECT a, SUM(a) FROM t1 GROUP BY a WITH ROLLUP) as t; + +DROP TABLE t1; + + + + diff --git a/sql/opt_range.cc b/sql/opt_range.cc index dfb3af87c29..0e284850cbe 100644 --- a/sql/opt_range.cc +++ b/sql/opt_range.cc @@ -7504,7 +7504,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree) if ((join->tables != 1) || /* The query must reference one table. */ ((!join->group_list) && /* Neither GROUP BY nor a DISTINCT query. */ (!join->select_distinct)) || - (thd->lex->select_lex.olap == ROLLUP_TYPE)) /* Check (B3) for ROLLUP */ + (join->select_lex->olap == ROLLUP_TYPE)) /* Check (B3) for ROLLUP */ DBUG_RETURN(NULL); if (table->s->keys == 0) /* There are no indexes to use. */ DBUG_RETURN(NULL); From 6f6b9ae3ada5de135228eed2ccc8281c9f989be7 Mon Sep 17 00:00:00 2001 From: "evgen@moonbone.local" <> Date: Sat, 10 Mar 2007 19:55:34 +0300 Subject: [PATCH 49/73] Bug#15757: Wrong SUBSTRING() result when a tmp table was employed. When the SUBSTRING() function was used over a LONGTEXT field the max_length of the SUBSTRING() result was wrongly calculated and set to 0. As the max_length parameter is used while tmp field creation it limits the length of the result field and leads to printing an empty string instead of the correct result. Now the Item_func_substr::fix_length_and_dec() function correctly calculates the max_length parameter. --- mysql-test/r/func_str.result | 11 +++++++++++ mysql-test/t/func_str.test | 11 +++++++++++ sql/item_strfunc.cc | 7 +++---- 3 files changed, 25 insertions(+), 4 deletions(-) diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result index d09d3aeb529..1ecdea851ce 100644 --- a/mysql-test/r/func_str.result +++ b/mysql-test/r/func_str.result @@ -1946,4 +1946,15 @@ NULL SELECT UNHEX('G') IS NULL; UNHEX('G') IS NULL 1 +create table t1(f1 longtext); +insert into t1 values ("123"),("456"); +select substring(f1,1,1) from t1 group by 1; +substring(f1,1,1) +1 +4 +create table t2(f1 varchar(3)); +insert into t1 values ("123"),("456"); +select substring(f1,4,1), substring(f1,-4,1) from t2; +substring(f1,4,1) substring(f1,-4,1) +drop table t1,t2; End of 5.0 tests diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test index 2e76dc2ca31..4b44669cb91 100644 --- a/mysql-test/t/func_str.test +++ b/mysql-test/t/func_str.test @@ -1014,4 +1014,15 @@ select lpad('abc', cast(5 as unsigned integer), 'x'); SELECT UNHEX('G'); SELECT UNHEX('G') IS NULL; +# +# Bug#15757: Wrong SUBSTRING() result when a tmp table was employed. +# +create table t1(f1 longtext); +insert into t1 values ("123"),("456"); +select substring(f1,1,1) from t1 group by 1; +create table t2(f1 varchar(3)); +insert into t1 values ("123"),("456"); +select substring(f1,4,1), substring(f1,-4,1) from t2; +drop table t1,t2; + --echo End of 5.0 tests diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc index 385f4ad9770..1d1f433789b 100644 --- a/sql/item_strfunc.cc +++ b/sql/item_strfunc.cc @@ -1184,11 +1184,10 @@ void Item_func_substr::fix_length_and_dec() if (args[1]->const_item()) { int32 start= (int32) args[1]->val_int(); - start= (int32)((start < 0) ? max_length + start : start - 1); - if (start < 0 || start >= (int32) max_length) - max_length=0; /* purecov: inspected */ + if (start < 0) + max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start); else - max_length-= (uint) start; + max_length-= min((uint)(start - 1), max_length); } if (arg_count == 3 && args[2]->const_item()) { From 4e4f18417024c5d2349417048defa35ebf5dc971 Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Mon, 12 Mar 2007 13:12:42 +0100 Subject: [PATCH 50/73] Makefile.am, configure.in, mysys.dsp: Removed unused files .del-my_winsem.c: Delete: mysys/my_winsem.c .del-my_semaphore.c: Delete: mysys/my_semaphore.c .del-my_semaphore.h: Delete: include/my_semaphore.h --- VC++Files/mysys/mysys.dsp | 4 - configure.in | 3 - include/Makefile.am | 2 +- include/my_semaphore.h | 64 ------ mysys/Makefile.am | 2 +- mysys/my_semaphore.c | 104 ---------- mysys/my_winsem.c | 406 -------------------------------------- 7 files changed, 2 insertions(+), 583 deletions(-) delete mode 100644 include/my_semaphore.h delete mode 100644 mysys/my_semaphore.c delete mode 100644 mysys/my_winsem.c diff --git a/VC++Files/mysys/mysys.dsp b/VC++Files/mysys/mysys.dsp index c021adb8d9c..4ad4ca1c70b 100644 --- a/VC++Files/mysys/mysys.dsp +++ b/VC++Files/mysys/mysys.dsp @@ -508,10 +508,6 @@ SOURCE=.\my_wincond.c # End Source File # Begin Source File -SOURCE=.\my_winsem.c -# End Source File -# Begin Source File - SOURCE=.\my_winthread.c # End Source File # Begin Source File diff --git a/configure.in b/configure.in index f0307c7de2d..7b31057f6d3 100644 --- a/configure.in +++ b/configure.in @@ -772,9 +772,6 @@ AC_CHECK_FUNC(bind, , AC_CHECK_LIB(bind, bind)) AC_CHECK_LIB(crypt, crypt) AC_CHECK_FUNC(crypt, AC_DEFINE(HAVE_CRYPT)) -# For sem_xxx functions on Solaris 2.6 -AC_CHECK_FUNC(sem_init, , AC_CHECK_LIB(posix4, sem_init)) - # For compress in zlib case $SYSTEM_TYPE in *netware* | *modesto*) diff --git a/include/Makefile.am b/include/Makefile.am index bd1492766b1..2505eddb79b 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -18,7 +18,7 @@ BUILT_SOURCES = mysql_version.h m_ctype.h my_config.h pkginclude_HEADERS = my_dbug.h m_string.h my_sys.h my_list.h \ mysql.h mysql_com.h mysqld_error.h mysql_embed.h \ - my_semaphore.h my_pthread.h my_no_pthread.h raid.h \ + my_pthread.h my_no_pthread.h raid.h \ errmsg.h my_global.h my_net.h my_alloc.h \ my_getopt.h sslopt-longopts.h my_dir.h \ sslopt-vars.h sslopt-case.h $(BUILT_SOURCES) diff --git a/include/my_semaphore.h b/include/my_semaphore.h deleted file mode 100644 index 7f182bea6bf..00000000000 --- a/include/my_semaphore.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Module: semaphore.h - * - * Purpose: - * Semaphores aren't actually part of the PThreads standard. - * They are defined by the POSIX Standard: - * - * POSIX 1003.1b-1993 (POSIX.1b) - * - * Pthreads-win32 - POSIX Threads Library for Win32 - * Copyright (C) 1998 - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free - * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA - */ - -/* This is hacked by Monty to be included in mysys library */ - -#ifndef _my_semaphore_h_ -#define _my_semaphore_h_ - -#ifdef THREAD - -C_MODE_START -#ifdef HAVE_SEMAPHORE_H -#include -#elif !defined(__bsdi__) -#ifdef __WIN__ -typedef HANDLE sem_t; -#else -typedef struct { - pthread_mutex_t mutex; - pthread_cond_t cond; - uint count; -} sem_t; -#endif /* __WIN__ */ - -int sem_init(sem_t * sem, int pshared, unsigned int value); -int sem_destroy(sem_t * sem); -int sem_trywait(sem_t * sem); -int sem_wait(sem_t * sem); -int sem_post(sem_t * sem); -int sem_post_multiple(sem_t * sem, unsigned int count); -int sem_getvalue(sem_t * sem, unsigned int * sval); - -#endif /* !__bsdi__ */ - -C_MODE_END - -#endif /* THREAD */ - -#endif /* !_my_semaphore_h_ */ diff --git a/mysys/Makefile.am b/mysys/Makefile.am index 5dc54817fd7..68d5da5afe8 100644 --- a/mysys/Makefile.am +++ b/mysys/Makefile.am @@ -49,7 +49,7 @@ libmysys_a_SOURCES = my_init.c my_getwd.c mf_getdate.c\ my_quick.c my_lockmem.c my_static.c \ my_sync.c my_getopt.c my_mkdir.c \ default.c my_compress.c checksum.c raid.cc \ - my_net.c my_semaphore.c my_port.c my_sleep.c \ + my_net.c my_port.c my_sleep.c \ my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c \ my_gethostbyname.c rijndael.c my_aes.c sha1.c \ my_netware.c diff --git a/mysys/my_semaphore.c b/mysys/my_semaphore.c deleted file mode 100644 index aa216cbc289..00000000000 --- a/mysys/my_semaphore.c +++ /dev/null @@ -1,104 +0,0 @@ -/* Copyright (C) 2002 MySQL AB & MySQL Finland AB & TCX DataKonsult AB - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - -/* - Simple implementation of semaphores, needed to compile MySQL on systems - that doesn't support semaphores. -*/ - -#include -#include -#include - -#if !defined(__WIN__) && !defined(HAVE_SEMAPHORE_H) && defined(THREAD) - -int sem_init(sem_t * sem, int pshared, uint value) -{ - sem->count=value; - pthread_cond_init(&sem->cond, 0); - pthread_mutex_init(&sem->mutex, 0); - return 0; -} - -int sem_destroy(sem_t * sem) -{ - int err1,err2; - err1=pthread_cond_destroy(&sem->cond); - err2=pthread_mutex_destroy(&sem->mutex); - if (err1 || err2) - { - errno=err1 ? err1 : err2; - return -1; - } - return 0; -} - -int sem_wait(sem_t * sem) -{ - if ((errno=pthread_mutex_lock(&sem->mutex))) - return -1; - while (!sem->count) - pthread_cond_wait(&sem->cond, &sem->mutex); - if (errno) - return -1; - sem->count--; /* mutex is locked here */ - pthread_mutex_unlock(&sem->mutex); - return 0; -} - -int sem_trywait(sem_t * sem) -{ - if ((errno=pthread_mutex_lock(&sem->mutex))) - return -1; - if (sem->count) - sem->count--; - else - errno=EAGAIN; - pthread_mutex_unlock(&sem->mutex); - return errno ? -1 : 0; -} - - -int sem_post(sem_t * sem) -{ - if ((errno=pthread_mutex_lock(&sem->mutex))) - return -1; - sem->count++; - pthread_mutex_unlock(&sem->mutex); /* does it really matter what to do */ - pthread_cond_signal(&sem->cond); /* first: x_unlock or x_signal ? */ - return 0; -} - -int sem_post_multiple(sem_t * sem, uint count) -{ - if ((errno=pthread_mutex_lock(&sem->mutex))) - return -1; - sem->count+=count; - pthread_mutex_unlock(&sem->mutex); /* does it really matter what to do */ - pthread_cond_broadcast(&sem->cond); /* first: x_unlock or x_broadcast ? */ - return 0; -} - -int sem_getvalue(sem_t * sem, uint *sval) -{ - if ((errno=pthread_mutex_lock(&sem->mutex))) - return -1; - *sval=sem->count; - pthread_mutex_unlock(&sem->mutex); - return 0; -} - -#endif /* !defined(__WIN__) && !defined(HAVE_SEMAPHORE_H) && defined(THREAD) */ diff --git a/mysys/my_winsem.c b/mysys/my_winsem.c deleted file mode 100644 index e2713d189b2..00000000000 --- a/mysys/my_winsem.c +++ /dev/null @@ -1,406 +0,0 @@ -/* - * ------------------------------------------------------------- - * - * Module: my_semaphore.c (Original: semaphore.c from pthreads library) - * - * Purpose: - * Semaphores aren't actually part of the PThreads standard. - * They are defined by the POSIX Standard: - * - * POSIX 1003.1b-1993 (POSIX.1b) - * - * ------------------------------------------------------------- - * - * Pthreads-win32 - POSIX Threads Library for Win32 - * Copyright (C) 1998 - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Library General Public License for more details. - * - * You should have received a copy of the GNU Library General Public - * License along with this library; if not, write to the Free - * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA - */ - -/* - NEED_SEM is not used in MySQL and should only be needed under - Windows CE. - - The big changes compared to the original version was to not allocate - any additional memory in sem_init() but to instead store everthing - we need in sem_t. - - TODO: - To get HAVE_CREATESEMAPHORE we have to define the struct - in my_semaphore.h -*/ - -#include "mysys_priv.h" -#ifdef __WIN__ -#include "my_semaphore.h" -#include - -/* - DOCPUBLIC - This function initializes an unnamed semaphore. the - initial value of the semaphore is 'value' - - PARAMETERS - sem Pointer to an instance of sem_t - - pshared If zero, this semaphore may only be shared between - threads in the same process. - If nonzero, the semaphore can be shared between - processes - - value Initial value of the semaphore counter - - RESULTS - 0 Successfully created semaphore, - -1 Failed, error in errno - - ERRNO - EINVAL 'sem' is not a valid semaphore, - ENOSPC A required resource has been exhausted, - ENOSYS Semaphores are not supported, - EPERM The process lacks appropriate privilege - -*/ - -int -sem_init (sem_t *sem, int pshared, unsigned int value) -{ - int result = 0; - - if (pshared != 0) - { - /* - We don't support creating a semaphore that can be shared between - processes - */ - result = EPERM; - } - else - { -#ifndef HAVE_CREATESEMAPHORE - sem->value = value; - sem->event = CreateEvent(NULL, - FALSE, /* manual reset */ - FALSE, /* initial state */ - NULL); - if (!sem->event) - result = ENOSPC; - else - { - if (value) - SetEvent(sem->event); - InitializeCriticalSection(&sem->sem_lock_cs); - } -#else /* HAVE_CREATESEMAPHORE */ - *sem = CreateSemaphore (NULL, /* Always NULL */ - value, /* Initial value */ - 0x7FFFFFFFL, /* Maximum value */ - NULL); /* Name */ - if (!*sem) - result = ENOSPC; -#endif /* HAVE_CREATESEMAPHORE */ - } - if (result != 0) - { - errno = result; - return -1; - } - return 0; -} /* sem_init */ - - -/* - DOCPUBLIC - This function destroys an unnamed semaphore. - - PARAMETERS - sem Pointer to an instance of sem_t - - RESULTS - 0 Successfully destroyed semaphore, - -1 Failed, error in errno - ERRNO - EINVAL 'sem' is not a valid semaphore, - ENOSYS Semaphores are not supported, - EBUSY Threads (or processes) are currently blocked on 'sem' -*/ - -int -sem_destroy (sem_t * sem) -{ - int result = 0; - -#ifdef EXTRA_DEBUG - if (sem == NULL || *sem == NULL) - { - errno=EINVAL; - return; - } -#endif /* EXTRA_DEBUG */ - -#ifndef HAVE_CREATESEMAPHORE - if (! CloseHandle(sem->event)) - result = EINVAL; - else - DeleteCriticalSection(&sem->sem_lock_cs); -#else /* HAVE_CREATESEMAPHORE */ - if (!CloseHandle(*sem)) - result = EINVAL; -#endif /* HAVE_CREATESEMAPHORE */ - if (result) - { - errno = result; - return -1; - } - *sem=0; /* Safety */ - return 0; -} /* sem_destroy */ - - -/* - DOCPUBLIC - This function tries to wait on a semaphore. If the - semaphore value is greater than zero, it decreases - its value by one. If the semaphore value is zero, then - this function returns immediately with the error EAGAIN - - PARAMETERS - sem Pointer to an instance of sem_t - - RESULTS - 0 Successfully decreased semaphore, - -1 Failed, error in errno - - ERRNO - EAGAIN The semaphore was already locked, - EINVAL 'sem' is not a valid semaphore, - ENOSYS Semaphores are not supported, - EINTR The function was interrupted by a signal, - EDEADLK A deadlock condition was detected. -*/ - -int -sem_trywait(sem_t * sem) -{ -#ifndef HAVE_CREATESEMAPHORE - /* not yet implemented! */ - int errno = EINVAL; - return -1; -#else /* HAVE_CREATESEMAPHORE */ -#ifdef EXTRA_DEBUG - if (sem == NULL || *sem == NULL) - { - errno=EINVAL; - return -1; - } -#endif /* EXTRA_DEBUG */ - if (WaitForSingleObject (*sem, 0) == WAIT_TIMEOUT) - { - errno= EAGAIN; - return -1; - } - return 0; -#endif /* HAVE_CREATESEMAPHORE */ - -} /* sem_trywait */ - - -#ifndef HAVE_CREATESEMAPHORE - -static void -ptw32_decrease_semaphore(sem_t * sem) -{ - EnterCriticalSection(&sem->sem_lock_cs); - DBUG_ASSERT(sem->value != 0); - sem->value--; - if (sem->value != 0) - SetEvent(sem->event); - LeaveCriticalSection(&sem->sem_lock_cs); -} - -static BOOL -ptw32_increase_semaphore(sem_t * sem, unsigned int n) -{ - BOOL result=FALSE; - - EnterCriticalSection(&sem->sem_lock_cs); - if (sem->value + n > sem->value) - { - sem->value += n; - SetEvent(sem->event); - result = TRUE; - } - LeaveCriticalSection(&sem->sem_lock_cs); - return result; -} - -#endif /* HAVE_CREATESEMAPHORE */ - - -/* - ------------------------------------------------------ - DOCPUBLIC - This function waits on a semaphore. If the - semaphore value is greater than zero, it decreases - its value by one. If the semaphore value is zero, then - the calling thread (or process) is blocked until it can - successfully decrease the value or until interrupted by - a signal. - - PARAMETERS - sem Pointer to an instance of sem_t - - RESULTS - 0 Successfully decreased semaphore, - -1 Failed, error in errno - - ERRNO - EINVAL 'Sem' is not a valid semaphore, - ENOSYS Semaphores are not supported, - EINTR The function was interrupted by a signal, - EDEADLK A deadlock condition was detected. -*/ - -int -sem_wait(sem_t *sem) -{ - int result; - -#ifdef EXTRA_DEBUG - if (sem == NULL || *sem == NULL) - { - errno=EINVAL; - return -1; - } -#endif /* EXTRA_DEBUG */ - -#ifndef HAVE_CREATESEMAPHORE - result=WaitForSingleObject(sem->event, INFINITE); -#else - result=WaitForSingleObject(*sem, INFINITE); -#endif - if (result == WAIT_FAILED || result == WAIT_ABANDONED_0) - result = EINVAL; - else if (result == WAIT_TIMEOUT) - result = ETIMEDOUT; - else - result=0; - if (result) - { - errno = result; - return -1; - } -#ifndef HAVE_CREATESEMAPHORE - ptw32_decrease_semaphore(sem); -#endif /* HAVE_CREATESEMAPHORE */ - return 0; -} - - -/* - ------------------------------------------------------ - DOCPUBLIC - This function posts a wakeup to a semaphore. If there - are waiting threads (or processes), one is awakened; - otherwise, the semaphore value is incremented by one. - - PARAMETERS - sem Pointer to an instance of sem_t - - RESULTS - 0 Successfully posted semaphore, - -1 Failed, error in errno - - ERRNO - EINVAL 'sem' is not a valid semaphore, - ENOSYS Semaphores are not supported, - -*/ - -int -sem_post (sem_t * sem) -{ -#ifdef EXTRA_DEBUG - if (sem == NULL || *sem == NULL) - { - errno=EINVAL; - return -1; - } -#endif /* EXTRA_DEBUG */ - -#ifndef HAVE_CREATESEMAPHORE - if (! ptw32_increase_semaphore(sem, 1)) -#else /* HAVE_CREATESEMAPHORE */ - if (! ReleaseSemaphore(*sem, 1, 0)) -#endif /* HAVE_CREATESEMAPHORE */ - { - errno=EINVAL; - return -1; - } - return 0; -} - - -/* - ------------------------------------------------------ - DOCPUBLIC - This function posts multiple wakeups to a semaphore. If there - are waiting threads (or processes), n <= count are awakened; - the semaphore value is incremented by count - n. - - PARAMETERS - sem Pointer to an instance of sem_t - count Counter, must be greater than zero. - - RESULTS - 0 Successfully posted semaphore, - -1 Failed, error in errno - - ERRNO - EINVAL 'sem' is not a valid semaphore or count is less - than or equal to zero. -*/ - -int -sem_post_multiple (sem_t * sem, unsigned int count) -{ -#ifdef EXTRA_DEBUG - if (sem == NULL || *sem == NULL || count <= 0) - { - errno=EINVAL; - return -1; - } -#endif /* EXTRA_DEBUG */ -#ifndef HAVE_CREATESEMAPHORE - if (! ptw32_increase_semaphore (sem, count)) -#else /* HAVE_CREATESEMAPHORE */ - if (! ReleaseSemaphore(*sem, count, 0)) -#endif /* HAVE_CREATESEMAPHORE */ - { - errno = EINVAL; - return -1; - } - return 0; -} - -int -sem_getvalue (sem_t *sem, unsigned int *sval) -{ - errno = ENOSYS; - return -1; -} /* sem_getvalue */ - -#endif /* __WIN__ */ From e10e81d1545be8248d87f4e39215b531098923ca Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Mon, 12 Mar 2007 13:18:48 +0100 Subject: [PATCH 51/73] mysys_ia64.dsp, mysys.vcproj: Removed references to unused files --- VC++Files/mysys/mysys.vcproj | 43 ---------------------------------- VC++Files/mysys/mysys_ia64.dsp | 4 ---- 2 files changed, 47 deletions(-) diff --git a/VC++Files/mysys/mysys.vcproj b/VC++Files/mysys/mysys.vcproj index f728c47fb40..a7550b0b4bd 100644 --- a/VC++Files/mysys/mysys.vcproj +++ b/VC++Files/mysys/mysys.vcproj @@ -4094,49 +4094,6 @@ PreprocessorDefinitions=""/> - - - - - - - - - - - - - - - - - Date: Mon, 12 Mar 2007 14:52:37 +0100 Subject: [PATCH 52/73] Makefile.am, CMakeLists.txt: Removed references to my_winsem.c --- mysys/CMakeLists.txt | 2 +- mysys/Makefile.am | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/mysys/CMakeLists.txt b/mysys/CMakeLists.txt index 77933d57d21..f529b559fb0 100755 --- a/mysys/CMakeLists.txt +++ b/mysys/CMakeLists.txt @@ -39,7 +39,7 @@ ADD_LIBRARY(mysys array.c charset-def.c charset.c checksum.c default.c default_m my_mkdir.c my_mmap.c my_net.c my_once.c my_open.c my_pread.c my_pthread.c my_quick.c my_read.c my_realloc.c my_redel.c my_rename.c my_seek.c my_sleep.c my_static.c my_symlink.c my_symlink2.c my_sync.c my_thr_init.c my_wincond.c - my_windac.c my_winsem.c my_winthread.c my_write.c ptr_cmp.c queues.c + my_windac.c my_winthread.c my_write.c ptr_cmp.c queues.c rijndael.c safemalloc.c sha1.c string.c thr_alarm.c thr_lock.c thr_mutex.c thr_rwlock.c tree.c typelib.c base64.c my_memmem.c my_getpagesize.c) diff --git a/mysys/Makefile.am b/mysys/Makefile.am index d145b7faf86..a835492e670 100644 --- a/mysys/Makefile.am +++ b/mysys/Makefile.am @@ -58,7 +58,7 @@ libmysys_a_SOURCES = my_init.c my_getwd.c mf_getdate.c my_mmap.c \ my_windac.c my_access.c base64.c my_libwrap.c EXTRA_DIST = thr_alarm.c thr_lock.c my_pthread.c my_thr_init.c \ thr_mutex.c thr_rwlock.c mf_soundex.c my_conio.c \ - my_wincond.c my_winsem.c my_winthread.c CMakeLists.txt + my_wincond.c my_winthread.c CMakeLists.txt libmysys_a_LIBADD = @THREAD_LOBJECTS@ # test_dir_DEPENDENCIES= $(LIBRARIES) # testhash_DEPENDENCIES= $(LIBRARIES) From ab230132cab5f1810c09cb4ab6de8c39c1cb7925 Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Mon, 12 Mar 2007 14:55:45 +0100 Subject: [PATCH 53/73] CMakeLists.txt: Removed references to my_winsem.c --- mysys/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mysys/CMakeLists.txt b/mysys/CMakeLists.txt index c4d67f1e552..1ae625c4c03 100644 --- a/mysys/CMakeLists.txt +++ b/mysys/CMakeLists.txt @@ -39,6 +39,6 @@ ADD_LIBRARY(mysys array.c charset-def.c charset.c checksum.c default.c default_m my_mkdir.c my_mmap.c my_net.c my_once.c my_open.c my_pread.c my_pthread.c my_quick.c my_read.c my_realloc.c my_redel.c my_rename.c my_seek.c my_sleep.c my_static.c my_symlink.c my_symlink2.c my_sync.c my_thr_init.c my_wincond.c - my_windac.c my_winsem.c my_winthread.c my_write.c ptr_cmp.c queues.c + my_windac.c my_winthread.c my_write.c ptr_cmp.c queues.c rijndael.c safemalloc.c sha1.c string.c thr_alarm.c thr_lock.c thr_mutex.c thr_rwlock.c tree.c typelib.c my_vle.c base64.c my_memmem.c my_getpagesize.c) From 512202a88f683ef9b416b7f8d076eaef4e2aaee6 Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Mon, 12 Mar 2007 21:27:07 +0100 Subject: [PATCH 54/73] configure.in: Restored accidently removed line to check for zlib --- configure.in | 2 ++ 1 file changed, 2 insertions(+) diff --git a/configure.in b/configure.in index 34da88c33a7..6c239e3a1e7 100644 --- a/configure.in +++ b/configure.in @@ -845,6 +845,8 @@ AC_CHECK_FUNC(bind, , AC_CHECK_LIB(bind, bind)) # Check if crypt() exists in libc or libcrypt, sets LIBS if needed AC_SEARCH_LIBS(crypt, crypt, AC_DEFINE(HAVE_CRYPT, 1, [crypt])) +MYSQL_CHECK_ZLIB_WITH_COMPRESS + #-------------------------------------------------------------------- # Check for TCP wrapper support #-------------------------------------------------------------------- From c32b4084ec73053684a508f3032f788abf38f2da Mon Sep 17 00:00:00 2001 From: "Justin.He/justin.he@dev3-240.dev.cn.tlan" <> Date: Tue, 13 Mar 2007 18:13:06 +0800 Subject: [PATCH 55/73] BUG#25880, Adding new column to ndb_dd table moves data for non_indexed fields in memory correct the inconsistency between columns' storage type with table's storage_media & tablespace --- sql/ha_ndbcluster.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 86a2f9d8544..aa3de5311cf 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -4831,7 +4831,8 @@ int ha_ndbcluster::create(const char *name, if ((my_errno= create_ndb_column(col, field, create_info))) DBUG_RETURN(my_errno); - if (create_info->storage_media == HA_SM_DISK) + if (create_info->storage_media == HA_SM_DISK || + create_info->tablespace) col.setStorageType(NdbDictionary::Column::StorageTypeDisk); else col.setStorageType(NdbDictionary::Column::StorageTypeMemory); From e2853bddbc8072ad39075618e91ea82ec3fa36b1 Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Tue, 13 Mar 2007 11:29:14 +0100 Subject: [PATCH 56/73] ndb - bug#27003 Handle random(not in order) LQHKEYREQ failures during node-restart --- ndb/src/kernel/blocks/ERROR_codes.txt | 12 ++++ ndb/src/kernel/blocks/dblqh/DblqhMain.cpp | 19 ++++++- .../kernel/blocks/dbtup/DbtupExecQuery.cpp | 24 ++++++++ ndb/src/kernel/blocks/dbtup/DbtupGen.cpp | 2 +- ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp | 1 + ndb/test/ndbapi/testNodeRestart.cpp | 56 +++++++++++++++++++ ndb/test/run-test/daily-basic-tests.txt | 4 ++ 7 files changed, 114 insertions(+), 4 deletions(-) diff --git a/ndb/src/kernel/blocks/ERROR_codes.txt b/ndb/src/kernel/blocks/ERROR_codes.txt index f7cb49014cb..ed35db91738 100644 --- a/ndb/src/kernel/blocks/ERROR_codes.txt +++ b/ndb/src/kernel/blocks/ERROR_codes.txt @@ -489,3 +489,15 @@ Dbdict: 6003 Crash in participant @ CreateTabReq::Prepare 6004 Crash in participant @ CreateTabReq::Commit 6005 Crash in participant @ CreateTabReq::CreateDrop + +TUP: +---- + +4025: Fail all inserts with out of memory +4026: Fail one insert with oom +4027: Fail inserts randomly with oom +4028: Fail one random insert with oom + +NDBCNTR: + +1000: Crash insertion on SystemError::CopyFragRef diff --git a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp index 698e5ac292c..5847e1063aa 100644 --- a/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp +++ b/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp @@ -9641,6 +9641,15 @@ void Dblqh::copyCompletedLab(Signal* signal) closeCopyLab(signal); return; }//if + + if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY && + scanptr.p->scanErrorCounter) + { + jam(); + closeCopyLab(signal); + return; + } + if (scanptr.p->scanState == ScanRecord::WAIT_LQHKEY_COPY) { jam(); /*---------------------------------------------------------------------------*/ @@ -9717,13 +9726,16 @@ void Dblqh::continueCopyAfterBlockedLab(Signal* signal) void Dblqh::copyLqhKeyRefLab(Signal* signal) { ndbrequire(tcConnectptr.p->transid[1] == signal->theData[4]); - tcConnectptr.p->copyCountWords -= signal->theData[3]; + Uint32 copyWords = signal->theData[3]; scanptr.i = tcConnectptr.p->tcScanRec; c_scanRecordPool.getPtr(scanptr); scanptr.p->scanErrorCounter++; tcConnectptr.p->errorCode = terrorCode; - closeCopyLab(signal); - return; + + LqhKeyConf* conf = (LqhKeyConf*)signal->getDataPtrSend(); + conf->transId1 = copyWords; + conf->transId2 = tcConnectptr.p->transid[1]; + copyCompletedLab(signal); }//Dblqh::copyLqhKeyRefLab() void Dblqh::closeCopyLab(Signal* signal) @@ -9734,6 +9746,7 @@ void Dblqh::closeCopyLab(Signal* signal) // Wait until all of those have arrived until we start the // close process. /*---------------------------------------------------------------------------*/ + scanptr.p->scanState = ScanRecord::WAIT_LQHKEY_COPY; jam(); return; }//if diff --git a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp index 9917ac4e340..15ce54e594c 100644 --- a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp +++ b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp @@ -213,6 +213,30 @@ void Dbtup::execTUP_ALLOCREQ(Signal* signal) //--------------------------------------------------- PagePtr pagePtr; Uint32 pageOffset; + + if (ERROR_INSERTED(4025)) + { + signal->theData[0] = 827; + return; + } + if (ERROR_INSERTED(4026)) + { + CLEAR_ERROR_INSERT_VALUE; + signal->theData[0] = 827; + return; + } + if (ERROR_INSERTED(4027) && (rand() % 100) > 25) + { + signal->theData[0] = 827; + return; + } + if (ERROR_INSERTED(4028) && (rand() % 100) > 25) + { + CLEAR_ERROR_INSERT_VALUE; + signal->theData[0] = 827; + return; + } + if (!allocTh(regFragPtr.p, regTabPtr.p, NORMAL_PAGE, diff --git a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp index 6b1056fdeac..f5b4e1fb944 100644 --- a/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp +++ b/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp @@ -66,6 +66,7 @@ void Dbtup::initData() undoPage = 0; totNoOfPagesAllocated = 0; cnoOfAllocatedPages = 0; + CLEAR_ERROR_INSERT_VALUE; // Records with constant sizes }//Dbtup::initData() @@ -570,7 +571,6 @@ void Dbtup::execSTTOR(Signal* signal) switch (startPhase) { case ZSTARTPHASE1: ljam(); - CLEAR_ERROR_INSERT_VALUE; cownref = calcTupBlockRef(0); break; default: diff --git a/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp index a9039385805..c05f04d700c 100644 --- a/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp +++ b/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp @@ -180,6 +180,7 @@ void Ndbcntr::execSYSTEM_ERROR(Signal* signal) break; case SystemError::CopyFragRefError: + CRASH_INSERTION(1000); BaseString::snprintf(buf, sizeof(buf), "Killed by node %d as " "copyfrag failed, error: %u", diff --git a/ndb/test/ndbapi/testNodeRestart.cpp b/ndb/test/ndbapi/testNodeRestart.cpp index c8c8ddd88d6..e8f8ac66f74 100644 --- a/ndb/test/ndbapi/testNodeRestart.cpp +++ b/ndb/test/ndbapi/testNodeRestart.cpp @@ -1125,6 +1125,59 @@ runBug26481(NDBT_Context* ctx, NDBT_Step* step) return NDBT_OK; } +int +runBug27003(NDBT_Context* ctx, NDBT_Step* step) +{ + int result = NDBT_OK; + int loops = ctx->getNumLoops(); + int records = ctx->getNumRecords(); + NdbRestarter res; + + static const int errnos[] = { 4025, 4026, 4027, 4028, 0 }; + + int node = res.getRandomNotMasterNodeId(rand()); + ndbout_c("node: %d", node); + if (res.restartOneDbNode(node, false, true, true)) + return NDBT_FAILED; + + Uint32 pos = 0; + for (Uint32 i = 0; i Date: Tue, 13 Mar 2007 12:38:47 +0100 Subject: [PATCH 57/73] ndb - bug#27003 merge to 5.1, adopt testprg to optimized node recovery --- .../ndb/include/kernel/signaldata/LqhKey.hpp | 1 + storage/ndb/src/kernel/blocks/restore.cpp | 17 ++++++++++++++++- storage/ndb/test/ndbapi/testNodeRestart.cpp | 4 ++-- 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/storage/ndb/include/kernel/signaldata/LqhKey.hpp b/storage/ndb/include/kernel/signaldata/LqhKey.hpp index 15ed7c25395..c85a4d4a796 100644 --- a/storage/ndb/include/kernel/signaldata/LqhKey.hpp +++ b/storage/ndb/include/kernel/signaldata/LqhKey.hpp @@ -582,6 +582,7 @@ class LqhKeyRef { * Reciver(s) */ friend class Dbtc; + friend class Restore; /** * Sender(s) diff --git a/storage/ndb/src/kernel/blocks/restore.cpp b/storage/ndb/src/kernel/blocks/restore.cpp index 214cddeeda5..51644ef0712 100644 --- a/storage/ndb/src/kernel/blocks/restore.cpp +++ b/storage/ndb/src/kernel/blocks/restore.cpp @@ -1154,8 +1154,23 @@ Restore::calulate_hash(Uint32 tableId, const Uint32 *src) } void -Restore::execLQHKEYREF(Signal*) +Restore::execLQHKEYREF(Signal* signal) { + FilePtr file_ptr; + LqhKeyRef* ref = (LqhKeyRef*)signal->getDataPtr(); + m_file_pool.getPtr(file_ptr, ref->connectPtr); + + char buf[255], name[100]; + BaseString::snprintf(name, sizeof(name), "%u/T%dF%d", + file_ptr.p->m_lcp_no, + file_ptr.p->m_table_id, + file_ptr.p->m_fragment_id); + + BaseString::snprintf(buf, sizeof(buf), + "Error %d during restore of %s", + ref->errorCode, name); + + progError(__LINE__, NDBD_EXIT_INVALID_LCP_FILE, buf); ndbrequire(false); } diff --git a/storage/ndb/test/ndbapi/testNodeRestart.cpp b/storage/ndb/test/ndbapi/testNodeRestart.cpp index 35873bdf7d0..39b80611731 100644 --- a/storage/ndb/test/ndbapi/testNodeRestart.cpp +++ b/storage/ndb/test/ndbapi/testNodeRestart.cpp @@ -1332,7 +1332,7 @@ runBug27003(NDBT_Context* ctx, NDBT_Step* step) int node = res.getRandomNotMasterNodeId(rand()); ndbout_c("node: %d", node); - if (res.restartOneDbNode(node, false, true, true)) + if (res.restartOneDbNode(node, true, true, true)) return NDBT_FAILED; Uint32 pos = 0; @@ -1351,7 +1351,7 @@ runBug27003(NDBT_Context* ctx, NDBT_Step* step) if (res.insertErrorInNode(node, errnos[pos])) return NDBT_FAILED; - int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 }; + int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 3 }; if (res.dumpStateOneNode(node, val2, 2)) return NDBT_FAILED; From cb132bea8fd94a17653a971e74636a36a74f14c5 Mon Sep 17 00:00:00 2001 From: "svoj@mysql.com/april.(none)" <> Date: Tue, 13 Mar 2007 18:02:06 +0400 Subject: [PATCH 58/73] BUG#26881 - Large MERGE tables report incorrect specification when no differences in tables Certain merge tables were wrongly reported as having incorrect definition: - Some fields that are 1 byte long (e.g. TINYINT, CHAR(1)), might be internally casted (in certain cases) to a different type on a storage engine layer. (affects 4.1 and up) - If tables in a merge (and a MERGE table itself) had short VARCHAR column (less than 4 bytes) and at least one (but not all) tables were ALTER'ed (even to an identical table: ALTER TABLE xxx ENGINE=yyy), table definitions went ouf of sync. (affects 4.1 only) This is fixed by relaxing a check for underlying conformance and setting field type to FIELD_TYPE_STRING in case varchar is shorter than 4 when a table is created. --- myisam/mi_create.c | 4 ++++ mysql-test/r/merge.result | 13 +++++++++++++ mysql-test/t/merge.test | 17 +++++++++++++++++ sql/ha_myisam.cc | 37 ++++++++++++++++++++++++++++++++++++- sql/sql_parse.cc | 8 +++++++- 5 files changed, 77 insertions(+), 2 deletions(-) diff --git a/myisam/mi_create.c b/myisam/mi_create.c index da9e0887b00..5e363a4e670 100644 --- a/myisam/mi_create.c +++ b/myisam/mi_create.c @@ -158,6 +158,10 @@ int mi_create(const char *name,uint keys,MI_KEYDEF *keydefs, rec--; if (rec->type == (int) FIELD_SKIP_ZERO && rec->length == 1) { + /* + NOTE1: here we change a field type FIELD_SKIP_ZERO -> + FIELD_NORMAL + */ rec->type=(int) FIELD_NORMAL; packed--; min_pack_length++; diff --git a/mysql-test/r/merge.result b/mysql-test/r/merge.result index 33de735d714..00d8aa3d586 100644 --- a/mysql-test/r/merge.result +++ b/mysql-test/r/merge.result @@ -806,3 +806,16 @@ CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1); INSERT DELAYED INTO t2 VALUES(1); ERROR HY000: Table storage engine for 't2' doesn't have this option DROP TABLE t1, t2; +CREATE TABLE t1(c1 VARCHAR(1)); +CREATE TABLE m1 LIKE t1; +ALTER TABLE m1 ENGINE=MERGE UNION=(t1); +SELECT * FROM m1; +c1 +DROP TABLE t1, m1; +CREATE TABLE t1(c1 VARCHAR(4), c2 TINYINT, c3 TINYINT, c4 TINYINT, +c5 TINYINT, c6 TINYINT, c7 TINYINT, c8 TINYINT, c9 TINYINT); +CREATE TABLE m1 LIKE t1; +ALTER TABLE m1 ENGINE=MERGE UNION=(t1); +SELECT * FROM m1; +c1 c2 c3 c4 c5 c6 c7 c8 c9 +DROP TABLE t1, m1; diff --git a/mysql-test/t/merge.test b/mysql-test/t/merge.test index f759d20dd80..032e80ecc93 100644 --- a/mysql-test/t/merge.test +++ b/mysql-test/t/merge.test @@ -437,4 +437,21 @@ CREATE TABLE t2(c1 INT) ENGINE=MERGE UNION=(t1); INSERT DELAYED INTO t2 VALUES(1); DROP TABLE t1, t2; +# +# BUG#26881 - Large MERGE tables report incorrect specification when no +# differences in tables +# +CREATE TABLE t1(c1 VARCHAR(1)); +CREATE TABLE m1 LIKE t1; +ALTER TABLE m1 ENGINE=MERGE UNION=(t1); +SELECT * FROM m1; +DROP TABLE t1, m1; + +CREATE TABLE t1(c1 VARCHAR(4), c2 TINYINT, c3 TINYINT, c4 TINYINT, + c5 TINYINT, c6 TINYINT, c7 TINYINT, c8 TINYINT, c9 TINYINT); +CREATE TABLE m1 LIKE t1; +ALTER TABLE m1 ENGINE=MERGE UNION=(t1); +SELECT * FROM m1; +DROP TABLE t1, m1; + # End of 4.1 tests diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc index 2cec03a51db..c6802ffe53c 100644 --- a/sql/ha_myisam.cc +++ b/sql/ha_myisam.cc @@ -304,6 +304,12 @@ int table2myisam(TABLE *table_arg, MI_KEYDEF **keydef_out, RETURN VALUE 0 - Equal definitions. 1 - Different definitions. + + TODO + - compare FULLTEXT keys; + - compare SPATIAL keys; + - compare FIELD_SKIP_ZERO which is converted to FIELD_NORMAL correctly + (should be corretly detected in table2myisam). */ int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo, @@ -329,6 +335,28 @@ int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo, { HA_KEYSEG *t1_keysegs= t1_keyinfo[i].seg; HA_KEYSEG *t2_keysegs= t2_keyinfo[i].seg; + if (t1_keyinfo[i].flag & HA_FULLTEXT && t2_keyinfo[i].flag & HA_FULLTEXT) + continue; + else if (t1_keyinfo[i].flag & HA_FULLTEXT || + t2_keyinfo[i].flag & HA_FULLTEXT) + { + DBUG_PRINT("error", ("Key %d has different definition", i)); + DBUG_PRINT("error", ("t1_fulltext= %d, t2_fulltext=%d", + test(t1_keyinfo[i].flag & HA_FULLTEXT), + test(t2_keyinfo[i].flag & HA_FULLTEXT))); + DBUG_RETURN(1); + } + if (t1_keyinfo[i].flag & HA_SPATIAL && t2_keyinfo[i].flag & HA_SPATIAL) + continue; + else if (t1_keyinfo[i].flag & HA_SPATIAL || + t2_keyinfo[i].flag & HA_SPATIAL) + { + DBUG_PRINT("error", ("Key %d has different definition", i)); + DBUG_PRINT("error", ("t1_spatial= %d, t2_spatial=%d", + test(t1_keyinfo[i].flag & HA_SPATIAL), + test(t2_keyinfo[i].flag & HA_SPATIAL))); + DBUG_RETURN(1); + } if (t1_keyinfo[i].keysegs != t2_keyinfo[i].keysegs || t1_keyinfo[i].key_alg != t2_keyinfo[i].key_alg) { @@ -365,7 +393,14 @@ int check_definition(MI_KEYDEF *t1_keyinfo, MI_COLUMNDEF *t1_recinfo, { MI_COLUMNDEF *t1_rec= &t1_recinfo[i]; MI_COLUMNDEF *t2_rec= &t2_recinfo[i]; - if (t1_rec->type != t2_rec->type || + /* + FIELD_SKIP_ZERO can be changed to FIELD_NORMAL in mi_create, + see NOTE1 in mi_create.c + */ + if ((t1_rec->type != t2_rec->type && + !(t1_rec->type == (int) FIELD_SKIP_ZERO && + t1_rec->length == 1 && + t2_rec->type == (int) FIELD_NORMAL)) || t1_rec->length != t2_rec->length || t1_rec->null_bit != t2_rec->null_bit) { diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index d537da7080b..66b68cfc2f1 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -4653,8 +4653,14 @@ bool add_field_to_list(THD *thd, char *field_name, enum_field_types type, new_field->length++; } break; - case FIELD_TYPE_STRING: case FIELD_TYPE_VAR_STRING: + if (new_field->length < 4) + { + new_field->sql_type= FIELD_TYPE_STRING; + break; + } + /* fall through */ + case FIELD_TYPE_STRING: if (new_field->length <= MAX_FIELD_CHARLENGTH || default_value) break; /* Convert long CHAR() and VARCHAR columns to TEXT or BLOB */ From 67d97254b02fc73aaad20bc8c07b4e2a5b404ab5 Mon Sep 17 00:00:00 2001 From: "istruewing@chilla.local" <> Date: Tue, 13 Mar 2007 16:43:45 +0100 Subject: [PATCH 59/73] Bug#25460 - High concurrency MyISAM access causes severe mysqld crash. The previous two patches for this bug worked together so that no permanent table was memory mapped. The first patch tried to avoid mapping while a table is in use. It allowed mapping only if there was exactly one lock on the table, assuming that the calling thread owned it. During mi_open(), a different call to memory mapping was coded, which did not have this limitation. The second patch tried to remove the code duplication and just called mi_extra() from mi_open() an thus inherited the limitation. But on open, a thread does not have a lock on the table... A possible solution would be to check for zero or one lock. But since I learned that it is safe to memory map a file while normal file I/O is done on it, I removed the restriction altogether and allow to memory map while a table is in use. No test case. I do not see a chance to verify with the test suite which kind of I/O is used on a table. --- storage/myisam/mi_extra.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/storage/myisam/mi_extra.c b/storage/myisam/mi_extra.c index ae584b06173..729174b6f88 100644 --- a/storage/myisam/mi_extra.c +++ b/storage/myisam/mi_extra.c @@ -350,11 +350,13 @@ int mi_extra(MI_INFO *info, enum ha_extra_function function, void *extra_arg) #ifdef HAVE_MMAP pthread_mutex_lock(&share->intern_lock); /* - Memory map the data file if it is not already mapped and if there - are no other threads using this table. intern_lock prevents other - threads from starting to use the table while we are mapping it. + Memory map the data file if it is not already mapped. It is safe + to memory map a file while other threads are using file I/O on it. + Assigning a new address to a function pointer is an atomic + operation. intern_lock prevents that two or more mappings are done + at the same time. */ - if (!share->file_map && (share->tot_locks == 1)) + if (!share->file_map) { if (mi_dynmap_file(info, share->state.state.data_file_length)) { From 5ea42fb2ea6be5c4496e0077f30cac1d5a03f8ca Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Tue, 13 Mar 2007 21:03:34 +0100 Subject: [PATCH 60/73] ndb - bug#27102 Make sure head after undo execute does not point to last page of file As this will confuse next write to group --- storage/ndb/src/kernel/blocks/lgman.cpp | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/storage/ndb/src/kernel/blocks/lgman.cpp b/storage/ndb/src/kernel/blocks/lgman.cpp index d61dc422556..59b95f4e97f 100644 --- a/storage/ndb/src/kernel/blocks/lgman.cpp +++ b/storage/ndb/src/kernel/blocks/lgman.cpp @@ -2924,6 +2924,25 @@ Lgman::stop_run_undo_log(Signal* signal) ptr.p->m_file_pos[TAIL] = tail; init_logbuffer_pointers(ptr); + + { + Buffer_idx head= ptr.p->m_file_pos[HEAD]; + Ptr file; + m_file_pool.getPtr(file, head.m_ptr_i); + if (head.m_idx == file.p->m_file_size - 1) + { + Local_undofile_list files(m_file_pool, ptr.p->m_files); + if(!files.next(file)) + { + jam(); + files.first(file); + } + head.m_idx = 0; + head.m_ptr_i = file.i; + ptr.p->m_file_pos[HEAD] = head; + } + } + ptr.p->m_free_file_words = (Uint64)File_formats::UNDO_PAGE_WORDS * (Uint64)compute_free_file_pages(ptr); ptr.p->m_next_reply_ptr_i = ptr.p->m_file_pos[HEAD].m_ptr_i; From d7311aab777cf1d851d4808c9f249034fc5bb8c7 Mon Sep 17 00:00:00 2001 From: "svoj@mysql.com/april.(none)" <> Date: Wed, 14 Mar 2007 02:30:05 +0400 Subject: [PATCH 61/73] Removed tabs. --- myisam/mi_open.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/myisam/mi_open.c b/myisam/mi_open.c index f7edaf34494..274933679ef 100644 --- a/myisam/mi_open.c +++ b/myisam/mi_open.c @@ -1199,7 +1199,7 @@ int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup __attr int mi_open_keyfile(MYISAM_SHARE *share) { if ((share->kfile=my_open(share->unique_file_name, share->mode | O_SHARE, - MYF(MY_WME))) < 0) + MYF(MY_WME))) < 0) return 1; return 0; } From 820901f9289df6c6f653abe453196e8fcfa9a30c Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Wed, 14 Mar 2007 11:22:11 +0100 Subject: [PATCH 62/73] ndb - bug#27087 Make sure not to handle API_FAILREQ if it's already handled --- storage/ndb/src/kernel/blocks/suma/Suma.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/storage/ndb/src/kernel/blocks/suma/Suma.cpp b/storage/ndb/src/kernel/blocks/suma/Suma.cpp index b201d05726d..9ad530b6591 100644 --- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp +++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp @@ -578,6 +578,18 @@ void Suma::execAPI_FAILREQ(Signal* signal) return; } + if (c_failedApiNodes.get(failedApiNode)) + { + jam(); + return; + } + + if (!c_subscriber_nodes.get(failedApiNode)) + { + jam(); + return; + } + c_failedApiNodes.set(failedApiNode); c_connected_nodes.clear(failedApiNode); bool found = removeSubscribersOnNode(signal, failedApiNode); @@ -591,9 +603,12 @@ void Suma::execAPI_FAILREQ(Signal* signal) Ptr gcp; for(c_gcp_list.first(gcp); !gcp.isNull(); c_gcp_list.next(gcp)) { + jam(); ack->rep.gci = gcp.p->m_gci; if(gcp.p->m_subscribers.get(failedApiNode)) { + jam(); + gcp.p->m_subscribers.clear(failedApiNode); ack->rep.senderRef = numberToRef(0, failedApiNode); sendSignal(SUMA_REF, GSN_SUB_GCP_COMPLETE_ACK, signal, SubGcpCompleteAck::SignalLength, JBB); From be226152ab0d1eb2e8aca382ff8f2da1950c035f Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Wed, 14 Mar 2007 14:27:46 +0100 Subject: [PATCH 63/73] configure.in: Added test for sched_yield() possibly in -lposix4 on Solaris --- configure.in | 3 +++ 1 file changed, 3 insertions(+) diff --git a/configure.in b/configure.in index 7b31057f6d3..7e7431465a8 100644 --- a/configure.in +++ b/configure.in @@ -772,6 +772,9 @@ AC_CHECK_FUNC(bind, , AC_CHECK_LIB(bind, bind)) AC_CHECK_LIB(crypt, crypt) AC_CHECK_FUNC(crypt, AC_DEFINE(HAVE_CRYPT)) +# For the sched_yield() function on Solaris +AC_CHECK_FUNC(sched_yield, , AC_CHECK_LIB(posix4, sched_yield)) + # For compress in zlib case $SYSTEM_TYPE in *netware* | *modesto*) From 3b21f00f875ae5844a478f8a83e5bdad9cff91c1 Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Wed, 14 Mar 2007 15:37:47 +0100 Subject: [PATCH 64/73] ndb - bug#27005 Handle API failure during resend API failure could cause release of table object, which will make resend crash when dereferencing table object Solution, use table_id+hash+schemaversion instead of *raw* pointer in resend --- storage/ndb/src/kernel/blocks/suma/Suma.cpp | 78 +++++++++++++-------- storage/ndb/test/tools/listen.cpp | 8 ++- 2 files changed, 56 insertions(+), 30 deletions(-) diff --git a/storage/ndb/src/kernel/blocks/suma/Suma.cpp b/storage/ndb/src/kernel/blocks/suma/Suma.cpp index 9ad530b6591..407280638d9 100644 --- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp +++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp @@ -756,6 +756,17 @@ Suma::execNODE_FAILREP(Signal* signal){ Restart.resetRestart(signal); } + if (ERROR_INSERTED(13032)) + { + Uint32 node = c_subscriber_nodes.find(0); + if (node != NodeBitmask::NotFound) + { + ndbout_c("Inserting API_FAILREQ node: %u", node); + signal->theData[0] = node; + EXECUTE_DIRECT(QMGR, GSN_API_FAILREQ, signal, 1); + } + } + signal->theData[0] = SumaContinueB::RESEND_BUCKET; NdbNodeBitmask tmp; @@ -3460,7 +3471,10 @@ Suma::execFIRE_TRIG_ORD(Signal* signal) */ f_bufferLock = 0; b_bufferLock = 0; - + + ndbrequire((tabPtr.p = c_tablePool.getPtr(tabPtr.i)) != 0); + Uint32 tableId = tabPtr.p->m_tableId; + Uint32 bucket= hashValue % c_no_of_buckets; m_max_seen_gci = (gci > m_max_seen_gci ? gci : m_max_seen_gci); if(m_active_buckets.get(bucket) || @@ -3483,7 +3497,7 @@ Suma::execFIRE_TRIG_ORD(Signal* signal) SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg; data->gci = gci; - data->tableId = tabPtr.p->m_tableId; + data->tableId = tableId; data->requestInfo = 0; SubTableData::setOperation(data->requestInfo, event); data->logType = 0; @@ -3506,10 +3520,11 @@ Suma::execFIRE_TRIG_ORD(Signal* signal) else { Uint32* dst; - Uint32 sz = f_trigBufferSize + b_trigBufferSize + 2; + Uint32 sz = f_trigBufferSize + b_trigBufferSize + 3; if((dst = get_buffer_ptr(signal, bucket, gci, sz))) { - * dst++ = tabPtr.i; + * dst++ = tableId; + * dst++ = tabPtr.p->m_schemaVersion; * dst++ = (event << 16) | f_trigBufferSize; memcpy(dst, f_buffer, f_trigBufferSize << 2); dst += f_trigBufferSize; @@ -3641,7 +3656,7 @@ Suma::execSUB_GCP_COMPLETE_REP(Signal* signal) if(c_buckets[i].m_buffer_tail != RNIL) { - Uint32* dst; + //Uint32* dst; get_buffer_ptr(signal, i, gci, 0); } } @@ -3986,8 +4001,8 @@ void Suma::completeSubRemove(SubscriptionPtr subPtr) { DBUG_ENTER("Suma::completeSubRemove"); - Uint32 subscriptionId = subPtr.p->m_subscriptionId; - Uint32 subscriptionKey = subPtr.p->m_subscriptionKey; + //Uint32 subscriptionId = subPtr.p->m_subscriptionId; + //Uint32 subscriptionKey = subPtr.p->m_subscriptionKey; c_subscriptions.release(subPtr); DBUG_PRINT("info",("c_subscriptionPool size: %d free: %d", @@ -5003,43 +5018,48 @@ Suma::resend_bucket(Signal* signal, Uint32 buck, Uint32 min_gci, { g_cnt++; Uint32 table = * src++ ; + Uint32 schemaVersion = * src++; Uint32 event = * src >> 16; Uint32 sz_1 = (* src ++) & 0xFFFF; - - ndbassert(sz - 2 >= sz_1); + + ndbassert(sz - 3 >= sz_1); LinearSectionPtr ptr[3]; const Uint32 nptr= reformat(signal, ptr, src, sz_1, - src + sz_1, sz - 2 - sz_1); + src + sz_1, sz - 3 - sz_1); Uint32 ptrLen= 0; for(Uint32 i =0; i < nptr; i++) ptrLen+= ptr[i].sz; + /** * Signal to subscriber(s) */ Ptr tabPtr; - ndbrequire((tabPtr.p = c_tablePool.getPtr(table)) != 0); - - SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg; - data->gci = last_gci; - data->tableId = tabPtr.p->m_tableId; - data->requestInfo = 0; - SubTableData::setOperation(data->requestInfo, event); - data->logType = 0; - data->changeMask = 0; - data->totalLen = ptrLen; - + if (c_tables.find(tabPtr, table) && + tabPtr.p->m_schemaVersion == schemaVersion) { - LocalDLList list(c_subscriberPool,tabPtr.p->c_subscribers); - SubscriberPtr subbPtr; - for(list.first(subbPtr); !subbPtr.isNull(); list.next(subbPtr)) + SubTableData * data = (SubTableData*)signal->getDataPtrSend();//trg; + data->gci = last_gci; + data->tableId = table; + data->requestInfo = 0; + SubTableData::setOperation(data->requestInfo, event); + data->logType = 0; + data->changeMask = 0; + data->totalLen = ptrLen; + { - DBUG_PRINT("info",("GSN_SUB_TABLE_DATA to node %d", - refToNode(subbPtr.p->m_senderRef))); - data->senderData = subbPtr.p->m_senderData; - sendSignal(subbPtr.p->m_senderRef, GSN_SUB_TABLE_DATA, signal, - SubTableData::SignalLength, JBB, ptr, nptr); + LocalDLList + list(c_subscriberPool,tabPtr.p->c_subscribers); + SubscriberPtr subbPtr; + for(list.first(subbPtr); !subbPtr.isNull(); list.next(subbPtr)) + { + DBUG_PRINT("info",("GSN_SUB_TABLE_DATA to node %d", + refToNode(subbPtr.p->m_senderRef))); + data->senderData = subbPtr.p->m_senderData; + sendSignal(subbPtr.p->m_senderRef, GSN_SUB_TABLE_DATA, signal, + SubTableData::SignalLength, JBB, ptr, nptr); + } } } } diff --git a/storage/ndb/test/tools/listen.cpp b/storage/ndb/test/tools/listen.cpp index 3e2bc03857a..661193bf4b8 100644 --- a/storage/ndb/test/tools/listen.cpp +++ b/storage/ndb/test/tools/listen.cpp @@ -168,9 +168,15 @@ main(int argc, const char** argv){ break; case NdbDictionary::Event::TE_DROP: break; + case NdbDictionary::Event::TE_NODE_FAILURE: + break; + case NdbDictionary::Event::TE_SUBSCRIBE: + case NdbDictionary::Event::TE_UNSUBSCRIBE: + break; default: /* We should REALLY never get here. */ - ndbout_c("Error: unknown event type"); + ndbout_c("Error: unknown event type: %u", + (Uint32)pOp->getEventType()); abort(); } } while ((pOp= MyNdb.nextEvent()) && gci == pOp->getGCI()); From 7c4385c4ad050295070bb532e874e669dd1c93fe Mon Sep 17 00:00:00 2001 From: "kent@mysql.com/kent-amd64.(none)" <> Date: Wed, 14 Mar 2007 18:28:16 +0100 Subject: [PATCH 65/73] EXCEPTIONS-CLIENT: Updated to version 0.6 of the text --- EXCEPTIONS-CLIENT | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/EXCEPTIONS-CLIENT b/EXCEPTIONS-CLIENT index 19b86cab32b..c570ff7ba24 100644 --- a/EXCEPTIONS-CLIENT +++ b/EXCEPTIONS-CLIENT @@ -4,7 +4,7 @@ The MySQL AB Exception for Free/Libre and Open Source Software-only Applications Using MySQL Client Libraries (the "FLOSS Exception"). -Version 0.5, 30 August 2006 +Version 0.6, 7 March 2007 Exception Intent @@ -59,10 +59,12 @@ Apache Software License 1.0/1.1/2.0 Apple Public Source License 2.0 Artistic license From Perl 5.8.0 BSD license "July 22 1999" +Common Development and Distribution License (CDDL) 1.0 Common Public License 1.0 +Eclipse Public License 1.0 GNU Library or "Lesser" General Public License (LGPL) 2.0/2.1 Jabber Open Source License 1.0 -MIT license --- +MIT license (As listed in file MIT-License.txt) --- Mozilla Public License (MPL) 1.0/1.1 Open Software License 2.0 OpenSSL license (with original SSLeay license) "2003" ("1998") From 1fa2a6477826d1c99b44599aaae426eb023e9c4d Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Thu, 15 Mar 2007 07:08:15 +0100 Subject: [PATCH 66/73] ndb - fix test_event -n EventOperationApplier --- storage/ndb/test/ndbapi/test_event.cpp | 14 +++++++++++--- storage/ndb/test/src/HugoCalculator.cpp | 25 +++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 5 deletions(-) diff --git a/storage/ndb/test/ndbapi/test_event.cpp b/storage/ndb/test/ndbapi/test_event.cpp index 5af3ff77df8..54ea88d143c 100644 --- a/storage/ndb/test/ndbapi/test_event.cpp +++ b/storage/ndb/test/ndbapi/test_event.cpp @@ -500,6 +500,12 @@ int runEventMixedLoad(NDBT_Context* ctx, NDBT_Step* step) int records = ctx->getNumRecords(); HugoTransactions hugoTrans(*ctx->getTab()); + if(ctx->getPropertyWait("LastGCI", ~(Uint32)0)) + { + g_err << "FAIL " << __LINE__ << endl; + return NDBT_FAILED; + } + while(loops -- && !ctx->isTestStopped()) { hugoTrans.clearTable(GETNDB(step), 0); @@ -606,9 +612,11 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step) goto end; } + ctx->setProperty("LastGCI", ~(Uint32)0); + ctx->broadcast(); + while(!ctx->isTestStopped()) { - int r; int count= 0; Uint32 stop_gci= ~0; Uint64 curr_gci = 0; @@ -778,7 +786,7 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step) if (trans->getNdbError().status == NdbError::PermanentError) { - g_err << "Ignoring execute " << r << " failed " + g_err << "Ignoring execute failed " << trans->getNdbError().code << " " << trans->getNdbError().message << endl; @@ -788,7 +796,7 @@ int runEventApplier(NDBT_Context* ctx, NDBT_Step* step) } else if (noRetries++ == 10) { - g_err << "execute " << r << " failed " + g_err << "execute failed " << trans->getNdbError().code << " " << trans->getNdbError().message << endl; trans->close(); diff --git a/storage/ndb/test/src/HugoCalculator.cpp b/storage/ndb/test/src/HugoCalculator.cpp index 4d05c99738f..1589d4a9eb0 100644 --- a/storage/ndb/test/src/HugoCalculator.cpp +++ b/storage/ndb/test/src/HugoCalculator.cpp @@ -89,6 +89,27 @@ HugoCalculator::float calcValue(int record, int attrib, int updates) const; HugoCalculator::double calcValue(int record, int attrib, int updates) const; #endif +static +Uint32 +calc_len(Uint32 rvalue, int maxlen) +{ + Uint32 minlen = 25; + + if ((rvalue >> 16) < 4096) + minlen = 15; + else if ((rvalue >> 16) < 8192) + minlen = 25; + else if ((rvalue >> 16) < 16384) + minlen = 35; + else + minlen = 64; + + if (maxlen <= minlen) + return maxlen; + + return minlen + (rvalue % (maxlen - minlen)); +} + const char* HugoCalculator::calcValue(int record, int attrib, @@ -178,7 +199,7 @@ HugoCalculator::calcValue(int record, break; case NdbDictionary::Column::Varbinary: case NdbDictionary::Column::Varchar: - len = 1 + (myRand(&seed) % (len - 1)); + len = calc_len(myRand(&seed), len - 1); assert(len < 256); * outlen = len + 1; * buf = len; @@ -186,7 +207,7 @@ HugoCalculator::calcValue(int record, goto write_char; case NdbDictionary::Column::Longvarchar: case NdbDictionary::Column::Longvarbinary: - len = 1 + (myRand(&seed) % (len - 2)); + len = calc_len(myRand(&seed), len - 2); assert(len < 65536); * outlen = len + 2; int2store(buf, len); From f2cb6641741b814140d805046fc34928e69cfac7 Mon Sep 17 00:00:00 2001 From: "dlenev@mockturtle.local" <> Date: Thu, 15 Mar 2007 11:30:17 +0300 Subject: [PATCH 67/73] Fix for bug #25966 "2MB per second endless memory consumption after LOCK TABLE ... WRITE". CPU hogging occured when connection which had to wait for table lock was serviced by thread which previously serviced connection that was killed (note that connections can reuse threads if thread cache is enabled). One possible scenario which exposed this problem was when thread which provided binlog dump to replication slave was implicitly/automatically killed when the same slave reconnected and started pulling data through different thread/connection. In 5.* versions memory hogging was added to CPU hogging. Moreover in those versions the problem also occured when one killed particular query in connection (using KILL QUERY) and later this connection had to wait for some table lock. This problem was caused by the fact that thread-specific mysys_var::abort variable, which indicates that waiting operations on mysys layer should be aborted (this includes waiting for table locks), was set by kill operation but was never reset back. So this value was "inherited" by the following statements or even other connections (which reused the same physical thread). Such discrepancy between this variable and THD::killed flag broke logic on SQL-layer and caused CPU and memory hogging. This patch tries to fix this problem by properly resetting this member. There is no test-case associated with this patch since it is hard to test for memory/CPU hogging conditions in our test-suite. --- sql/mysqld.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 0efc1339467..20f20a0a86b 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -1572,6 +1572,12 @@ void end_thread(THD *thd, bool put_in_cache) thd=thread_cache.get(); thd->real_id=pthread_self(); (void) thd->store_globals(); + /* + THD::mysys_var::abort is associated with physical thread rather + than with THD object. So we need to reset this flag before using + this thread for handling of new THD object/connection. + */ + thd->mysys_var->abort= 0; thd->thr_create_time= time(NULL); threads.append(thd); pthread_mutex_unlock(&LOCK_thread_count); From 01bd08b5d72818f9ad1165394f42202c3c6ada6b Mon Sep 17 00:00:00 2001 From: "dlenev@mockturtle.local" <> Date: Thu, 15 Mar 2007 11:51:35 +0300 Subject: [PATCH 68/73] Fix for bug #25966 "2MB per second endless memory consumption after LOCK TABLE ... WRITE". Memory and CPU hogging occured when connection which had to wait for table lock was serviced by thread which previously serviced connection that was killed (note that connections can reuse threads if thread cache is enabled). One possible scenario which exposed this problem was when thread which provided binlog dump to replication slave was implicitly/automatically killed when the same slave reconnected and started pulling data through different thread/connection. The problem also occured when one killed particular query in connection (using KILL QUERY) and later this connection had to wait for some table lock. This problem was caused by the fact that thread-specific mysys_var::abort variable, which indicates that waiting operations on mysys layer should be aborted (this includes waiting for table locks), was set by kill operation but was never reset back. So this value was "inherited" by the following statements or even other connections (which reused the same physical thread). Such discrepancy between this variable and THD::killed flag broke logic on SQL-layer and caused CPU and memory hogging. This patch tries to fix this problem by properly resetting this member. There is no test-case associated with this patch since it is hard to test for memory/CPU hogging conditions in our test-suite. --- sql/mysqld.cc | 6 ++++++ sql/sp_head.cc | 1 + sql/sql_parse.cc | 3 +++ 3 files changed, 10 insertions(+) diff --git a/sql/mysqld.cc b/sql/mysqld.cc index 9a7928b214f..99d66134405 100644 --- a/sql/mysqld.cc +++ b/sql/mysqld.cc @@ -1681,6 +1681,12 @@ void end_thread(THD *thd, bool put_in_cache) thd->real_id=pthread_self(); thd->thread_stack= (char*) &thd; // For store_globals (void) thd->store_globals(); + /* + THD::mysys_var::abort is associated with physical thread rather + than with THD object. So we need to reset this flag before using + this thread for handling of new THD object/connection. + */ + thd->mysys_var->abort= 0; thd->thr_create_time= time(NULL); threads.append(thd); pthread_mutex_unlock(&LOCK_thread_count); diff --git a/sql/sp_head.cc b/sql/sp_head.cc index baeedc1c9b3..4cb56e003ee 100644 --- a/sql/sp_head.cc +++ b/sql/sp_head.cc @@ -1087,6 +1087,7 @@ sp_head::execute(THD *thd) ctx->enter_handler(hip); thd->clear_error(); thd->killed= THD::NOT_KILLED; + thd->mysys_var->abort= 0; continue; } } diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc index b503e147624..6500def76f7 100644 --- a/sql/sql_parse.cc +++ b/sql/sql_parse.cc @@ -1604,7 +1604,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd, DBUG_ENTER("dispatch_command"); if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA) + { thd->killed= THD::NOT_KILLED; + thd->mysys_var->abort= 0; + } thd->command=command; /* From 06219769ac91d04ec1eaab0a7a3c8bff45c0e6c8 Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Thu, 15 Mar 2007 11:05:12 +0100 Subject: [PATCH 69/73] ndb - fix bug in UtilTransactions::compare reset rowcount on temporary error during scan of base table --- ndb/test/src/UtilTransactions.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ndb/test/src/UtilTransactions.cpp b/ndb/test/src/UtilTransactions.cpp index 31c323045ed..c3941bda5dd 100644 --- a/ndb/test/src/UtilTransactions.cpp +++ b/ndb/test/src/UtilTransactions.cpp @@ -1382,6 +1382,7 @@ UtilTransactions::compare(Ndb* pNdb, const char* tab_name2, int flags){ goto error; } + row_count= 0; { int eof; while((eof = pOp->nextResult(true)) == 0) From 1bf8202fce873be494282b3c78d7394253fde866 Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Thu, 15 Mar 2007 13:30:42 +0100 Subject: [PATCH 70/73] ndb - bug#27169 Fix bug in SUMA::resend_bucket which could cause mysqld to crash --- storage/ndb/src/kernel/blocks/suma/Suma.cpp | 5 +- storage/ndb/test/ndbapi/test_event.cpp | 150 ++++++++++++++++++ .../ndb/test/run-test/daily-basic-tests.txt | 4 + 3 files changed, 158 insertions(+), 1 deletion(-) diff --git a/storage/ndb/src/kernel/blocks/suma/Suma.cpp b/storage/ndb/src/kernel/blocks/suma/Suma.cpp index 407280638d9..5ebb075d636 100644 --- a/storage/ndb/src/kernel/blocks/suma/Suma.cpp +++ b/storage/ndb/src/kernel/blocks/suma/Suma.cpp @@ -4997,8 +4997,11 @@ Suma::resend_bucket(Signal* signal, Uint32 buck, Uint32 min_gci, { continue; } + + ndbrequire(sz); + sz --; // remove *len* part of sz - if(sz == 1) + if(sz == 0) { SubGcpCompleteRep * rep = (SubGcpCompleteRep*)signal->getDataPtrSend(); rep->gci = last_gci; diff --git a/storage/ndb/test/ndbapi/test_event.cpp b/storage/ndb/test/ndbapi/test_event.cpp index 54ea88d143c..563819689a8 100644 --- a/storage/ndb/test/ndbapi/test_event.cpp +++ b/storage/ndb/test/ndbapi/test_event.cpp @@ -836,6 +836,67 @@ end: DBUG_RETURN(result); } +int runEventListenerUntilStopped(NDBT_Context* ctx, NDBT_Step* step) +{ + + int result = NDBT_OK; + const NdbDictionary::Table * table= ctx->getTab(); + HugoTransactions hugoTrans(* table); + + char buf[1024]; + sprintf(buf, "%s_EVENT", table->getName()); + NdbEventOperation *pOp, *pCreate = 0; + pCreate = pOp = GETNDB(step)->createEventOperation(buf); + if ( pOp == NULL ) { + g_err << "Event operation creation failed on %s" << buf << endl; + return NDBT_FAILED; + } + + int i; + int n_columns= table->getNoOfColumns(); + NdbRecAttr* recAttr[1024]; + NdbRecAttr* recAttrPre[1024]; + for (i = 0; i < n_columns; i++) { + recAttr[i] = pOp->getValue(table->getColumn(i)->getName()); + recAttrPre[i] = pOp->getPreValue(table->getColumn(i)->getName()); + } + + if (pOp->execute()) + { // This starts changes to "start flowing" + g_err << "execute operation execution failed: \n"; + g_err << pOp->getNdbError().code << " " + << pOp->getNdbError().message << endl; + result = NDBT_FAILED; + goto end; + } + + Ndb* ndb= GETNDB(step); + while(!ctx->isTestStopped()) + { + Uint64 curr_gci = 0; + while(!ctx->isTestStopped()) + { + ndb->pollEvents(100, &curr_gci); + while ((pOp= ndb->nextEvent()) != 0) + { + assert(pOp == pCreate); + } + } + } + +end: + if(pCreate) + { + if (GETNDB(step)->dropEventOperation(pCreate)) { + g_err << "dropEventOperation execution failed " + << GETNDB(step)->getNdbError().code << " " + << GETNDB(step)->getNdbError().message << endl; + result = NDBT_FAILED; + } + } + return result; +} + int runRestarter(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; int loops = ctx->getNumLoops(); @@ -877,6 +938,51 @@ int runRestarter(NDBT_Context* ctx, NDBT_Step* step){ return result; } +int runRestarterLoop(NDBT_Context* ctx, NDBT_Step* step) +{ + int result = NDBT_OK; + int loops = ctx->getNumLoops(); + NdbRestarter restarter; + int i = 0; + int lastId = 0; + + if (restarter.getNumDbNodes() < 2){ + ctx->stopTest(); + return NDBT_OK; + } + + if(restarter.waitClusterStarted(60) != 0){ + g_err << "Cluster failed to start" << endl; + return NDBT_FAILED; + } + + while(result != NDBT_FAILED + && !ctx->isTestStopped() + && i < loops) + { + int id = lastId % restarter.getNumDbNodes(); + int nodeId = restarter.getDbNodeId(id); + ndbout << "Restart node " << nodeId << endl; + if(restarter.restartOneDbNode(nodeId, false, false, true) != 0){ + g_err << "Failed to restartNextDbNode" << endl; + result = NDBT_FAILED; + break; + } + + if(restarter.waitClusterStarted(60) != 0){ + g_err << "Cluster failed to start" << endl; + result = NDBT_FAILED; + break; + } + + lastId++; + i++; + } + + ctx->stopTest(); + return result; +} + Vector pTabs; Vector pShadowTabs; @@ -1616,6 +1722,42 @@ runSubscribeUnsubscribe(NDBT_Context* ctx, NDBT_Step* step) return NDBT_OK; } +int +runScanUpdateUntilStopped(NDBT_Context* ctx, NDBT_Step* step){ + int records = ctx->getNumRecords(); + int parallelism = ctx->getProperty("Parallelism", (Uint32)0); + int abort = ctx->getProperty("AbortProb", (Uint32)0); + HugoTransactions hugoTrans(*ctx->getTab()); + while (ctx->isTestStopped() == false) + { + if (hugoTrans.scanUpdateRecords(GETNDB(step), records, abort, + parallelism) == NDBT_FAILED){ + return NDBT_FAILED; + } + } + return NDBT_OK; +} + +int +runInsertDeleteUntilStopped(NDBT_Context* ctx, NDBT_Step* step) +{ + int result = NDBT_OK; + int records = ctx->getNumRecords(); + HugoTransactions hugoTrans(*ctx->getTab()); + UtilTransactions utilTrans(*ctx->getTab()); + while (ctx->isTestStopped() == false) + { + if (hugoTrans.loadTable(GETNDB(step), records, 1) != 0){ + return NDBT_FAILED; + } + if (utilTrans.clearTable(GETNDB(step), records) != 0){ + return NDBT_FAILED; + } + } + + return NDBT_OK; +} + NDBT_TESTSUITE(test_event); TESTCASE("BasicEventOperation", "Verify that we can listen to Events" @@ -1737,6 +1879,14 @@ TESTCASE("SubscribeUnsubscribe", STEPS(runSubscribeUnsubscribe, 16); FINALIZER(runDropEvent); } +TESTCASE("Bug27169", ""){ + INITIALIZER(runCreateEvent); + STEP(runEventListenerUntilStopped); + STEP(runInsertDeleteUntilStopped); + STEP(runScanUpdateUntilStopped); + STEP(runRestarterLoop); + FINALIZER(runDropEvent); +} NDBT_TESTSUITE_END(test_event); int main(int argc, const char** argv){ diff --git a/storage/ndb/test/run-test/daily-basic-tests.txt b/storage/ndb/test/run-test/daily-basic-tests.txt index c0f1ff4db48..ad33a1d52d7 100644 --- a/storage/ndb/test/run-test/daily-basic-tests.txt +++ b/storage/ndb/test/run-test/daily-basic-tests.txt @@ -788,6 +788,10 @@ max-time: 1000 cmd: testNodeRestart args: -n Bug25468 T1 +max-time: 1000 +cmd: test_event +args: -l 10 -n Bug27169 T1 + # OLD FLEX max-time: 500 cmd: flexBench From 4c9f4a006f7fc36004f5241e5a5379a246db857a Mon Sep 17 00:00:00 2001 From: "hartmut@mysql.com/hartmut-desktop.buero.foebud.org" <> Date: Thu, 15 Mar 2007 13:35:49 +0100 Subject: [PATCH 71/73] added missing prototype implementations (bug #25933) --- storage/ndb/src/ndbapi/NdbOperation.cpp | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/storage/ndb/src/ndbapi/NdbOperation.cpp b/storage/ndb/src/ndbapi/NdbOperation.cpp index ff9c50da77c..9b3d20a1c33 100644 --- a/storage/ndb/src/ndbapi/NdbOperation.cpp +++ b/storage/ndb/src/ndbapi/NdbOperation.cpp @@ -368,12 +368,24 @@ NdbOperation::subValue( const char* anAttrName, Uint32 aValue) return subValue(m_currentTable->getColumn(anAttrName), aValue); } +int +NdbOperation::subValue( const char* anAttrName, Uint64 aValue) +{ + return subValue(m_currentTable->getColumn(anAttrName), aValue); +} + int NdbOperation::subValue(Uint32 anAttrId, Uint32 aValue) { return subValue(m_currentTable->getColumn(anAttrId), aValue); } +int +NdbOperation::subValue(Uint32 anAttrId, Uint64 aValue) +{ + return subValue(m_currentTable->getColumn(anAttrId), aValue); +} + int NdbOperation::read_attr(const char* anAttrName, Uint32 RegDest) { From 6d99387502f9c8b9ec1994421c254cd2686c23c1 Mon Sep 17 00:00:00 2001 From: "jbruehe/mysqldev@mysql.com/production.mysql.com" <> Date: Thu, 15 Mar 2007 22:28:31 +0100 Subject: [PATCH 72/73] Raise version number after cloning 5.0.38 --- configure.in | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/configure.in b/configure.in index 53f666bad00..7867bf444ad 100644 --- a/configure.in +++ b/configure.in @@ -7,7 +7,7 @@ AC_INIT(sql/mysqld.cc) AC_CANONICAL_SYSTEM # The Docs Makefile.am parses this line! # remember to also change ndb version below and update version.c in ndb -AM_INIT_AUTOMAKE(mysql, 5.0.38) +AM_INIT_AUTOMAKE(mysql, 5.0.40) AM_CONFIG_HEADER(config.h) PROTOCOL_VERSION=10 @@ -23,7 +23,7 @@ NDB_SHARED_LIB_VERSION=$NDB_SHARED_LIB_MAJOR_VERSION:0:0 # ndb version NDB_VERSION_MAJOR=5 NDB_VERSION_MINOR=0 -NDB_VERSION_BUILD=38 +NDB_VERSION_BUILD=40 NDB_VERSION_STATUS="" # Set all version vars based on $VERSION. How do we do this more elegant ? From f161857d3e98e5389476a92695de5d34d3069b3d Mon Sep 17 00:00:00 2001 From: "jonas@perch.ndb.mysql.com" <> Date: Fri, 16 Mar 2007 10:58:24 +0100 Subject: [PATCH 73/73] ndb - bug#27203 Allow readTablePk to stumble on scan+deleted tuple, reporting no-match instead of crash (in case scan is lock-owner) --- storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp | 2 +- .../ndb/src/kernel/blocks/dbacc/DbaccMain.cpp | 19 +++++++++++++++---- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp index 6337e252c0b..e75e88d95fa 100644 --- a/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp +++ b/storage/ndb/src/kernel/blocks/dbacc/Dbacc.hpp @@ -760,7 +760,7 @@ private: void increaselistcont(Signal* signal); void seizeLeftlist(Signal* signal); void seizeRightlist(Signal* signal); - Uint32 readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec*); + Uint32 readTablePk(Uint32 localkey1, Uint32 eh, OperationrecPtr); Uint32 getElement(Signal* signal, OperationrecPtr& lockOwner); void getdirindex(Signal* signal); void commitdelete(Signal* signal); diff --git a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp index bf2fa5b7584..58032c92d5f 100644 --- a/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp +++ b/storage/ndb/src/kernel/blocks/dbacc/DbaccMain.cpp @@ -46,6 +46,7 @@ ndbrequire(false); } } while(0) #else #define vlqrequire(x) ndbrequire(x) +#define dump_lock_queue(x) #endif @@ -3184,7 +3185,7 @@ void Dbacc::getdirindex(Signal* signal) }//Dbacc::getdirindex() Uint32 -Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec* op) +Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, Ptr opPtr) { int ret; Uint32 tableId = fragrecptr.p->myTableId; @@ -3205,8 +3206,17 @@ Dbacc::readTablePk(Uint32 localkey1, Uint32 eh, const Operationrec* op) else { ndbrequire(ElementHeader::getLocked(eh)); - ndbrequire((op->m_op_bits & Operationrec::OP_MASK) != ZSCAN_OP); - ret = c_lqh->readPrimaryKeys(op->userptr, ckeys, xfrm); + if (unlikely((opPtr.p->m_op_bits & Operationrec::OP_MASK) == ZSCAN_OP)) + { + dump_lock_queue(opPtr); + ndbrequire(opPtr.p->nextParallelQue == RNIL); + ndbrequire(opPtr.p->nextSerialQue == RNIL); + ndbrequire(opPtr.p->m_op_bits & Operationrec::OP_ELEMENT_DISAPPEARED); + ndbrequire(opPtr.p->m_op_bits & Operationrec::OP_COMMIT_DELETE_CHECK); + ndbrequire((opPtr.p->m_op_bits & Operationrec::OP_STATE_MASK) == Operationrec::OP_STATE_RUNNING); + return 0; + } + ret = c_lqh->readPrimaryKeys(opPtr.p->userptr, ckeys, xfrm); } jamEntry(); ndbrequire(ret >= 0); @@ -3351,7 +3361,7 @@ Dbacc::getElement(Signal* signal, OperationrecPtr& lockOwnerPtr) if (! searchLocalKey) { Uint32 len = readTablePk(localkey1, tgeElementHeader, - lockOwnerPtr.p); + lockOwnerPtr); found = (len == operationRecPtr.p->xfrmtupkeylen) && (memcmp(Tkeydata, ckeys, len << 2) == 0); } else { @@ -6866,6 +6876,7 @@ void Dbacc::execACC_TO_REQ(Signal* signal) { tatrOpPtr.p->transId1 = signal->theData[2]; tatrOpPtr.p->transId2 = signal->theData[3]; + validate_lock_queue(tatrOpPtr); } else { jam(); signal->theData[0] = cminusOne;