guardinari 0.1.0

data/ext/guardinari/guardinari.l

@@ -0,0 +1,245 @@
+%option noyywrap caseless yylineno nodefault reentrant header-file="scanner.h"
+
+%{
+
+#include <stdbool.h>
+
+#include "ruby.h"
+
+enum tokens { 
+  // Keywords (we care about)
+  T_SELECT  = 260,
+  T_ORDER   = 262,
+  T_BY      = 263,
+  T_LIMIT   = 264,
+  T_OFFSET  = 265,
+
+  // Data types
+  T_STR     = 266,
+};
+
+#define TOK(x) DEBUG(#x"(%s)\n", yytext); yyextra->last_token = T_##x; return T_##x;
+
+#define MAX_QUERY_NESTING 5
+
+typedef struct {
+  bool select;
+  bool order_by;
+  bool have_limit;
+  int limit;
+  bool have_offset;
+  int offset;
+} query_state;
+
+typedef struct {
+  query_state stack[MAX_QUERY_NESTING];
+  VALUE bind_params;
+  int stack_index;
+  int last_token;
+  bool broken_pagination;
+  int error;
+} scanner_state;
+
+#define YY_EXTRA_TYPE scanner_state*
+
+int ERR_NESTING = 1;
+int ERR_PARSE = 2;
+
+//#define DEBUG_BUILD 1
+#ifdef DEBUG_BUILD
+  #define DEBUG(...) do { fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); } while (0)
+#else
+  #define DEBUG(...) 
+#endif
+
+void guardinari_check_pagination(scanner_state*); 
+
+/* Ruby stuff */
+
+VALUE guardinari_find_broken_pagination(VALUE self, VALUE sql, VALUE bind_params);
+
+VALUE rb_mGuardinari;
+VALUE rb_eError;
+VALUE rb_eNestingError;
+VALUE rb_eParseError;
+
+RUBY_FUNC_EXPORTED void Init_guardinari(void) {
+  rb_mGuardinari = rb_define_module("Guardinari");
+
+  rb_eError = rb_define_class_under(rb_mGuardinari, "Error", rb_eRuntimeError);
+  rb_eNestingError = rb_define_class_under(rb_mGuardinari, "NestingError", rb_eError);
+  rb_eParseError = rb_define_class_under(rb_mGuardinari, "ParseError", rb_eError);
+
+  rb_define_module_function(rb_mGuardinari, "find_broken_pagination", &guardinari_find_broken_pagination, 2);
+}
+
+%}
+
+
+%x COMMENT
+
+%%
+
+  /* The subset of keywords that are relevant */
+select  { yyextra->stack[yyextra->stack_index].select = true; TOK(SELECT); }
+order   { TOK(ORDER); }
+by      {
+  if (yyextra->last_token == T_ORDER) {
+    yyextra->stack[yyextra->stack_index].order_by = true;
+  } else {
+    DEBUG("last token: %d", yyextra->last_token);
+  }
+
+  TOK(BY);
+}
+limit   { TOK(LIMIT); }
+offset  { TOK(OFFSET); }
+
+[0-9]+ {
+  DEBUG("have number: %s", yytext);
+  if (yyextra->last_token == T_LIMIT) {
+    yyextra->stack[yyextra->stack_index].have_limit = true;
+    yyextra->stack[yyextra->stack_index].limit = atoi(yytext);
+  } else if (yyextra->last_token == T_OFFSET) {
+    yyextra->stack[yyextra->stack_index].have_offset = true;
+    yyextra->stack[yyextra->stack_index].offset = atoi(yytext);
+  }
+}
+
+$[0-9]+ {
+  DEBUG("have bind param %s", yytext);
+  // The only time we care about evaluating a bound parameter is when we're finding the limit or offset
+  // When we have a "limit 1 offset 0" query, it's not broken pagination; it's a finder method that is
+  // expected to return exactly 1 value
+  if (yyextra->last_token == T_LIMIT || yyextra->last_token == T_OFFSET) {
+    int param_index = atoi(yytext + 1) - 1;
+    DEBUG("Looking up bind param %d", param_index);
+    VALUE param = RARRAY_AREF(yyextra->bind_params, param_index);
+    DEBUG("Found %d", NUM2INT(param));
+
+    if (yyextra->last_token == T_LIMIT) {
+      yyextra->stack[yyextra->stack_index].limit = NUM2INT(param);
+      yyextra->stack[yyextra->stack_index].have_limit = true;
+    } else {
+      yyextra->stack[yyextra->stack_index].offset = NUM2INT(param);
+      yyextra->stack[yyextra->stack_index].have_offset = true;
+    }
+  }
+}
+
+\"([^"]|(\\\"))+\" { TOK(STR); }
+\'([^']|(\\\'))+\' { TOK(STR); }
+
+  /* Comments */
+--.+ { /* skip single line comments */ }
+"/*" { BEGIN COMMENT; }
+<COMMENT>{
+  "*/" { BEGIN INITIAL; }
+  .|\n { /* skip */ }
+}
+
+"("  {
+  if (yyextra->stack_index + 1 == MAX_QUERY_NESTING) {
+    yyextra->stack_index = MAX_QUERY_NESTING - 1;
+
+    DEBUG("Maximum nesting reached, halting parsing");
+
+    yyextra->error = ERR_NESTING;
+
+    // Halt parsing, clean up
+    yyterminate();
+
+  } else {
+    ++yyextra->stack_index;
+  }
+}
+
+")" {
+  if (yyextra->stack_index == 0) {
+    printf("Unmatched ')'\n");
+
+    yyextra->error = ERR_PARSE;
+
+    yyterminate();
+  } else {
+    guardinari_check_pagination(yyextra);
+    // Reset this "stack frame" to zero for any subsequent queries
+    yyextra->stack[yyextra->stack_index] = (query_state){0};
+    --yyextra->stack_index;
+  }
+}
+
+<<EOF>> {
+  if (yyextra->stack_index != 0) {
+    fprintf(stderr, "Error: Unexpected EOF looking for ')' to terminate sub-query\n");
+  }
+
+  guardinari_check_pagination(yyextra);
+  return 0;
+}
+
+[ \t\n] { /* Whitespace */ }
+
+. { DEBUG("Unknown character %c", *yytext); }
+
+%%
+
+void guardinari_check_pagination(scanner_state *state) {
+  // Bail when we already know the query has broken pagination
+  if (state->broken_pagination) {
+    return;
+  }
+
+  query_state q = state->stack[state->stack_index];
+  DEBUG("Checking pagination");
+  DEBUG("select: %d", q.select);
+  DEBUG("have_limit/limit: %d/%d", q.have_limit, q.limit);
+  DEBUG("have_offset/offset: %d/%d", q.have_offset, q.offset);
+  DEBUG("have_order_by: %d", q.order_by);
+
+  bool broken = q.select && !q.order_by && (q.have_limit && q.have_offset && (q.limit > 1 || (q.limit == 1 && (q.offset > 0))));
+
+  DEBUG("Broken: %d", broken);
+  state->broken_pagination = broken;
+}
+
+VALUE guardinari_find_broken_pagination(VALUE self, VALUE sql, VALUE bind_params) {
+  Check_Type(sql, T_STRING);
+  Check_Type(bind_params, T_ARRAY);
+
+  yyscan_t scanner;
+  yylex_init(&scanner);
+
+  scanner_state state = {};
+
+  // Note that we don't hold onto this value beyond the end of the function, so we don't
+  // need to increment its reference count.
+  state.bind_params = bind_params;
+
+  if (yylex_init_extra(&state, &scanner)) {
+    DEBUG("Unable to pass state to scanner");
+    abort();
+  }
+  
+  const char* sql_str = StringValueCStr(sql);
+  DEBUG("Checking SQL %s", sql_str);
+  YY_BUFFER_STATE buf = yy_scan_string(sql_str, scanner);  // or
+
+  int tok;
+  while ((tok = yylex(scanner))) {
+    if (state.broken_pagination) {
+      break;
+    }
+  }
+
+  yy_delete_buffer(buf, scanner);
+  yylex_destroy(scanner);
+
+  if (state.error) {
+    rb_raise(rb_eNestingError, "sub-queries are nested too deeply");
+  }
+
+  return state.broken_pagination ? Qtrue : Qfalse;
+}
+
+