fix: guard against non-Value params in Connection.execute + auto-convert boxed Java types

Reject non-Value parameters in Connection.execute instead of crashing the JVM.

Option A: Accept boxed Java values (String, Long, UUID, etc.) by reusing the
type-conversion ladder from lbugValueCreateValue in bindJavaParamsToPreparedStatement.

Option B: Guard unrecognized types with IllegalArgumentException instead of
reinterpret_cast crash.

- Moves the JNI type-conversion ladder into a reusable javaObjectToValue helper
- Adds throwIllegalArgumentException and getClassName JNI helpers
- Widens Connection.execute signature from Map<String, Value> to Map<String, ?>
- Adds early-return guard in lbugConnectionExecute after param binding
- Adds 7 new tests: raw String/Long/Double/Boolean, mixed raw+Value,
  unsupported type throws, Value-wrapped regression

Fixes: #11

Author: adsharma

src/jni/lbug_java.cpp

@@ -160,6 +160,14 @@ static void throwJNIException(JNIEnv* env, const char* message) {
     env->ThrowNew(exClass, message);
 }
 
+static void throwIllegalArgumentException(JNIEnv* env, const char* message) {
+    jclass exClass = env->FindClass("java/lang/IllegalArgumentException");
+    if (exClass == nullptr) {
+        return;
+    }
+    env->ThrowNew(exClass, message);
+}
+
 template<typename... Args>
 static jobject callObjectMethodChecked(JNIEnv* env, jobject object, jmethodID method,
     Args... args) {
@@ -504,6 +512,111 @@ std::string dataTypeToString(lbug_data_type_id dataType) {
     }
 }
 
