Add JSON support to UDF parameter and return types

Author: kesmit13

AC_PLAN.md

@@ -0,0 +1,35 @@
+<!-- AutoClaude Planning Metadata
+Complexity: medium
+Branch: auto-generated
+Files: 0 files to modify/create
+Dependencies: 0 new dependencies
+-->
+
+# Implementation Plan - COMPLETED ✅
+
+All requirements from the specification have been successfully implemented:
+
+## Completed Tasks
+
+- [x] **JSON Type Support**: Added Dict[str, Any] support for scalar parameters and List[Dict[str, Any]] for vector parameters
+- [x] **Type Aliases**: Created JSON and JsonArray type aliases in functions/typing module following existing patterns
+- [x] **SQL Mappings**: Updated sql_type_map and sql_to_type_map to properly map JSON types to SingleStore JSON columns
+- [x] **Function Signatures**: Enhanced signature processing to correctly handle JSON types in both parameters and return values
+- [x] **Type Validation**: Added proper validation to ensure only Dict[str, Any] is accepted as JSON type
+- [x] **Testing**: Verified all JSON variations work correctly (scalar, vector, optional, and type aliases)
+- [x] **Code Quality**: Fixed all linting issues and ensured pre-commit checks pass
+
+## Files Modified
+
+1. **singlestoredb/functions/signature.py**: Added JSON type mappings, validation, and normalization
+2. **singlestoredb/functions/typing/__init__.py**: Added JSON and JsonArray type aliases
+
+## Key Features Implemented
+
+- ✅ Scalar JSON parameters: `def my_func(data: Dict[str, Any]) -> Dict[str, Any]`
+- ✅ Vector JSON parameters: `def my_func(data: List[Dict[str, Any]]) -> List[Dict[str, Any]]`
+- ✅ Optional JSON parameters: `def my_func(data: Optional[Dict[str, Any]]) -> str`
+- ✅ Type aliases: `def my_func(data: JSON) -> JSON`
+- ✅ Vector type aliases: `def my_func(data: JsonArray) -> JsonArray`
+- ✅ Proper SQL generation: `JSON NOT NULL`, `JSON NULL`
+- ✅ CREATE EXTERNAL FUNCTION integration

AC_PROMPT.md

@@ -0,0 +1,55 @@
+# AutoClaude Implementation Session
+
+You are now in an AutoClaude implementation session. Your task is to implement the specification according to the AC_PLAN.md plan.
+
+## Specification Details
+**Title:** Summary
+**Project:** singlestoredb-python
+**Branch:** udf-json
+
+## Your Task
+You are running in the project directory with all necessary context. Please:
+
+1. **Review @AC_SPEC.md** - This contains the original specification
+2. **Review @AC_PLAN.md** - This contains your implementation plan
+3. **Implement each task** systematically, checking off items as you complete them
+4. **Test your implementation** where appropriate
+5. **Update AC_PLAN.md** - Mark completed items with [x] instead of [ ]
+6. **Create a commit when finished** - See commit instructions below
+
+## Guidelines
+- Work incrementally, implementing one feature at a time
+- Test frequently to ensure everything works
+- Follow the existing code style and patterns
+- Create new files only when necessary
+- Update existing files when appropriate
+- Run any tests that exist in the project
+
+## Commit Instructions
+**IMPORTANT:** When you have completed the implementation and all tests are passing:
+
+1. Stage all your changes: `git add .`
+2. Create a commit using this message format:
+   ```
+   {spec_type}: {spec_title}
+
+{spec_summary}
+   ```
+
+   Replace:
+   - `{spec_type}` with "feature"
+   - `{spec_title}` with "Summary"
+   - `{spec_summary}` with a brief summary of what was implemented
+
+   Example commit command:
+   ```
+   git commit -m "feature: Summary
+
+   [Brief summary of implementation]"
+   ```
+
+## Session Information
+- **Working Directory:** /home/ksmith/src/singlestoredb-python/trees/udf-json
+- **Branch:** udf-json
+
+Start by running `ls -la` to see the current project structure, then begin implementing according to @AC_PLAN.md.

AC_SPEC.md

@@ -0,0 +1,20 @@
+# Summary
+
+We need to support the JSON data type in the UDF application. This means that functions decorated with the @udf decorator need to have a type that corresponds to the JSON type in singlestoredb.
+
+For scalar-valued parameters in UDFs, we will use the Dict[str, Any] type. For vector-valued params, we have to use a generic object type, but in the @udf decorator we can support a Dict[str, Any] override. We can also add type aliases like for other vector types (functions/typing).
+
+Make sure that the SQL type mappings in CREATE EXTERNAL FUNCTION map to JSON.
+
+Make sure that Function signatures in the show/create-function have the JSON type.
+
+## Code locations
+• singlestoredb/functions/
+
+---
+
+## Visual Description
+
+This appears to be a handwritten specification or development note on white paper with black ink. The document is structured with a bullet-pointed summary section followed by implementation notes and a code locations section. The handwriting is clear and legible, written in a casual style typical of technical notes or planning documents.
+
+The content focuses on implementing JSON data type support in UDF (User Defined Functions) applications, specifically for SingleStoreDB, with technical details about type mappings and decorator usage.

singlestoredb/functions/decorator.py

@@ -10,6 +10,8 @@
 
 from . import utils
 from .dtypes import SQLString
+from .typing import JSON
+from .typing import JSONArray
 
 
 ParameterType = Union[
@@ -73,6 +75,8 @@ def expand_types(args: Any) -> Optional[List[Any]]:
         for arg in args:
             if isinstance(arg, str):
                 new_args.append(arg)
+            elif arg in [JSON, JSONArray]:
+                new_args.append(arg)
             elif is_sqlstr_callable(arg):
                 new_args.append(arg())
             elif type(arg) is type:

singlestoredb/functions/dtypes.py

@@ -117,6 +117,7 @@ def bytestr(x: Any) -> Optional[bytes]:
     -9: converters[9],
     15: utf8str,
     -15: bytestr,
+    245: utf8str,
     249: utf8str,
     -249: bytestr,
     250: utf8str,