/*
* Routine: EvalRowcountExpr(expr_t *pExpr, StringBuffer_t *pBuf);
* Purpose: set the values to be used to replace a given tag for this query generation
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO:
*/
int
EvalRowcountExpr(expr_t *pExpr, Expr_Val_t *pBuf, Expr_Val_t *pParams)
{
char szBuf[20],
szTable[40],
*szName;
int i;
szName = GetBuffer(pParams->pBuf);
if (pExpr->nFlags & EXPR_FL_TABLENAME)
{
for (i=1; i <= distsize("rowcounts"); i++)
{
dist_member(szTable, "rowcounts", i, 1);
if (strcasecmp(szTable, szName) == 0)
break;
}
if (i > distsize("rowcounts"))
ReportError(QERR_BAD_NAME, szName, 1);
sprintf(szBuf, HUGE_FORMAT, get_rowcount(i));
}
else
sprintf(szBuf, "%d", distsize(szName));
AddBuffer(pBuf->pBuf, szBuf);
return(DT_INT);
}
static uint64_t get_tab_row_count( const VDatabase * db, const char * table_name )
{
uint64_t res = 0;
const VTable * tab;
rc_t rc = VDatabaseOpenTableRead( db, &tab, table_name );
if ( rc == 0 )
{
res = get_rowcount( tab );
VTableRelease( tab );
}
return res;
}
/*
* Routine: randomSparseKey()
* Purpose: randomly select one of the valid key values for a sparse table
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
ds_key_t
randomSparseKey(int nTable, int nColumn)
{
int nKeyIndex;
ds_key_t kRowcount;
tdef *pTdef;
pTdef = getTdefsByNumber(nTable);
kRowcount = get_rowcount(nTable);
genrand_integer(&nKeyIndex, DIST_UNIFORM, 1, (long)kRowcount, 0, nColumn);
return(pTdef->arSparseKeys[nKeyIndex]);
}
/*
* Routine: split_work(int tnum, worker_t *w)
* Purpose: allocate work between processes and threads
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions:
* Side Effects:
* TODO: None
*/
int
split_work (int tnum, ds_key_t * pkFirstRow, ds_key_t * pkRowCount)
{
ds_key_t kTotalRows, kRowsetSize, kExtraRows;
int nParallel, nChild;
kTotalRows = get_rowcount(tnum);
nParallel = get_int ("PARALLEL");
nChild = get_int ("CHILD");
/*
* 1. small tables aren't paralelized
* 2. nothing is parallelized unless a command line arg is supplied
*/
*pkFirstRow = 1;
*pkRowCount = kTotalRows;
if (kTotalRows < 1000000)
{
if (nChild > 1) /* small table; only build it once */
{
*pkFirstRow = 1;
*pkRowCount = 0;
return (0);
}
return (1);
}
if (!is_set ("PARALLEL"))
{
return (1);
}
/*
* at this point, do the calculation to set the rowcount for this part of a parallel build
*/
kExtraRows = kTotalRows % nParallel;
kRowsetSize = (kTotalRows - kExtraRows) / nParallel;
/* start the starting row id */
*pkFirstRow += (nChild - 1) * kRowsetSize;
if (kExtraRows && (nChild - 1))
*pkFirstRow += ((nChild - 1) < kExtraRows) ? (nChild - 1) : kExtraRows;
/* set the rowcount for this child */
*pkRowCount = kRowsetSize;
if (kExtraRows && (nChild <= kExtraRows))
*pkRowCount += 1;
return (1);
}
static rc_t vdb_info_db( vdb_info_data * data, VSchema * schema, const VDBManager *mgr )
{
const VDatabase * db;
rc_t rc = VDBManagerOpenDBRead( mgr, &db, schema, "%s", data->acc );
if ( rc == 0 )
{
const VTable * tab;
const KMetadata * meta = NULL;
rc_t rc1 = VDatabaseOpenTableRead( db, &tab, "SEQUENCE" );
if ( rc1 == 0 )
{
data->s_platform = get_platform( tab );
data->seq_rows = get_rowcount( tab );
VTableRelease( tab );
}
data->ref_rows = get_tab_row_count( db, "REFERENCE" );
data->prim_rows = get_tab_row_count( db, "PRIMARY_ALIGNMENT" );
data->sec_rows = get_tab_row_count( db, "SECONDARY_ALIGNMENT" );
data->ev_rows = get_tab_row_count( db, "EVIDENCE_ALIGNMENT" );
data->ev_int_rows = get_tab_row_count( db, "EVIDENCE_INTERVAL" );
data->consensus_rows = get_tab_row_count( db, "CONSENSUS" );
data->passes_rows = get_tab_row_count( db, "PASSES" );
data->metrics_rows = get_tab_row_count( db, "ZMW_METRICS" );
if ( data->ref_rows > 0 )
get_species( data->species, sizeof data->species, db, mgr );
rc = VDatabaseOpenMetadataRead ( db, &meta );
if ( rc == 0 )
{
get_meta_info( data, meta );
KMetadataRelease ( meta );
}
VDatabaseRelease( db );
}
return rc;
}
static rc_t vdb_info_tab( vdb_info_data * data, VSchema * schema, const VDBManager *mgr )
{
const VTable * tab;
rc_t rc = VDBManagerOpenTableRead( mgr, &tab, schema, "%s", data->acc );
if ( rc == 0 )
{
const KMetadata * meta = NULL;
data->s_platform = get_platform( tab );
data->seq_rows = get_rowcount( tab );
rc = VTableOpenMetadataRead ( tab, &meta );
if ( rc == 0 )
{
get_meta_info( data, meta );
KMetadataRelease ( meta );
}
VTableRelease( tab );
}
return rc;
}
/*
* Routine: initSparseKeys()
* Purpose: set up the set of valid key values for a sparse table.
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By:
* Calls:
* Assumptions: The total population will fit in 32b
* Side Effects:
* TODO: None
*/
int
initSparseKeys(int nTable)
{
ds_key_t kRowcount,
kOldSeed;
int k;
tdef *pTdef;
kRowcount = get_rowcount(nTable);
pTdef = getTdefsByNumber(nTable);
pTdef->arSparseKeys = (ds_key_t *)malloc((long)kRowcount * sizeof(ds_key_t));
MALLOC_CHECK(pTdef->arSparseKeys);
if (pTdef->arSparseKeys == NULL)
ReportError(QERR_NO_MEMORY, "initSparseKeys()", 1);
memset(pTdef->arSparseKeys, 0, (long)kRowcount * sizeof(ds_key_t));
kOldSeed = setSeed(0, nTable);
for (k = 0; k < kRowcount; k++)
genrand_key(&pTdef->arSparseKeys[k], DIST_UNIFORM, 1, pTdef->nParam, 0, 0);
setSeed(0, (int)kOldSeed);
return(0);
}
