re_match.cc 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579
  1. #include "re_match.h"
  2. #include "re_comm.h"
  3. #include "log.h"
  4. #include "re_cache.h"
  5. using namespace hsql;
  6. using namespace std;
  7. hsql::SQLParserResult sql_ast;
  8. #define SPECIFIC_L3_SCHEMA "L3"
  9. #define SPECIFIC_L1_SCHEMA "L1"
  10. #define SPECIFIC_L2_SCHEMA "L2"
  11. //legitimacy check.
  12. int do_check_sql()
  13. {
  14. return 0;
  15. }
  16. // parse sql to AST.
  17. int re_parse_sql(std::string sql, hsql::SQLParserResult* sql_ast)
  18. {
  19. log4cplus_debug("input sql parse start..");
  20. bool r = hsql::SQLParser::parse(sql, sql_ast);
  21. if(r == false)
  22. {
  23. log4cplus_debug("parse failed, sql: %s", sql.c_str());
  24. return -1;
  25. }
  26. if (!sql_ast->isValid() || sql_ast->size() <= 0)
  27. {
  28. log4cplus_debug("valid:%d, size:%d, %s", sql_ast->isValid(), sql_ast->size(), sql.c_str());
  29. return -1;
  30. }
  31. log4cplus_debug("input sql parse end");
  32. return 0;
  33. }
  34. bool hsql_convert_value_int(hsql::Expr* input, int* out)
  35. {
  36. if(input->isType(kExprLiteralInt))
  37. {
  38. *out = input->ival;
  39. return true;
  40. }
  41. else if(input->isType(kExprLiteralString))
  42. {
  43. char *endptr = NULL;
  44. long result = strtol(input->name, &endptr, 10);
  45. if(endptr == input->name)
  46. return false;
  47. if(strlen(endptr) > 0)
  48. return false;
  49. *out = result;
  50. return true;
  51. }
  52. else if(input->isType(kExprLiteralFloat))
  53. {
  54. *out = static_cast<int>(input->fval);
  55. return true;
  56. }
  57. return false;
  58. }
  59. std::string hsql_convert_value_string(hsql::Expr* input)
  60. {
  61. if(input->isType(kExprLiteralInt))
  62. {
  63. return to_string(input->ival);
  64. }
  65. else if(input->isType(kExprLiteralString))
  66. {
  67. return input->name;
  68. }
  69. else if(input->isType(kExprLiteralFloat))
  70. {
  71. return to_string(input->fval);
  72. }
  73. return "";
  74. }
  75. bool hsql_convert_value_float(hsql::Expr* input, double* out)
  76. {
  77. if(input->isType(kExprLiteralFloat))
  78. {
  79. *out = input->fval;
  80. return true;
  81. }
  82. else if(input->isType(kExprLiteralString))
  83. {
  84. char *endptr = NULL;
  85. double result = strtod(input->name, &endptr);
  86. if(endptr == input->name)
  87. return false;
  88. if(strlen(endptr) > 0)
  89. return false;
  90. *out = result;
  91. return true;
  92. }
  93. else if(input->isType(kExprLiteralInt))
  94. {
  95. *out = static_cast<double>(input->ival);
  96. return true;
  97. }
  98. return false;
  99. }
  100. bool cmp_expr_value(hsql::Expr* input, hsql::Expr* rule, OperatorType input_type, OperatorType rule_type)
  101. {
  102. if(input->type != rule->type)
  103. {
  104. if(input->type > kExprLiteralInt || rule->type > kExprLiteralInt)
  105. return false;
  106. }
  107. if(input_type >= kOpLess && input_type <= kOpGreaterEq && input->isType(kExprLiteralString))
  108. return false;
  109. if(input_type == kOpEquals && rule_type == kOpEquals)
  110. {
  111. if(rule->isType(kExprLiteralFloat))
  112. {
  113. double v;
  114. bool valid = hsql_convert_value_float(input, &v);
  115. if(!valid)
  116. return false;
  117. if(v == rule->fval)
  118. return true;
  119. else
  120. return false;
  121. }
  122. else if(rule->isType(kExprLiteralInt))
  123. {
  124. int v;
  125. bool valid = hsql_convert_value_int(input, &v);
  126. if(!valid)
  127. return false;
  128. if(v == rule->ival)
  129. return true;
  130. else
  131. return false;
  132. }
  133. else if(rule->isType(kExprLiteralString))
  134. {
  135. std::string v = hsql_convert_value_string(input);
  136. if(v == std::string(rule->name))
  137. return true;
  138. else
  139. return false;
  140. }
  141. }
  142. else if(input_type == kOpNotEquals && rule_type == kOpNotEquals)
  143. {
  144. if(rule->isType(kExprLiteralFloat))
  145. {
  146. double v;
  147. bool valid = hsql_convert_value_float(input, &v);
  148. if(!valid)
  149. return false;
  150. if(v != rule->fval)
  151. return true;
  152. else
  153. return false;
  154. }
  155. else if(rule->isType(kExprLiteralInt))
  156. {
  157. int v;
  158. bool valid = hsql_convert_value_int(input, &v);
  159. if(!valid)
  160. return false;
  161. if(v != rule->ival)
  162. return true;
  163. else
  164. return false;
  165. }
  166. else if(rule->isType(kExprLiteralString))
  167. {
  168. std::string v = hsql_convert_value_string(input);
  169. if(v == std::string(rule->name))
  170. return false;
  171. else
  172. return true;
  173. }
  174. }
  175. else if(rule_type == kOpLess)
  176. {
  177. if(rule->isType(kExprLiteralFloat))
  178. {
  179. double v;
  180. bool valid = hsql_convert_value_float(input, &v);
  181. if(!valid)
  182. return false;
  183. if(input_type == kOpLess)
  184. {
  185. if(v <= rule->fval)
  186. return true;
  187. else
  188. return false;
  189. }
  190. else if(input_type == kOpLessEq)
  191. {
  192. if(v < rule->fval)
  193. return true;
  194. else
  195. return false;
  196. }
  197. else if(input_type == kOpEquals)
  198. {
  199. if(v < rule->fval)
  200. return true;
  201. else
  202. return false;
  203. }
  204. }
  205. else if(rule->isType(kExprLiteralInt))
  206. {
  207. int v;
  208. bool valid = hsql_convert_value_int(input, &v);
  209. if(!valid)
  210. return false;
  211. if(input_type == kOpLess)
  212. {
  213. if(v <= rule->ival)
  214. return true;
  215. else
  216. return false;
  217. }
  218. else if(input_type == kOpLessEq)
  219. {
  220. if(v < rule->ival)
  221. return true;
  222. else
  223. return false;
  224. }
  225. else if(input_type == kOpEquals)
  226. {
  227. if(v < rule->ival)
  228. return true;
  229. else
  230. return false;
  231. }
  232. }
  233. }
  234. else if(rule_type == kOpLessEq)
  235. {
  236. if(rule->isType(kExprLiteralFloat))
  237. {
  238. if(input_type == kOpLess || input_type == kOpLessEq || input_type == kOpEquals)
  239. {
  240. double v;
  241. bool valid = hsql_convert_value_float(input, &v);
  242. if(!valid)
  243. return false;
  244. if(v <= rule->fval)
  245. return true;
  246. else
  247. return false;
  248. }
  249. }
  250. else if(rule->isType(kExprLiteralInt))
  251. {
  252. int v;
  253. bool valid = hsql_convert_value_int(input, &v);
  254. if(!valid)
  255. return false;
  256. if(input_type == kOpLess || input_type == kOpLessEq || input_type == kOpEquals)
  257. {
  258. if(v <= rule->ival)
  259. return true;
  260. else
  261. return false;
  262. }
  263. }
  264. }
  265. else if(rule_type == kOpGreater)
  266. {
  267. if(rule->isType(kExprLiteralFloat))
  268. {
  269. double v;
  270. bool valid = hsql_convert_value_float(input, &v);
  271. if(!valid)
  272. return false;
  273. if(input_type == kOpGreater)
  274. {
  275. if(v >= rule->fval)
  276. return true;
  277. else
  278. return false;
  279. }
  280. else if(input_type == kOpGreaterEq)
  281. {
  282. if(v > rule->fval)
  283. return true;
  284. else
  285. return false;
  286. }
  287. else if(input_type == kOpEquals)
  288. {
  289. if(v > rule->fval)
  290. return true;
  291. else
  292. return false;
  293. }
  294. }
  295. else if(rule->isType(kExprLiteralInt))
  296. {
  297. int v;
  298. bool valid = hsql_convert_value_int(input, &v);
  299. if(!valid)
  300. return false;
  301. if(input_type == kOpGreater)
  302. {
  303. if(v >= rule->ival)
  304. return true;
  305. else
  306. return false;
  307. }
  308. else if(input_type == kOpGreaterEq)
  309. {
  310. if(v > rule->ival)
  311. return true;
  312. else
  313. return false;
  314. }
  315. else if(input_type == kOpEquals)
  316. {
  317. if(v > rule->ival)
  318. return true;
  319. else
  320. return false;
  321. }
  322. }
  323. }
  324. else if(rule_type == kOpGreaterEq)
  325. {
  326. if(rule->isType(kExprLiteralFloat))
  327. {
  328. if(input_type == kOpGreater || input_type == kOpGreaterEq || input_type == kOpEquals)
  329. {
  330. double v;
  331. bool valid = hsql_convert_value_float(input, &v);
  332. if(!valid)
  333. return false;
  334. if(v >= rule->fval)
  335. return true;
  336. else
  337. return false;
  338. }
  339. }
  340. else if(rule->isType(kExprLiteralInt))
  341. {
  342. if(input_type == kOpGreater || input_type == kOpGreaterEq || input_type == kOpEquals)
  343. {
  344. int v;
  345. bool valid = hsql_convert_value_int(input, &v);
  346. if(!valid)
  347. return false;
  348. if(v >= rule->ival)
  349. return true;
  350. else
  351. return false;
  352. }
  353. }
  354. }
  355. return false;
  356. }
  357. bool do_match_expr(hsql::Expr* input, hsql::Expr* rule)
  358. {
  359. if(!input->isType(kExprOperator) || !rule->isType(kExprOperator))
  360. return false;
  361. if(input->opType != rule->opType && (input->opType < kOpEquals || input->opType > kOpGreaterEq))
  362. return false;
  363. log4cplus_debug("do_MATCH_EXPR:%s %s", input->expr->getName(), rule->expr->getName());
  364. if(strcasecmp(input->expr->getName(), rule->expr->getName()) != 0)
  365. return false;
  366. return cmp_expr_value(input->expr2, rule->expr2, input->opType, rule->opType);
  367. }
  368. bool is_write_type(SQLParserResult* sql_ast)
  369. {
  370. StatementType t = sql_ast->getStatement(0)->type();
  371. if(t == kStmtInsert)
  372. return true;
  373. else if(t == kStmtUpdate)
  374. return true;
  375. else if(t == kStmtDelete)
  376. return true;
  377. else
  378. return false;
  379. }
  380. bool is_update_delete_type(SQLParserResult* sql_ast)
  381. {
  382. StatementType t = sql_ast->getStatement(0)->type();
  383. if(t == kStmtUpdate)
  384. return true;
  385. else if(t == kStmtDelete)
  386. return true;
  387. else
  388. return false;
  389. }
  390. Expr* get_expr(SQLParserResult* sql_ast)
  391. {
  392. if(!sql_ast)
  393. return NULL;
  394. StatementType t = sql_ast->getStatement(0)->type();
  395. if(t == kStmtSelect)
  396. {
  397. const SelectStatement* stmt = (const SelectStatement*)(sql_ast->getStatement(0));
  398. if(stmt)
  399. {
  400. return stmt->whereClause;
  401. }
  402. }
  403. else if(t == kStmtUpdate)
  404. {
  405. const UpdateStatement* stmt = (const UpdateStatement*)(sql_ast->getStatement(0));
  406. if(stmt)
  407. {
  408. return stmt->where;
  409. }
  410. }
  411. else if(t == kStmtDelete)
  412. {
  413. const DeleteStatement* stmt = (const DeleteStatement*)(sql_ast->getStatement(0));
  414. if(stmt)
  415. {
  416. return stmt->expr;
  417. }
  418. }
  419. return NULL;
  420. }
  421. bool traverse_input_sql(hsql::Expr* input, vector<hsql::Expr*> rules)
  422. {
  423. bool left = false;
  424. bool right = false;
  425. if(!input)
  426. return false;
  427. if(!input->expr || !input->expr2)
  428. return false;
  429. if(input->opType >= kOpEquals && input->opType <= kOpGreaterEq)
  430. {
  431. for(int i = 0; i < rules.size(); i++)
  432. {
  433. if(do_match_expr(input, rules[i]))
  434. {
  435. return true;
  436. }
  437. }
  438. }
  439. if(input->expr->opType >= kOpEquals && input->expr->opType <= kOpGreaterEq)
  440. {
  441. for(int i = 0; i < rules.size(); i++)
  442. {
  443. if(do_match_expr(input->expr, rules[i]))
  444. {
  445. left = true;
  446. break;
  447. }
  448. }
  449. }
  450. else if(input->expr->opType == kOpAnd || input->expr->opType == kOpOr)
  451. {
  452. left = traverse_input_sql(input->expr, rules);
  453. }
  454. if(input->expr2->opType >= kOpEquals && input->expr2->opType <= kOpGreaterEq)
  455. {
  456. for(int i = 0; i < rules.size(); i++)
  457. {
  458. if(do_match_expr(input->expr2, rules[i]))
  459. {
  460. right = true;
  461. break;
  462. }
  463. }
  464. }
  465. else if(input->expr2->opType == kOpAnd || input->expr2->opType == kOpOr)
  466. {
  467. right = traverse_input_sql(input->expr2, rules);
  468. }
  469. if(input->opType == kOpAnd)
  470. {
  471. if(left || right)
  472. return true;
  473. }
  474. else if(input->opType == kOpOr)
  475. {
  476. if(left && right)
  477. return true;
  478. }
  479. return false;
  480. }
  481. int re_match_sql(hsql::SQLParserResult* sql_ast, vector<vector<hsql::Expr*> > expr_rules, hsql::SQLParserResult* ast)
  482. {
  483. bool b_match = false;
  484. hsql::Expr* input_expr = NULL;
  485. int ret = -1;
  486. bool is_write = false;
  487. int statment_num = 0;
  488. log4cplus_debug("sql match start..");
  489. if(!sql_ast)
  490. {
  491. log4cplus_debug("sql_ast is null");
  492. ret = -1;
  493. goto RESULT;
  494. }
  495. statment_num = sql_ast->size();
  496. if(statment_num > 1)
  497. {
  498. ret = -2;
  499. goto RESULT;
  500. }
  501. if(is_write_type(sql_ast))
  502. {
  503. is_write = true;
  504. input_expr = get_expr(ast);
  505. }
  506. else
  507. {
  508. input_expr = get_expr(sql_ast);
  509. }
  510. if(!input_expr)
  511. {
  512. if(is_write)
  513. return -100;
  514. ret = -1;
  515. goto RESULT;
  516. }
  517. log4cplus_debug("expr rule count: %d", expr_rules.size());
  518. for(int i = 0; i < expr_rules.size(); i++)
  519. {
  520. if(traverse_input_sql(input_expr, expr_rules[i]))
  521. {
  522. ret = 0;
  523. goto RESULT;
  524. }
  525. }
  526. if(is_write)
  527. {
  528. ret = -100;
  529. goto RESULT;
  530. }
  531. ret = -2;
  532. RESULT:
  533. log4cplus_debug("sql match end: %d", ret);
  534. return ret;
  535. }