int main( int argc_, const char* argv_[])
{
int rt = 0;
std::auto_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
strus::ProgramOptions opt;
bool printUsageAndExit = false;
try
{
opt = strus::ProgramOptions(
argc_, argv_, 14,
"h,help", "v,version", "license",
"Q,quiet", "u,user:"******"N,nofranks:", "I,firstrank:",
"D,time", "m,module:", "M,moduledir:", "R,resourcedir:",
"s,storage:", "r,rpc:", "T,trace:");
if (opt( "help")) printUsageAndExit = true;
std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get()));
if (!moduleLoader.get()) throw strus::runtime_error(_TXT("failed to create module loader"));
if (opt("moduledir"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
std::vector<std::string> modirlist( opt.list("moduledir"));
std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end();
for (; mi != me; ++mi)
{
moduleLoader->addModulePath( *mi);
}
moduleLoader->addSystemModulePath();
}
if (opt("module"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--module", "--rpc");
std::vector<std::string> modlist( opt.list("module"));
std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end();
for (; mi != me; ++mi)
{
if (!moduleLoader->loadModule( *mi))
{
throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str());
}
}
}
if (opt("license"))
{
std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts();
std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end();
if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl;
for (; ti != te; ++ti)
{
std::cout << *ti << std::endl;
}
std::cerr << std::endl;
if (!printUsageAndExit) return 0;
}
if (opt( "version"))
{
std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl;
std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl;
std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl;
std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl;
std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts();
std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end();
if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl;
for (; vi != ve; ++vi)
{
std::cout << *vi << std::endl;
}
if (!printUsageAndExit) return 0;
}
else if (!printUsageAndExit)
{
if (opt.nofargs() > 3)
{
std::cerr << _TXT("too many arguments") << std::endl;
printUsageAndExit = true;
rt = 1;
}
if (opt.nofargs() < 3)
{
std::cerr << _TXT("too few arguments") << std::endl;
printUsageAndExit = true;
rt = 2;
}
}
if (printUsageAndExit)
{
std::cout << _TXT("usage:") << " strusQuery [options] <anprg> <qeprg> <query>" << std::endl;
std::cout << "<anprg> = " << _TXT("path of query analyzer program") << std::endl;
std::cout << "<qeprg> = " << _TXT("path of query eval program") << std::endl;
std::cout << "<query> = " << _TXT("path of query or '-' for stdin") << std::endl;
std::cout << _TXT("description: Executes a query or a list of queries from a file.") << std::endl;
std::cout << _TXT("options:") << std::endl;
std::cout << "-h|--help" << std::endl;
std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl;
std::cout << "-v|--version" << std::endl;
std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl;
std::cout << "--license" << std::endl;
std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl;
std::cout << "-s|--storage <CONFIG>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl;
if (!opt("rpc"))
{
std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl;
printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get());
}
std::cout << "-u|--user <NAME>" << std::endl;
std::cout << " " << _TXT("Use user name <NAME> for the query") << std::endl;
std::cout << "-N|--nofranks <N>" << std::endl;
std::cout << " " << _TXT("Return maximum <N> ranks as query result") << std::endl;
std::cout << "-I|--firstrank <N>" << std::endl;
std::cout << " " << _TXT("Return the result starting with rank <N> as first rank") << std::endl;
std::cout << "-Q|--quiet" << std::endl;
std::cout << " " << _TXT("No output of results") << std::endl;
std::cout << "-D|--time" << std::endl;
std::cout << " " << _TXT("Do print duration of pure query evaluation") << std::endl;
std::cout << "-m|--module <MOD>" << std::endl;
std::cout << " " << _TXT("Load components from module <MOD>") << std::endl;
std::cout << "-M|--moduledir <DIR>" << std::endl;
std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl;
std::cout << "-R|--resourcedir <DIR>" << std::endl;
std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl;
std::cout << "-r|--rpc <ADDR>" << std::endl;
std::cout << " " << _TXT("Execute the command on the RPC server specified by <ADDR>") << std::endl;
std::cout << "-T|--trace <CONFIG>" << std::endl;
std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl;
std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl;
return rt;
}
// Parse arguments:
bool quiet = opt( "quiet");
bool measureDuration = opt( "time");
std::string username;
std::size_t nofRanks = 20;
std::size_t firstRank = 0;
std::string storagecfg;
if (opt("user"))
{
username = opt[ "user"];
}
if (opt("nofranks"))
{
nofRanks = opt.asUint( "nofranks");
}
if (opt("firstrank"))
{
firstRank = opt.asUint( "firstrank");
}
if (opt("storage"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
storagecfg = opt["storage"];
}
std::string analyzerprg = opt[0];
std::string queryprg = opt[1];
std::string querypath = opt[2];
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (opt("trace"))
{
std::vector<std::string> tracecfglist( opt.list("trace"));
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get()));
}
}
// Set paths for locating resources:
if (opt("resourcedir"))
{
std::vector<std::string> pathlist( opt.list("resourcedir"));
std::vector<std::string>::const_iterator
pi = pathlist.begin(), pe = pathlist.end();
for (; pi != pe; ++pi)
{
moduleLoader->addResourcePath( *pi);
}
}
std::string resourcepath;
if (0!=strus::getParentPath( analyzerprg, resourcepath))
{
throw strus::runtime_error( _TXT("failed to evaluate resource path"));
}
if (!resourcepath.empty())
{
moduleLoader->addResourcePath( resourcepath);
}
// Create objects for query evaluation:
std::auto_ptr<strus::RpcClientMessagingInterface> messaging;
std::auto_ptr<strus::RpcClientInterface> rpcClient;
std::auto_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder;
std::auto_ptr<strus::StorageObjectBuilderInterface> storageBuilder;
if (opt("rpc"))
{
messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get()));
if (!messaging.get()) throw strus::runtime_error(_TXT("failed to create rpc client messaging"));
rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get()));
if (!rpcClient.get()) throw strus::runtime_error(_TXT("failed to create rpc client"));
(void)messaging.release();
analyzerBuilder.reset( rpcClient->createAnalyzerObjectBuilder());
if (!analyzerBuilder.get()) throw strus::runtime_error(_TXT("failed to create rpc analyzer object builder"));
storageBuilder.reset( rpcClient->createStorageObjectBuilder());
if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create rpc storage object builder"));
}
else
{
analyzerBuilder.reset( moduleLoader->createAnalyzerObjectBuilder());
if (!analyzerBuilder.get()) throw strus::runtime_error(_TXT("failed to create analyzer object builder"));
storageBuilder.reset( moduleLoader->createStorageObjectBuilder());
if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create storage object builder"));
}
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::AnalyzerObjectBuilderInterface* aproxy = (*ti)->createProxy( analyzerBuilder.get());
analyzerBuilder.release();
analyzerBuilder.reset( aproxy);
strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get());
storageBuilder.release();
storageBuilder.reset( sproxy);
}
// Create objects:
std::auto_ptr<strus::StorageClientInterface>
storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg));
if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client"));
strus::utils::ScopedPtr<strus::QueryAnalyzerInterface>
analyzer( analyzerBuilder->createQueryAnalyzer());
if (!analyzer.get()) throw strus::runtime_error(_TXT("failed to create query analyzer"));
strus::utils::ScopedPtr<strus::QueryEvalInterface>
qeval( storageBuilder->createQueryEval());
if (!qeval.get()) throw strus::runtime_error(_TXT("failed to create query evaluation interface"));
const strus::QueryProcessorInterface* qproc = storageBuilder->getQueryProcessor();
if (!qproc) throw strus::runtime_error(_TXT("failed to get query processor"));
const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor();
if (!textproc) throw strus::runtime_error(_TXT("failed to get text processor"));
// Load query analyzer program:
unsigned int ec;
std::string analyzerProgramSource;
ec = strus::readFile( analyzerprg, analyzerProgramSource);
if (ec) throw strus::runtime_error(_TXT("failed to load analyzer program %s (errno %u)"), analyzerprg.c_str(), ec);
if (!strus::loadQueryAnalyzerProgram( *analyzer, textproc, analyzerProgramSource, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query analyzer program"));
}
// Load query evaluation program:
std::string qevalProgramSource;
ec = strus::readFile( queryprg, qevalProgramSource);
if (ec) throw strus::runtime_error(_TXT("failed to load query eval program %s (errno %u)"), queryprg.c_str(), ec);
if (!strus::loadQueryEvalProgram( *qeval, qproc, qevalProgramSource, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query evaluation program"));
}
// Load query:
std::string querystring;
if (querypath == "-")
{
ec = strus::readStdin( querystring);
if (ec) throw strus::runtime_error( _TXT("failed to read query string from stdin (errno %u)"), ec);
}
else
{
ec = strus::readFile( querypath, querystring);
if (ec) throw strus::runtime_error(_TXT("failed to read query string from file %s (errno %u)"), querypath.c_str(), ec);
}
unsigned int nofQueries = 0;
double startTime = 0.0;
if (measureDuration)
{
startTime = getTimeStamp();
}
std::string::const_iterator si = querystring.begin(), se = querystring.end();
std::string qs;
while (strus::scanNextProgram( qs, si, se, errorBuffer.get()))
{
++nofQueries;
std::auto_ptr<strus::QueryInterface> query(
qeval->createQuery( storage.get()));
if (!query.get()) throw strus::runtime_error(_TXT("failed to create query object"));
if (!strus::loadQuery( *query, analyzer.get(), qproc, qs, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query from source"));
}
query->setMaxNofRanks( nofRanks);
query->setMinRank( firstRank);
if (!username.empty())
{
query->addUserName( username);
}
strus::QueryResult result = query->evaluate();
if (!quiet)
{
std::cout << strus::string_format( _TXT("evaluated till pass %u, got %u ranks (%u without restrictions applied):"), result.evaluationPass(), result.nofDocumentsRanked(), result.nofDocumentsVisited()) << std::endl;
std::cout << strus::string_format( _TXT("ranked list (starting with rank %u, maximum %u results):"), firstRank, nofRanks) << std::endl;
}
std::vector<strus::ResultDocument>::const_iterator wi = result.ranks().begin(), we = result.ranks().end();
if (!quiet)
{
for (int widx=1; wi != we; ++wi,++widx)
{
std::cout << strus::string_format( _TXT( "[%u] %u score %f"), widx, wi->docno(), wi->weight()) << std::endl;
std::vector<strus::SummaryElement>::const_iterator
ai = wi->summaryElements().begin(),
ae = wi->summaryElements().end();
for (; ai != ae; ++ai)
{
std::cout << "\t" << ai->name();
if (ai->index() >= 0)
{
std::cout << "[" << ai->index() << "]";
}
std::cout << " = '" << ai->value() << "'";
std::cout << " " << ai->weight() << std::endl;
}
}
}
}
if (measureDuration)
{
double endTime = getTimeStamp();
double duration = endTime - startTime;
std::cerr << strus::string_format( _TXT("evaluated %u queries in %.4f seconds"), nofQueries, duration) << std::endl;
}
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("unhandled error in command line query"));
}
return 0;
}
catch (const std::bad_alloc&)
{
std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl;
}
catch (const std::runtime_error& e)
{
const char* errormsg = errorBuffer->fetchError();
if (errormsg)
{
std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << _TXT("ERROR ") << e.what() << std::endl;
}
}
catch (const std::exception& e)
{
std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl;
}
return -1;
}
int main( int argc, const char* argv[])
{
int rt = 0;
std::auto_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
strus::ProgramOptions opt;
bool printUsageAndExit = false;
try
{
opt = strus::ProgramOptions(
argc, argv, 6,
"h,help", "v,version", "license", "m,module:", "M,moduledir:", "T,trace:");
if (opt( "help"))
{
printUsageAndExit = true;
}
std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader(
strus::createModuleLoader( errorBuffer.get()));
if (!moduleLoader.get()) throw strus::runtime_error(_TXT("error creating module loader"));
if (opt("moduledir"))
{
std::vector<std::string> modirlist( opt.list("moduledir"));
std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end();
for (; mi != me; ++mi)
{
moduleLoader->addModulePath( *mi);
}
moduleLoader->addSystemModulePath();
}
if (opt("module"))
{
std::vector<std::string> modlist( opt.list("module"));
std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end();
for (; mi != me; ++mi)
{
if (!moduleLoader->loadModule( *mi))
{
throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str());
}
}
}
if (opt("license"))
{
std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts();
std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end();
if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl;
for (; ti != te; ++ti)
{
std::cout << *ti << std::endl;
}
std::cerr << std::endl;
if (!printUsageAndExit) return 0;
}
if (opt( "version"))
{
std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl;
std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl;
std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl;
std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts();
std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end();
if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl;
for (; vi != ve; ++vi)
{
std::cout << *vi << std::endl;
}
if (!printUsageAndExit) return 0;
}
else if (!printUsageAndExit)
{
if (opt.nofargs() < 2)
{
std::cerr << _TXT("too few arguments") << std::endl;
printUsageAndExit = true;
rt = 1;
}
if (opt.nofargs() > 2)
{
std::cerr << _TXT("too many arguments") << std::endl;
printUsageAndExit = true;
rt = 2;
}
}
if (printUsageAndExit)
{
std::cout << _TXT("usage:") << " strusAlterMetaData [options] <config> <cmds>" << std::endl;
std::cout << "<config> : " << _TXT("configuration string of the storage") << std::endl;
std::cout << " " << _TXT("semicolon';' separated list of assignments:") << std::endl;
printStorageConfigOptions( std::cout, moduleLoader.get(), (opt.nofargs()>=1?opt[0]:""), errorBuffer.get());
std::cout << "<cmds> : " << _TXT("semicolon separated list of commands:") << std::endl;
std::cout << " alter <name> <newname> <newtype>" << std::endl;
std::cout << " <name> :" << _TXT("name of the element to change") << std::endl;
std::cout << " <newname> :" << _TXT("new name of the element") << std::endl;
std::cout << " <newtype> :" << _TXT("new type (*) of the element") << std::endl;
std::cout << " add <name> <type>" << std::endl;
std::cout << " <name> :" << _TXT("name of the element to add") << std::endl;
std::cout << " <type> :" << _TXT("type (*) of the element to add") << std::endl;
std::cout << " delete <name>" << std::endl;
std::cout << " <name> :" << _TXT("name of the element to remove") << std::endl;
std::cout << " rename <name> <newname>" << std::endl;
std::cout << " <name> :" << _TXT("name of the element to rename") << std::endl;
std::cout << " <newname> :" << _TXT("new name of the element") << std::endl;
std::cout << " clear <name>" << std::endl;
std::cout << " <name> :" << _TXT("name of the element to clear all values") << std::endl;
std::cout << "(*) :" << _TXT("type of an element is one of the following:") << std::endl;
std::cout << " INT8 :" << _TXT("one byte signed integer value") << std::endl;
std::cout << " UINT8 :" << _TXT("one byte unsigned integer value") << std::endl;
std::cout << " INT16 :" << _TXT("two bytes signed integer value") << std::endl;
std::cout << " UINT16 :" << _TXT("two bytes unsigned integer value") << std::endl;
std::cout << " INT32 :" << _TXT("four bytes signed integer value") << std::endl;
std::cout << " UINT32 :" << _TXT("four bytes unsigned integer value") << std::endl;
std::cout << " FLOAT16 :" << _TXT("two bytes floating point value (IEEE 754 small)") << std::endl;
std::cout << " FLOAT32 :" << _TXT("four bytes floating point value (IEEE 754 single)") << std::endl;
std::cout << _TXT("description: Executes a list of alter the meta data table commands.") << std::endl;
std::cout << _TXT("options:") << std::endl;
std::cout << "-h|--help" << std::endl;
std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl;
std::cout << "-v|--version" << std::endl;
std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl;
std::cout << "--license" << std::endl;
std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl;
std::cout << "-m|--module <MOD>" << std::endl;
std::cout << " " << _TXT("Load components from module <MOD>") << std::endl;
std::cout << "-M|--moduledir <DIR>" << std::endl;
std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl;
std::cout << "-T|--trace <CONFIG>" << std::endl;
std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl;
std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl;
return rt;
}
// Parse arguments:
std::string storagecfg = opt[0];
std::vector<AlterMetaDataCommand> cmds = parseCommands( opt[1]);
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (opt("trace"))
{
std::vector<std::string> tracecfglist( opt.list("trace"));
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get()));
}
}
// Create objects for altering the meta data table:
std::auto_ptr<strus::StorageObjectBuilderInterface> builder;
std::auto_ptr<strus::StorageAlterMetaDataTableInterface> md;
builder.reset( moduleLoader->createStorageObjectBuilder());
if (!builder.get()) throw strus::runtime_error(_TXT("failed to create storage object builder"));
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::StorageObjectBuilderInterface* builderproxy = (*ti)->createProxy( builder.get());
builder.release();
builder.reset( builderproxy);
}
md.reset( strus::createAlterMetaDataTable( builder.get(), errorBuffer.get(), storagecfg));
if (!md.get()) throw strus::runtime_error(_TXT("failed to create storage alter metadata table structure"));
// Execute alter meta data table commands:
std::vector<AlterMetaDataCommand>::const_iterator ci = cmds.begin(), ce = cmds.end();
for (; ci != ce; ++ci)
{
switch (ci->id())
{
case AlterMetaDataCommand::Alter:
md->alterElement( ci->name(), ci->newname(), ci->type());
break;
case AlterMetaDataCommand::Add:
md->addElement( ci->name(), ci->type());
break;
case AlterMetaDataCommand::Delete:
md->deleteElement( ci->name());
break;
case AlterMetaDataCommand::Rename:
md->renameElement( ci->name(), ci->newname());
break;
case AlterMetaDataCommand::Clear:
md->clearElement( ci->name());
break;
}
}
std::cerr << _TXT("updating meta data table changes...") << std::endl;
if (!md->commit()) throw strus::runtime_error(_TXT("alter meta data commit failed"));
std::cerr << _TXT("done") << std::endl;
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("unhandled error in alter meta data"));
}
return 0;
}
catch (const std::bad_alloc&)
{
std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl;
}
catch (const std::runtime_error& e)
{
const char* errormsg = errorBuffer->fetchError();
if (errormsg)
{
std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << _TXT("ERROR ") << e.what() << std::endl;
}
}
catch (const std::exception& e)
{
std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl;
}
return -1;
}
int main( int argc, const char* argv[])
{
int rt = 0;
std::auto_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
strus::ProgramOptions opt;
bool printUsageAndExit = false;
try
{
opt = strus::ProgramOptions(
argc, argv, 9,
"h,help", "v,version", "license",
"m,module:", "M,moduledir:", "r,rpc:",
"s,storage:", "e,exists", "T,trace:");
if (opt( "help")) printUsageAndExit = true;
std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get()));
if (!moduleLoader.get()) throw strus::runtime_error( _TXT("error creating module loader"));
if (opt("moduledir"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
std::vector<std::string> modirlist( opt.list("moduledir"));
std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end();
for (; mi != me; ++mi)
{
moduleLoader->addModulePath( *mi);
}
moduleLoader->addSystemModulePath();
}
if (opt("module"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
std::vector<std::string> modlist( opt.list("module"));
std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end();
for (; mi != me; ++mi)
{
if (!moduleLoader->loadModule( *mi))
{
throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str());
}
}
}
if (opt("license"))
{
std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts();
std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end();
if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl;
for (; ti != te; ++ti)
{
std::cout << *ti << std::endl;
}
std::cerr << std::endl;
if (!printUsageAndExit) return 0;
}
if (opt( "version"))
{
std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl;
std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl;
std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl;
std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts();
std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end();
if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl;
for (; vi != ve; ++vi)
{
std::cout << *vi << std::endl;
}
if (!printUsageAndExit) return 0;
}
else if (!printUsageAndExit)
{
if (opt.nofargs() > 0)
{
std::cerr << _TXT("too many arguments") << std::endl;
printUsageAndExit = true;
rt = 1;
}
}
if (printUsageAndExit)
{
std::cout << _TXT("usage:") << " strusCheckStorage [options]" << std::endl;
std::cout << _TXT("description: Checks a storage for corrupt data.") << std::endl;
std::cout << _TXT("options:") << std::endl;
std::cout << "-h|--help" << std::endl;
std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl;
std::cout << "-v|--version" << std::endl;
std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl;
std::cout << "--license" << std::endl;
std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl;
std::cout << "-s|--storage <CONFIG>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl;
if (!opt("rpc"))
{
std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl;
printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get());
}
std::cout << "-e|--exists" << std::endl;
std::cout << " " << _TXT("Checks if the database of the storage exists and return 'yes'/'no'") << std::endl;
std::cout << "-m|--module <MOD>" << std::endl;
std::cout << " " << _TXT("Load components from module <MOD>") << std::endl;
std::cout << "-M|--moduledir <DIR>" << std::endl;
std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl;
std::cout << "-r|--rpc <ADDR>" << std::endl;
std::cout << " " << _TXT("Execute the commands on the RPC server specified by <ADDR>") << std::endl;
std::cout << "-T|--trace <CONFIG>" << std::endl;
std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl;
std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl;
return rt;
}
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (opt("trace"))
{
std::vector<std::string> tracecfglist( opt.list("trace"));
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get()));
}
}
std::string storagecfg;
if (opt("storage"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
storagecfg = opt["storage"];
}
// Create objects to check storage:
std::auto_ptr<strus::RpcClientMessagingInterface> messaging;
std::auto_ptr<strus::RpcClientInterface> rpcClient;
std::auto_ptr<strus::StorageObjectBuilderInterface> storageBuilder;
if (opt("rpc"))
{
messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get()));
if (!messaging.get()) throw strus::runtime_error( _TXT("error creating rpc client messaging"));
rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get()));
if (!rpcClient.get()) throw strus::runtime_error( _TXT("error creating rpc client"));
(void)messaging.release();
storageBuilder.reset( rpcClient->createStorageObjectBuilder());
if (!storageBuilder.get()) throw strus::runtime_error( _TXT("error creating rpc storage object builder"));
}
else
{
storageBuilder.reset( moduleLoader->createStorageObjectBuilder());
if (!storageBuilder.get()) throw strus::runtime_error( _TXT("error creating storage object builder"));
}
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get());
storageBuilder.release();
storageBuilder.reset( sproxy);
}
if (opt("exists"))
{
const strus::DatabaseInterface* dbi = storageBuilder->getDatabase( storagecfg);
if (!dbi) throw strus::runtime_error(_TXT("could not find key/value store database"));
if (dbi->exists( storagecfg))
{
std::cout << "yes" << std::endl;
}
else
{
std::cout << "no" << std::endl;
}
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("unhandled error in analyze"));
}
}
else
{
std::auto_ptr<strus::StorageClientInterface>
storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg));
if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client"));
if (!storage->checkStorage( std::cerr))
{
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("error in check storage"));
}
std::cerr << _TXT("check storage failed") << std::endl;
}
else
{
std::cerr << _TXT("done") << std::endl;
}
}
return 0;
}
catch (const std::bad_alloc&)
{
std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl;
}
catch (const std::runtime_error& e)
{
const char* errormsg = errorBuffer->fetchError();
if (errormsg)
{
std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << _TXT("ERROR ") << e.what() << std::endl;
}
}
catch (const std::exception& e)
{
std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl;
}
return -1;
}
int main( int argc_, const char* argv_[])
{
int rt = 0;
strus::DebugTraceInterface* dbgtrace = strus::createDebugTrace_standard( 2);
if (!dbgtrace)
{
std::cerr << _TXT("failed to create debug trace") << std::endl;
return -1;
}
strus::local_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2, dbgtrace/*passed with ownership*/));
if (!errorBuffer.get())
{
delete dbgtrace;
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
try
{
bool printUsageAndExit = false;
bool withDebugInfo = false;
strus::ProgramOptions opt(
errorBuffer.get(), argc_, argv_, 18,
"h,help", "v,version", "license",
"G,debug:", "Q,quiet", "u,user:"******"N,nofranks:", "I,firstrank:", "F,fileinput",
"D,time", "m,module:", "M,moduledir:", "R,resourcedir:",
"s,storage:", "S,configfile:", "r,rpc:", "T,trace:", "V,verbose");
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("failed to parse program arguments"));
}
if (opt( "help")) printUsageAndExit = true;
// Enable debugging selected with option 'debug':
{
std::vector<std::string> dbglist = opt.list( "debug");
std::vector<std::string>::const_iterator gi = dbglist.begin(), ge = dbglist.end();
for (; gi != ge; ++gi)
{
if (*gi == "weighting")
{
withDebugInfo = true;
}
if (!dbgtrace->enable( *gi))
{
throw strus::runtime_error(_TXT("failed to enable debug '%s'"), gi->c_str());
}
}
}
strus::local_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get()));
if (!moduleLoader.get()) throw std::runtime_error( _TXT("failed to create module loader"));
if (opt("moduledir"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc");
std::vector<std::string> modirlist( opt.list("moduledir"));
std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end();
for (; mi != me; ++mi)
{
moduleLoader->addModulePath( *mi);
}
moduleLoader->addSystemModulePath();
}
if (opt("module"))
{
if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--module", "--rpc");
std::vector<std::string> modlist( opt.list("module"));
std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end();
for (; mi != me; ++mi)
{
if (!moduleLoader->loadModule( *mi))
{
throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str());
}
}
}
if (opt("license"))
{
std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts();
std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end();
if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl;
for (; ti != te; ++ti)
{
std::cout << *ti << std::endl;
}
std::cout << std::endl;
if (!printUsageAndExit) return 0;
}
if (opt( "version"))
{
std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl;
std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl;
std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl;
std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl;
std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts();
std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end();
if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl;
for (; vi != ve; ++vi)
{
std::cout << *vi << std::endl;
}
if (!printUsageAndExit) return 0;
}
else if (!printUsageAndExit)
{
if (opt.nofargs() > 3)
{
std::cerr << _TXT("too many arguments") << std::endl;
printUsageAndExit = true;
rt = 1;
}
if (opt.nofargs() < 3)
{
std::cerr << _TXT("too few arguments") << std::endl;
printUsageAndExit = true;
rt = 2;
}
}
if (printUsageAndExit)
{
std::cout << _TXT("usage:") << " strusQuery [options] <anprg> <qeprg> <query>" << std::endl;
std::cout << "<anprg> = " << _TXT("path of query analyzer program") << std::endl;
std::cout << "<qeprg> = " << _TXT("path of query eval program") << std::endl;
std::cout << "<query> = " << _TXT("query string") << std::endl;
std::cout << " " << _TXT("file or '-' for stdin if option -F is specified)") << std::endl;
std::cout << _TXT("description: Executes a query or a list of queries from a file.") << std::endl;
std::cout << _TXT("options:") << std::endl;
std::cout << "-h|--help" << std::endl;
std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl;
std::cout << "-v|--version" << std::endl;
std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl;
std::cout << "--license" << std::endl;
std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl;
std::cout << "-s|--storage <CONFIG>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl;
if (!opt("rpc"))
{
std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl;
printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get());
}
std::cout << "-S|--configfile <FILENAME>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration file as <FILENAME>") << std::endl;
std::cout << " " << _TXT("<FILENAME> is a file containing the configuration string") << std::endl;
std::cout << "-u|--user <NAME>" << std::endl;
std::cout << " " << _TXT("Use user name <NAME> for the query") << std::endl;
std::cout << "-N|--nofranks <N>" << std::endl;
std::cout << " " << _TXT("Return maximum <N> ranks as query result") << std::endl;
std::cout << "-I|--firstrank <N>" << std::endl;
std::cout << " " << _TXT("Return the result starting with rank <N> as first rank") << std::endl;
std::cout << "-Q|--quiet" << std::endl;
std::cout << " " << _TXT("No output of results") << std::endl;
std::cout << "-D|--time" << std::endl;
std::cout << " " << _TXT("Do print duration of pure query evaluation") << std::endl;
std::cout << "-F|--fileinput" << std::endl;
std::cout << " " << _TXT("Interpret query argument as a file name containing the input") << std::endl;
std::cout << "-G|--debug <COMP>" << std::endl;
std::cout << " " << _TXT("Issue debug messages for component <COMP> to stderr") << std::endl;
std::cout << "-m|--module <MOD>" << std::endl;
std::cout << " " << _TXT("Load components from module <MOD>") << std::endl;
std::cout << "-M|--moduledir <DIR>" << std::endl;
std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl;
std::cout << "-R|--resourcedir <DIR>" << std::endl;
std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl;
std::cout << "-r|--rpc <ADDR>" << std::endl;
std::cout << " " << _TXT("Execute the command on the RPC server specified by <ADDR>") << std::endl;
std::cout << "-T|--trace <CONFIG>" << std::endl;
std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl;
std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl;
std::cout << "-V|--verbose" << std::endl;
std::cout << " " << _TXT("Verbose mode: Print some info like query analysis") << std::endl;
return rt;
}
// Parse arguments:
bool quiet = opt( "quiet");
bool doMeasureDuration = opt( "time");
bool verbose = opt("verbose");
std::string username;
std::size_t nofRanks = 20;
std::size_t firstRank = 0;
std::string storagecfg;
bool queryIsFile = opt("fileinput");
if (opt("user"))
{
username = opt[ "user"];
}
if (opt("nofranks"))
{
nofRanks = opt.asUint( "nofranks");
}
if (opt("firstrank"))
{
firstRank = opt.asUint( "firstrank");
}
if (opt("configfile"))
{
if (opt("storage")) throw strus::runtime_error(_TXT("conflicting configuration options specified: '%s' and '%s'"), "--storage", "--configfile");
std::string configfile = opt[ "configfile"];
int ec = strus::readFile( configfile, storagecfg);
if (ec) throw strus::runtime_error(_TXT("failed to read configuration file %s (errno %u)"), configfile.c_str(), ec);
std::string::iterator di = storagecfg.begin(), de = storagecfg.end();
for (; di != de; ++di)
{
if ((unsigned char)*di < 32) *di = ' ';
}
}
if (opt("storage"))
{
if (opt("configfile")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--storage", "--configfile");
storagecfg = opt["storage"];
}
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (opt("trace"))
{
std::vector<std::string> tracecfglist( opt.list("trace"));
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get()));
}
}
// Enable debugging selected with option 'debug':
{
std::vector<std::string> dbglist = opt.list( "debug");
std::vector<std::string>::const_iterator gi = dbglist.begin(), ge = dbglist.end();
for (; gi != ge; ++gi)
{
if (!dbgtrace->enable( *gi))
{
throw strus::runtime_error(_TXT("failed to enable debug '%s'"), gi->c_str());
}
}
}
// Set paths for locating resources:
if (opt("resourcedir"))
{
std::vector<std::string> pathlist( opt.list("resourcedir"));
std::vector<std::string>::const_iterator
pi = pathlist.begin(), pe = pathlist.end();
for (; pi != pe; ++pi)
{
moduleLoader->addResourcePath( *pi);
}
}
std::string analyzerprg = getFileArg( opt[0], moduleLoader.get());
std::string queryprg = getFileArg( opt[1], moduleLoader.get());
std::string querystring = opt[2];
if (errorBuffer->hasError())
{
throw std::runtime_error( _TXT("error in initialization"));
}
// Create objects for query evaluation:
strus::local_ptr<strus::RpcClientMessagingInterface> messaging;
strus::local_ptr<strus::RpcClientInterface> rpcClient;
strus::local_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder;
strus::local_ptr<strus::StorageObjectBuilderInterface> storageBuilder;
if (opt("rpc"))
{
messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get()));
if (!messaging.get()) throw std::runtime_error( _TXT("failed to create rpc client messaging"));
rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get()));
if (!rpcClient.get()) throw std::runtime_error( _TXT("failed to create rpc client"));
(void)messaging.release();
analyzerBuilder.reset( rpcClient->createAnalyzerObjectBuilder());
if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create rpc analyzer object builder"));
storageBuilder.reset( rpcClient->createStorageObjectBuilder());
if (!storageBuilder.get()) throw std::runtime_error( _TXT("failed to create rpc storage object builder"));
}
else
{
analyzerBuilder.reset( moduleLoader->createAnalyzerObjectBuilder());
if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create analyzer object builder"));
storageBuilder.reset( moduleLoader->createStorageObjectBuilder());
if (!storageBuilder.get()) throw std::runtime_error( _TXT("failed to create storage object builder"));
}
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::AnalyzerObjectBuilderInterface* aproxy = (*ti)->createProxy( analyzerBuilder.get());
analyzerBuilder.release();
analyzerBuilder.reset( aproxy);
strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get());
storageBuilder.release();
storageBuilder.reset( sproxy);
}
// Create objects:
strus::local_ptr<strus::StorageClientInterface>
storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg));
if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client: %s"), errorBuffer->fetchError());
strus::local_ptr<strus::QueryAnalyzerInstanceInterface> analyzer( analyzerBuilder->createQueryAnalyzer());
if (!analyzer.get()) throw strus::runtime_error(_TXT("failed to create query analyzer: %s"), errorBuffer->fetchError());
strus::local_ptr<strus::QueryEvalInterface> qeval( storageBuilder->createQueryEval());
if (!qeval.get()) throw strus::runtime_error(_TXT("failed to create query evaluation interface: %s"), errorBuffer->fetchError());
const strus::QueryProcessorInterface* qproc = storageBuilder->getQueryProcessor();
if (!qproc) throw strus::runtime_error(_TXT("failed to get query processor: %s"), errorBuffer->fetchError());
const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor();
if (!textproc) throw strus::runtime_error(_TXT("failed to get text processor: %s"), errorBuffer->fetchError());
if (errorBuffer->hasError()) throw strus::runtime_error(_TXT("error in initialization: %s"), errorBuffer->fetchError());
// Load query analyzer program:
if (!strus::load_QueryAnalyzer_programfile_std( analyzer.get(), textproc, analyzerprg, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query analyzer program: %s"), errorBuffer->fetchError());
}
// Load query evaluation program:
std::string qevalProgramSource;
std::string queryprgpath = strus::isExplicitPath( queryprg) ? queryprg : textproc->getResourceFilePath( queryprg);
int ec = strus::readFile( queryprgpath, qevalProgramSource);
if (ec) throw strus::runtime_error(_TXT("failed to load query eval program %s (errno %u)"), queryprg.c_str(), ec);
if (!strus::load_queryeval_program( *qeval, analyzer->queryTermTypes(), qproc, qevalProgramSource, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query evaluation program: %s"), errorBuffer->fetchError());
}
// Load query:
if (queryIsFile)
{
std::string qs;
if (querystring == "-")
{
ec = strus::readStdin( qs);
if (ec) throw strus::runtime_error( _TXT("failed to read query from stdin (errno %u)"), ec);
}
else
{
ec = strus::readFile( querystring, qs);
if (ec) throw strus::runtime_error(_TXT("failed to read query from file %s (errno %u)"), querystring.c_str(), ec);
}
querystring = qs;
}
unsigned int nofQueries = 0;
double startTime = 0.0;
if (doMeasureDuration)
{
startTime = getTimeStamp();
}
std::string::const_iterator si = querystring.begin(), se = querystring.end();
std::string qs;
while (strus::scanNextProgram( qs, si, se, errorBuffer.get()))
{
++nofQueries;
strus::local_ptr<strus::QueryInterface> query( qeval->createQuery( storage.get()));
if (!query.get()) throw strus::runtime_error(_TXT("failed to create query object: %s"), errorBuffer->fetchError());
std::string selectionFeatureSet;
std::string weightingFeatureSet;
std::vector<std::string> selfset = qeval->getSelectionFeatureSets();
if (!selfset.empty()) selectionFeatureSet = selfset[0];
std::vector<std::string> weightset = qeval->getWeightingFeatureSets();
if (!weightset.empty()) weightingFeatureSet = weightset[0];
if (!strus::loadQuery( *query, analyzer.get(), selectionFeatureSet, weightingFeatureSet, qproc, qs, errorBuffer.get()))
{
throw strus::runtime_error(_TXT("failed to load query from source: %s"), errorBuffer->fetchError());
}
if (withDebugInfo)
{
query->setDebugMode( true);
}
query->setMaxNofRanks( nofRanks);
query->setMinRank( firstRank);
if (!username.empty())
{
query->addAccess( username);
}
if (verbose)
{
std::cerr << "Query:" << std::endl;
std::cerr << query->tostring() << std::endl;
}
strus::QueryResult result = query->evaluate();
if (!quiet)
{
std::cout << strus::string_format( _TXT("evaluated till pass %u, got %u ranks (%u without restrictions applied):"), result.evaluationPass(), result.nofRanked(), result.nofVisited()) << std::endl;
std::cout << strus::string_format( _TXT("ranked list (starting with rank %u, maximum %u results):"), (unsigned int)firstRank, (unsigned int)nofRanks) << std::endl;
}
std::vector<strus::ResultDocument>::const_iterator wi = result.ranks().begin(), we = result.ranks().end();
if (!quiet)
{
for (int widx=1; wi != we; ++wi,++widx)
{
std::cout << strus::string_format( _TXT( "[%u] score %f"), widx, wi->weight()) << std::endl;
std::vector<strus::SummaryElement>::const_iterator
ai = wi->summaryElements().begin(),
ae = wi->summaryElements().end();
for (; ai != ae; ++ai)
{
std::cout << "\t" << ai->name();
if (ai->index() >= 0)
{
std::cout << "[" << ai->index() << "]";
}
std::cout << " = '" << ai->value() << "'";
std::cout << " " << ai->weight() << std::endl;
}
}
}
}
if (doMeasureDuration)
{
double endTime = getTimeStamp();
double duration = endTime - startTime;
std::cerr << strus::string_format( _TXT("evaluated %u queries in %.4f seconds"), nofQueries, duration) << std::endl;
}
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("unhandled error in command line query: %s"), errorBuffer->fetchError());
}
std::cerr << _TXT("done.") << std::endl;
if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/))
{
std::cerr << _TXT("failed to dump debug trace to file") << std::endl;
}
return 0;
}
catch (const std::bad_alloc&)
{
std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl;
return -2;
}
catch (const std::runtime_error& e)
{
const char* errormsg = errorBuffer->fetchError();
if (errormsg)
{
std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << _TXT("ERROR ") << e.what() << std::endl;
}
}
catch (const std::exception& e)
{
std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl;
}
if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/))
{
std::cerr << _TXT("failed to dump debug trace to file") << std::endl;
}
return -1;
}
int main( int argc, const char* argv[])
{
int rt = 0;
std::auto_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
strus::ProgramOptions opt;
bool printUsageAndExit = false;
try
{
opt = strus::ProgramOptions(
argc, argv, 8,
"h,help", "v,version", "license",
"m,module:", "M,moduledir:",
"s,storage:", "S,configfile:", "T,trace:");
if (opt( "help")) printUsageAndExit = true;
std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get()));
if (!moduleLoader.get()) throw strus::runtime_error(_TXT("failed to create module loader"));
if (opt("moduledir"))
{
std::vector<std::string> modirlist( opt.list("moduledir"));
std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end();
for (; mi != me; ++mi)
{
moduleLoader->addModulePath( *mi);
}
moduleLoader->addSystemModulePath();
}
if (opt("module"))
{
std::vector<std::string> modlist( opt.list("module"));
std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end();
for (; mi != me; ++mi)
{
if (!moduleLoader->loadModule( *mi))
{
throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str());
}
}
}
if (opt("license"))
{
std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts();
std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end();
if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl;
for (; ti != te; ++ti)
{
std::cout << *ti << std::endl;
}
std::cerr << std::endl;
if (!printUsageAndExit) return 0;
}
if (opt( "version"))
{
std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl;
std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl;
std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl;
std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl;
std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts();
std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end();
if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl;
for (; vi != ve; ++vi)
{
std::cout << *vi << std::endl;
}
if (!printUsageAndExit) return 0;
}
else if (!printUsageAndExit)
{
if (opt.nofargs() > 1)
{
std::cerr << _TXT("too many arguments") << std::endl;
printUsageAndExit = true;
rt = 1;
}
}
std::string storagecfg;
int nof_storagecfg = 0;
if (opt("configfile"))
{
nof_storagecfg += 1;
std::string configfile = opt[ "configfile"];
int ec = strus::readFile( configfile, storagecfg);
if (ec) throw strus::runtime_error(_TXT("failed to read configuration file %s (errno %u)"), configfile.c_str(), ec);
std::string::iterator di = storagecfg.begin(), de = storagecfg.end();
for (; di != de; ++di)
{
if ((unsigned char)*di < 32) *di = ' ';
}
}
if (opt("storage"))
{
nof_storagecfg += 1;
storagecfg = opt[ "storage"];
}
if (opt.nofargs() == 1)
{
std::cerr << _TXT("warning: passing storage as first parameter instead of option -s (deprecated)") << std::endl;
nof_storagecfg += 1;
storagecfg = opt[0];
}
if (nof_storagecfg > 1)
{
std::cerr << _TXT("conflicting configuration options specified: --storage and --configfile") << std::endl;
rt = 10003;
printUsageAndExit = true;
}
else if (!printUsageAndExit && nof_storagecfg == 0)
{
std::cerr << _TXT("missing configuration option: --storage or --configfile has to be defined") << std::endl;
rt = 10004;
printUsageAndExit = true;
}
if (printUsageAndExit)
{
std::cout << _TXT("usage:") << " strusCreate [options]" << std::endl;
std::cout << _TXT("description: Creates a storage with its key value store database.") << std::endl;
std::cout << _TXT("options:") << std::endl;
std::cout << "-h|--help" << std::endl;
std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl;
std::cout << "-v|--version" << std::endl;
std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl;
std::cout << "--license" << std::endl;
std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl;
std::cout << "-m|--module <MOD>" << std::endl;
std::cout << " " << _TXT("Load components from module <MOD>") << std::endl;
std::cout << "-M|--moduledir <DIR>" << std::endl;
std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl;
std::cout << "-s|--storage <CONFIG>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl;
std::cout << " " << _TXT("<CONFIG> is a semicolon ';' separated list of assignments:") << std::endl;
printStorageConfigOptions( std::cout, moduleLoader.get(), storagecfg, errorBuffer.get());
std::cout << "-S|--configfile <FILENAME>" << std::endl;
std::cout << " " << _TXT("Define the storage configuration file as <FILENAME>") << std::endl;
std::cout << " " << _TXT("<FILENAME> is a file containing the configuration string") << std::endl;
std::cout << "-T|--trace <CONFIG>" << std::endl;
std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl;
std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl;
return rt;
}
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (opt("trace"))
{
std::vector<std::string> tracecfglist( opt.list("trace"));
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get()));
}
}
// Create root object:
std::auto_ptr<strus::StorageObjectBuilderInterface>
storageBuilder( moduleLoader->createStorageObjectBuilder());
if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create storage object builder"));
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get());
storageBuilder.release();
storageBuilder.reset( sproxy);
}
// Create objects:
std::string dbname;
(void)strus::extractStringFromConfigString( dbname, storagecfg, "database", errorBuffer.get());
const strus::DatabaseInterface* dbi = storageBuilder->getDatabase( dbname);
if (!dbi) throw strus::runtime_error(_TXT("failed to get database interface"));
const strus::StorageInterface* sti = storageBuilder->getStorage();
if (!sti) throw strus::runtime_error(_TXT("failed to get storage interface"));
if (!sti->createStorage( storagecfg, dbi))
{
throw strus::runtime_error(_TXT("failed to create storage"));
}
if (errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("unhandled error in create storage"));
}
std::cerr << _TXT("storage successfully created.") << std::endl;
return 0;
}
catch (const std::bad_alloc&)
{
std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl;
}
catch (const std::runtime_error& e)
{
const char* errormsg = errorBuffer->fetchError();
if (errormsg)
{
std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << _TXT("ERROR ") << e.what() << std::endl;
}
}
catch (const std::exception& e)
{
std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl;
}
return -1;
}