NdbDictionary::Column::Type m_type;

bool m_fixed;

bool m_binary;

uint m_len; // native

uint m_bytelen; // in bytes

uint m_totlen; // plus length bytes

const char* m_cs;

CHARSET_INFO* m_csinfo;

uint m_mblen;

bool m_caseins; // for latin letters

Chr() :

m_type(NdbDictionary::Column::Varchar),

m_fixed(false),

m_binary(false),

m_len(55),

m_bytelen(0),

m_totlen(0),

m_cs("latin1"),

m_csinfo(0),

m_caseins(true)

{}

unsigned m_batch;

bool m_core;

bool m_dbg;

const char* m_debug;

bool m_fac;

bool m_full;

unsigned m_loop;

bool m_min;

unsigned m_parts;

unsigned m_rows;

int m_seed;

const char* m_skip;

const char* m_test;

int m_timeout_retries;

int m_blob_version;

// metadata

const char* m_tname;

const char* m_x1name; // hash index

const char* m_x2name; // ordered index

unsigned m_pk1off;

Chr m_pk2chr;

bool m_pk2part;

bool m_oneblob;

int m_rbatch;

int m_wbatch;

// perf

const char* m_tnameperf;

unsigned m_rowsperf;

// bugs

int m_bug;

int (*m_bugtest)();

Opt() :

m_batch(7),

m_core(false),

m_dbg(false),

m_debug(0),

m_fac(false),

m_full(false),

m_loop(1),

m_min(false),

m_parts(10),

m_rows(100),

m_seed(-1),

m_skip(0),

m_test(0),

m_timeout_retries(10),

m_blob_version(2),

// metadata

m_tname("TB1"),

m_x1name("TB1X1"),

m_x2name("TB1X2"),

m_pk1off(0x12340000),

m_pk2chr(),

m_pk2part(false),

m_oneblob(false),

m_rbatch(-1),

m_wbatch(-1),

// perf

m_tnameperf("TB2"),

m_rowsperf(10000),

// bugs

m_bug(0),

m_bugtest(0)

{}

