Java

/*
 ******************************************************************************
 *
 *    Name     : cpptojava.cpp
 *
 *    Function : Basic Console application to call a Java class.
 *
 *    Created  : 09 Jun 2022
 *
 ******************************************************************************
 */

#include <Windows.h>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <filesystem> // requires -std:c++17

#include "jni.h"

//
// Find the path to the jvm.dll given the base path to the Java runtime (or JDK if installed)
//
HMODULE LoadDll(
    const char* jrePath
)
{
    const char* pszjvmname = "bin\\server\\jvm.dll";   // Java VM name
    HMODULE hJVMDLL = 0;

    std::filesystem::path jvmpath(jrePath);
    jvmpath /= pszjvmname;
    if (!std::filesystem::exists(jvmpath))
    {
        std::cerr << "JVM library " << jvmpath << " not found." << std::endl;
        // throw an exception 
    }

    // load the Java VM DLL into our address space
    // NB filesystem::path is Unicode
    hJVMDLL = LoadLibraryW(reinterpret_cast<PCWSTR>(jvmpath.c_str()));
    if (hJVMDLL != NULL)
    {
        std::clog << "jvm.dll loaded from: " << jvmpath << std::endl;
    }
    return hJVMDLL; // a Windows HANDLE to the DLL
}


//
// A function to load the Java VM and initialise the JNI interface
// There are a number of diagnostic messages to show progress
//
JNIEnv* AttachJVM(
    const char* jrePath,
    JavaVM* jvm,
    std::string strcwd
)
{
    HMODULE     hJVMDLL = LoadDll(jrePath);
    if (hJVMDLL == 0)
    {
        return nullptr;
    }
    typedef jint(JNICALL* fpCJV)(JavaVM**, void**, void*);
    fpCJV JNI_CreateJavaVM = (fpCJV)::GetProcAddress(hJVMDLL, "JNI_CreateJavaVM");

    // tell the JVM where to find the class
    JavaVMOption    options[2];
    std::stringstream ssoptions;
    ssoptions << "-Djava.class.path=";
    ssoptions << strcwd;
    std::string stropts = ssoptions.str();
    options[0].optionString = const_cast<char*>(stropts.c_str());
    options[1].optionString = const_cast<char*>("-verbose:jni");   // print JNI-related messages

    JavaVMInitArgs  vm_args; // JDK/JRE 6 VM initialization arguments
    vm_args.version = JNI_VERSION_1_8;
    vm_args.nOptions = 1; // change to 2 for verbose output
    vm_args.ignoreUnrecognized = false;
    vm_args.options = options;
    for (int i = 0; i < vm_args.nOptions; ++i)
    {
        std::clog << "Options[" << i << "]: " << options[i].optionString << std::endl;
    }
    JNIEnv* env;            // pointer to native method interface
    jint res = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
    if (res != 0)
    {
        std::cerr << "C++: JNI_CreateJavaVM returned: " << res << std::endl;
    }
    jint version = env->GetVersion();
    std::clog << "JVM Version: " << (version >> 16) << "." << (version & 0xffff) << std::endl;

    return env; // the pointer to the jvm dll
}


void CallClass(
    JNIEnv* jniEnv,
    const char* pszClassname,
    const char* pszMethodname,
    const char* pszSignature
)
{
    jclass jvmclass = jniEnv->FindClass(pszClassname);
    if (jvmclass != NULL)
    {
        std::cout << "C++: Found the class: " << pszClassname << std::endl;
        jmethodID jmid = jniEnv->GetStaticMethodID(jvmclass, pszMethodname, pszSignature);
        if (jmid != NULL)
        {
            std::cout << "C++: Found the method: " << pszMethodname << std::endl;
            jniEnv->CallStaticVoidMethod(jvmclass, jmid, NULL);
            std::cout << "C++: env->CallStaticVoidMethod complete" << std::endl;
        }
        else
        {
            std::cerr << "C++: Failed to find the method: " << pszMethodname << std::endl;
        }
    }
    else
    {
        std::cerr << "C++: Failed to find the class: " << pszClassname << std::endl;
    }
}


