/*
* Set the result vector with strings corresponding to the input string:
* - If inputStr is partially or completely found in the keys, all the matching <key,words> are returned;
* - If inputStr is partially or completely in the words, all the matching <key, words> are returned.
* The following tags can modify the behaviour of the search algorithm:
* - ^mystring returns mystring only if it is at the beginning of a key or word
* - mystring$ returns mystring only if it is at the end of a key or word
* All returned words are in UTF8.
*/
void CWordsDictionary::lookup( const CSString& inputStr, CVectorSString& resultVec ) const
{
// Prepare search string
if ( inputStr.empty() )
return;
CSString searchStr = inputStr;
bool findAtBeginning = false, findAtEnd = false;
if ( searchStr[0] == '^' )
{
searchStr = searchStr.substr( 1 );
findAtBeginning = true;
}
if ( searchStr[searchStr.size()-1] == '$' )
{
searchStr = searchStr.rightCrop( 1 );
findAtEnd = true;
}
// Search
const vector<string> &vec = reinterpret_cast<const vector<string>&>(_Keys);
// for ( CVectorSString::const_iterator ivs=_Keys.begin(); ivs!=_Keys.end(); ++ivs )
for ( vector<string>::const_iterator ivs=vec.begin(); ivs!=vec.end(); ++ivs )
{
const CSString& key = *ivs;
string::size_type p;
if ( (p = key.findNS( searchStr.c_str() )) != string::npos )
{
if ( ((!findAtBeginning) || (p==0)) && ((!findAtEnd) || (p==key.size()-searchStr.size())) )
resultVec.push_back( makeResult( key, _Words[ivs-vec.begin()] ) );
}
}
for ( CVectorSString::const_iterator ivs=_Words.begin(); ivs!=_Words.end(); ++ivs )
{
const CSString& word = *ivs;
string::size_type p;
if ( (p = word.findNS( searchStr.c_str() )) != string::npos )
{
if ( ((!findAtBeginning) || (p==0)) && ((!findAtEnd) || (p==word.size()-searchStr.size())) )
resultVec.push_back( makeResult( _Keys[ivs-_Words.begin()], word ) );
}
}
}
void MMSegmentation::splitSourceSegment()
{
source_segment= getSourceSegment();
//获取字典
word_dictionary_map = new Word_Dictionary_Map();
DataConvertor * dataconvertor = new DataConvertor();
dataconvertor->convertDictionary(word_dictionary_map);
result_segment_list = new Result_Segment_List();
int wordlength = dataconvertor->getMaxWordLength();
delete dataconvertor;
int segmentlenth = this->source_segment.length();
string source = this->source_segment;
int begin=0;
for(int i = 0 ; i < segmentlenth ; )
{
string temp = source.substr(i,wordlength);
int returnlength = splitSourceSegment(temp);
i = returnlength +i;
}
makeResult();
}
TEST_F(VirtualTableTests, test_constraints_stacking) {
// Add two testing tables to the registry.
Registry::add<pTablePlugin>("table", "p");
Registry::add<kTablePlugin>("table", "k");
auto dbc = SQLiteDBManager::get();
{
// To simplify the attach, just access the column definition directly.
auto p = std::make_shared<pTablePlugin>();
attachTableInternal("p", p->columnDefinition(), dbc->db());
auto k = std::make_shared<kTablePlugin>();
attachTableInternal("k", k->columnDefinition(), dbc->db());
}
QueryData results;
std::string statement;
std::map<std::string, std::string> expected;
std::vector<std::pair<std::string, QueryData> > constraint_tests = {
MP("select k.x from p, k", makeResult("x", {"1", "2", "1", "2"})),
MP("select k.x from (select * from k) k2, p, k where k.x = p.x",
makeResult("k.x", {"1", "1", "2", "2"})),
MP("select k.x from (select * from k where z = 1) k2, p, k where k.x = "
"p.x",
makeResult("k.x", {"1", "2"})),
MP("select k.x from k k1, (select * from p) p1, k where k.x = p1.x",
makeResult("k.x", {"1", "1", "2", "2"})),
MP("select k.x from (select * from p) p1, k, (select * from k) k2 where "
"k.x = p1.x",
makeResult("k.x", {"1", "1", "2", "2"})),
MP("select k.x from (select * from p) p1, k, (select * from k where z = "
"2) k2 where k.x = p1.x",
makeResult("k.x", {"1", "2"})),
MP("select k.x from k, (select * from p) p1, k k2, (select * from k "
"where z = 1) k3 where k.x = p1.x",
makeResult("k.x", {"1", "1", "2", "2"})),
MP("select p.x from (select * from k where z = 1) k1, (select * from k "
"where z != 1) k2, p where p.x = k2.x",
makeResult("p.x", {"1"})),
MP("select p.x from (select * from k, (select x as xx from k where x = "
"1) k2 where z = 1) k1, (select * from k where z != 1) k2, p, k as k3 "
"where p.x = k2.x",
makeResult("p.x", {"1", "1"})),
};
for (const auto& test : constraint_tests) {
QueryData results;
queryInternal(test.first, results, dbc->db());
EXPECT_EQ(results, test.second);
}
std::vector<QueryData> union_results = {
makeResult("x", {"1", "2"}), makeResult("k.x", {"1", "2"}),
makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}),
makeResult("k.x", {"1", "2"}), makeResult("k.x", {"1", "2"}),
makeResult("k.x", {"1", "2"}), makeResult("p.x", {"1"}),
makeResult("p.x", {"1"}),
};
size_t index = 0;
for (const auto& test : constraint_tests) {
QueryData results;
queryInternal(test.first + " union " + test.first, results, dbc->db());
EXPECT_EQ(results, union_results[index++]);
}
}
/**
* Main entry point.
* @param argc
* The number of arguments.
* @param argv
* The array containing all arguments.
*/
int
main(int argc, char *argv[])
{
struct Address addr;
char const *err = NULL;
int minArg;
if (argc < 3 || argc > 5) {
return usage(argv[0]);
}
if (strcmp(argv[1], "isip") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return isValidAddress(&addr) ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "isipv4") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return addr.type == AF_INET ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "isipv6") == 0) {
if (argc == 3) {
parseAddressWithoutMask(argv[2], &addr);
return addr.type == AF_INET6 ? 0 : 1;
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "netmask") == 0) {
if (argc == 3) {
if (parseAddressWithMask(argv[2], &addr)) {
convertCIDRToNetmask(&addr);
}
return makeResult(&addr, argv[2], FALSE);
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "netmaskbits") == 0) {
if (argc == 3) {
if (parseAddressWithoutMask(argv[2], &addr)) {
convertNetmaskToCIDR(&addr);
}
else {
parseAddressWithMask(argv[2], &addr);
}
if (isValidAddress(&addr)) {
printf("%u\n", addr.netmaskbits);
return 0;
}
else {
return makeResult(&addr, argv[2], FALSE);
}
}
else {
return usage(argv[0]);
}
}
if (strcmp(argv[1], "combine") == 0) {
minArg = 4;
}
else {
minArg = 3;
}
if (argc < minArg || argc > minArg + 1) {
return usage(argv[0]);
}
else if (argc == minArg) {
parseAddressWithMask(argv[2], &addr);
err = argv[2];
}
else {
if (parseAddressWithoutMask(argv[2], &addr)) {
struct Address mask;
if (parseAddressWithoutMask(argv[3], &mask)
&& convertNetmaskToCIDR(&mask)) {
if (addr.type == mask.type) {
addr.netmaskbits = mask.netmaskbits;
}
else {
fprintf(stderr, "address and netmask must belong to the same address family\n");
return -ERR_INVALID_NETMASK + 1;
}
}
else {
err = argv[3];
addr.type = mask.type == ERR_INVALID_ADDRESS
? ERR_INVALID_NETMASK : mask.type;
}
}
else if (parseAddressWithMask(argv[2], &addr)) {
return usage(argv[0]);
}
else {
err = argv[2];
}
}
if (strcmp(argv[1], "canonicalize") == 0) {
return makeResult(&addr, err, TRUE);
}
if (strcmp(argv[1], "network") == 0) {
if (isValidAddress(&addr)) {
convertCIDRToNetwork(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
if (strcmp(argv[1], "host") == 0) {
if (isValidAddress(&addr)) {
convertCIDRToHost(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
if (strcmp(argv[1], "broadcast") == 0) {
if (addr.type == AF_INET6) {
printf("ff02::1\n");
return 0;
}
else {
if (isValidAddress(&addr)) {
convertCIDRToBroadcast(&addr);
err = argv[2];
}
return makeResult(&addr, err, FALSE);
}
}
if (strcmp(argv[1], "dnsrev") == 0) {
if (isValidAddress(&addr) &&
convertCIDRToNetwork(&addr)) {
char *str = buildReverseDNSName(&addr);
if (str) {
printf("%s\n", str);
free(str);
return 0;
}
else {
fprintf(stderr, "conversion to DNS name failed\n");
return -ERR_DNS_CONVERSION_FAILED + 1;
}
}
else {
return makeResult(&addr, err, FALSE);
}
}
if (strcmp(argv[1], "combine") == 0) {
struct Address addr2;
if (isValidAddress(&addr)) {
if (parseAddressWithoutMask(argv[argc - 1], &addr2)) {
if (addr.type == addr2.type) {
combineAddresses(&addr, &addr2);
return makeResult(&addr, argv[2], TRUE);
}
else {
fprintf(stderr, "addresses to be combined must belong to the same address family\n");
return -ERR_INVALID_ADDRESS + 1;
}
}
else {
return makeResult(&addr2, argv[argc - 1], FALSE);
}
}
else {
return makeResult(&addr, err, FALSE);
}
}
// from old source:
if (! strcmp (argv[1], "dnsnet")) {
if (isValidAddress(&addr)) {
return (dnsnet (argc, argv));
}
}
return usage(argv[0]);
}