{

Opt d;

ndbout

<< "usage: testBlobs options [default/max]" << endl

<< " -batch N number of pk ops in batch [" << d.m_batch << "]" << endl

<< " -core dump core on error" << endl

<< " -dbg print program debug" << endl

<< " -debug opt also ndb api DBUG (if no ':' becomes d:t:F:L:o,opt)" << endl

<< " -fac fetch across commit in scan delete" << endl

<< " -full read/write only full blob values" << endl

<< " -loop N loop N times 0=forever [" << d.m_loop << "]" << endl

<< " -min small blob sizes" << endl

<< " -parts N max parts in blob value [" << d.m_parts << "]" << endl

<< " -rows N number of rows [" << d.m_rows << "]" << endl

<< " -rowsperf N rows for performace test [" << d.m_rowsperf << "]" << endl

<< " -seed N random seed 0=loop number -1=random [" << d.m_seed << "]" << endl

<< " -skip xxx skip given tests (see list) [no tests]" << endl

<< " -test xxx only given tests (see list) [all tests]" << endl

<< " -timeoutretries N Number of times to retry in deadlock situations ["

<< d.m_timeout_retries << "]" << endl

<< " -version N blob version 1 or 2 [" << d.m_blob_version << "]" << endl

<< "metadata" << endl

<< " -pk2len N native length of PK2, zero omits PK2,PK3 [" << d.m_pk2chr.m_len << "]" << endl

<< " -pk2fixed PK2 is Char [default Varchar]" << endl

<< " -pk2binary PK2 is Binary or Varbinary" << endl

<< " -pk2cs PK2 charset or collation [" << d.m_pk2chr.m_cs << "]" << endl

<< " -pk2part partition primary table by PK2" << endl

<< " -oneblob only 1 blob attribute [default 2]" << endl

<< " -rbatch N Read parts batchsize (bytes) [default -1] -1=random" << endl

<< " -wbatch N Write parts batchsize (bytes) [default -1] -1=random" << endl

<< "disk or memory storage for blobs. Don't apply to performance test" << endl

<< " m Blob columns stored in memory" << endl

<< " h Blob columns stored on disk" << endl

<< "api styles for test/skip. Don't apply to performance test" << endl

<< " a NdbRecAttr(old) interface" << endl

<< " b NdbRecord interface" << endl

<< "test cases for test/skip" << endl

<< " k primary key ops" << endl

<< " i hash index ops" << endl

<< " s table scans" << endl

<< " r ordered index scans" << endl

<< " p performance test" << endl

<< "operations for test/skip" << endl

<< " u update existing blob value" << endl

<< " n normal insert and update" << endl

<< " w insert and update using writeTuple" << endl

<< " d delete, can skip only for one subtest" << endl

<< " l read with lock and unlock" << endl

<< "blob operation styles for test/skip" << endl

<< " 0 getValue / setValue" << endl

<< " 1 setActiveHook" << endl

<< " 2 readData / writeData" << endl

<< "example: -test makn0 (need all 4 parts)" << endl

<< "example: -test mhabkisrunwd012 (Everything except performance tests" << endl

<< "bug tests" << 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 27370 Potential inconsistent blob reads for ReadCommitted reads" << endl

<< " -bug 36756 Handling execute(.., abortOption) and Blobs " << endl

<< " -bug 45768 execute(Commit) after failing blob batch " << endl

<< " -bug 62321 Blob obscures ignored error codes in batch" << endl

;

{

if (x < 10)

x += '0';

return

(g_opt.m_test == 0 || strchr(g_opt.m_test, x) != 0) &&

(g_opt.m_skip == 0 || strchr(g_opt.m_skip, x) == 0);

{

ndbout << "line " << line << " FAIL " << msg << endl;

if (! g_printerror) {

return;

}

if (g_ndb != 0 && g_ndb->getNdbError().code != 0) {

ndbout << "ndb: " << g_ndb->getNdbError() << endl;

}

if (g_dic != 0 && g_dic->getNdbError().code != 0) {

ndbout << "dic: " << g_dic->getNdbError() << endl;

}

if (g_con != 0 && g_con->getNdbError().code != 0) {

ndbout << "con: " << g_con->getNdbError() << endl;

if (g_opr != 0 && g_opr->getNdbError().code != 0) {

ndbout << "opr: table=" << g_opr->getTableName() << " " << g_opr->getNdbError() << endl;

}

if (g_const_opr != 0 && g_const_opr->getNdbError().code !=0) {

ndbout << "const_opr: table=" << g_const_opr->getTableName() << " " << g_const_opr->getNdbError() << endl;

}

if (g_opx != 0 && g_opx->getNdbError().code != 0) {

ndbout << "opx: table=" << g_opx->getTableName() << " " << g_opx->getNdbError() << endl;

}

if (g_ops != 0 && g_ops->getNdbError().code != 0) {

ndbout << "ops: table=" << g_ops->getTableName() << " " << g_ops->getNdbError() << endl;

}

NdbOperation* ope = g_con->getNdbErrorOperation();

if (ope != 0 && ope->getNdbError().code != 0) {

if (ope != g_opr && ope != g_const_opr && ope != g_opx && ope != g_ops)

ndbout << "ope: ptr=" << ope << " table=" << ope->getTableName() << " type= "<< ope->getType() << " " << ope->getNdbError() << endl;

}

}

if (g_bh1 != 0 && g_bh1->getNdbError().code != 0) {

ndbout << "bh1: " << g_bh1->getNdbError() << endl;

}

if (g_bh2 != 0 && g_bh2->getNdbError().code != 0) {

ndbout << "bh2: " << g_bh2->getNdbError() << endl;

}

if (g_opt.m_core) {

abort();

}

g_printerror = false;

int m_type;

int m_version;

bool m_nullable;

uint m_inline;

uint m_partsize;

uint m_stripe;

char m_btname[200];

Bcol() { memset(this, 0, sizeof(*this)); }

{

{

Bcol& b = g_blob1;

b.m_type = NdbDictionary::Column::Text;

b.m_version = g_opt.m_blob_version;

b.m_nullable = false;

b.m_inline = g_opt.m_min ? 8 : 240;

b.m_partsize = g_opt.m_min ? 8 : 2000;

b.m_stripe = b.m_version == 1 ? 4 : 0;

}

{

Bcol& b = g_blob2;

b.m_type = NdbDictionary::Column::Blob;

b.m_version = g_opt.m_blob_version;

b.m_nullable = true;

b.m_inline = g_opt.m_min ? 9 : 99;

b.m_partsize = g_opt.m_min ? 5 : 55;

b.m_stripe = 3;

}

{

g_pk1_offset= 0;

g_pk2_offset= g_pk1_offset + 4;

g_pk3_offset= g_pk2_offset + g_opt.m_pk2chr.m_totlen;

g_blob1_offset= g_pk3_offset + 2;

g_blob2_offset= g_blob1_offset + sizeof(NdbBlob *);

g_blob1_null_offset= g_blob2_offset + sizeof(NdbBlob *);

g_blob2_null_offset= g_blob1_null_offset + 1;

g_rowsize= g_blob2_null_offset + 1;

{

/* 'Inspired' by NDBT_Tables::create_default_tablespace */

int res;

NdbDictionary::LogfileGroup lg = g_dic->getLogfileGroup("DEFAULT-LG");

if (strcmp(lg.getName(), "DEFAULT-LG") != 0)

{

lg.setName("DEFAULT-LG");

lg.setUndoBufferSize(8*1024*1024);

res = g_dic->createLogfileGroup(lg);

if(res != 0){

DBG("Failed to create logfilegroup:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

{

NdbDictionary::Undofile uf = g_dic->getUndofile(0, "undofile01.dat");

if (strcmp(uf.getPath(), "undofile01.dat") != 0)

{

uf.setPath("undofile01.dat");

uf.setSize(32*1024*1024);

uf.setLogfileGroup("DEFAULT-LG");

res = g_dic->createUndofile(uf, true);

if(res != 0){

DBG("Failed to create undofile:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

}

{

NdbDictionary::Undofile uf = g_dic->getUndofile(0, "undofile02.dat");

if (strcmp(uf.getPath(), "undofile02.dat") != 0)

{

uf.setPath("undofile02.dat");

uf.setSize(32*1024*1024);

uf.setLogfileGroup("DEFAULT-LG");

res = g_dic->createUndofile(uf, true);

if(res != 0){

DBG("Failed to create undofile:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

}

NdbDictionary::Tablespace ts = g_dic->getTablespace(g_tsName);

if (strcmp(ts.getName(), g_tsName) != 0)

{

ts.setName(g_tsName);

ts.setExtentSize(1024*1024);

ts.setDefaultLogfileGroup("DEFAULT-LG");

res = g_dic->createTablespace(ts);

if(res != 0){

DBG("Failed to create tablespace:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

{

NdbDictionary::Datafile df = g_dic->getDatafile(0, "datafile01.dat");

if (strcmp(df.getPath(), "datafile01.dat") != 0)

{

df.setPath("datafile01.dat");

df.setSize(64*1024*1024);

df.setTablespace(g_tsName);

res = g_dic->createDatafile(df, true);

if(res != 0){

DBG("Failed to create datafile:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

}

{

NdbDictionary::Datafile df = g_dic->getDatafile(0, "datafile02.dat");

if (strcmp(df.getPath(), "datafile02.dat") != 0)

{

df.setPath("datafile02.dat");

df.setSize(64*1024*1024);

df.setTablespace(g_tsName);

res = g_dic->createDatafile(df, true);

if(res != 0){

DBG("Failed to create datafile:"

<< endl << g_dic->getNdbError() << endl);

return -1;

}

}

}

return 0;

{

NdbDictionary::Table tab(g_opt.m_tname);

if (g_dic->getTable(g_opt.m_tname) != 0)

CHK(g_dic->dropTable(g_opt.m_tname) == 0);

if (g_key_record != NULL)

g_dic->releaseRecord(g_key_record);

if (g_blob_record != NULL)

g_dic->releaseRecord(g_blob_record);

if (g_full_record != NULL)

g_dic->releaseRecord(g_full_record);

if (g_opt.m_pk2chr.m_len != 0)

{

if (g_idx_record != NULL)

g_dic->releaseRecord(g_idx_record);

if (g_ord_record != NULL)

g_dic->releaseRecord(g_ord_record);

}

g_key_record= NULL;

g_blob_record= NULL;

g_full_record= NULL;

g_idx_record= NULL;

g_ord_record= NULL;

return 0;

{

/* No logging for memory tables */

bool loggingRequired=(storageType == STORAGE_DISK);

NdbDictionary::Column::StorageType blobStorageType=

(storageType == STORAGE_MEM)?

NdbDictionary::Column::StorageTypeMemory :

NdbDictionary::Column::StorageTypeDisk;

NdbDictionary::Table tab(g_opt.m_tname);

if (storageType == STORAGE_DISK)

tab.setTablespaceName(g_tsName);

tab.setLogging(loggingRequired);

/* Choose from the interesting fragmentation types :

Uint32 fragTypeRange= 1 + (NdbDictionary::Object::HashMapPartition -

NdbDictionary::Object::DistrKeyHash);

Uint32 fragType= NdbDictionary::Object::DistrKeyHash + urandom(fragTypeRange);

/* Value 8 is unused currently, map it to something else */

if (fragType == 8)

fragType= NdbDictionary::Object::UserDefined;

tab.setFragmentType((NdbDictionary::Object::FragmentType)fragType);

if (fragType == NdbDictionary::Object::UserDefined)

{

/* Need to set the FragmentCount and fragment to NG mapping

const Uint32 numNodes= g_ncc->no_db_nodes();

const Uint32 numReplicas= 2; // Assumption

const Uint32 guessNumNgs= numNodes/2;

const Uint32 numNgs= guessNumNgs?guessNumNgs : 1;

const Uint32 numFragsPerNode= 2 + (rand() % 3);

const Uint32 numPartitions= numReplicas * numNgs * numFragsPerNode;

tab.setFragmentCount(numPartitions);

for (Uint32 i=0; i<numPartitions; i++)

{

frag_ng_mappings[i]= i % numNgs;

}

tab.setFragmentData(frag_ng_mappings, numPartitions);

}

const Chr& pk2chr = g_opt.m_pk2chr;

// col PK1 - Uint32

{ NdbDictionary::Column col("PK1");

col.setType(NdbDictionary::Column::Unsigned);

col.setPrimaryKey(true);

tab.addColumn(col);

}

// col BL1 - Text not-nullable

{ NdbDictionary::Column col("BL1");

const Bcol& b = g_blob1;

col.setType((NdbDictionary::Column::Type)b.m_type);

col.setBlobVersion(b.m_version);

col.setNullable(b.m_nullable);

col.setInlineSize(b.m_inline);

col.setPartSize(b.m_partsize);

col.setStripeSize(b.m_stripe);

col.setStorageType(blobStorageType);

tab.addColumn(col);

}

// col PK2 - Char or Varchar

if (pk2chr.m_len != 0)

{ NdbDictionary::Column col("PK2");

col.setType(pk2chr.m_type);

col.setPrimaryKey(true);

col.setLength(pk2chr.m_bytelen);

if (pk2chr.m_csinfo != 0)

col.setCharset(pk2chr.m_csinfo);

if (g_opt.m_pk2part)

col.setPartitionKey(true);

tab.addColumn(col);

}

// col BL2 - Blob nullable

if (! g_opt.m_oneblob)

{ NdbDictionary::Column col("BL2");

const Bcol& b = g_blob2;

col.setType((NdbDictionary::Column::Type)b.m_type);

col.setBlobVersion(b.m_version);

col.setNullable(b.m_nullable);

col.setInlineSize(b.m_inline);

col.setPartSize(b.m_partsize);

col.setStripeSize(b.m_stripe);

col.setStorageType(blobStorageType);

tab.addColumn(col);

}

// col PK3 - puts the Var* key PK2 between PK1 and PK3

if (pk2chr.m_len != 0)

{ NdbDictionary::Column col("PK3");

col.setType(NdbDictionary::Column::Smallunsigned);

col.setPrimaryKey(true);

tab.addColumn(col);

}

// create table

CHK(g_dic->createTable(tab) == 0);

// unique hash index on PK2,PK3

if (g_opt.m_pk2chr.m_len != 0)

{ NdbDictionary::Index idx(g_opt.m_x1name);

idx.setType(NdbDictionary::Index::UniqueHashIndex);

idx.setLogging(loggingRequired);

idx.setTable(g_opt.m_tname);

idx.addColumnName("PK2");

idx.addColumnName("PK3");

CHK(g_dic->createIndex(idx) == 0);

}

// ordered index on PK2

if (g_opt.m_pk2chr.m_len != 0)

{ NdbDictionary::Index idx(g_opt.m_x2name);

idx.setType(NdbDictionary::Index::OrderedIndex);

idx.setLogging(false);

idx.setTable(g_opt.m_tname);

idx.addColumnName("PK2");

CHK(g_dic->createIndex(idx) == 0);

}

NdbDictionary::RecordSpecification spec[5];

unsigned numpks= g_opt.m_pk2chr.m_len == 0 ? 1 : 3;

unsigned numblobs= g_opt.m_oneblob ? 1 : 2;

const NdbDictionary::Table *dict_table;

CHK((dict_table= g_dic->getTable(g_opt.m_tname)) != 0);

memset(spec, 0, sizeof(spec));

spec[0].column= dict_table->getColumn("PK1");

spec[0].offset= g_pk1_offset;

spec[numpks].column= dict_table->getColumn("BL1");

spec[numpks].offset= g_blob1_offset;

spec[numpks].nullbit_byte_offset= g_blob1_null_offset;

spec[numpks].nullbit_bit_in_byte= 0;

if (g_opt.m_pk2chr.m_len != 0)

{

spec[1].column= dict_table->getColumn("PK2");

spec[1].offset= g_pk2_offset;

spec[2].column= dict_table->getColumn("PK3");

spec[2].offset= g_pk3_offset;

}

if (! g_opt.m_oneblob)

{

spec[numpks+1].column= dict_table->getColumn("BL2");

spec[numpks+1].offset= g_blob2_offset;

spec[numpks+1].nullbit_byte_offset= g_blob2_null_offset;

spec[numpks+1].nullbit_bit_in_byte= 0;

}

CHK((g_key_record= g_dic->createRecord(dict_table, &spec[0], numpks,

sizeof(spec[0]))) != 0);

CHK((g_blob_record= g_dic->createRecord(dict_table, &spec[numpks], numblobs,

sizeof(spec[0]))) != 0);

CHK((g_full_record= g_dic->createRecord(dict_table, &spec[0], numpks+numblobs,

sizeof(spec[0]))) != 0);

if (g_opt.m_pk2chr.m_len != 0)

{

const NdbDictionary::Index *dict_index;

CHK((dict_index= g_dic->getIndex(g_opt.m_x1name, g_opt.m_tname)) != 0);

CHK((g_idx_record= g_dic->createRecord(dict_index, &spec[1], 2,

sizeof(spec[0]))) != 0);

CHK((dict_index= g_dic->getIndex(g_opt.m_x2name, g_opt.m_tname)) != 0);

CHK((g_ord_record= g_dic->createRecord(dict_index, &spec[1], 1,

sizeof(spec[0]))) != 0);

}

return 0;

const Bcol& m_bcol;

char* m_val;

unsigned m_len;

char* m_buf; // read/write buffer

unsigned m_buflen;

int m_error_code; // for testing expected error code

Bval(const Bcol& bcol) :

m_bcol(bcol),

m_val(0),

m_len(0),

m_buf(0),

m_buflen(0),

m_error_code(0)

{}

~Bval() { delete [] m_val; delete [] m_buf; }

void alloc() {

alloc(m_bcol.m_inline + m_bcol.m_partsize * g_opt.m_parts);

}

void alloc(unsigned buflen) {

m_buflen = buflen;

delete [] m_buf;

m_buf = new char [m_buflen];

trash();

}

void copyfrom(const Bval& v) {

m_len = v.m_len;

delete [] m_val;

if (v.m_val == 0)

m_val = 0;

else

m_val = (char*)memcpy(new char [m_len], v.m_val, m_len);

}

void trash() const {

assert(m_buf != 0);

memset(m_buf, 'x', m_buflen);

}

Bval(const Bval&);

Bval& operator=(const Bval&);

bool m_exists; // exists in table

Uint32 m_pk1; // in V1 primary keys concatenated like keyinfo

char* m_pk2;

char* m_pk2eq; // equivalent (if case independent)

Uint16 m_pk3;

Bval m_bval1;

Bval m_bval2;

char *m_key_row;

char *m_row;

Uint32 m_frag;

Tup() :

m_exists(false),

m_pk2(new char [g_opt.m_pk2chr.m_totlen + 1]), // nullterm for convenience

m_pk2eq(new char [g_opt.m_pk2chr.m_totlen + 1]),

m_bval1(g_blob1),

m_bval2(g_blob2),

m_key_row(new char[g_rowsize]),

m_row(new char[g_rowsize]),

m_frag(~(Uint32)0)

{}

~Tup() {

delete [] m_pk2;

m_pk2 = 0;

delete [] m_pk2eq;

m_pk2eq = 0;

delete [] m_key_row;

m_key_row= 0;

delete [] m_row;

m_row= 0;

}

// alloc buffers of max size

void alloc() {

m_bval1.alloc();

m_bval2.alloc();

}

void copyfrom(const Tup& tup) {

assert(m_pk1 == tup.m_pk1);

m_bval1.copyfrom(tup.m_bval1);

m_bval2.copyfrom(tup.m_bval2);

}

/*

char* pk2() {

if (g_opt.m_blob_version == 1)

return m_pk2;

return urandom(2) == 0 ? m_pk2 : m_pk2eq;

}

Uint32 getPartitionId(Uint32 numParts) const {

/* Only for UserDefined tables really */

return m_pk1 % numParts; // MySQLD hash(PK1) style partitioning

}

Tup(const Tup&);

Tup& operator=(const Tup&);

{

const NdbDictionary::Table* tab= op->getTable();

if (tab->getFragmentType() == NdbDictionary::Object::UserDefined)

{

Uint32 partId= tup.getPartitionId(tab->getFragmentCount());

DBG("Setting partition id to " << partId << " out of " <<

tab->getFragmentCount());

op->setPartitionId(partId);

}

const NdbDictionary::Table* tab,

NdbOperation::OperationOptions& opts)

{

opts.optionsPresent= 0;

if (tab->getFragmentType() == NdbDictionary::Object::UserDefined)

{

opts.optionsPresent= NdbOperation::OperationOptions::OO_PARTITION_ID;

opts.partitionId= tup.getPartitionId(tab->getFragmentCount());

}

{

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

v.m_len = 0;

delete [] v.m_val;

v.m_val = 0;

v.m_buf = new char [1];

} else {

if (keepsize && v.m_val != 0)

;

else if (urandom(10) == 0)

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;

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

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

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

v.m_val[v.m_len] = 0;

v.m_buf = new char [v.m_len];

}

v.m_buflen = v.m_len;

v.trash();

{

Uint32 code= g_con->getNdbError().code;

/* Indicate timeout for cases where LQH too slow responding

// 296 == Application timeout waiting for SCAN_NEXTREQ from API

// 297 == Error code in response to SCAN_NEXTREQ for timed-out scan

bool isTimeout= ((code == 274) || // General TC connection timeout

(code == 266)); // TC Scan frag timeout

if (!isTimeout)

ndbout << "Connection error is not timeout, but is "

<< code << endl;

return isTimeout;

{

calcBval(g_blob1, tup.m_bval1, keepsize);

if (! g_opt.m_oneblob)

calcBval(g_blob2, tup.m_bval2, keepsize);

{

for (uint k = 0; k < g_opt.m_rows; k++) {

Tup& tup = g_tups[k];

if (keys) {

tup.m_pk1 = g_opt.m_pk1off + k;

{

const Chr& c = g_opt.m_pk2chr;

char* const p = tup.m_pk2;

char* const q = tup.m_pk2eq;

uint len = urandom(c.m_len + 1);

uint i = 0;

if (! c.m_fixed) {

*(uchar*)&p[0] = *(uchar*)&q[0] = len;

i++;

}

uint j = 0;

while (j < len) {

// mixed case for distribution check

if (urandom(3) == 0) {

uint u = urandom(26);

p[i] = 'A' + u;

q[i] = c.m_caseins ? 'a' + u : 'A' + u;

} else {

uint u = urandom(26);

p[i] = 'a' + u;

q[i] = c.m_caseins ? 'A' + u : 'a' + u;

}

i++;

j++;

}

while (j < c.m_bytelen) {

if (c.m_fixed)

p[i] = q[i] = 0x20;

else

p[i] = q[i] = '#'; // garbage

i++;

j++;

}

assert(i == c.m_totlen);

p[i] = q[i] = 0; // convenience

}

tup.m_pk3 = (Uint16)k;

}

calcBval(tup, keepsize);

}

{

if (g_opt.m_rbatch != 0)

{

Uint32 byteSize = (g_opt.m_rbatch == -1) ?

urandom(~Uint32(0)) :

g_opt.m_rbatch;

DBG("Setting read batch size to " << byteSize

<< " bytes.");

g_con->setMaxPendingBlobReadBytes(byteSize);

}

if (g_opt.m_wbatch != 0)

{

Uint32 byteSize = (g_opt.m_wbatch == -1) ?

urandom(~Uint32(0)) :

g_opt.m_wbatch;

DBG("Setting write batch size to " << byteSize

<< " bytes.");

g_con->setMaxPendingBlobWriteBytes(byteSize);

}

{

CHK((g_bh1 = opr->getBlobHandle("BL1")) != 0);

if (! g_opt.m_oneblob)

CHK((g_bh2 = opr->getBlobHandle("BL2")) != 0);

setBatchSizes();

return 0;

{

CHK((g_bh1 = opr->getBlobHandle("BL1")) != 0);

if (! g_opt.m_oneblob)

CHK((g_bh2 = opr->getBlobHandle("BL2")) != 0);

setBatchSizes();

return 0;