hogql-parser 1.0.0__tar.gz → 1.0.2__tar.gz

{hogql_parser-1.0.0 → hogql_parser-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hogql_parser
-Version: 1.0.0
+Version: 1.0.2
 Summary: HogQL parser for internal PostHog use
 Home-page: https://github.com/PostHog/posthog/tree/master/hogql_parser
 Author: PostHog Inc.

{hogql_parser-1.0.0 → hogql_parser-1.0.2}/hogql_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hogql-parser
-Version: 1.0.0
+Version: 1.0.2
 Summary: HogQL parser for internal PostHog use
 Home-page: https://github.com/PostHog/posthog/tree/master/hogql_parser
 Author: PostHog Inc.

{hogql_parser-1.0.0 → hogql_parser-1.0.2}/parser.cpp

@@ -17,7 +17,7 @@
     throw NotImplementedException("Unsupported rule: " #RULE); \
   }
 
-#define HANDLE_HOGQL_EXCEPTION(TYPE)                                                                    \
+#define HANDLE_HOGQL_EXCEPTION(TYPE, OTHER_CLEANUP)                                                     \
   (const TYPE& e) {                                                                                     \
     string err_what = e.what();                                                                         \
     PyObject *error_type = NULL, *py_err_args = NULL, *py_err = NULL, *py_start = NULL, *py_end = NULL; \
@@ -37,11 +37,12 @@
     err_indicator = PyObject_SetAttrString(py_err, "end", py_end);                                      \
     if (err_indicator == -1) goto exit##TYPE;                                                           \
     PyErr_SetObject(error_type, py_err);                                                                \
-    exit##TYPE:;                                                                                        \
+    exit##TYPE :;                                                                                       \
     Py_XDECREF(py_end);                                                                                 \
     Py_XDECREF(py_start);                                                                               \
     Py_XDECREF(py_err);                                                                                 \
     Py_XDECREF(error_type);                                                                             \
+    OTHER_CLEANUP                                                                                       \
     return NULL;                                                                                        \
   }
 
@@ -98,6 +99,7 @@ PyObject* X_PyList_FromStrings(const vector<string>& items) {
 class HogQLParseTreeConverter : public HogQLParserBaseVisitor {
  private:
   parser_state* state;
+  bool is_internal;
 
   const vector<string> RESERVED_KEYWORDS = {"true", "false", "null", "team_id"};
 
@@ -151,7 +153,7 @@ class HogQLParseTreeConverter : public HogQLParserBaseVisitor {
 #undef IS_AST_NODE_INSTANCE_IMPL
 
  public:
-  HogQLParseTreeConverter(parser_state* state) : state(state) {}
+  HogQLParseTreeConverter(parser_state* state, bool is_internal) : state(state), is_internal(is_internal) {}
 
   any visit(antlr4::tree::ParseTree* tree) override {
     // Find the start and stop indices of the parse tree node
@@ -169,17 +171,18 @@ class HogQLParseTreeConverter : public HogQLParserBaseVisitor {
       start = ctx->getStart()->getStartIndex();
       stop = ctx->getStop()->getStopIndex();
     }
-    // Visit the parse tree node
+    // Visit the parse tree node (while making sure that nodes/errors have spans - except for internal expressions)
     any node;
     try {
       node = tree->accept(this);
     } catch (const SyntaxException& e) {
-      if (e.start == 0 && e.end == 0) {  // If start and end are unset, rethrow with the current start and stop
+      // If start and end are unset, rethrow with the current start and stop
+      if (!is_internal && e.start == 0 && e.end == 0) {
         throw SyntaxException(e.what(), start, stop + 1);
       }
       throw;
     }
-    if (node.has_value() && node.type() == typeid(PyObject*)) {
+    if (!is_internal && node.has_value() && node.type() == typeid(PyObject*)) {
       PyObject* py_node = any_cast<PyObject*>(node);
       if (py_node) {
         int is_ast = is_ast_node_instance(py_node);
@@ -218,8 +221,9 @@ class HogQLParseTreeConverter : public HogQLParserBaseVisitor {
   PyObject* visitAsPyObjectFinal(antlr4::tree::ParseTree* tree) {
     try {
       return visitAsPyObject(tree);
-    } catch HANDLE_HOGQL_EXCEPTION(SyntaxException) catch HANDLE_HOGQL_EXCEPTION(NotImplementedException
-    ) catch HANDLE_HOGQL_EXCEPTION(ParsingException) catch (const PyInternalException& e) {
+    } catch HANDLE_HOGQL_EXCEPTION(SyntaxException, ) catch HANDLE_HOGQL_EXCEPTION(
+        NotImplementedException,
+    ) catch HANDLE_HOGQL_EXCEPTION(ParsingException, ) catch (const PyInternalException& e) {
       return NULL;
     } catch (const bad_any_cast& e) {
       PyObject* error_type = PyObject_GetAttrString(state->errors_module, "ParsingException");
@@ -1789,7 +1793,8 @@ class HogQLParseTreeConverter : public HogQLParserBaseVisitor {
   VISIT(TableFunctionExpr) {
     string table_name = visitAsString(ctx->identifier());
     auto table_args_ctx = ctx->tableArgList();
-    PyObject* table_args = table_args_ctx ? visitAsPyObject(table_args_ctx) : Py_NewRef(Py_None);
+    PyObject* table_args = table_args_ctx ? visitAsPyObject(table_args_ctx) : PyList_New(0);
+    if (!table_args) throw PyInternalException();
     PyObject* table = build_ast_node("Field", "{s:[s#]}", "chain", table_name.data(), table_name.size());
     if (!table) {
       Py_DECREF(table_args);
@@ -2030,32 +2035,35 @@ parser_state* get_module_state(PyObject* module) {
 
 // MODULE METHODS
 
-#define METHOD_PARSE_NODE(PASCAL_CASE, CAMEL_CASE, SNAKE_CASE)                  \
-  static PyObject* method_parse_##SNAKE_CASE(PyObject* self, PyObject* args) {  \
-    parser_state* state = get_module_state(self);                               \
-    const char* str;                                                            \
-    if (!PyArg_ParseTuple(args, "s", &str)) {                                   \
-      return NULL;                                                              \
-    }                                                                           \
-    auto input_stream = new antlr4::ANTLRInputStream(str, strnlen(str, 65536)); \
-    auto lexer = new HogQLLexer(input_stream);                                  \
-    auto stream = new antlr4::CommonTokenStream(lexer);                         \
-    auto parser = new HogQLParser(stream);                                      \
-    parser->removeErrorListeners();                                             \
-    auto error_listener = new HogQLErrorListener(str);                          \
-    parser->addErrorListener(error_listener);                                   \
-    HogQLParser::PASCAL_CASE##Context* parse_tree;                              \
-    try {                                                                       \
-      parse_tree = parser->CAMEL_CASE();                                        \
-    } catch HANDLE_HOGQL_EXCEPTION(SyntaxException);                            \
-    HogQLParseTreeConverter converter = HogQLParseTreeConverter(state);         \
-    PyObject* result_node = converter.visitAsPyObjectFinal(parse_tree);         \
-    delete error_listener;                                                      \
-    delete parser;                                                              \
-    delete stream;                                                              \
-    delete lexer;                                                               \
-    delete input_stream;                                                        \
-    return result_node;                                                         \
+#define METHOD_PARSE_NODE(PASCAL_CASE, CAMEL_CASE, SNAKE_CASE)                                                         \
+  static PyObject* method_parse_##SNAKE_CASE(PyObject* self, PyObject* args, PyObject* kwargs) {                       \
+    parser_state* state = get_module_state(self);                                                                      \
+    const char* str;                                                                                                   \
+    int internal = 0;                                                                                                  \
+    static const char* kwlist[] = {"input", "is_internal", NULL};                                                      \
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|p", (char**)kwlist, &str, &internal)) {                          \
+      return NULL;                                                                                                     \
+    }                                                                                                                  \
+    auto input_stream = new antlr4::ANTLRInputStream(str, strnlen(str, 65536));                                        \
+    auto lexer = new HogQLLexer(input_stream);                                                                         \
+    auto stream = new antlr4::CommonTokenStream(lexer);                                                                \
+    auto parser = new HogQLParser(stream);                                                                             \
+    parser->removeErrorListeners();                                                                                    \
+    auto error_listener = new HogQLErrorListener(str);                                                                 \
+    parser->addErrorListener(error_listener);                                                                          \
+    HogQLParser::PASCAL_CASE##Context* parse_tree;                                                                     \
+    try {                                                                                                              \
+      parse_tree = parser->CAMEL_CASE();                                                                               \
+    } catch HANDLE_HOGQL_EXCEPTION(SyntaxException, delete error_listener; delete parser; delete stream; delete lexer; \
+                                   delete input_stream;);                                                              \
+    HogQLParseTreeConverter converter = HogQLParseTreeConverter(state, internal == 1);                                 \
+    PyObject* result_node = converter.visitAsPyObjectFinal(parse_tree);                                                \
+    delete error_listener;                                                                                             \
+    delete parser;                                                                                                     \
+    delete stream;                                                                                                     \
+    delete lexer;                                                                                                      \
+    delete input_stream;                                                                                               \
+    return result_node;                                                                                                \
   }
 
 METHOD_PARSE_NODE(Expr, expr, expr)
@@ -2073,7 +2081,7 @@ static PyObject* method_unquote_string(PyObject* self, PyObject* args) {
   string unquoted_string;
   try {
     unquoted_string = unquote_string(str);
-  } catch HANDLE_HOGQL_EXCEPTION(SyntaxException);
+  } catch HANDLE_HOGQL_EXCEPTION(SyntaxException, );
   return PyUnicode_FromStringAndSize(unquoted_string.data(), unquoted_string.size());
 }
 
@@ -2081,22 +2089,23 @@ static PyObject* method_unquote_string(PyObject* self, PyObject* args) {
 
 static PyMethodDef parser_methods[] = {
     {.ml_name = "parse_expr",
-     .ml_meth = method_parse_expr,
-     .ml_flags = METH_VARARGS,
+     .ml_meth = (PyCFunction)method_parse_expr,
+     .ml_flags = METH_VARARGS | METH_KEYWORDS,
      .ml_doc = "Parse the HogQL expression string into an AST"},
     {.ml_name = "parse_order_expr",
-     .ml_meth = method_parse_order_expr,
-     .ml_flags = METH_VARARGS,
+     .ml_meth = (PyCFunction)method_parse_order_expr,
+     .ml_flags = METH_VARARGS | METH_KEYWORDS,
      .ml_doc = "Parse the ORDER BY clause string into an AST"},
     {.ml_name = "parse_select",
-     .ml_meth = method_parse_select,
-     .ml_flags = METH_VARARGS,
+     .ml_meth = (PyCFunction)method_parse_select,
+     .ml_flags = METH_VARARGS | METH_KEYWORDS,
      .ml_doc = "Parse the HogQL SELECT statement string into an AST"},
     {.ml_name = "unquote_string",
      .ml_meth = method_unquote_string,
      .ml_flags = METH_VARARGS,
      .ml_doc = "Unquote the string (an identifier or a string literal))"},
-    {NULL, NULL, 0, NULL}};
+    {NULL, NULL, 0, NULL}
+};
 
 static int parser_modexec(PyObject* module) {
   parser_state* state = get_module_state(module);
@@ -2118,7 +2127,8 @@ static int parser_modexec(PyObject* module) {
 static PyModuleDef_Slot parser_slots[] = {
     {Py_mod_exec, (void*)parser_modexec},  // If Python were written in C++, then Py_mod_exec would be typed better, but
                                            // because it's in C, it expects a void pointer
-    {0, NULL}};
+    {0, NULL}
+};
 
 static int parser_traverse(PyObject* module, visitproc visit, void* arg) {
   parser_state* state = get_module_state(module);

{hogql_parser-1.0.0 → hogql_parser-1.0.2}/setup.py

@@ -32,7 +32,7 @@ module = Extension(
 
 setup(
     name="hogql_parser",
-    version="1.0.0",
+    version="1.0.2",
     url="https://github.com/PostHog/posthog/tree/master/hogql_parser",
     author="PostHog Inc.",
     author_email="hey@posthog.com",

{hogql_parser-1.0.0 → hogql_parser-1.0.2}/string.cpp

@@ -40,7 +40,7 @@ string unquote_string(string text) {
   boost::replace_all(text, "\\r", "\r");
   boost::replace_all(text, "\\t", "\t");
   boost::replace_all(text, "\\v", "\v");
-  boost::replace_all(text, "\\0", ""); // NUL characters are ignored
+  boost::replace_all(text, "\\0", "");  // NUL characters are ignored
   boost::replace_all(text, "\\\\", "\\");
 
   return text;