final List<String> list = new ArrayList<>();
            list.add(strValue);
            return list;
        }
        if (value instanceof List<?> listValue) {
            return (List<String>) listValue;
        }
        throw new IllegalArgumentException("The value for key '" + key + "' should be String or List, but was " + value.getClass());
    }

    /**

            final List<String> list = new ArrayList<>();
            list.add(strValue);
            return list;
        }
        if (value instanceof List<?> listValue) {
            return (List<String>) listValue;
        }
        throw new IllegalArgumentException("The value should be String or List, but " + value.getClass());
    }

    /**

            WebApiUtil.setObject("objectValue", new Object());

            // Test with collections
            java.util.List<String> list = java.util.Arrays.asList("item1", "item2");
            WebApiUtil.setObject("listValue", list);

            java.util.Map<String, String> map = new java.util.HashMap<>();
            map.put("key", "value");
            WebApiUtil.setObject("mapValue", map);

        } catch (Exception e) {

      @Nullable C lastValue;

      @Override
      protected @Nullable C computeNext() {
        while (merged.hasNext()) {
          C next = merged.next();
          boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0;

          // Keep looping till we find a non-duplicate value.
          if (!duplicate) {
            lastValue = next;
            return lastValue;

      @Nullable C lastValue;

      @Override
      protected @Nullable C computeNext() {
        while (merged.hasNext()) {
          C next = merged.next();
          boolean duplicate = lastValue != null && comparator.compare(next, lastValue) == 0;

          // Keep looping till we find a non-duplicate value.
          if (!duplicate) {
            lastValue = next;
            return lastValue;

        assertEquals("value2", arrayValues[0]);
        assertEquals("value3", arrayValues[1]);

        String[] listValues = defaultContentsParser.getFieldValues(document, "list_field");
        assertEquals(2, listValues.length);
        assertEquals("value4", listValues[0]);
        assertEquals("value5", listValues[1]);

        String[] intValues = defaultContentsParser.getFieldValues(document, "int_field");

	Timestamp1 *PrimaryTerm `parser:" @@ \",\" "`
	Timestamp2 *PrimaryTerm `parser:" @@ \")\" "`
}

// LitValue represents a literal value parsed from the sql
type LitValue struct {
	Float   *float64       `parser:"(  @Float"`
	Int     *float64       `parser:" | @Int"` // To avoid value out of range, use float64 instead

		if !from.Table.PathExpr[0].ArrayWildcard {
			return errBadTableName(errors.New("keypath table name is invalid - please check the service documentation"))
		}
	}
	return nil
}

func parseLimit(v *LitValue) (int64, error) {
	switch {
	case v == nil:
		return -1, nil
	case v.Int == nil:
		return -1, errBadLimitSpecified
	default:
		r := int64(*v.Int)
		if r < 0 {
			return -1, errBadLimitSpecified

	default:
		return e.evalSQLFnNode(r, tableAlias)
	}
}

// evalNode on a literal value is independent of the node being an
// aggregation or a row function - it always returns a value.
func (e *LitValue) evalNode(_ Record) (res *Value, err error) {
	switch {
	case e.Int != nil:
		if *e.Int < math.MaxInt64 && *e.Int > math.MinInt64 {
			return FromInt(int64(*e.Int)), nil
		}
		return FromFloat(*e.Int), nil