nQuery | remote control jQuery/Zepto with node.js | Frontend Framework library

so the solution was simply to comment out

For a and b you can do msg.Vars["a"] and msg.Vars["b"] respectively to access those values. For d, f, and g you need to first access their parents just like you would access a and b. Then you need to type-assert the result of that access to the map[string]interface{} type and then access the desired fields through the result of the type assertion.

Solve it> Just added the countQuery to the @Query annotation, I was not so sure what to place there, but it was simple

As noted above, the answer is in the Examples section of MySqlDataReader but the code is not very well written. A better version should make it clear how to read multiple values from a select query:

In general you should remove single quotes and timestamp from the query text and use FromSqlInterpolated. It will bind a parameter with the appropriate type (the mappings can be seen in .NET types and PostgreSQL types section of the Npgsql documentaion) for each token inside the interpolated string, e.g.

For starters:

Well after quite a few tests I've discovered what I need to do to be able to have the DELETE throw the "Foreign Key Constraint" error. There are three things I needed to do. 1). I need the PRAGMA statement as a part of the DELETE query like this:

I ve no idea why it looks is getting bool(__x) <=> false as an bool and int comparison. I would think you got some strange macro in your files included before to include the header that is going to break the standard code. I would suggest you try to move above the standard headers and below them your 'user defined' headers.

One of the issues I see here is that your controller is doing all the work - getting a query, setting it up, executing it, and returning the results from the API call. Doing all these things in one place makes it hard to test. That also raises a question - what exactly are you trying to test? And what issues are you running into?

You might want to look at refactoring it to use a layered architecture instead. API -> Service Layer -> Repository layer.

This might be a cleaner structure, and you can then test layers independently:

1. Check that the API calls the correct service layer method with the correct parameters.
2. Check that the service layer calls the repository with the correct arguments.
3. Check that the repository creates the correct query.

Alternatively, you could also do integration testing - just invoke the API and make sure that the correct result is returned.

Also, be wary of using String replacement in your queries. Rather have a look at PreparedStatement (https://docs.oracle.com/javase/tutorial/jdbc/basics/prepared.html).