Infer JSON parameters in Python binding

Author: adsharma

src_cpp/py_connection.cpp

@@ -397,8 +397,8 @@ static LogicalType pyLogicalType(const py::handle& val) {
         if (!strVal.empty() && (strVal.front() == '{' || strVal.front() == '[')) {
             auto jsonModule = py::module_::import("json");
             try {
-                auto parsed = jsonModule.attr("loads")(val);
-                return pyLogicalType(parsed);
+                jsonModule.attr("loads")(val);
+                return LogicalType::JSON();
             } catch (...) {}
         }
         return LogicalType::STRING();
@@ -414,6 +414,9 @@ static LogicalType pyLogicalType(const py::handle& val) {
         return LogicalType::UUID();
     } else if (py::isinstance<py::dict>(val)) {
         py::dict dict = py::reinterpret_borrow<py::dict>(val);
+        if (dict.empty()) {
+            return LogicalType::JSON();
+        }
         auto childKeyType = LogicalType::ANY(), childValueType = LogicalType::ANY();
         for (auto child : dict) {
             auto curChildKeyType = pyLogicalType(child.first),
@@ -433,6 +436,9 @@ static LogicalType pyLogicalType(const py::handle& val) {
             childKeyType = std::move(resultKey);
             childValueType = std::move(resultValue);
         }
+        if (childKeyType.containsAny() || childValueType.containsAny()) {
+            return LogicalType::JSON();
+        }
         return LogicalType::MAP(std::move(childKeyType), std::move(childValueType));
     } else if (py::isinstance<py::list>(val)) {
         py::list lst = py::reinterpret_borrow<py::list>(val);
@@ -447,6 +453,9 @@ static LogicalType pyLogicalType(const py::handle& val) {
             }
             childType = std::move(result);
         }
+        if (childType.containsAny()) {
+            return LogicalType::JSON();
+        }
         return LogicalType::LIST(std::move(childType));
     } else if (PyConnection::isPyArrowTable(val) || PyConnection::isPandasDataframe(val) ||
                PyConnection::isPolarsDataframe(val)) {
@@ -517,10 +526,28 @@ static bool tryCastToMap(py::dict& dict, LogicalType& result) {
 }
 
 static LogicalType pyLogicalTypeFromParameter(const py::handle& val) {
+    if (py::isinstance<py::str>(val)) {
+        auto strVal = py::cast<std::string>(val);
+        if (!strVal.empty() && (strVal.front() == '{' || strVal.front() == '[')) {
+            auto jsonModule = py::module_::import("json");
+            try {
+                jsonModule.attr("loads")(val);
+                return LogicalType::JSON();
+            } catch (...) {}
+        }
+        return LogicalType::STRING();
+    }
     if (py::isinstance<py::dict>(val)) {
         auto dict = py::reinterpret_borrow<py::dict>(val);
+        if (dict.empty()) {
+            return LogicalType::JSON();
+        }
         LogicalType resultType;
         if (tryCastToMap(dict, resultType)) {
+            if (MapType::getKeyType(resultType).containsAny() ||
+                MapType::getValueType(resultType).containsAny()) {
+                return LogicalType::JSON();
+            }
             return resultType;
         }
         auto structFields = std::vector<StructField>{};
@@ -529,6 +556,11 @@ static LogicalType pyLogicalTypeFromParameter(const py::handle& val) {
             auto keyType = pyLogicalTypeFromParameter(child.second);
             structFields.emplace_back(std::move(keyName), std::move(keyType));
         }
+        for (const auto& field : structFields) {
+            if (field.getType().containsAny()) {
+                return LogicalType::JSON();
+            }
+        }
         return LogicalType::STRUCT(std::move(structFields));
     } else if (py::isinstance<py::list>(val)) {
         py::list lst = py::reinterpret_borrow<py::list>(val);
@@ -552,6 +584,9 @@ static LogicalType pyLogicalTypeFromParameter(const py::handle& val) {
             }
             childType = std::move(result);
         }
+        if (childType.containsAny()) {
+            return LogicalType::JSON();
+        }
         return LogicalType::LIST(std::move(childType));
     } else {
         return pyLogicalType(val);
@@ -603,18 +638,9 @@ Value PyConnection::transformPythonValueAs(const py::handle& val, const LogicalT
     }
     case LogicalTypeID::STRING:
         if (py::isinstance<py::str>(val)) {
-            auto strVal = val.cast<std::string>();
-            if (!strVal.empty() && (strVal.front() == '{' || strVal.front() == '[')) {
-                auto jsonModule = py::module_::import("json");
-                try {
-                    auto parsed = jsonModule.attr("loads")(val);
-                    return transformPythonValue(parsed);
-                } catch (...) {}
-            }
-            return Value::createValue<std::string>(strVal);
-        } else {
-            return Value::createValue<std::string>(py::str(val));
+            return Value::createValue<std::string>(val.cast<std::string>());
         }
+        return Value::createValue<std::string>(py::str(val));
     case LogicalTypeID::BLOB: {
         auto bytes = py::cast<py::bytes>(val);
         const char* data = PyBytes_AsString(bytes.ptr());
@@ -727,16 +753,6 @@ Value PyConnection::transformPythonValueAs(const py::handle& val, const LogicalT
 
 Value PyConnection::transformPythonValueFromParameterAs(const py::handle& val,
     const LogicalType& type) {
-    if (py::isinstance<py::str>(val)) {
-        auto strVal = py::cast<std::string>(val);
-        if (!strVal.empty() && (strVal.front() == '{' || strVal.front() == '[')) {
-            auto jsonModule = py::module_::import("json");
-            try {
-                auto parsed = jsonModule.attr("loads")(val);
-                return transformPythonValueFromParameter(parsed);
-            } catch (...) {}
-        }
-    }
     switch (type.getLogicalTypeID()) {
     case LogicalTypeID::LIST: {
         if (ListType::getChildType(type).getLogicalTypeID() == LogicalTypeID::JSON) {
@@ -785,6 +801,9 @@ Value PyConnection::transformPythonValueFromParameterAs(const py::handle& val,
         return Value(type.copy(), std::move(children));
     }
     case LogicalTypeID::JSON: {
+        if (py::isinstance<py::str>(val)) {
+            return Value::createValue<std::string>(py::cast<std::string>(val));
+        }
         auto jsonStr = pythonObjectToJsonString(val);
         return Value::createValue<std::string>(jsonStr);
     }