jSQL | a SQL like database using javascript | SQL Database library

Select the project, then File > ProjectStructure > ProjectSettings > Modules -> sources You probably have the Language Level set at 9:

Just change it to 8 (or whatever you need) and you're set to go.

Also, check the same Language Level settings mentioned above, under Project Settings > Project

Function map() can be used only on array. In this situation it looks like props.results is not array or has not been set yet (this can happen if you are fetching data with Axios or something like that).

I would recommend you to place something like this at the start of function:

It looks like several issues with working with async functions in your code.

1. Your handler of get request should be also async function and use await for asynchronous functions.
2. A promise inside getResult should be resolved like con.query(sql, resolve)

Try this variant.

Circular JSON means, there is a reference to an object inside the object, which makes the JSON.stringify not possible.

in your case, res.send(JSON.stringify(answer)) could be the problem. The response of con.query(sql) may not be a simple object.

Also, the function is asynchronous and expects a callback to get the answer (I am assuming you are using mysqljs https://github.com/mysqljs/mysql)

give more details to explain further, but the underlying problem is the value of the variable "answer"

Calling one native method from another is in fact permitted. At least, I did not receive any errors or warnings when I did this. But the call must include the full function name as expected of any native method - i.e. Java_com_project_package_JSQ_destroy and the parameters should include:

1. the JNI environment
2. jobject Object
3. parameters expected by the method. In this case, shdl

Therefore, the call must be like so:

A Java long variable is guaranteed to be 64 bits wide, so it is enough to contain an address, even on a 64-bit system. The cast to long is just there to make the C++ type system happy. As you see, the SQ macro is used to convert this address back to a proper pointer to an sq_stsm_t object.

As for your second question: all the macro does is get rid of some typing work. The Java part of your program will always pass the long-typed shdl variable, so the SQ macro just provides easy access to the actual sq_stsm_t object.

Finally, new and delete in C++ go together: new allocates memory and calls the constructor, delete calls the destructor and frees the memory again. Note that "free" does not necessarily mean "give back to the OS", so your process's memory usage can remain the same after this delete operation.

As for the comment in your code: Java_com_project_package_JSQ_set_shdl tries to call the Java method boolean com.project.package.JSQ#set_JSQ_shdl(jlong), although it is not present in the code you pasted. I guess it is a simple setter for the shdl field?

As for your follow-up plans: implementing AutoCloseable is a good idea. You would need to create a native void close() method in your JSQ object which calls delete on the sq_stsm_t object stored in the shdl field and then replaces the shdl field with (jlong)nullptr.

The answer is: it depends.

JSqlParser is only a parser and does not have information about the database schema. In some databases parameterless functions are allowed to be called without parenthesis, e.g. select NOW (hope that is indeed a function ;)). In this case NOW would be accepted as a column name.

But JSqlParser supports parameterized functions, e.g. select testfunc(param1). In this case it will be accepted as a function.

Syntactically the usage of view and table is identical and JSqlParser is not able to differ between those. The view name would be accepted as a table name.

To get a differentiation:

1. first you would let JSqlParser parse your statement
2. extract all column names, table names, function names (a good start here is the TableNameFinder utility of JSqlParser)
3. get the final type you need to check it with your database schema

So here is a little example for point 1 and 2:

If it were not for that your dates are surrounded by double quotes, we could have just done a blanket replacement of "(.*?)" with [$1] using String#replaceAll(). But the presence of double quoted dates makes the problem more difficult. My updated answer uses the following pattern to target only non dates in double quotes: