Commit 6fe073e1 authored by unknown's avatar unknown
Browse files

ndb - test progs 


ndb/test/ndbapi/testOIBasic.cpp:
  random order of ndbapi calls
ndb/test/ndbapi/testBlobs.cpp:
  valgrind fix, compile fix for 5.1
parent aeda2652

ndb/test/ndbapi/testBlobs.cpp

+3 −4
Original line number Diff line number Diff line
@@ -23,14 +23,13 @@ 
#include <NdbOut.hpp>

#include <NdbTest.hpp>

#include <NdbTick.h>

#include <ndb/src/ndbapi/NdbBlobImpl.hpp>



struct Bcol {

  bool m_nullable;

  unsigned m_inline;

  unsigned m_partsize;

  unsigned m_stripe;

  char m_btname[NdbBlobImpl::BlobTableNameSize];

  char m_btname[200];

  Bcol(bool a, unsigned b, unsigned c, unsigned d) :

    m_nullable(a),

    m_inline(b),
@@ -365,7 +364,7 @@ calcBval(const Bcol& b, Bval& v, bool keepsize) 
{

  if (b.m_nullable && urandom(10) == 0) {

    v.m_len = 0;

    delete v.m_val;

    delete [] v.m_val;

    v.m_val = 0;

    v.m_buf = new char [1];

  } else {
@@ -375,7 +374,7 @@ calcBval(const Bcol& b, Bval& v, bool keepsize) 
      v.m_len = urandom(b.m_inline);

    else

      v.m_len = urandom(b.m_inline + g_opt.m_parts * b.m_partsize + 1);

    delete v.m_val;

    delete [] v.m_val;

    v.m_val = new char [v.m_len + 1];

    for (unsigned i = 0; i < v.m_len; i++)

      v.m_val[i] = 'a' + urandom(25);

ndb/test/ndbapi/testOIBasic.cpp

+96 −34
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include <NdbSleep.h>

#include <my_sys.h>

#include <NdbSqlUtil.hpp>

#include <ndb_version.h>



// options
@@ -171,6 +172,47 @@ randompct(unsigned pct) 
  return urandom(100) < pct;

}



static unsigned

random_coprime(unsigned n)

{

    unsigned prime[] = { 101, 211, 307, 401, 503, 601, 701, 809, 907 };

    unsigned count = sizeof(prime) / sizeof(prime[0]);

    if (n == 0)

      return 0;

    while (1) {

      unsigned i = urandom(count);

      if (n % prime[i] != 0)

        return prime[i];

    }

}



// random re-sequence of 0...(n-1)



struct Rsq {

  Rsq(unsigned n);

  unsigned next();

private:

  unsigned m_n;

  unsigned m_i;

  unsigned m_start;

  unsigned m_prime;

};



Rsq::Rsq(unsigned n)

{

  m_n = n;

  m_i = 0;

  m_start = urandom(n);

  m_prime = random_coprime(n);

}



unsigned

Rsq::next()

{

  assert(m_n != 0);

  return (m_start + m_i++ * m_prime) % m_n;

}



// log and error macros



static NdbMutex *ndbout_mutex = NULL;
@@ -1032,8 +1074,8 @@ makebuiltintables(Par par) 
    // name - pk - type - length - nullable - cs

    t->coladd(0, new Col(*t, 0, "a", 0, Col::Unsigned, 1, 0, 0));

    t->coladd(1, new Col(*t, 1, "b", 1, Col::Unsigned, 1, 0, 0));

    t->coladd(2, new Col(*t, 2, "c", 0, Col::Char, 20, 1, getcs(par)));

    t->coladd(3, new Col(*t, 3, "d", 0, Col::Varchar, 5, 0, getcs(par)));

    t->coladd(2, new Col(*t, 2, "c", 0, Col::Varchar, 20, 0, getcs(par)));

    t->coladd(3, new Col(*t, 3, "d", 0, Col::Char, 5, 0, getcs(par)));

    t->coladd(4, new Col(*t, 4, "e", 0, Col::Longvarchar, 5, 1, getcs(par)));

    if (useindex(par, 0)) {

      // b
@@ -1071,10 +1113,10 @@ makebuiltintables(Par par) 
      t->itabadd(4, x);

    }

    if (useindex(par, 5)) {

      // a, b, d

      // b, c, d

      ITab* x = new ITab(*t, "ti1z5", ITab::UniqueHashIndex, 3);

      x->icoladd(0, new ICol(*x, 0, *t->m_col[0]));

      x->icoladd(1, new ICol(*x, 1, *t->m_col[1]));

      x->icoladd(0, new ICol(*x, 0, *t->m_col[1]));

      x->icoladd(1, new ICol(*x, 1, *t->m_col[2]));

      x->icoladd(2, new ICol(*x, 2, *t->m_col[3]));

      t->itabadd(5, x);

    }
@@ -2254,14 +2296,18 @@ Row::insrow(Par par) 
  assert(! m_exist);

  CHK(con.getNdbOperation(tab) == 0);

  CHKCON(con.m_op->insertTuple() == 0, con);

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq1.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (col.m_pk)

      CHK(val.equal(par) == 0);

  }

