PPL: Add json function and cast(x as json) function

core/src/main/java/org/opensearch/sql/ast/expression/Cast.java

@@ -13,6 +13,7 @@
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_FLOAT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_INT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_IP;
+import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_JSON;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_LONG;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_SHORT;
 import static org.opensearch.sql.expression.function.BuiltinFunctionName.CAST_TO_STRING;
@@ -56,6 +57,7 @@ public class Cast extends UnresolvedExpression {
           .put("timestamp", CAST_TO_TIMESTAMP.getName())
           .put("datetime", CAST_TO_DATETIME.getName())
           .put("ip", CAST_TO_IP.getName())
+          .put("json", CAST_TO_JSON.getName())
           .build();
 
   /** The source expression cast from. */

core/src/main/java/org/opensearch/sql/expression/DSL.java

@@ -843,6 +843,10 @@ public static FunctionExpression castIp(Expression value) {
     return compile(FunctionProperties.None, BuiltinFunctionName.CAST_TO_IP, value);
   }
 
+  public static FunctionExpression castJson(Expression value) {
+    return compile(FunctionProperties.None, BuiltinFunctionName.CAST_TO_JSON, value);
+  }
+
   public static FunctionExpression typeof(Expression value) {
     return compile(FunctionProperties.None, BuiltinFunctionName.TYPEOF, value);
   }
@@ -973,6 +977,10 @@ public static FunctionExpression utc_timestamp(
     return compile(functionProperties, BuiltinFunctionName.UTC_TIMESTAMP, args);
   }
 
+  public static FunctionExpression json_function(Expression value) {
+    return compile(FunctionProperties.None, BuiltinFunctionName.JSON, value);
+  }
+
   @SuppressWarnings("unchecked")
   private static <T extends FunctionImplementation> T compile(
       FunctionProperties functionProperties, BuiltinFunctionName bfn, Expression... args) {

core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java

@@ -206,6 +206,7 @@ public enum BuiltinFunctionName {
 
   /** Json Functions. */
   JSON_VALID(FunctionName.of("json_valid")),
+  JSON(FunctionName.of("json")),
 
   /** NULL Test. */
   IS_NULL(FunctionName.of("is null")),
@@ -235,6 +236,7 @@ public enum BuiltinFunctionName {
   CAST_TO_TIMESTAMP(FunctionName.of("cast_to_timestamp")),
   CAST_TO_DATETIME(FunctionName.of("cast_to_datetime")),
   CAST_TO_IP(FunctionName.of("cast_to_ip")),
+  CAST_TO_JSON(FunctionName.of("cast_to_json")),
   TYPEOF(FunctionName.of("typeof")),
 
   /** Relevance Function. */

core/src/main/java/org/opensearch/sql/expression/json/JsonFunctions.java

@@ -7,6 +7,7 @@
 
 import static org.opensearch.sql.data.type.ExprCoreType.BOOLEAN;
 import static org.opensearch.sql.data.type.ExprCoreType.STRING;
+import static org.opensearch.sql.data.type.ExprCoreType.UNDEFINED;
 import static org.opensearch.sql.expression.function.FunctionDSL.define;
 import static org.opensearch.sql.expression.function.FunctionDSL.impl;
 import static org.opensearch.sql.expression.function.FunctionDSL.nullMissingHandling;
@@ -21,11 +22,18 @@
 public class JsonFunctions {
   public void register(BuiltinFunctionRepository repository) {
     repository.register(jsonValid());
+    repository.register(jsonFunction());
   }
 
   private DefaultFunctionResolver jsonValid() {
     return define(
         BuiltinFunctionName.JSON_VALID.getName(),
         impl(nullMissingHandling(JsonUtils::isValidJson), BOOLEAN, STRING));
   }
+
+  private DefaultFunctionResolver jsonFunction() {
+    return define(
+        BuiltinFunctionName.JSON.getName(),
+        impl(nullMissingHandling(JsonUtils::castJson), UNDEFINED, STRING));
+  }
 }

core/src/main/java/org/opensearch/sql/expression/operator/convert/TypeCastOperators.java

@@ -17,6 +17,7 @@
 import static org.opensearch.sql.data.type.ExprCoreType.STRING;
 import static org.opensearch.sql.data.type.ExprCoreType.TIME;
 import static org.opensearch.sql.data.type.ExprCoreType.TIMESTAMP;
+import static org.opensearch.sql.data.type.ExprCoreType.UNDEFINED;
 import static org.opensearch.sql.expression.function.FunctionDSL.impl;
 import static org.opensearch.sql.expression.function.FunctionDSL.implWithProperties;
 import static org.opensearch.sql.expression.function.FunctionDSL.nullMissingHandling;
@@ -42,6 +43,7 @@
 import org.opensearch.sql.expression.function.BuiltinFunctionRepository;
 import org.opensearch.sql.expression.function.DefaultFunctionResolver;
 import org.opensearch.sql.expression.function.FunctionDSL;
+import org.opensearch.sql.utils.JsonUtils;
 
 @UtilityClass
 public class TypeCastOperators {
@@ -57,6 +59,7 @@ public static void register(BuiltinFunctionRepository repository) {
     repository.register(castToDouble());
     repository.register(castToBoolean());
     repository.register(castToIp());
+    repository.register(castToJson());
     repository.register(castToDate());
     repository.register(castToTime());
     repository.register(castToTimestamp());
@@ -183,6 +186,12 @@ private static DefaultFunctionResolver castToIp() {
         impl(nullMissingHandling((v) -> v), IP, IP));
   }
 
+  private static DefaultFunctionResolver castToJson() {
+    return FunctionDSL.define(
+        BuiltinFunctionName.CAST_TO_JSON.getName(),
+        impl(nullMissingHandling(JsonUtils::castJson), UNDEFINED, STRING));
+  }
+
   private static DefaultFunctionResolver castToDate() {
     return FunctionDSL.define(
         BuiltinFunctionName.CAST_TO_DATE.getName(),

core/src/main/java/org/opensearch/sql/utils/JsonUtils.java

@@ -1,10 +1,24 @@
 package org.opensearch.sql.utils;
 
+import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_FALSE;
+import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_NULL;
+import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
+
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 import lombok.experimental.UtilityClass;
+import org.opensearch.sql.data.model.ExprCollectionValue;
+import org.opensearch.sql.data.model.ExprDoubleValue;
+import org.opensearch.sql.data.model.ExprIntegerValue;
+import org.opensearch.sql.data.model.ExprStringValue;
+import org.opensearch.sql.data.model.ExprTupleValue;
 import org.opensearch.sql.data.model.ExprValue;
-import org.opensearch.sql.data.model.ExprValueUtils;
+import org.opensearch.sql.exception.SemanticCheckException;
 
 @UtilityClass
 public class JsonUtils {
@@ -18,9 +32,57 @@ public static ExprValue isValidJson(ExprValue jsonExprValue) {
     ObjectMapper objectMapper = new ObjectMapper();
     try {
       objectMapper.readTree(jsonExprValue.stringValue());
-      return ExprValueUtils.LITERAL_TRUE;
+      return LITERAL_TRUE;
     } catch (JsonProcessingException e) {
-      return ExprValueUtils.LITERAL_FALSE;
+      return LITERAL_FALSE;
     }
   }
+
+  /** Converts a JSON encoded string to an Expression object. */
+  public static ExprValue castJson(ExprValue json) {
+    ObjectMapper objectMapper = new ObjectMapper();
+    JsonNode jsonNode;
+    try {
+      jsonNode = objectMapper.readTree(json.stringValue());
+    } catch (JsonProcessingException e) {
+      final String errorFormat = "JSON string '%s' is not valid. Error details: %s";
+      throw new SemanticCheckException(String.format(errorFormat, json, e.getMessage()), e);
+    }
+
+    return processJsonNode(jsonNode);
+  }
+
+  private static ExprValue processJsonNode(JsonNode jsonNode) {
+    if (jsonNode.isFloatingPointNumber()) {
+      return new ExprDoubleValue(jsonNode.asDouble());
+    }
+    if (jsonNode.isIntegralNumber()) {
+      return new ExprIntegerValue(jsonNode.asLong());
+    }
+    if (jsonNode.isBoolean()) {
+      return jsonNode.asBoolean() ? LITERAL_TRUE : LITERAL_FALSE;
+    }
+    if (jsonNode.isTextual()) {
+      return new ExprStringValue(jsonNode.asText());
+    }
+    if (jsonNode.isArray()) {
+      List<ExprValue> elements = new LinkedList<>();
+      for (var iter = jsonNode.iterator(); iter.hasNext(); ) {
+        jsonNode = iter.next();
+        elements.add(processJsonNode(jsonNode));
+      }
+      return new ExprCollectionValue(elements);
+    }
+    if (jsonNode.isObject()) {
+      Map<String, ExprValue> values = new LinkedHashMap<>();
+      for (var iter = jsonNode.fields(); iter.hasNext(); ) {
+        Map.Entry<String, JsonNode> entry = iter.next();
+        values.put(entry.getKey(), processJsonNode(entry.getValue()));
+      }
+      return ExprTupleValue.fromExprValueMap(values);
+    }
+
+    // in all other cases, return null
+    return LITERAL_NULL;
+  }
 }

core/src/test/java/org/opensearch/sql/expression/json/JsonFunctionsTest.java

@@ -6,44 +6,146 @@
 package org.opensearch.sql.expression.json;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_FALSE;
+import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_NULL;
 import static org.opensearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
 
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.opensearch.sql.data.model.ExprBooleanValue;
+import org.opensearch.sql.data.model.ExprCollectionValue;
+import org.opensearch.sql.data.model.ExprDoubleValue;
+import org.opensearch.sql.data.model.ExprIntegerValue;
+import org.opensearch.sql.data.model.ExprLongValue;
+import org.opensearch.sql.data.model.ExprNullValue;
+import org.opensearch.sql.data.model.ExprStringValue;
+import org.opensearch.sql.data.model.ExprTupleValue;
 import org.opensearch.sql.data.model.ExprValue;
 import org.opensearch.sql.data.model.ExprValueUtils;
+import org.opensearch.sql.exception.SemanticCheckException;
 import org.opensearch.sql.expression.DSL;
 import org.opensearch.sql.expression.FunctionExpression;
 
 @ExtendWith(MockitoExtension.class)
 public class JsonFunctionsTest {
-  private static final ExprValue JsonObject =
-      ExprValueUtils.stringValue("{\"a\":\"1\",\"b\":\"2\"}");
-  private static final ExprValue JsonArray = ExprValueUtils.stringValue("[1, 2, 3, 4]");
-  private static final ExprValue JsonScalarString = ExprValueUtils.stringValue("\"abc\"");
-  private static final ExprValue JsonEmptyString = ExprValueUtils.stringValue("");
-  private static final ExprValue JsonInvalidObject =
-      ExprValueUtils.stringValue("{\"invalid\":\"json\", \"string\"}");
-  private static final ExprValue JsonInvalidScalar = ExprValueUtils.stringValue("abc");
 
   @Test
   public void json_valid_returns_false() {
-    assertEquals(LITERAL_FALSE, execute(JsonInvalidObject));
-    assertEquals(LITERAL_FALSE, execute(JsonInvalidScalar));
+    final ExprValue JsonInvalidObject =
+        ExprValueUtils.stringValue("{\"invalid\":\"json\", \"string\"}");
+    assertEquals(LITERAL_FALSE, DSL.jsonValid(DSL.literal(JsonInvalidObject)).valueOf());
+
+    final ExprValue JsonInvalidScalar = ExprValueUtils.stringValue("abc");
+    assertEquals(LITERAL_FALSE, DSL.jsonValid(DSL.literal(JsonInvalidScalar)).valueOf());
   }
 
   @Test
   public void json_valid_returns_true() {
-    assertEquals(LITERAL_TRUE, execute(JsonObject));
-    assertEquals(LITERAL_TRUE, execute(JsonArray));
-    assertEquals(LITERAL_TRUE, execute(JsonScalarString));
-    assertEquals(LITERAL_TRUE, execute(JsonEmptyString));
+    final ExprValue JsonObject = ExprValueUtils.stringValue("{\"a\":\"1\",\"b\":\"2\"}");
+    assertEquals(LITERAL_TRUE, DSL.jsonValid(DSL.literal(JsonObject)).valueOf());
+
+    final ExprValue JsonArray = ExprValueUtils.stringValue("[1, 2, 3, 4]");
+    assertEquals(LITERAL_TRUE, DSL.jsonValid(DSL.literal(JsonArray)).valueOf());
+
+    final ExprValue JsonScalarString = ExprValueUtils.stringValue("\"abc\"");
+    assertEquals(LITERAL_TRUE, DSL.jsonValid(DSL.literal(JsonScalarString)).valueOf());
+
+    final ExprValue JsonEmptyString = ExprValueUtils.stringValue("");
+    assertEquals(LITERAL_TRUE, DSL.jsonValid(DSL.literal(JsonEmptyString)).valueOf());
+  }
+
+  @Test
+  void json_returnsJsonObject() {
+    FunctionExpression exp;
+
+    // Setup
+    final String objectJson =
+        "{\"foo\": \"foo\", \"fuzz\": true, \"bar\": 1234, \"bar2\": 12.34, \"baz\": null, "
+            + "\"obj\": {\"internal\": \"value\"}, \"arr\": [\"string\", true, null]}";
+
+    LinkedHashMap<String, ExprValue> objectMap = new LinkedHashMap<>();
+    objectMap.put("foo", new ExprStringValue("foo"));
+    objectMap.put("fuzz", ExprBooleanValue.of(true));
+    objectMap.put("bar", new ExprLongValue(1234));
+    objectMap.put("bar2", new ExprDoubleValue(12.34));
+    objectMap.put("baz", ExprNullValue.of());
+    objectMap.put(
+        "obj", ExprTupleValue.fromExprValueMap(Map.of("internal", new ExprStringValue("value"))));
+    objectMap.put(
+        "arr",
+        new ExprCollectionValue(
+            List.of(new ExprStringValue("string"), ExprBooleanValue.of(true), ExprNullValue.of())));
+    ExprValue expectedTupleExpr = ExprTupleValue.fromExprValueMap(objectMap);
+
+    // exercise
+    exp = DSL.json_function(DSL.literal(objectJson));
+
+    // Verify
+    var value = exp.valueOf();
+    assertTrue(value instanceof ExprTupleValue);
+    assertEquals(expectedTupleExpr, value);
+  }
+
+  @Test
+  void json_returnsJsonArray() {
+    FunctionExpression exp;
+
+    // Setup
+    final String arrayJson = "[\"foo\", \"fuzz\", true, \"bar\", 1234, 12.34, null]";
+    ExprValue expectedArrayExpr =
+        new ExprCollectionValue(
+            List.of(
+                new ExprStringValue("foo"),
+                new ExprStringValue("fuzz"),
+                LITERAL_TRUE,
+                new ExprStringValue("bar"),
+                new ExprIntegerValue(1234),
+                new ExprDoubleValue(12.34),
+                LITERAL_NULL));
+
+    // exercise
+    exp = DSL.json_function(DSL.literal(arrayJson));
+
+    // Verify
+    var value = exp.valueOf();
+    assertTrue(value instanceof ExprCollectionValue);
+    assertEquals(expectedArrayExpr, value);
+  }
+
+  @Test
+  void json_returnsScalar() {
+    assertEquals(
+        new ExprStringValue("foobar"), DSL.json_function(DSL.literal("\"foobar\"")).valueOf());
+
+    assertEquals(new ExprIntegerValue(1234), DSL.json_function(DSL.literal("1234")).valueOf());
+
+    assertEquals(LITERAL_TRUE, DSL.json_function(DSL.literal("true")).valueOf());
+
+    assertEquals(LITERAL_NULL, DSL.json_function(DSL.literal("null")).valueOf());
+
+    assertEquals(LITERAL_NULL, DSL.json_function(DSL.literal("")).valueOf());
+
+    assertEquals(
+        ExprTupleValue.fromExprValueMap(Map.of()), DSL.json_function(DSL.literal("{}")).valueOf());
   }
 
-  private ExprValue execute(ExprValue jsonString) {
-    FunctionExpression exp = DSL.jsonValid(DSL.literal(jsonString));
-    return exp.valueOf();
+  @Test
+  void json_returnsSemanticCheckException() {
+    // invalid type
+    assertThrows(
+        SemanticCheckException.class, () -> DSL.castJson(DSL.literal("invalid")).valueOf());
+
+    // missing bracket
+    assertThrows(SemanticCheckException.class, () -> DSL.castJson(DSL.literal("{{[}}")).valueOf());
+
+    // mnissing quote
+    assertThrows(
+        SemanticCheckException.class, () -> DSL.castJson(DSL.literal("\"missing quote")).valueOf());
   }
 }