+// Convert a Java boxed primitive/String/UUID/etc. to an lbug_value*.
+// Returns nullptr if the type is not recognised.
+static lbug_value* javaObjectToValue(JNIEnv* env, jobject val) {
+    if (env->IsInstanceOf(val, J_C_Boolean)) {
+        jboolean value = callBooleanMethodChecked(env, val, J_C_Boolean_M_booleanValue);
+        return lbug_value_create_bool(static_cast<bool>(value));
+    } else if (env->IsInstanceOf(val, J_C_Byte)) {
+        jbyte value = callByteMethodChecked(env, val, J_C_Byte_M_byteValue);
+        return lbug_value_create_int8(static_cast<int8_t>(value));
+    } else if (env->IsInstanceOf(val, J_C_Short)) {
+        jshort value = callShortMethodChecked(env, val, J_C_Short_M_shortValue);
+        return lbug_value_create_int16(static_cast<int16_t>(value));
+    } else if (env->IsInstanceOf(val, J_C_Integer)) {
+        jint value = callIntMethodChecked(env, val, J_C_Integer_M_intValue);
+        return lbug_value_create_int32(static_cast<int32_t>(value));
+    } else if (env->IsInstanceOf(val, J_C_Long)) {
+        jlong value = callLongMethodChecked(env, val, J_C_Long_M_longValue);
+        return lbug_value_create_int64(static_cast<int64_t>(value));
+    } else if (env->IsInstanceOf(val, J_C_BigInteger)) {
+        int64_t lower =
+            static_cast<int64_t>(callLongMethodChecked(env, val, J_C_BigInteger_M_longValue));
+        jobject shifted = callObjectMethodChecked(env, val, J_C_BigInteger_M_shiftRight, 64);
+        int64_t upper = static_cast<int64_t>(
+            callLongMethodChecked(env, shifted, J_C_BigInteger_M_longValue));
+        return lbug_value_create_int128({.low = static_cast<uint64_t>(lower), .high = upper});
+    } else if (env->IsInstanceOf(val, J_C_Float)) {
+        jfloat value = callFloatMethodChecked(env, val, J_C_Float_M_floatValue);
+        return lbug_value_create_float(static_cast<float>(value));
+    } else if (env->IsInstanceOf(val, J_C_Double)) {
+        jdouble value = callDoubleMethodChecked(env, val, J_C_Double_M_doubleValue);
+        return lbug_value_create_double(static_cast<double>(value));
+    } else if (env->IsInstanceOf(val, J_C_BigDecimal)) {
+        jobject normalized =
+            callObjectMethodChecked(env, val, J_C_BigDecimal_M_stripTrailingZeros);
+        jstring value = static_cast<jstring>(
+            callObjectMethodChecked(env, normalized, J_C_BigDecimal_M_toString));
+        std::string str = jstringToUtf8String(env, value);
+        auto precision = static_cast<int32_t>(
+            callIntMethodChecked(env, normalized, J_C_BigDecimal_M_precision));
+        auto scale =
+            static_cast<int32_t>(callIntMethodChecked(env, normalized, J_C_BigDecimal_M_scale));
+        if (precision > JAVA_DECIMAL_PRECISION_LIMIT) {
+            throw NotImplementedException(
+                std::format("Decimal precision cannot be greater than {}"
+                            "Note: positive exponents contribute to precision",
+                    JAVA_DECIMAL_PRECISION_LIMIT));
+        }
+        return lbug_value_create_decimal(
+            str.c_str(), static_cast<uint32_t>(precision), static_cast<uint32_t>(scale));
+    } else if (env->IsInstanceOf(val, J_C_String)) {
+        jstring value = static_cast<jstring>(val);
+        std::string str = jstringToUtf8String(env, value);
+        return lbug_value_create_string(str.c_str());
+    } else if (env->IsInstanceOf(val, J_C_InternalID)) {
+        return lbug_value_create_internal_id(getInternalID(env, val));
+    } else if (env->IsInstanceOf(val, J_C_UUID)) {
+        jstring uuid =
+            static_cast<jstring>(callObjectMethodChecked(env, val, J_C_UUID_M_toString));
+        std::string uuidString = jstringToUtf8String(env, uuid);
+        return lbug_value_create_uuid(uuidString.c_str());
+    } else if (env->IsInstanceOf(val, J_C_LocalDate)) {
+        int64_t days =
+            static_cast<int64_t>(callLongMethodChecked(env, val, J_C_LocalDate_M_toEpochDay));
+        return lbug_value_create_date({.days = static_cast<int32_t>(days)});
+    } else if (env->IsInstanceOf(val, J_C_Instant)) {
+        // TODO: Need to review this for overflow
+        int64_t seconds = static_cast<int64_t>(
+            callLongMethodChecked(env, val, J_C_LocalDate_M_getEpochSecond));
+        int64_t nano =
+            static_cast<int64_t>(callLongMethodChecked(env, val, J_C_LocalDate_M_getNano));
+        int64_t micro = (seconds * 1000000L) + (nano / 1000L);
+        return lbug_value_create_timestamp({.value = micro});
+    } else if (env->IsInstanceOf(val, J_C_Duration)) {
+        auto milis = callLongMethodChecked(env, val, J_C_Duration_M_toMillis);
+        return lbug_value_create_interval({.months = 0, .days = 0, .micros = milis * 1000L});
+    }
+    return nullptr;
+}
+
+// Get the fully-qualified class name of a Java object as a std::string.
+// Returns "<unknown>" on error.
+static std::string getClassName(JNIEnv* env, jobject obj) {
+    jclass clazz = env->GetObjectClass(obj);
+    if (clazz == nullptr) return "<unknown>";
+    jclass classClass = env->FindClass("java/lang/Class");
+    if (classClass == nullptr) {
+        env->DeleteLocalRef(clazz);
+        return "<unknown>";
+    }
+    jmethodID getNameMethod =
+        env->GetMethodID(classClass, "getName", "()Ljava/lang/String;");
+    if (getNameMethod == nullptr) {
+        env->DeleteLocalRef(classClass);
+        env->DeleteLocalRef(clazz);
+        return "<unknown>";
+    }
+    jstring classNameJStr =
+        static_cast<jstring>(env->CallObjectMethod(clazz, getNameMethod));
+    std::string result = jstringToUtf8String(env, classNameJStr);
+    env->DeleteLocalRef(classNameJStr);
+    env->DeleteLocalRef(classClass);
+    env->DeleteLocalRef(clazz);
+    return result;
+}
+
 void bindJavaParamsToPreparedStatement(JNIEnv* env, lbug_prepared_statement* preparedStatement,
     jobject javaMap) {
     jobject set = callObjectMethodChecked(env, javaMap, J_C_Map_M_entrySet);
@@ -513,7 +626,33 @@ void bindJavaParamsToPreparedStatement(JNIEnv* env, lbug_prepared_statement* pre
         jstring key = (jstring)callObjectMethodChecked(env, entry, J_C_Map$Entry_M_getKey);
         jobject value = callObjectMethodChecked(env, entry, J_C_Map$Entry_M_getValue);
         std::string keyStr = jstringToUtf8String(env, key);
-        auto* clonedValue = lbug_value_clone(getValue(env, value));
+
+        lbug_value* clonedValue = nullptr;
+
+        if (env->IsInstanceOf(value, J_C_Value)) {
+            // Already a Value — use the direct JNI path (Option A, existing behaviour)
+            clonedValue = lbug_value_clone(getValue(env, value));
+        } else {
+            // Try conversion from a boxed Java type via the same ladder as
+            // Java_com_ladybugdb_Native_lbugValueCreateValue (Option A)
+            clonedValue = javaObjectToValue(env, value);
+            if (clonedValue == nullptr) {
+                // Not a recognised type — throw IllegalArgumentException instead
+                // of crashing (Option B)
+                std::string typeName = getClassName(env, value);
+                env->DeleteLocalRef(entry);
+                env->DeleteLocalRef(key);
+                env->DeleteLocalRef(value);
+                throwIllegalArgumentException(env,
+                    ("Parameter '" + keyStr + "' has unsupported type " + typeName
+                        + ". Accepted types: Value, Boolean, Byte, Short, Integer, "
+                          "Long, BigInteger, Float, Double, BigDecimal, String, "
+                          "InternalID, UUID, LocalDate, Instant, Duration")
+                        .c_str());
+                return;
+            }
+        }
+
         auto state =
             lbug_prepared_statement_bind_value(preparedStatement, keyStr.c_str(), clonedValue);
         lbug_value_destroy(clonedValue);
@@ -769,6 +908,9 @@ JNIEXPORT jobject JNICALL Java_com_ladybugdb_Native_lbugConnectionExecute(JNIEnv
         auto* conn = getConnection(env, thisConn);
         auto* ps = getPreparedStatement(env, preStm);
         bindJavaParamsToPreparedStatement(env, ps, paramMap);
+        if (env->ExceptionCheck()) {
+            return jobject();
+        }
         auto* queryResult = new lbug_query_result();
         lbug_state state = lbug_connection_execute(conn, ps, queryResult);
         if (state != LbugSuccess && queryResult->_query_result == nullptr) {

src/main/java/com/lbugdb/Connection.java

@@ -107,15 +107,24 @@ public PreparedStatement prepare(String queryStr) {
     /**
      * Executes the given prepared statement with args and returns the result.
      *
-     * @param ps: The prepared statement to execute.
-     * @param m:  The parameter pack where each arg is a std::pair with the first element being parameter name and second
-     *            element being parameter value
+     * <p>Values that are not already {@link Value} instances are automatically converted from
+     * their boxed Java type (e.g. {@link String}, {@link Long}, {@link java.util.UUID}, etc.).
+     * If a value's type is not supported, an {@link IllegalArgumentException} is thrown instead
+     * of crashing the JVM.
+     *
+     * @param ps The prepared statement to execute.
+     * @param params The parameter map. Each value must be a {@link Value} or one of the
+     *               supported boxed types: Boolean, Byte, Short, Integer, Long, BigInteger,
+     *               Float, Double, BigDecimal, String, InternalID, UUID, LocalDate, Instant,
+     *               Duration.
      * @return The result of the query.
-     * @throws RuntimeException If the connection has been destroyed.
+     * @throws RuntimeException         If the connection has been destroyed.
+     * @throws IllegalArgumentException  If a parameter value has an unsupported type.
      */
-    public QueryResult execute(PreparedStatement ps, Map<String, Value> m) {
+    @SuppressWarnings("unchecked")
+    public QueryResult execute(PreparedStatement ps, Map<String, ?> params) {
         checkNotDestroyed();
-        return Native.lbugConnectionExecute(this, ps, m);
+        return Native.lbugConnectionExecute(this, ps, (Map<String, Value>) (Map<?, ?>) params);
     }
 
     /**

src/test/java/com/lbugdb/PreparedStatementTest.java

@@ -4,7 +4,8 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class PreparedStatementTest extends TestBase {
 
@@ -61,4 +62,115 @@ void PrepStmtSpecialString() {
         }
     }
 
+    @Test
+    void executeWithRawBoxedString() {
+        // Option A: raw String value auto-converted by C++ layer
+        String query = "MATCH (n:person) WHERE n.fName = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", "Alice");
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+            String got = result.getNext().getValue(0).getValue();
+            assertEquals("Alice", got);
+        }
+    }
+
+    @Test
+    void executeWithRawBoxedLong() {
+        // Option A: raw Long value auto-converted by C++ layer
+        String query = "MATCH (n:person) WHERE n.ID = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", 0L);
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+            String got = result.getNext().getValue(0).getValue();
+            assertEquals("Alice", got);
+        }
+    }
+
+    @Test
+    void executeWithRawBoxedDouble() {
+        // Option A: raw Double value auto-converted
+        String query = "MATCH (n:person) WHERE n.eyeSight = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", 5.0);
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+            String got = result.getNext().getValue(0).getValue();
+            assertEquals("Alice", got);
+        }
+    }
+
+    @Test
+    void executeWithRawBoxedBoolean() {
+        // Option A: raw Boolean value auto-converted
+        String query = "MATCH (n:person) WHERE n.isStudent = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", true);
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+        }
+    }
+
+    @Test
+    void executeWithUnsupportedTypeThrows() {
+        // Option B: unsupported type throws IllegalArgumentException instead of crashing
+        String query = "MATCH (n:person) WHERE n.fName = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", new ArrayList<>(List.of("not", "supported")));
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            assertThrows(IllegalArgumentException.class, () -> {
+                conn.execute(ps, params);
+            });
+        }
+    }
+
+    @Test
+    void executeWithValueWrappedParamsRegression() {
+        // Regression: Value-wrapped path is unchanged
+        String query = "MATCH (n:person) WHERE n.fName = $1 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Value> params = Map.of("1", new Value("Alice"));
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+            String got = result.getNext().getValue(0).getValue();
+            assertEquals("Alice", got);
+        }
+    }
+
+    @Test
+    void executeWithMixedRawAndValueParams() {
+        // Option A: mixed raw and Value-wrapped params
+        String query = "MATCH (n:person) WHERE n.fName = $1 AND n.age = $2 RETURN n.fName";
+        try (PreparedStatement ps = conn.prepare(query)) {
+            Map<String, Object> raw = new HashMap<>();
+            raw.put("1", new Value("Alice"));
+            raw.put("2", 35L);
+            @SuppressWarnings("unchecked")
+            Map<String, ?> params = (Map<String, ?>) (Map<?, ?>) raw;
+            QueryResult result = conn.execute(ps, params);
+            assertTrue(result.isSuccess());
+            assertTrue(result.hasNext());
+        }
+    }
+
 }