  Rsq rsq2(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq2.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (! col.m_pk)

      CHK(val.setval(par) == 0);
@@ -2278,14 +2324,18 @@ Row::updrow(Par par) 
  assert(m_exist);

  CHK(con.getNdbOperation(tab) == 0);

  CHKCON(con.m_op->updateTuple() == 0, con);

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq1.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (col.m_pk)

      CHK(val.equal(par) == 0);

  }

  Rsq rsq2(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq2.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (! col.m_pk)

      CHK(val.setval(par) == 0);
@@ -2303,15 +2353,19 @@ Row::updrow(Par par, const ITab& itab) 
  assert(m_exist);

  CHK(con.getNdbIndexOperation(itab, tab) == 0);

  CHKCON(con.m_op->updateTuple() == 0, con);

  Rsq rsq1(itab.m_icols);

  for (unsigned k = 0; k < itab.m_icols; k++) {

    const ICol& icol = *itab.m_icol[k];

    unsigned k2 = rsq1.next();

    const ICol& icol = *itab.m_icol[k2];

    const Col& col = icol.m_col;

    unsigned m = col.m_num;

    const Val& val = *m_val[m];

    CHK(val.equal(par, icol) == 0);

  }

  Rsq rsq2(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq2.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (! col.m_pk)

      CHK(val.setval(par) == 0);
@@ -2328,8 +2382,10 @@ Row::delrow(Par par) 
  assert(m_exist);

  CHK(con.getNdbOperation(m_tab) == 0);

  CHKCON(con.m_op->deleteTuple() == 0, con);

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq1.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (col.m_pk)

      CHK(val.equal(par) == 0);
@@ -2347,8 +2403,10 @@ Row::delrow(Par par, const ITab& itab) 
  assert(m_exist);

  CHK(con.getNdbIndexOperation(itab, tab) == 0);

  CHKCON(con.m_op->deleteTuple() == 0, con);

  Rsq rsq1(itab.m_icols);

  for (unsigned k = 0; k < itab.m_icols; k++) {

    const ICol& icol = *itab.m_icol[k];

    unsigned k2 = rsq1.next();

    const ICol& icol = *itab.m_icol[k2];

    const Col& col = icol.m_col;

    unsigned m = col.m_num;

    const Val& val = *m_val[m];
@@ -2365,8 +2423,10 @@ Row::selrow(Par par) 
  const Tab& tab = m_tab;

  CHK(con.getNdbOperation(m_tab) == 0);

  CHKCON(con.m_op->readTuple() == 0, con);

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq1.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (col.m_pk)

      CHK(val.equal(par) == 0);
@@ -2382,8 +2442,10 @@ Row::selrow(Par par, const ITab& itab) 
  assert(itab.m_type == ITab::UniqueHashIndex && &itab.m_tab == &tab);

  CHK(con.getNdbIndexOperation(itab, tab) == 0);

  CHKCON(con.m_op->readTuple() == 0, con);

  Rsq rsq1(itab.m_icols);

  for (unsigned k = 0; k < itab.m_icols; k++) {

    const ICol& icol = *itab.m_icol[k];

    unsigned k2 = rsq1.next();

    const ICol& icol = *itab.m_icol[k2];

    const Col& col = icol.m_col;

    unsigned m = col.m_num;

    const Val& val = *m_val[m];
@@ -2397,8 +2459,10 @@ Row::setrow(Par par) 
{

  Con& con = par.con();

  const Tab& tab = m_tab;

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    const Val& val = *m_val[k];

    unsigned k2 = rsq1.next();

    const Val& val = *m_val[k2];

    const Col& col = val.m_col;

    if (! col.m_pk)

      CHK(val.setval(par) == 0);
@@ -2810,8 +2874,10 @@ Set::getval(Par par) 
{

  Con& con = par.con();

  const Tab& tab = m_tab;

  Rsq rsq1(tab.m_cols);

  for (unsigned k = 0; k < tab.m_cols; k++) {

    CHK(con.getValue(k, m_rec[k]) == 0);

    unsigned k2 = rsq1.next();

    CHK(con.getValue(k2, m_rec[k2]) == 0);

  }

  return 0;

}
@@ -3093,18 +3159,16 @@ int 
BSet::setbnd(Par par) const

{

  if (m_bvals != 0) {

    unsigned p1 = urandom(m_bvals);

    unsigned p2 = 10009;        // prime

    // random order

    Rsq rsq1(m_bvals);

    for (unsigned j = 0; j < m_bvals; j++) {

      unsigned k = p1 + p2 * j;

      const BVal& bval = *m_bval[k % m_bvals];

      unsigned j2 = rsq1.next();

      const BVal& bval = *m_bval[j2];

      CHK(bval.setbnd(par) == 0);

    }

    // duplicate

    if (urandom(5) == 0) {

      unsigned k = urandom(m_bvals);

      const BVal& bval = *m_bval[k];

      unsigned j3 = urandom(m_bvals);

      const BVal& bval = *m_bval[j3];

      CHK(bval.setbnd(par) == 0);

    }

  }
@@ -3118,19 +3182,16 @@ BSet::setflt(Par par) const 
  CHK(con.getNdbScanFilter() == 0);

  CHK(con.beginFilter(NdbScanFilter::AND) == 0);

  if (m_bvals != 0) {

    unsigned p1 = urandom(m_bvals);

    unsigned p2 = 10009;        // prime

    const unsigned extras = 5;

    // random order

    for (unsigned j = 0; j < m_bvals + extras; j++) {

      unsigned k = p1 + p2 * j;

      const BVal& bval = *m_bval[k % m_bvals];

    Rsq rsq1(m_bvals);

    for (unsigned j = 0; j < m_bvals; j++) {

      unsigned j2 = rsq1.next();

      const BVal& bval = *m_bval[j2];

      CHK(bval.setflt(par) == 0);

    }

    // duplicate

    if (urandom(5) == 0) {

      unsigned k = urandom(m_bvals);

      const BVal& bval = *m_bval[k];

      unsigned j3 = urandom(m_bvals);

      const BVal& bval = *m_bval[j3];

      CHK(bval.setflt(par) == 0);

    }

  }
@@ -4176,6 +4237,7 @@ readverifyfull(Par par) 
    CHK(scanreadtable(par) == 0);

    // once more via tup scan

    par.m_tupscan = true;

    if (NDB_VERSION < MAKE_VERSION(5, 1, 0)) //TODO

      CHK(scanreadtable(par) == 0);

  }

  // each thread scans different indexes