Deparse

binding.gyp

@@ -8,16 +8,21 @@
         "src/sync.cc",
         "src/async.cc"
       ],
-      'cflags!': [ '-fno-exceptions' ],
-      'cflags_cc!': [ '-fno-exceptions' ],
+      'cflags!': ['-fno-exceptions', '-O3'],
+      'cflags_cc!': ['-fno-exceptions', '-O3'],
       'include_dirs': [
         "libpg_query/include",
-        "<!@(node -p \"require('node-addon-api').include\")"
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "<!(pkg-config --variable=includedir protobuf)"
       ],
       'dependencies': ["<!(node -p \"require('node-addon-api').gyp\")"],
       'conditions': [
         ['OS=="linux"', {
-          "libraries": [ "-L<!(pwd)/libpg_query/linux", "-lpg_query" ],
+          "libraries": [
+            "-L<!(pwd)/libpg_query/linux",
+            "-lpg_query",
+            "<!(pkg-config --variable=libdir protobuf)/libprotobuf.a"
+          ],
           "actions": [
             {
               "outputs": ['libpg_query/include/pg_query.h'],
@@ -28,7 +33,11 @@
           ],
         }],
         ['OS=="mac"', {
-          "libraries": [ "-L<!(pwd)/libpg_query/osx", "-lpg_query" ],
+          "libraries": [
+            "-L<!(pwd)/libpg_query/osx",
+            "-lpg_query",
+            "<!(pkg-config --variable=libdir protobuf)/libprotobuf.a"
+          ],
           "xcode_settings": {
             "CLANG_CXX_LIBRARY": "libc++",
             'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',

index.js

@@ -9,6 +9,14 @@ module.exports = {
     });
   },
 
+  deparseQuery(ast) {
+    return new Promise((resolve, reject) => {
+      PgQuery.deparseQueryAsync(JSON.stringify(ast), (err, result) => {
+        err ? reject(err) : resolve(result);
+      });
+    });
+  },
+
   parsePlPgSQL(query) {
     return new Promise((resolve, reject) => {
       PgQuery.parsePlPgSQLAsync(query, (err, result) => {
@@ -21,6 +29,10 @@ module.exports = {
     return JSON.parse(PgQuery.parseQuerySync(query));
   },
 
+  deparseQuerySync(ast) {
+    return PgQuery.deparseQuerySync(JSON.stringify(ast));
+  },
+
   parsePlPgSQLSync(query) {
     return JSON.parse(PgQuery.parsePlPgSQLSync(query));
   },

script/buildAddon.sh

@@ -27,7 +27,7 @@ unset MFLAGS
 
 # Adaptively build for macOS or Linux
 if [ "$(uname)" == "Darwin" ]; then
-	make CFLAGS='-mmacosx-version-min=10.7' PG_CFLAGS='-mmacosx-version-min=10.7' $makeTarget
+	make CFLAGS='-mmacosx-version-min=10.7' PG_CFLAGS='-mmacosx-version-min=10.7' USE_PROTOBUF_CPP=1 $makeTarget
 elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
 	make CFLAGS='' PG_CFLAGS='' $makeTarget
 fi
@@ -61,6 +61,7 @@ fi
 
 # Copy header
 cp $(pwd)/pg_query.h $rDIR/libpg_query/include/
+cp $(pwd)/protobuf/pg_query.pb.h $rDIR/libpg_query/include/protobuf
 
 # Cleanup: revert to original directory and remove the temp
 cd "$rDIR"

src/addon.cc

@@ -14,6 +14,16 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     Napi::Function::New(env, ParseQueryAsync)
   );
 
+  exports.Set(
+    Napi::String::New(env, "deparseQuerySync"),
+    Napi::Function::New(env, DeparseQuerySync)
+  );
+
+  exports.Set(
+    Napi::String::New(env, "deparseQueryAsync"),
+    Napi::Function::New(env, DeparseQueryAsync)
+  );
+
   exports.Set(
     Napi::String::New(env, "parsePlPgSQLSync"),
     Napi::Function::New(env, ParsePlPgSQLSync)

src/async.cc

@@ -34,6 +34,43 @@ class QueryWorker : public Napi::AsyncWorker {
   PgQueryParseResult result;
 };
 
+class DeparseQueryWorker : public Napi::AsyncWorker {
+ public:
+  DeparseQueryWorker(Napi::Function& callback, const std::string& ast)
+    : Napi::AsyncWorker(callback), ast(ast) {}
+  ~DeparseQueryWorker() {}
+
+  // Executed inside the worker-thread.
+  // It is not safe to access JS engine data structure
+  // here, so everything we need for input and output
+  // should go on `this`.
+  void Execute () {
+    auto protobufResult = json_to_protobuf_parse_result(ast);
+
+    if (protobufResult.error) {
+      result.error = protobufResult.error;
+    } else {
+      result = pg_query_deparse_protobuf(protobufResult.protobuf);
+    }
+  }
+
+  // Executed when the async work is complete
+  // this function will be run inside the main event loop
+  // so it is safe to use JS engine data again
+  void OnOK() {
+    Napi::HandleScope scope(Env());
+    try {
+      Callback().Call({Env().Undefined(), QueryDeparseResult(Env(), result) });
+    } catch (const Napi::Error& e) {
+      Callback().Call({ e.Value(), Env().Undefined() });
+    }
+  }
+
+ private:
+  std::string ast;
+  PgQueryDeparseResult result;
+};
+
 class PgPlQSLWorker : public Napi::AsyncWorker {
  public:
   PgPlQSLWorker(Napi::Function& callback, const std::string& query)
@@ -105,6 +142,14 @@ Napi::Value ParseQueryAsync(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value DeparseQueryAsync(const Napi::CallbackInfo& info) {
+  std::string ast = info[0].As<Napi::String>();
+  Napi::Function callback = info[1].As<Napi::Function>();
+  DeparseQueryWorker* worker = new DeparseQueryWorker(callback, ast);
+  worker->Queue();
+  return info.Env().Undefined();
+}
+
 Napi::Value ParsePlPgSQLAsync(const Napi::CallbackInfo& info) {
   std::string query = info[0].As<Napi::String>();
   Napi::Function callback = info[1].As<Napi::Function>();

src/async.h

@@ -1,5 +1,6 @@
 #include <napi.h>
 
 Napi::Value ParseQueryAsync(const Napi::CallbackInfo& info);
+Napi::Value DeparseQueryAsync(const Napi::CallbackInfo& info);
 Napi::Value ParsePlPgSQLAsync(const Napi::CallbackInfo& info);
 Napi::Value FingerprintAsync(const Napi::CallbackInfo& info);

src/helpers.cc

@@ -1,7 +1,8 @@
 #include "helpers.h"  // NOLINT(build/include)
 #include "pg_query.h"
-#include "helpers.h"
+#include "protobuf/pg_query.pb.h"
 #include <napi.h>
+#include <google/protobuf/util/json_util.h>
 
 Napi::Error CreateError(Napi::Env env, const PgQueryError& err)
 {
@@ -27,6 +28,19 @@ Napi::String QueryParseResult(Napi::Env env, const PgQueryParseResult& result)
     return returnVal;
 }
 
+Napi::String QueryDeparseResult(Napi::Env env, const PgQueryDeparseResult& result)
+{
+    if (result.error) {
+        auto throwVal = CreateError(env, *result.error);
+        pg_query_free_deparse_result(result);
+        throw throwVal;
+    }
+
+    auto returnVal = Napi::String::New(env, result.query);
+    pg_query_free_deparse_result(result);
+    return returnVal;
+}
+
 Napi::String PlPgSQLParseResult(Napi::Env env, const PgQueryPlpgsqlParseResult& result)
 {
     if (result.error) {
@@ -53,3 +67,36 @@ Napi::String FingerprintResult(Napi::Env env, const PgQueryFingerprintResult & r
   pg_query_free_fingerprint_result(result);
   return returnVal;
 }
+
+JsonToProtobufResult json_to_protobuf_parse_result(const std::string& json) {
+  JsonToProtobufResult result;
+
+  pg_query::ParseResult parse_result;
+  google::protobuf::util::JsonParseOptions options; 
+
+  auto status = google::protobuf::util::JsonStringToMessage(json, &parse_result, options);
+
+  if (!status.ok()) {
+		auto error = (PgQueryError *)malloc(sizeof(PgQueryError));
+    error->message = strdup("Input AST did not match expected format");
+    error->filename = strdup("");
+    error->funcname = strdup("");
+		result.error = error;
+
+    return result;
+  }
+
+  std::string output;
+  parse_result.SerializeToString(&output);
+
+  PgQueryProtobuf protobuf;
+
+  protobuf.data = (char*) calloc(output.size(), sizeof(char));
+  memcpy(protobuf.data, output.data(), output.size());
+  protobuf.len = output.size();
+
+  result.protobuf = protobuf;
+  result.error = NULL;
+
+  return result;
+}

src/helpers.h

@@ -3,5 +3,13 @@
 
 Napi::Error CreateError(Napi::Env env, const PgQueryError& err);
 Napi::String QueryParseResult(Napi::Env env, const PgQueryParseResult& result);
+Napi::String QueryDeparseResult(Napi::Env env, const PgQueryDeparseResult& result);
 Napi::String PlPgSQLParseResult(Napi::Env env, const PgQueryPlpgsqlParseResult& result);
 Napi::String FingerprintResult(Napi::Env env, const PgQueryFingerprintResult & result);
+
+typedef struct {
+  PgQueryProtobuf protobuf;
+  PgQueryError* error;
+} JsonToProtobufResult;
+
+JsonToProtobufResult json_to_protobuf_parse_result(const std::string& json);

src/sync.cc

@@ -10,6 +10,21 @@ Napi::String ParseQuerySync(const Napi::CallbackInfo& info) {
   return QueryParseResult(info.Env(), result);
 }
 
+Napi::String DeparseQuerySync(const Napi::CallbackInfo& info) {
+  std::string ast = info[0].As<Napi::String>();
+  auto protobufResult = json_to_protobuf_parse_result(ast);
+  PgQueryDeparseResult result;
+
+  if (protobufResult.error) {
+    result.query = (char*)malloc(0);
+    result.error = protobufResult.error;
+  } else {
+    result = pg_query_deparse_protobuf(protobufResult.protobuf);
+  }
+
+  return QueryDeparseResult(info.Env(), result);
+}
+
 Napi::String ParsePlPgSQLSync(const Napi::CallbackInfo& info) {
   std::string query = info[0].As<Napi::String>();
   PgQueryPlpgsqlParseResult result = pg_query_parse_plpgsql(query.c_str());

src/sync.h

@@ -1,5 +1,6 @@
 #include <napi.h>
 
 Napi::String ParseQuerySync(const Napi::CallbackInfo& info);
+Napi::String DeparseQuerySync(const Napi::CallbackInfo& info);
 Napi::String ParsePlPgSQLSync(const Napi::CallbackInfo& info);
 Napi::String FingerprintSync(const Napi::CallbackInfo& info);

test/index.js

@@ -25,7 +25,7 @@ describe("Queries", () => {
         true
       );
       expect(selectedDatas[2][0].ResTarget.val.A_Const.sval.sval).to.eq(
-        ""
+        undefined
       );
       expect(selectedDatas[3]).to.have.lengthOf(2);
     });
@@ -50,6 +50,24 @@ describe("Queries", () => {
     });
   });
 
+  describe("Sync Deparsing", () => {
+    it("should return the same input sql", () => {
+      const testQuery = "select * from books";
+      const ast = query.parseQuerySync(testQuery);
+      const deparsedQuery = query.deparseQuerySync(ast).toLowerCase();
+
+      expect(deparsedQuery).to.eq(testQuery);
+    });
+
+    it("should error with bad input", () => {
+      try {
+        query.deparseQuerySync({ wrongFormat: 123 }).toLowerCase();
+      } catch (e) {
+        expect(e.message).to.eq("Input AST did not match expected format");
+      }
+    });
+  });
+
   describe("Async parsing", () => {
     it("should return a promise resolving to same result", async () => {
       const testQuery = "select * from john;";
@@ -73,6 +91,31 @@ describe("Queries", () => {
     });
   });
 
+  describe("Async deparsing", () => {
+    it("should return a promise resolving to same result", async () => {
+      const testQuery = "select * from books";
+      const ast = await query.parseQuery(testQuery);
+
+      const resPromise = query.deparseQuery(ast);
+      const res = await resPromise;
+
+      expect(resPromise).to.be.instanceof(Promise);
+      expect(res).to.deep.eq(query.deparseQuerySync(ast));
+    });
+
+    it("should reject on bad input", async () => {
+      return query.deparseQuery({ wrongFormat: 123 }).then(
+        () => {
+          throw new Error("should have rejected");
+        },
+        (e) => {
+          expect(e).instanceof(Error);
+          expect(e.message).to.eq("Input AST did not match expected format");
+        }
+      );
+    });
+  });
+
   describe("Fingerprint", () => {
     context("sync", () => {
       it("should not fingerprint a bogus query", () => {