int
Ndb_move_data::copy_blob_to_blob(const Attr& attr1, const Attr& attr2)
{
int ret = 0;
Op& op = m_op;
const int i1 = attr1.id;
const int i2 = attr2.id;
do
{
NdbBlob* bh1 = op.values[i1].bh;
require(bh1 != 0);
int isNull = -1;
CHK2(bh1->getNull(isNull) == 0, (bh1->getNdbError()));
require(isNull == 0 || isNull == 1);
Uint64 length64 = ~(Uint64)0;
CHK2(bh1->getLength(length64) == 0, (bh1->getNdbError()));
Uint32 data_length = (Uint32)length64;
require((uint64)data_length == length64);
NdbBlob* bh2 = op.updateop->getBlobHandle(i2);
CHK2(bh2 != 0, (op.updateop->getNdbError()));
if (isNull)
{
CHK2(bh2->setValue(0, 0) == 0, (bh2->getNdbError()));
}
else
{
char* data = alloc_data(data_length);
Uint32 bytes = data_length;
CHK2(bh1->readData(data, bytes) == 0, (bh1->getNdbError()));
require(bytes == data_length);
CHK2(bh2->setValue(data, data_length) == 0,
(bh2->getNdbError()));
}
}
while (0);
return ret;
}
static int
checkobjs()
{
int ret = 0;
do
{
CHK2((g_tab = g_dic->getTable(g_tabname)) != 0,
g_tabname << ": " << g_dic->getNdbError());
if (g_indcount == 0)
{
NdbDictionary::Dictionary::List list;
CHK2(g_dic->listIndexes(list, g_tabname) == 0, g_dic->getNdbError());
const int count = list.count;
g_indnames = (const char**)malloc(sizeof(char*) * count);
CHK2(g_indnames != 0, "out of memory");
for (int i = 0; i < count; i++)
{
const NdbDictionary::Dictionary::List::Element& e = list.elements[i];
if (e.type == NdbDictionary::Object::OrderedIndex)
{
g_indnames[g_indcount] = strdup(e.name);
CHK2(g_indnames[g_indcount] != 0, "out of memory");
g_indcount++;
}
}
CHK1(ret == 0);
}
g_indlist = (const NdbDictionary::Index**)malloc(sizeof(NdbDictionary::Index*) * g_indcount);
CHK2(g_indlist != 0, "out of memory");
for (int i = 0; i < g_indcount; i++)
{
CHK2((g_indlist[i] = g_dic->getIndex(g_indnames[i], g_tabname)) != 0,
g_tabname << "." << g_indnames[i] << ": " << g_dic->getNdbError());
}
}
while (0);
return ret;
}
int
Ndb_move_data::copy_data_to_array(const char* data1, const Attr& attr2,
Uint32 length1, Uint32 length1x)
{
int ret = 0;
const Opts& opts = m_opts;
Op& op = m_op;
const int i2 = attr2.id;
do
{
if (data1 == 0)
{
CHK2(op.updateop->setValue(i2, data1) == 0,
(op.updateop->getNdbError()));
}
else
{
/*
* length1 is bytes present in data1
* length1x may be longer for blob source
* see invocation from array and blob source
*/
require(length1 <= length1x);
if (length1x > attr2.data_size)
{
require(opts.flags & Opts::MD_ATTRIBUTE_DEMOTION);
length1 = attr2.data_size;
op.truncated_in_batch++;
}
uchar* uptr = (uchar*)&op.buf2[0];
switch (attr2.length_bytes) {
case 0:
break;
case 1:
require(length1 <= 0xFF);
uptr[0] = (uchar)length1;
break;
case 2:
require(length1 <= 0xFFFF);
uptr[0] = (uchar)(length1 & 0xFF);
uptr[1] = (uchar)(length1 >> 8);
break;
default:
require(false);
break;
}
char* data2 = &op.buf2[attr2.length_bytes];
memcpy(data2, data1, length1);
if (attr2.pad_char != -1)
{
char* pad_data2 = &data2[length1];
Uint32 pad_length2 = attr2.data_size - length1;
memset(pad_data2, attr2.pad_char, pad_length2);
}
CHK2(op.updateop->setValue(i2, (char*)op.buf2) == 0,
(op.updateop->getNdbError()));
}
}
while (0);
return ret;
}
int
Ndb_move_data::check_tables()
{
int ret = 0;
const Opts& opts = m_opts;
do
{
int attrcount1 = m_source->getNoOfColumns();
int attrcount2 = m_target->getNoOfColumns();
m_sourceattr = new Attr [attrcount1];
m_targetattr = new Attr [attrcount2];
// set type info, remap columns, check missing
for (int i1 = 0; i1 < attrcount1; i1++)
{
Attr& attr1 = m_sourceattr[i1];
attr1.id = i1;
const NdbDictionary::Column* c1 = m_source->getColumn(i1);
require(c1 != 0);
set_type(attr1, c1);
const NdbDictionary::Column* c2 = m_target->getColumn(attr1.name);
if (c2 == 0)
{
CHK2(opts.flags & Opts::MD_EXCLUDE_MISSING_COLUMNS,
(Error::NoExcludeMissingFlag,
"cannot convert source to target"
": source column #%d '%s' not found in target"
" and exclude-missing-columns has not been specified",
1+i1, attr1.name));
}
else
{
int i2 = c2->getColumnNo();
require(i2 >= 0 && i2 < attrcount2);
Attr& attr2 = m_targetattr[i2];
attr1.map_id = i2;
require(attr2.map_id == -1);
attr2.map_id = i1;
}
}
CHK1(ret == 0);
for (int i2 = 0; i2 < attrcount2; i2++)
{
Attr& attr2 = m_targetattr[i2];
attr2.id = i2;
const NdbDictionary::Column* c2 = m_target->getColumn(i2);
require(c2 != 0);
set_type(attr2, c2);
const NdbDictionary::Column* c1 = m_source->getColumn(attr2.name);
if (c1 == 0)
{
CHK2(opts.flags & Opts::MD_EXCLUDE_MISSING_COLUMNS,
(Error::NoExcludeMissingFlag,
"cannot convert source to target"
": target column #%d '%s' not found in source"
" and exclude-missing-columns has not been specified",
1+i2, attr2.name));
}
else
{
int i1 = c1->getColumnNo();
require(i2 >= 0 && i2 < attrcount2);
Attr& attr1 = m_sourceattr[i1];
require(attr1.map_id == i2);
require(attr2.map_id == i1);
}
}
CHK1(ret == 0);
// check conversion of non-excluded columns
for (int i1 = 0; i1 < attrcount1; i1++)
{
Attr& attr1 = m_sourceattr[i1];
int i2 = attr1.map_id;
if (i2 == -1) // excluded
continue;
Attr& attr2 = m_targetattr[i2];
{
/* Exclude internal implementation details when comparing */
NdbDictionary::Column a1ColCopy(*attr1.column);
NdbDictionary::Column a2ColCopy(*attr2.column);
/* [Non] Dynamic internal storage is irrelevant */
a1ColCopy.setDynamic(false);
a2ColCopy.setDynamic(false);
if ((attr1.equal = attr2.equal = a1ColCopy.equal(a2ColCopy)))
{
continue;
}
}
if (attr1.type == Attr::TypeArray &&
attr2.type == Attr::TypeBlob)
{
CHK1(check_nopk(attr1, attr2) == 0);
CHK1(check_promotion(attr1, attr2) == 0);
continue;
}
if (attr1.type == Attr::TypeBlob &&
attr2.type == Attr::TypeArray)
{
CHK1(check_nopk(attr1, attr2) == 0);
CHK1(check_demotion(attr1, attr2) == 0);
continue;
}
if (attr1.type == Attr::TypeArray &&
attr2.type == Attr::TypeArray)
{
CHK1(check_sizes(attr1, attr2) == 0);
continue;
}
CHK1(check_unsupported(attr1, attr2) == 0);
}
CHK1(ret == 0);
}
while (0);
return ret;
}
static int
dosys()
{
int ret = 0;
do
{
if (_sys_drop)
{
if (!_sys_skip_events)
{
g_info << "dropping sys events" << endl;
CHK2(g_is->drop_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_sysevents(g_ndb_sys) == -1, "unexpected success");
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysEvents,
"unexpected error: " << g_is->getNdbError());
}
if (!_sys_skip_tables)
{
g_info << "dropping all sys tables" << endl;
CHK2(g_is->drop_systables(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_systables(g_ndb_sys) == -1, "unexpected success");
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysTables,
"unexpected error: " << g_is->getNdbError());
}
g_info << "drop done" << endl;
}
if (_sys_create)
{
if (!_sys_skip_tables)
{
g_info << "creating all sys tables" << endl;
CHK2(g_is->create_systables(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_systables(g_ndb_sys) == 0, g_is->getNdbError());
}
if (!_sys_skip_events)
{
g_info << "creating sys events" << endl;
CHK2(g_is->create_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "create done" << endl;
}
}
if (_sys_create_if_not_exist)
{
if (!_sys_skip_tables)
{
if (g_is->check_systables(g_ndb_sys) == -1)
{
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysTables,
g_is->getNdbError());
g_info << "creating all sys tables" << endl;
CHK2(g_is->create_systables(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_systables(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "create done" << endl;
}
else
{
g_info << "using existing sys tables" << endl;
}
}
if (!_sys_skip_events)
{
if (g_is->check_sysevents(g_ndb_sys) == -1)
{
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysEvents,
g_is->getNdbError());
g_info << "creating sys events" << endl;
CHK2(g_is->create_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "create done" << endl;
}
else
{
g_info << "using existing sys events" << endl;
}
}
}
if (_sys_create_if_not_valid)
{
if (!_sys_skip_tables)
{
if (g_is->check_systables(g_ndb_sys) == -1)
{
if (g_is->getNdbError().code != NdbIndexStat::NoSysTables)
{
CHK2(g_is->getNdbError().code == NdbIndexStat::BadSysTables,
g_is->getNdbError());
g_info << "dropping invalid sys tables" << endl;
CHK2(g_is->drop_systables(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_systables(g_ndb_sys) == -1, "unexpected success");
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysTables,
"unexpected error: " << g_is->getNdbError());
g_info << "drop done" << endl;
}
g_info << "creating all sys tables" << endl;
CHK2(g_is->create_systables(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_systables(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "create done" << endl;
}
else
{
g_info << "using existing sys tables" << endl;
}
}
if (!_sys_skip_events)
{
if (g_is->check_sysevents(g_ndb_sys) == -1)
{
if (g_is->getNdbError().code != NdbIndexStat::NoSysEvents)
{
CHK2(g_is->getNdbError().code == NdbIndexStat::BadSysEvents,
g_is->getNdbError());
g_info << "dropping invalid sys events" << endl;
CHK2(g_is->drop_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_sysevents(g_ndb_sys) == -1, "unexpected success");
CHK2(g_is->getNdbError().code == NdbIndexStat::NoSysEvents,
"unexpected error: " << g_is->getNdbError());
g_info << "drop done" << endl;
}
g_info << "creating sys events" << endl;
CHK2(g_is->create_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
CHK2(g_is->check_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "create done" << endl;
}
else
{
g_info << "using existing sys events" << endl;
}
}
}
if (_sys_check)
{
if (!_sys_skip_tables)
{
CHK2(g_is->check_systables(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "sys tables ok" << endl;
}
if (!_sys_skip_events)
{
CHK2(g_is->check_sysevents(g_ndb_sys) == 0, g_is->getNdbError());
g_info << "sys events ok" << endl;
}
}
}
while (0);
return ret;
}
static int
dostats(int i)
{
int ret = 0;
do
{
g_indname = g_indnames[i];
g_ind = g_indlist[i];
g_is->reset_index();
CHK2(g_is->set_index(*g_ind, *g_tab) == 0, g_is->getNdbError());
if (_delete)
{
g_info << g_indname << ": delete stats" << endl;
if (ndb_rand() % 2 == 0)
{
CHK2(g_dic->deleteIndexStat(*g_ind, *g_tab) == 0, g_dic->getNdbError());
}
else
{
CHK2(g_is->delete_stat(g_ndb_sys) == 0, g_is->getNdbError());
}
}
if (_update)
{
g_info << g_indname << ": update stats" << endl;
if (ndb_rand() % 2 == 0)
{
CHK2(g_dic->updateIndexStat(*g_ind, *g_tab) == 0, g_dic->getNdbError());
}
else
{
CHK2(g_is->update_stat(g_ndb_sys) == 0, g_is->getNdbError());
}
}
NdbIndexStat::Head head;
g_is->read_head(g_ndb_sys);
g_is->get_head(head);
CHK2(head.m_found != -1, g_is->getNdbError());
if (head.m_found == false)
{
g_info << "no stats" << endl;
break;
}
show_head(head);
g_info << "read stats" << endl;
CHK2(g_is->read_stat(g_ndb_sys) == 0, g_is->getNdbError());
g_is->move_cache();
g_is->clean_cache();
g_info << "query cache created" << endl;
NdbIndexStat::CacheInfo infoQuery;
g_is->get_cache_info(infoQuery, NdbIndexStat::CacheQuery);
show_cache_info("query cache", infoQuery);
if (_dump)
{
NdbIndexStatImpl& impl = g_is->getImpl();
NdbIndexStatImpl::CacheIter iter(impl);
CHK2(impl.dump_cache_start(iter) == 0, g_is->getNdbError());
while (impl.dump_cache_next(iter) == true)
{
show_cache_entry(iter);
}
}
if (_query > 0)
{
CHK2(doquery() == 0, "failed");
}
}
while (0);
return ret;
}
/* Test various atomic.h macros. */
static int
do_test (void)
{
atomic_t mem, expected, retval;
int ret = 0;
#ifdef atomic_compare_and_exchange_val_acq
mem = 24;
CHK2(atomic_compare_and_exchange_val_acq, 35, 24, 24, 35);
mem = 12;
CHK2(atomic_compare_and_exchange_val_acq, 10, 15, 12, 12);
mem = -15;
CHK2(atomic_compare_and_exchange_val_acq, -56, -15, -15, -56);
mem = -1;
CHK2(atomic_compare_and_exchange_val_acq, 17, 0, -1, -1);
#endif
mem = 24;
CHK2(atomic_compare_and_exchange_bool_acq, 35, 24, 0, 35);
mem = 12;
CHK2(atomic_compare_and_exchange_bool_acq, 10, 15, 1, 12);
mem = -15;
CHK2(atomic_compare_and_exchange_bool_acq, -56, -15, 0, -56);
mem = -1;
CHK2(atomic_compare_and_exchange_bool_acq, 17, 0, 1, -1);
mem = 64;
CHK1(atomic_exchange_acq, 31, 64, 31);
mem = 2;
CHK1(atomic_exchange_and_add, 11, 2, 13);
mem = 2;
CHK1(atomic_exchange_and_add_acq, 11, 2, 13);
mem = 2;
CHK1(atomic_exchange_and_add_rel, 11, 2, 13);
mem = -21;
atomic_add (&mem, 22);
if (mem != 1)
{
printf ("atomic_add(mem, 22): mem %lu != expected 1\n", mem);
ret = 1;
}
mem = -1;
atomic_increment (&mem);
if (mem != 0)
{
printf ("atomic_increment(mem): mem %lu != expected 0\n", mem);
ret = 1;
}
mem = 2;
if ((retval = atomic_increment_val (&mem)) != 3)
{
printf ("atomic_increment_val(mem): retval %lu != expected 3\n", retval);
ret = 1;
}
mem = 0;
CHK0(atomic_increment_and_test, 0, 1);
mem = 35;
CHK0(atomic_increment_and_test, 0, 36);
mem = -1;
CHK0(atomic_increment_and_test, 1, 0);
mem = 17;
atomic_decrement (&mem);
if (mem != 16)
{
printf ("atomic_increment(mem): mem %lu != expected 16\n", mem);
ret = 1;
}
if ((retval = atomic_decrement_val (&mem)) != 15)
{
printf ("atomic_decrement_val(mem): retval %lu != expected 15\n", retval);
ret = 1;
}
mem = 0;
CHK0(atomic_decrement_and_test, 0, -1);
mem = 15;
CHK0(atomic_decrement_and_test, 0, 14);
mem = 1;
CHK0(atomic_decrement_and_test, 1, 0);
mem = 1;
if (atomic_decrement_if_positive (&mem) != 1
|| mem != 0)
{
puts ("atomic_decrement_if_positive test 1 failed");
ret = 1;
}
mem = 0;
if (atomic_decrement_if_positive (&mem) != 0
|| mem != 0)
{
puts ("atomic_decrement_if_positive test 2 failed");
ret = 1;
}
mem = -1;
if (atomic_decrement_if_positive (&mem) != -1
|| mem != -1)
{
puts ("atomic_decrement_if_positive test 3 failed");
ret = 1;
}
mem = -12;
if (! atomic_add_negative (&mem, 10)
|| mem != -2)
{
puts ("atomic_add_negative test 1 failed");
ret = 1;
}
mem = 0;
if (atomic_add_negative (&mem, 100)
|| mem != 100)
{
puts ("atomic_add_negative test 2 failed");
ret = 1;
}
mem = 15;
if (atomic_add_negative (&mem, -10)
|| mem != 5)
{
puts ("atomic_add_negative test 3 failed");
ret = 1;
}
mem = -12;
if (atomic_add_negative (&mem, 14)
|| mem != 2)
{
puts ("atomic_add_negative test 4 failed");
ret = 1;
}
mem = 0;
if (! atomic_add_negative (&mem, -1)
|| mem != -1)
{
puts ("atomic_add_negative test 5 failed");
ret = 1;
}
mem = -31;
if (atomic_add_negative (&mem, 31)
|| mem != 0)
{
puts ("atomic_add_negative test 6 failed");
ret = 1;
}
mem = -34;
if (atomic_add_zero (&mem, 31)
|| mem != -3)
{
puts ("atomic_add_zero test 1 failed");
ret = 1;
}
mem = -36;
if (! atomic_add_zero (&mem, 36)
|| mem != 0)
{
puts ("atomic_add_zero test 2 failed");
ret = 1;
}
mem = 113;
if (atomic_add_zero (&mem, -13)
|| mem != 100)
{
puts ("atomic_add_zero test 3 failed");
ret = 1;
}
mem = -18;
if (atomic_add_zero (&mem, 20)
|| mem != 2)
{
puts ("atomic_add_zero test 4 failed");
ret = 1;
}
mem = 10;
if (atomic_add_zero (&mem, -20)
|| mem != -10)
{
puts ("atomic_add_zero test 5 failed");
ret = 1;
}
mem = 10;
if (! atomic_add_zero (&mem, -10)
|| mem != 0)
{
puts ("atomic_add_zero test 6 failed");
ret = 1;
}
mem = 0;
atomic_bit_set (&mem, 1);
if (mem != 2)
{
puts ("atomic_bit_set test 1 failed");
ret = 1;
}
mem = 8;
atomic_bit_set (&mem, 3);
if (mem != 8)
{
puts ("atomic_bit_set test 2 failed");
ret = 1;
}
#ifdef TEST_ATOMIC64
mem = 16;
atomic_bit_set (&mem, 35);
if (mem != 0x800000010LL)
{
puts ("atomic_bit_set test 3 failed");
ret = 1;
}
#endif
mem = 0;
if (atomic_bit_test_set (&mem, 1)
|| mem != 2)
{
puts ("atomic_bit_test_set test 1 failed");
ret = 1;
}
mem = 8;
if (! atomic_bit_test_set (&mem, 3)
|| mem != 8)
{
puts ("atomic_bit_test_set test 2 failed");
ret = 1;
}
#ifdef TEST_ATOMIC64
mem = 16;
if (atomic_bit_test_set (&mem, 35)
|| mem != 0x800000010LL)
{
puts ("atomic_bit_test_set test 3 failed");
ret = 1;
}
mem = 0x100000000LL;
if (! atomic_bit_test_set (&mem, 32)
|| mem != 0x100000000LL)
{
puts ("atomic_bit_test_set test 4 failed");
ret = 1;
}
#endif
#ifdef catomic_compare_and_exchange_val_acq
mem = 24;
if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
|| mem != 35)
{
puts ("catomic_compare_and_exchange_val_acq test 1 failed");
ret = 1;
}
mem = 12;
if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
|| mem != 12)
{
puts ("catomic_compare_and_exchange_val_acq test 2 failed");
ret = 1;
}
mem = -15;
if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
|| mem != -56)
{
puts ("catomic_compare_and_exchange_val_acq test 3 failed");
ret = 1;
}
mem = -1;
if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
|| mem != -1)
{
puts ("catomic_compare_and_exchange_val_acq test 4 failed");
ret = 1;
}
#endif
mem = 24;
if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24)
|| mem != 35)
{
puts ("catomic_compare_and_exchange_bool_acq test 1 failed");
ret = 1;
}
mem = 12;
if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15)
|| mem != 12)
{
puts ("catomic_compare_and_exchange_bool_acq test 2 failed");
ret = 1;
}
mem = -15;
if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15)
|| mem != -56)
{
puts ("catomic_compare_and_exchange_bool_acq test 3 failed");
ret = 1;
}
mem = -1;
if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0)
|| mem != -1)
{
puts ("catomic_compare_and_exchange_bool_acq test 4 failed");
ret = 1;
}
mem = 2;
if (catomic_exchange_and_add (&mem, 11) != 2
|| mem != 13)
{
puts ("catomic_exchange_and_add test failed");
ret = 1;
}
mem = -21;
catomic_add (&mem, 22);
if (mem != 1)
{
puts ("catomic_add test failed");
ret = 1;
}
mem = -1;
catomic_increment (&mem);
if (mem != 0)
{
puts ("catomic_increment test failed");
ret = 1;
}
mem = 2;
if (catomic_increment_val (&mem) != 3)
{
puts ("catomic_increment_val test failed");
ret = 1;
}
mem = 17;
catomic_decrement (&mem);
if (mem != 16)
{
puts ("catomic_decrement test failed");
ret = 1;
}
if (catomic_decrement_val (&mem) != 15)
{
puts ("catomic_decrement_val test failed");
ret = 1;
}
/* Tests for C11-like atomics. */
mem = 11;
if (atomic_load_relaxed (&mem) != 11 || atomic_load_acquire (&mem) != 11)
{
puts ("atomic_load_{relaxed,acquire} test failed");
ret = 1;
}
atomic_store_relaxed (&mem, 12);
if (mem != 12)
{
puts ("atomic_store_relaxed test failed");
ret = 1;
}
atomic_store_release (&mem, 13);
if (mem != 13)
{
puts ("atomic_store_release test failed");
ret = 1;
}
mem = 14;
expected = 14;
if (!atomic_compare_exchange_weak_relaxed (&mem, &expected, 25)
|| mem != 25 || expected != 14)
{
puts ("atomic_compare_exchange_weak_relaxed test 1 failed");
ret = 1;
}
if (atomic_compare_exchange_weak_relaxed (&mem, &expected, 14)
|| mem != 25 || expected != 25)
{
puts ("atomic_compare_exchange_weak_relaxed test 2 failed");
ret = 1;
}
mem = 14;
expected = 14;
if (!atomic_compare_exchange_weak_acquire (&mem, &expected, 25)
|| mem != 25 || expected != 14)
{
puts ("atomic_compare_exchange_weak_acquire test 1 failed");
ret = 1;
}
if (atomic_compare_exchange_weak_acquire (&mem, &expected, 14)
|| mem != 25 || expected != 25)
{
puts ("atomic_compare_exchange_weak_acquire test 2 failed");
ret = 1;
}
mem = 14;
expected = 14;
if (!atomic_compare_exchange_weak_release (&mem, &expected, 25)
|| mem != 25 || expected != 14)
{
puts ("atomic_compare_exchange_weak_release test 1 failed");
ret = 1;
}
if (atomic_compare_exchange_weak_release (&mem, &expected, 14)
|| mem != 25 || expected != 25)
{
puts ("atomic_compare_exchange_weak_release test 2 failed");
ret = 1;
}
mem = 23;
if (atomic_exchange_acquire (&mem, 42) != 23 || mem != 42)
{
puts ("atomic_exchange_acquire test failed");
ret = 1;
}
mem = 23;
if (atomic_exchange_release (&mem, 42) != 23 || mem != 42)
{
puts ("atomic_exchange_release test failed");
ret = 1;
}
mem = 23;
if (atomic_fetch_add_relaxed (&mem, 1) != 23 || mem != 24)
{
puts ("atomic_fetch_add_relaxed test failed");
ret = 1;
}
mem = 23;
if (atomic_fetch_add_acquire (&mem, 1) != 23 || mem != 24)
{
puts ("atomic_fetch_add_acquire test failed");
ret = 1;
}
mem = 23;
if (atomic_fetch_add_release (&mem, 1) != 23 || mem != 24)
{
puts ("atomic_fetch_add_release test failed");
ret = 1;
}
mem = 23;
if (atomic_fetch_add_acq_rel (&mem, 1) != 23 || mem != 24)
{
puts ("atomic_fetch_add_acq_rel test failed");
ret = 1;
}
mem = 3;
if (atomic_fetch_and_acquire (&mem, 2) != 3 || mem != 2)
{
puts ("atomic_fetch_and_acquire test failed");
ret = 1;
}
mem = 4;
if (atomic_fetch_or_relaxed (&mem, 2) != 4 || mem != 6)
{
puts ("atomic_fetch_or_relaxed test failed");
ret = 1;
}
mem = 4;
if (atomic_fetch_or_acquire (&mem, 2) != 4 || mem != 6)
{
puts ("atomic_fetch_or_acquire test failed");
ret = 1;
}
/* This is a single-threaded test, so we can't test the effects of the
fences. */
atomic_thread_fence_acquire ();
atomic_thread_fence_release ();
atomic_thread_fence_seq_cst ();
return ret;
}
static int
runBug14702377(NDBT_Context* ctx, NDBT_Step* step)
{
Ndb* pNdb = GETNDB(step);
NdbDictionary::Dictionary * pDict = pNdb->getDictionary();
int records = ctx->getNumRecords();
int result = NDBT_OK;
while (ctx->getProperty("HalfStartedDone", (Uint32)0) == 0)
{
ndbout << "Wait for half started..." << endl;
NdbSleep_SecSleep(15);
}
ndbout << "Got half started" << endl;
while (1)
{
require(table_list.size() == 1);
const char* tabname = table_list[0].c_str();
const NdbDictionary::Table* tab = 0;
CHK2((tab = pDict->getTable(tabname)) != 0,
tabname << ": " << pDict->getNdbError());
const int ncol = tab->getNoOfColumns();
{
HugoTransactions trans(*tab);
CHK2(trans.loadTable(pNdb, records) == 0, trans.getNdbError());
}
for (int r = 0; r < records; r++)
{
// with 1000 records will surely hit bug case
const int lm = myRandom48(4); // 2
const int nval = myRandom48(ncol + 1); // most
const bool exist = myRandom48(2); // false
NdbTransaction* pTx = 0;
NdbOperation* pOp = 0;
CHK2((pTx = pNdb->startTransaction()) != 0,
pNdb->getNdbError());
CHK2((pOp = pTx->getNdbOperation(tab)) != 0,
pTx->getNdbError());
CHK2((pOp->readTuple((NdbOperation::LockMode)lm)) == 0,
pOp->getNdbError());
for (int id = 0; id <= 0; id++)
{
const NdbDictionary::Column* c = tab->getColumn(id);
require(c != 0 && c->getPrimaryKey() &&
c->getType() == NdbDictionary::Column::Unsigned);
Uint32 val = myRandom48(records);
if (!exist)
val = 0xaaaa0000 + myRandom48(0xffff + 1);
const char* valp = (const char*)&val;
CHK2(pOp->equal(id, valp) == 0, pOp->getNdbError());
}
CHK2(result == NDBT_OK, "failed");
for (int id = 0; id < nval; id++)
{
const NdbDictionary::Column* c = tab->getColumn(id);
require(c != 0 && (id == 0 || !c->getPrimaryKey()));
CHK2(pOp->getValue(id) != 0, pOp->getNdbError());
}
CHK2(result == NDBT_OK, "failed");
char info1[200];
sprintf(info1, "lm=%d nval=%d exist=%d",
lm, nval, exist);
g_info << "PK read T1 exec: " << info1 << endl;
Uint64 t1 = NdbTick_CurrentMillisecond();
int ret = pTx->execute(NdbTransaction::NoCommit);
Uint64 t2 = NdbTick_CurrentMillisecond();
int msec = (int)(t2-t1);
const NdbError& txerr = pTx->getNdbError();
const NdbError& operr = pOp->getNdbError();
char info2[200];
sprintf(info2, "%s msec=%d ret=%d txerr=%d operr=%d",
info1, msec, ret, txerr.code, operr.code);
g_info << "PK read T1 done: " << info2 << endl;
if (ret == 0 && txerr.code == 0 && operr.code == 0)
{
CHK2(exist, "row should not be found: " << info2);
}
else if (ret == 0 && txerr.code == 626 && operr.code == 626)
{
CHK2(!exist, "row should be found: " << info2);
}
else if (txerr.status == NdbError::TemporaryError)
{
g_err << "PK read T1 temporary error (tx): " << info2 << endl;
NdbSleep_MilliSleep(50);
}
else if (operr.status == NdbError::TemporaryError)
{
g_err << "PK read T1 temporary error (op): " << info2 << endl;
NdbSleep_MilliSleep(50);
}
else
{
// gets 4012 before bugfix
CHK2(false, "unexpected error: " << info2);
}
pNdb->closeTransaction(pTx);
pTx = 0;
}
break;
}
g_err << "Clear half started hold..." << endl;
ctx->setProperty("HalfStartedHold", (Uint32)0);
return result;
}
static int
getobjs()
{
int ret = 0;
do
{
g_tab = g_dic->getTable(g_tabname);
CHK2(g_tab != 0, g_tabname << ": " << g_dic->getNdbError());
const int tabid = g_tab->getObjectId();
const int ncol = g_tab->getNoOfColumns();
g_pklist = new Pk [NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY];
for (int i = 0; i < ncol; i++)
{
const NdbDictionary::Column* c = g_tab->getColumn(i);
if (c->getPrimaryKey())
{
Pk& p = g_pklist[g_pkcount++];
const char* colname = c->getName();
p.colname = newstr(colname);
}
}
assert(g_pkcount != 0 && g_pkcount == g_tab->getNoOfPrimaryKeys());
g_valcount = g_pkcount + 1;
g_vallist = new Val [g_valcount];
for (int i = 0; i < g_valcount; i++)
{
Val& v = g_vallist[i];
if (i < g_pkcount)
{
const Pk& p = g_pklist[i];
v.colname = newstr(p.colname);
}
if (i == g_pkcount + 0) // first blob attr to scan
{
v.colname = newstr("NDB$PART");
}
}
if (g_blobcount == 0)
{
for (int i = 0; i < ncol; i++)
{
const NdbDictionary::Column* c = g_tab->getColumn(i);
if (isblob(c))
{
Blob& b = g_bloblist[g_blobcount++];
const char* colname = c->getName();
b.colname = newstr(colname);
}
}
}
for (int i = 0; i < g_blobcount; i++)
{
Blob& b = g_bloblist[i];
b.blobno = i;
const NdbDictionary::Column* c = g_tab->getColumn(b.colname);
CHK2(c != 0, g_tabname << ": " << b.colname << ": no such column");
CHK2(isblob(c), g_tabname << ": " << b.colname << ": not a blob");
b.colno = c->getColumnNo();
{
char blobname[100];
sprintf(blobname, "NDB$BLOB_%d_%d", tabid, b.colno);
b.blobname = newstr(blobname);
}
b.blobtab = g_dic->getTable(b.blobname);
CHK2(b.blobtab != 0, g_tabname << ": " << b.colname << ": " << b.blobname << ": " << g_dic->getNdbError());
}
CHK1(ret == 0);
}
while (0);
return ret;
}
