static int
doall()
{
int ret = 0;
do
{
CHK2(doconnect() == 0, "connect to NDB");
int loop = 0;
while (++loop <= _loops)
{
g_info << "loop " << loop << " of " << _loops << endl;
if (!_sys_any)
{
if (loop == 1)
{
CHK1(checkobjs() == 0);
}
CHK2(dostats() == 0, "at loop " << loop);
}
else
{
CHK2(dosys() == 0, "at loop " << loop);
}
}
CHK1(ret == 0);
}
while (0);
dodisconnect();
return ret;
}
int
Ndb_move_data::copy_array_to_array(const Attr& attr1, const Attr& attr2)
{
int ret = 0;
Op& op = m_op;
const int i1 = attr1.id;
do
{
const NdbRecAttr* ra1 = op.values[i1].ra;
require(ra1 != 0 && ra1->isNULL() != -1);
if (ra1->isNULL())
{
const char* data1 = 0;
CHK1(copy_data_to_array(data1, attr2, 0, 0) == 0);
}
else
{
Uint32 size1 = ra1->get_size_in_bytes();
require(size1 >= attr1.length_bytes);
Uint32 length1 = size1 - attr1.length_bytes;
const char* aref1 = ra1->aRef();
const char* data1 = &aref1[attr1.length_bytes];
if (attr1.length_bytes == 0)
while (length1 != 0 && data1[length1-1] == attr1.pad_char)
length1--;
CHK1(copy_data_to_array(data1, attr2, length1, length1) == 0);
}
}
while (0);
return ret;
}
int
Ndb_move_data::move_batch()
{
int ret = 0;
Op& op = m_op;
op.rows_in_batch = 0;
op.truncated_in_batch = 0;
do
{
int res;
CHK2((res = op.scanop->nextResult(true)) != -1,
(op.scanop->getNdbError()));
require(res == 0 || res == 1);
if (res == 1)
{
op.end_of_scan = true;
op.ndb->closeTransaction(op.scantrans);
op.scantrans = 0;
break;
}
require(op.updatetrans == 0);
op.updatetrans = op.ndb->startTransaction();
CHK2(op.updatetrans != 0, (op.ndb->getNdbError()));
do
{
CHK1(move_row() == 0);
op.rows_in_batch++;
CHK2((res = op.scanop->nextResult(false)) != -1,
(op.scanop->getNdbError()));
require(res == 0 || res == 2);
}
while (res == 0);
CHK1(ret == 0);
if (m_error_insert && ndb_rand() % 5 == 0)
{
invoke_error_insert();
CHK1(false);
}
CHK2(op.updatetrans->execute(NdbTransaction::Commit) == 0,
(op.updatetrans->getNdbError()));
op.ndb->closeTransaction(op.updatetrans);
op.updatetrans = 0;
}
while (0);
release_data();
return ret;
}
static int
dostats()
{
int ret = 0;
do
{
for (int i = 0; i < g_indcount; i++)
{
CHK1(dostats(i) == 0);
}
CHK1(ret == 0);
}
while (0);
return ret;
}
static int
scanblobstart(const Blob& b)
{
int ret = 0;
do
{
assert(g_scantx == 0);
g_scantx = g_ndb->startTransaction();
CHK2(g_scantx != 0, g_ndb->getNdbError());
g_scanop = g_scantx->getNdbScanOperation(b.blobtab);
CHK2(g_scanop != 0, g_scantx->getNdbError());
const NdbOperation::LockMode lm = NdbOperation::LM_Exclusive;
CHK2(g_scanop->readTuples(lm) == 0, g_scanop->getNdbError());
for (int i = 0; i < g_valcount; i++)
{
Val& v = g_vallist[i];
v.ra = g_scanop->getValue(v.colname);
CHK2(v.ra != 0, v.colname << ": " << g_scanop->getNdbError());
}
CHK1(ret == 0);
CHK2(g_scantx->execute(NoCommit) == 0, g_scantx->getNdbError());
}
while (0);
return ret;
}
static int
doall()
{
int ret = 0;
do
{
if (opt_dump_file)
{
g_dump_file = fopen(opt_dump_file, "w");
CHK2(g_dump_file != 0, opt_dump_file << ": " << strerror(errno));
g_dump_out = new FileOutputStream(g_dump_file);
new (&g_dump) NdbOut(*g_dump_out);
const char* action = 0;
if (opt_check_orphans)
action = "check";
if (opt_delete_orphans)
action = "delete";
g_dump << "table: " << g_tabname << endl;
g_dump << "action: " << action << endl;
}
CHK1(doconnect() == 0);
CHK1(getobjs() == 0);
if (g_blobcount == 0)
{
g_err << g_tabname << ": no blob columns" << endl;
break;
}
CHK1(doorphans() == 0);
}
while (0);
dodisconnect();
if (g_dump_file != 0)
{
g_dump << "result: "<< (ret == 0 ? "ok" : "failed") << endl;
flush(g_dump);
if (fclose(g_dump_file) != 0)
{
g_err << opt_dump_file << ": write failed: " << strerror(errno) << endl;
}
g_dump_file = 0;
}
return ret;
}
int
Ndb_move_data::check_sizes(const Attr& attr1, const Attr& attr2)
{
int ret = 0;
do
{
if (attr1.data_size < attr2.data_size)
{
CHK1(check_promotion(attr1, attr2) == 0);
}
if (attr1.data_size > attr2.data_size)
{
CHK1(check_demotion(attr1, attr2) == 0);
}
}
while (0);
return ret;
}
int
Ndb_move_data::copy_attr(const Attr& attr1, const Attr& attr2)
{
int ret = 0;
require(attr1.map_id == attr2.id);
do
{
if (attr1.equal && attr1.type != Attr::TypeBlob)
{
require(attr2.equal && attr2.type != Attr::TypeBlob);
CHK1(copy_other_to_other(attr1, attr2) == 0);
break;
}
if (attr1.type == Attr::TypeArray &&
attr2.type == Attr::TypeArray)
{
CHK1(copy_array_to_array(attr1, attr2) == 0);
break;
}
if (attr1.type == Attr::TypeArray &&
attr2.type == Attr::TypeBlob)
{
CHK1(copy_array_to_blob(attr1, attr2) == 0);
break;
}
if (attr1.type == Attr::TypeBlob &&
attr2.type == Attr::TypeArray)
{
CHK1(copy_blob_to_array(attr1, attr2) == 0);
break;
}
if (attr1.type == Attr::TypeBlob &&
attr2.type == Attr::TypeBlob)
{
CHK1(copy_blob_to_blob(attr1, attr2) == 0);
break;
}
require(false);
}
while (0);
return ret;
}
static int
checkorphan(const Blob&b, int& res)
{
int ret = 0;
NdbTransaction* tx = 0;
NdbOperation* op = 0;
do
{
tx = g_ndb->startTransaction();
CHK2(tx != 0, g_ndb->getNdbError());
op = tx->getNdbOperation(g_tab);
CHK2(op != 0, tx->getNdbError());
const NdbOperation::LockMode lm = NdbOperation::LM_Read;
CHK2(op->readTuple(lm) == 0, op->getNdbError());
for (int i = 0; i < g_pkcount; i++)
{
Val& v = g_vallist[i];
assert(v.ra != 0);
assert(v.ra->isNULL() == 0);
const char* data = v.ra->aRef();
CHK2(op->equal(v.colname, data) == 0, op->getNdbError());
}
CHK1(ret == 0);
// read something to be safe
NdbRecAttr* ra0 = op->getValue(g_vallist[0].colname);
assert(ra0 != 0);
// not sure about the rules
assert(tx->getNdbError().code == 0);
tx->execute(Commit);
if (tx->getNdbError().code == 626)
{
g_info << "parent not found" << endl;
res = 1; // not found
}
else
{
CHK2(tx->getNdbError().code == 0, tx->getNdbError());
res = 0; // found
}
}
while (0);
if (tx != 0)
g_ndb->closeTransaction(tx);
return ret;
}
static int
doorphans()
{
int ret = 0;
g_err << "processing " << g_blobcount << " blobs" << endl;
for (int i = 0; i < g_blobcount; i++)
{
const Blob& b = g_bloblist[i];
CHK1(doorphan(b) == 0);
}
return ret;
}
int
Ndb_move_data::move_row()
{
int ret = 0;
Op& op = m_op;
const int attrcount1 = m_source->getNoOfColumns();
do
{
op.updateop = op.updatetrans->getNdbOperation(m_target);
CHK2(op.updateop != 0, (op.updatetrans->getNdbError()));
CHK2(op.updateop->insertTuple() == 0, (op.updateop->getNdbError()));
for (int j = 0; j <= 1; j++)
{
for (int i1 = 0; i1 < attrcount1; i1++)
{
const Attr& attr1 = m_sourceattr[i1];
int i2 = attr1.map_id;
if (unlikely(i2 == -1))
continue;
const Attr& attr2 = m_targetattr[i2];
const NdbDictionary::Column* c = attr2.column;
if (j == 0 && !c->getPrimaryKey())
continue;
if (j == 1 && c->getPrimaryKey())
continue;
CHK1(copy_attr(attr1, attr2) == 0);
}
CHK1(ret == 0);
}
CHK1(ret == 0);
CHK2(op.scanop->deleteCurrentTuple(op.updatetrans) == 0,
(op.scanop->getNdbError()));
}
while (0);
return ret;
}
int
Ndb_move_data::move_data(Ndb* ndb)
{
int ret = 0;
Op& op = m_op;
Stat& stat = m_stat;
stat.rows_moved = 0; // keep rows_total
do
{
const NDB_TICKS now = NdbTick_getCurrentTicks();
ndb_srand((unsigned)now.getUint64());
reset_error();
CHK2(m_source != 0 && m_target != 0,
(Error::InvalidState, "source / target not defined"));
op.ndb = ndb;
CHK1(m_error.code == 0);
CHK1(check_tables() == 0);
CHK1(start_scan() == 0);
while (1)
{
CHK1(move_batch() == 0);
stat.rows_moved += op.rows_in_batch;
stat.rows_total += op.rows_in_batch;
stat.truncated += op.truncated_in_batch;
require(op.end_of_scan == (op.rows_in_batch == 0));
if (op.end_of_scan)
break;
}
CHK1(ret == 0);
}
while (0);
close_op(ndb, ret);
return ret;
}
static int
checkopts(int argc, char** argv)
{
int ret = 0;
do
{
_stats_any =
(_dbname != 0) +
(_delete != 0) +
(_update != 0) +
(_dump != 0) +
(_query != 0);
_sys_any =
(_sys_create != 0) +
(_sys_create_if_not_exist != 0) +
(_sys_create_if_not_valid != 0) +
(_sys_drop != 0) +
( _sys_check != 0) +
(_sys_skip_tables != 0) +
(_sys_skip_events != 0);
if (!_sys_any)
{
if (_dbname == 0)
_dbname = "TEST_DB";
CHK2(argc >= 1, "stats options require table");
g_tabname = strdup(argv[0]);
CHK2(g_tabname != 0, "out of memory");
g_indcount = argc - 1;
if (g_indcount != 0)
{
g_indnames = (const char**)malloc(sizeof(char*) * g_indcount);
CHK2(g_indnames != 0, "out of memory");
for (int i = 0; i < g_indcount; i++)
{
g_indnames[i] = strdup(argv[1 + i]);
CHK2(g_indnames[i] != 0, "out of memory");
}
CHK1(ret == 0);
}
}
else
{
CHK2(_stats_any == 0, "cannot mix --sys options with stats options");
CHK2(argc == 0, "--sys options take no args");
}
}
while (0);
return ret;
}
int
Ndb_move_data::copy_blob_to_array(const Attr& attr1, const Attr& attr2)
{
int ret = 0;
Op& op = m_op;
const int i1 = attr1.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);
if (isNull)
{
const char* data1 = 0;
CHK1(copy_data_to_array(data1, attr2, 0, 0) == 0);
}
else
{
char* data1 = &op.buf1[0];
Uint32 length1 = attr2.data_size;
CHK2(bh1->readData(data1, length1) == 0, (bh1->getNdbError()));
// pass also real length to detect truncation
CHK1(copy_data_to_array(data1, attr2, length1, data_length) == 0);
}
}
while (0);
return ret;
}
int
Ndb_move_data::start_scan()
{
int ret = 0;
Op& op = m_op;
const int attrcount1 = m_source->getNoOfColumns();
do
{
require(op.scantrans == 0);
op.scantrans = op.ndb->startTransaction(m_source);
CHK2(op.scantrans != 0, (op.ndb->getNdbError()));
op.scanop = op.scantrans->getNdbScanOperation(m_source);
CHK2(op.scanop != 0, (op.scantrans->getNdbError()));
NdbOperation::LockMode lm = NdbOperation::LM_Exclusive;
Uint32 flags = 0;
CHK2(op.scanop->readTuples(lm, flags) == 0, (op.scanop->getNdbError()));
require(op.values == 0);
op.values = new Op::Value [attrcount1];
for (int i1 = 0; i1 < attrcount1; i1++)
{
const Attr& attr1 = m_sourceattr[i1];
if (attr1.type != Attr::TypeBlob)
{
NdbRecAttr* ra = op.scanop->getValue(i1);
CHK2(ra != 0, (op.scanop->getNdbError()));
op.values[i1].ra = ra;
}
else
{
NdbBlob* bh = op.scanop->getBlobHandle(i1);
CHK2(bh != 0, (op.scanop->getNdbError()));
op.values[i1].bh = bh;
}
}
CHK1(ret == 0);
CHK2(op.scantrans->execute(NdbTransaction::NoCommit) == 0,
(op.scantrans->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;
}
static int
doorphan(const Blob& b)
{
int ret = 0;
do
{
g_err << "processing blob #" << b.blobno << " " << b.colname
<< " " << b.blobname << endl;
if (opt_dump_file)
{
g_dump << "column: " << b.colname << endl;
g_dump << "blob: " << b.blobname << endl;
g_dump << "orphans (table key; blob part number):" << endl;
}
int totcount = 0;
int orphancount = 0;
CHK1(scanblobstart(b) == 0);
while (1)
{
int res;
res = -1;
CHK1(scanblobnext(b, res) == 0);
if (res != 0)
break;
totcount++;
res = -1;
CHK1(checkorphan(b, res) == 0);
if (res != 0)
{
orphancount++;
if (opt_dump_file)
{
g_dump << "key: ";
for (int i = 0; i < g_valcount; i++)
{
const Val& v = g_vallist[i];
g_dump << *v.ra;
if (i + 1 < g_valcount)
g_dump << ";";
}
g_dump << endl;
}
if (opt_delete_orphans)
{
CHK1(deleteorphan(b) == 0);
}
}
}
CHK1(ret == 0);
g_err << "total parts: " << totcount << endl;
g_err << "orphan parts: " << orphancount << endl;
if (opt_dump_file)
{
g_dump << "total parts: " << totcount << endl;
g_dump << "orphan parts: " << orphancount << endl;
}
}
while (0);
scanblobclose(b);
return ret;
}
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;
}
/* 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;
}
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;
}