int main(
    int argc,
    const char** argv
)
{
    const char* jreDir = nullptr;

    // suppress debug messages
    std::clog.setstate(std::ios::badbit);
    for (argv++; argc > 1; ++argv, --argc)
    {
        if (*argv[0] == '-')
        {
            // handle any execution options ...
            if (strstr(*argv, "-d"))
                std::clog.clear();
        }
        else
        {
            jreDir = *argv;
        }
    }
    if (jreDir == nullptr)
    {
        std::cerr << "No root path provided for JVM." << std::endl;
        return 1;
    }
    JNIEnv* jniEnv = NULL;
    std::filesystem::path cwd = std::filesystem::current_path();
    JavaVM jvm;
    jniEnv = AttachJVM(jreDir, &jvm, cwd.string());
    if (jniEnv == NULL)
    {
        std::cerr << "C++: Failed to get Java environment" << std::endl;
        return 1;
    }
        CallClass(jniEnv, "CppToJava", "main", "([Ljava/lang/String;)V");

    // clean up
    jint jvmres = jvm.DestroyJavaVM(); // never returns ???
    std::clog << "C++: DestroyJavaVM and terminate: " << jvmres << std::endl;

}

std::filesystem::path jvmpath(jrePath);       // name followed by '::' must be a class or namespace name   and expected a;
    jvmpath /= pszjvmname;                    // identifier jvmpath undifined
    if (!std::filesystem::exists(jvmpath)) {  // name followed by '::' must be a class or namespace name 

std::filesystem::path cwd = std::filesystem::current_path();   // name followed by '::' must be a class or namespace name   and expected a;

jniEnv = AttachJVM(jreDir, &jvm, cwd.string()); // identifier cwd undifined

FString UCreateVM::createVM(FString location) {
	std::string javaLocation = TCHAR_TO_ANSI(*location);
	javaLocation.insert(0, "-Djava.class.path=");
	javaLocation.append("Data/Java");
	JavaVMInitArgs vm_args;
	JavaVMOption* options = new JavaVMOption[1];
	options[0].optionString = &javaLocation[0];
	vm_args.version = JNI_VERSION_10;
	vm_args.nOptions = 1;
	vm_args.options = options;
	vm_args.ignoreUnrecognized = false;
	JNIEnv* env = nullptr;
	jint rc = JNI_OK;
	if (jvm == nullptr) {
		rc = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
	}
	else {
		rc = jvm->AttachCurrentThread((void**)&env, NULL);
	}
	delete[] options;
	if (rc != JNI_OK) {
		if (rc == JNI_EVERSION)
			return "JNI_EVERSION";
		else if (rc == JNI_ENOMEM)
			return "JNI_ENOMEM";
		else if (rc == JNI_EINVAL)
			return "JNI_EINVAL";
		else if (rc == JNI_EEXIST)
			return "JNI_EEXIST";
		else
			return "JNI_FATALERROR";
	}
	return "JNI_CREATED";
}

cl -nologo -EHsc -RTC1 -W3  -std:c++17 -I "C:\Program Files\Java\jdk-18.0.2\include" -I "C:\Program Files\Java\jdk-18.0.2\include\win32" cpptojava.cpp

hJVMDLL = LoadLibraryW(reinterpret_cast<PCWSTR>(jvmpath.c_str()));

JohnCodding wrote:

Would AddDllDirectory with the path of the jvm.dll help

std::string dllLocation = "C:\\Program Files\\Eclipse Adoptium\\jdk-18.0.1.10-hotspot\\bin\\server";
std::wstring temp = std::wstring(dllLocation.begin(), dllLocation.end());

AddDllDirectory(temp.c_str());

Valentinor wrote:

SELECT Column FROM Table WHERE Condition

Valentinor wrote:

Does the database create in memory a list with all the rows/values that have the given condition

Valentinor wrote:

FETCH NEXT X ROWS ONLY

Valentinor wrote:

database with millions of entries, that would save time and resources when you only want X rows,

jschell wrote:

That is not how the jdbc is defined to work.

jschell wrote:

But a bad driver could definitely do that.

jschell wrote:

The result should be paged.

jschell wrote:

You should NEVER, for example, allow for a design where a UI could expect a user to view 'millions' of rows.

jschell wrote:

That is not how the jdbc is defined to work. But a bad driver could definitely do that.

Valentinor wrote:

Is this a good example of paging?[^]

PLSQL paging query

final String caseId1 = caseID; // add this final variable
FilenameFilter filter = new FilenameFilter() {
  public boolean accept (File dir, String name) { 
   return name.startsWith(caseId1); // use the final variable here
   } 
 };