Невозможно проанализировать тип SQL, где условие использует boost :: spirit :: qi

Возможно, я задаю очень тривиальный вопрос, но у меня не выходит из мозга блоков, чтобы взломать его.
Попытка разобрать SQL как предложение where, как показано ниже, используя boost :: spirit :: qi для генерации вектора пар

std::string input = "book.author_id = '1234' and book.isbn = 'xy99' and book.type = 'abc' and book.lang = 'Eng'"

Я прошел через следующие темы, но все еще не смог сделать это 🙁 Thread5 Thread4Thread3
Резьба2
Резьба1

[Thread1][6]
[Thread2][7]
[Thread3][8]
[Thread4][9]
[Thread5][10]

Я искренне прошу, любезно помогите мне понять, как этого достичь … может быть, я не полностью отдал свои 100%, но, пожалуйста, будьте добры ….

Вот полный код (некоторая часть закомментирована, что я хотел бы сделать), в качестве первого шага я просто проверял, могу ли я получить все токены в векторе, а затем анализировал каждый элемент вектора, чтобы сгенерировать еще один вектор из std :: pair

#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/qi.hpp>
#include <map>
#include <vector>

namespace qi    = boost::spirit::qi;
namespace phx   = boost::phoenix;

typedef std::string str_t;
typedef std::pair<str_t, str_t> pair_t;
typedef std::vector<pair_t> pairs_t;

typedef std::vector<str_t> strings_t;
//typedef std::map<std::string, std::string> map_t;
//typedef std::vector<map_t> maps_t;

template <typename It, typename Skipper = qi::space_type>
//struct parser : qi::grammar<It, pairs_t(), Skipper>
struct parser : qi::grammar<It, strings_t(), Skipper>
{
parser() : parser::base_type(start)
{
using namespace qi;

cond    = lexeme [ *(char_) ];
conds   =  *(char_) >> cond % (lit("and"));

//conds =  *(char_ - lit("and")) >>(cond % lit("and"));
/*cond  = lexeme [ *(char_ - lit("and")) ];
cond    = key >> "=" >> value;
key     = *(char_ - "=");
value   = ('\'' >> *(~char_('\'')) >> '\'');
kv_pair = key >> value;*/
start   = conds;
//cond  = key >> "=" >> value;
//key       = *(char_ - "=");
//value = ('\'' >> *(~char_('\'')) >> '\'');
//      kv_pair   = key >> value;
//      start = kv_pair;
}

private:
qi::rule<It, str_t(), Skipper> cond;
qi::rule<It, strings_t(), Skipper> conds;
//qi::rule<It, std::string(), Skipper> key, value;//, cond;
//qi::rule<It, pair_t(), Skipper> kv_pair;
//qi::rule<It, pairs_t(), Skipper> start;
qi::rule<It, strings_t(), Skipper> start;
};

template <typename C, typename Skipper>
bool doParse(const C& input, const Skipper& skipper)
{
auto f(std::begin(input)), l(std::end(input));

parser<decltype(f), Skipper> p;
strings_t data;

try
{
bool ok = qi::phrase_parse(f,l,p,skipper,data);
if (ok)
{
std::cout << "parse success\n";
std::cout << "No Of Key-Value Pairs=  "<<data.size()<<"\n";
}
else    std::cerr << "parse failed: '" << std::string(f,l) << "'\n";
return ok;
}
catch(const qi::expectation_failure<decltype(f)>& e)
{
std::string frag(e.first, e.last);
std::cerr << e.what() << "'" << frag << "'\n";
}

return false;
}

int main()
{
std::cout<<"Pair Test \n";
const std::string input = "book.author_id = '1234' and book.isbn = 'xy99' and book.type = 'abc' and book.lang = 'Eng'";
bool ok = doParse(input, qi::space);
std::cout<< input <<"\n";
return ok? 0 : 255;
}

ВЫХОД:

Pair Test
parse success
No Of Key-Value Pairs=  2
book.author_id = '1234' and book.isbn = 'xy99' and book.type = 'abc' and book.lang = 'Eng'

Что я ожидаю 4 … так как есть 4 условия!

Заранее спасибо
С Уважением,
Вивек

какой-то пример жить на колиру

2

Решение

Извините, что сломал это для вас, но ваша грамматика намного более сломана, чем вы себе представляли.

    conds   =  *(char_) // ...

Прямо здесь, вы просто анализируете все входные данные в одну строку, пропуская пробелы. На самом деле, добавляя

    for (auto& el : data)
std::cout << "'" << el << "'\n";

после разбора отпечатков:

Pair Test
parse success
No Of Key-Value Pairs=  2
'book.author_id='1234'andbook.isbn='xy99'andbook.type='abc'andbook.lang='Eng''
''

Как видите, первый элемент — это строка, *char_ разбор, и вы получите пустой элемент бесплатно из-за того, что оба conds а также cond совпадать на пустом входе.

Я настоятельно рекомендую вам начать просто. И я имею в виду, намного проще.

Медленно строите свою грамматику с земли. Spirit — очень хороший инструмент для разработки на основе тестов (за исключением времени компиляции, но у вас больше времени для размышлений!).

Вот кое-что, что я только что придумал, начав думать с самого первого строительного блока, indentи если я доберусь до элементов более высокого уровня:

// lexemes (no skipper)
ident     = +char_("a-zA-Z.");
op        = no_case [ lit("=") | "<>" | "LIKE" | "IS" ];
nulllit   = no_case [ "NULL" ];
and_      = no_case [ "AND" ];
stringlit = "'" >> *~char_("'") >> "'";

// other productions
field     = ident;
value     = stringlit | nulllit;
condition = field >> op >> value;

conjunction = condition % and_;
start       = conjunction;

Они близки к самой простой вещи, которая, я полагаю, могла бы проанализировать вашу грамматику (с несколькими творческими заметками слева и справа, где они не кажутся слишком навязчивыми).

ОБНОВИТЬ Так вот где я попал за 20 минут:

Я всегда начинаю с отображения типов, которые я хочу раскрыть в правилах:

namespace ast
{
enum op { op_equal, op_inequal, op_like, op_is };

struct null { };

typedef boost::variant<null, std::string> value;

struct condition
{
std::string _field;
op _op;
value _value;
};

typedef std::vector<condition> conditions;
}

Только condition не может быть «естественно» использовано в грамматике Духа без адаптации:

BOOST_FUSION_ADAPT_STRUCT(ast::condition, (std::string,_field)(ast::op,_op)(ast::value,_value))

Теперь перейдем к самой грамматике:

    // lexemes (no skipper)
ident       = +char_("a-zA-Z._");
op_token.add
("=",    ast::op_equal)
("<>",   ast::op_inequal)
("like", ast::op_like)
("is",   ast::op_is);
op          = no_case [ op_token ];
nulllit     = no_case [ "NULL" >> attr(ast::null()) ];
and_        = no_case [ "AND" ];
stringlit   = "'" >> *~char_("'") >> "'";

//// other productions
field       = ident;
value       = stringlit | nulllit;
condition   = field >> op >> value;

whereclause = condition % and_;
start       = whereclause;

Вы можете увидеть небольшие отклонения от моего оригинального эскиза, это интересно:

  • добавленной _ идентифицировать символы
  • переехать op_token в сопоставление символов (потому что это проще сопоставить значения перечисления)

Увидеть все Жить и работать На колиру, выход:

Pair Test
parse success
No Of Key-Value Pairs=  4
( [book.author_id] = 1234 )
( [book.isbn] LIKE xy99 )
( [book.type] = abc )
( [book.lang] IS NULL )

book.author_id = '1234' and book.isbn liKE 'xy99' and book.type = 'abc' and book.lang IS null
1

Другие решения


По вопросам рекламы [email protected]