All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.neo4j.driver.Values Maven / Gradle / Ivy

    There is a newer version: 5.27.0
    Show newest version
    /*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [http://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.neo4j.driver;

import static org.neo4j.driver.internal.util.Extract.assertParameter;
import static org.neo4j.driver.internal.util.Iterables.newHashMapWithSize;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.Period;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Stream;
import org.neo4j.driver.exceptions.ClientException;
import org.neo4j.driver.internal.AsValue;
import org.neo4j.driver.internal.InternalIsoDuration;
import org.neo4j.driver.internal.InternalPoint2D;
import org.neo4j.driver.internal.InternalPoint3D;
import org.neo4j.driver.internal.value.BooleanValue;
import org.neo4j.driver.internal.value.BytesValue;
import org.neo4j.driver.internal.value.DateTimeValue;
import org.neo4j.driver.internal.value.DateValue;
import org.neo4j.driver.internal.value.DurationValue;
import org.neo4j.driver.internal.value.FloatValue;
import org.neo4j.driver.internal.value.IntegerValue;
import org.neo4j.driver.internal.value.ListValue;
import org.neo4j.driver.internal.value.LocalDateTimeValue;
import org.neo4j.driver.internal.value.LocalTimeValue;
import org.neo4j.driver.internal.value.MapValue;
import org.neo4j.driver.internal.value.NullValue;
import org.neo4j.driver.internal.value.PointValue;
import org.neo4j.driver.internal.value.StringValue;
import org.neo4j.driver.internal.value.TimeValue;
import org.neo4j.driver.types.Entity;
import org.neo4j.driver.types.IsoDuration;
import org.neo4j.driver.types.MapAccessor;
import org.neo4j.driver.types.Node;
import org.neo4j.driver.types.Path;
import org.neo4j.driver.types.Point;
import org.neo4j.driver.types.Relationship;
import org.neo4j.driver.types.TypeSystem;

/**
 * Utility for wrapping regular Java types and exposing them as {@link Value}
 * objects, and vice versa.
 * 
    
 * The long set of {@code ofXXX} methods in this class are meant to be used as
 * arguments for methods like {@link Value#asList(Function)}, {@link Value#asMap(Function)},
 * {@link Record#asMap(Function)} and so on.
 *
 * @since 1.0
 */
public abstract class Values {
    public static final Value EmptyMap = value(Collections.emptyMap());
    public static final Value NULL = NullValue.NULL;

    private Values() {
        throw new UnsupportedOperationException();
    }

    @SuppressWarnings("unchecked")
    public static Value value(Object value) {
        if (value == null) {
            return NullValue.NULL;
        }

        if (value instanceof AsValue) {
            return ((AsValue) value).asValue();
        }
        if (value instanceof Boolean) {
            return value((boolean) value);
        }
        if (value instanceof String) {
            return value((String) value);
        }
        if (value instanceof Character) {
            return value((char) value);
        }
        if (value instanceof Long) {
            return value((long) value);
        }
        if (value instanceof Short) {
            return value((short) value);
        }
        if (value instanceof Byte) {
            return value((byte) value);
        }
        if (value instanceof Integer) {
            return value((int) value);
        }
        if (value instanceof Double) {
            return value((double) value);
        }
        if (value instanceof Float) {
            return value((float) value);
        }
        if (value instanceof LocalDate) {
            return value((LocalDate) value);
        }
        if (value instanceof OffsetTime) {
            return value((OffsetTime) value);
        }
        if (value instanceof LocalTime) {
            return value((LocalTime) value);
        }
        if (value instanceof LocalDateTime) {
            return value((LocalDateTime) value);
        }
        if (value instanceof OffsetDateTime) {
            return value((OffsetDateTime) value);
        }
        if (value instanceof ZonedDateTime) {
            return value((ZonedDateTime) value);
        }
        if (value instanceof IsoDuration) {
            return value((IsoDuration) value);
        }
        if (value instanceof Period) {
            return value((Period) value);
        }
        if (value instanceof Duration) {
            return value((Duration) value);
        }
        if (value instanceof Point) {
            return value((Point) value);
        }

        if (value instanceof List) {
            return value((List) value);
        }
        if (value instanceof Map) {
            return value((Map) value);
        }
        if (value instanceof Iterable) {
            return value((Iterable) value);
        }
        if (value instanceof Iterator) {
            return value((Iterator) value);
        }
        if (value instanceof Stream) {
            return value((Stream) value);
        }

        if (value instanceof char[]) {
            return value((char[]) value);
        }
        if (value instanceof byte[]) {
            return value((byte[]) value);
        }
        if (value instanceof boolean[]) {
            return value((boolean[]) value);
        }
        if (value instanceof String[]) {
            return value((String[]) value);
        }
        if (value instanceof long[]) {
            return value((long[]) value);
        }
        if (value instanceof int[]) {
            return value((int[]) value);
        }
        if (value instanceof short[]) {
            return value((short[]) value);
        }
        if (value instanceof double[]) {
            return value((double[]) value);
        }
        if (value instanceof float[]) {
            return value((float[]) value);
        }
        if (value instanceof Value[]) {
            return value((Value[]) value);
        }
        if (value instanceof Object[]) {
            return value(Arrays.asList((Object[]) value));
        }

        throw new ClientException("Unable to convert " + value.getClass().getName() + " to Neo4j Value.");
    }

    public static Value[] values(final Object... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return values;
    }

    public static Value value(Value... input) {
        int size = input.length;
        Value[] values = new Value[size];
        System.arraycopy(input, 0, values, 0, size);
        return new ListValue(values);
    }

    public static BytesValue value(byte... input) {
        return new BytesValue(input);
    }

    public static Value value(String... input) {
        StringValue[] values = new StringValue[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = new StringValue(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(boolean... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(char... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(long... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(short... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(int... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(double... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(float... input) {
        Value[] values = new Value[input.length];
        for (int i = 0; i < input.length; i++) {
            values[i] = value(input[i]);
        }
        return new ListValue(values);
    }

    public static Value value(List vals) {
        Value[] values = new Value[vals.size()];
        int i = 0;
        for (Object val : vals) {
            values[i++] = value(val);
        }
        return new ListValue(values);
    }

    public static Value value(Iterable val) {
        return value(val.iterator());
    }

    public static Value value(Iterator val) {
        List values = new ArrayList<>();
        while (val.hasNext()) {
            values.add(value(val.next()));
        }
        return new ListValue(values.toArray(new Value[0]));
    }

    public static Value value(Stream stream) {
        Value[] values = stream.map(Values::value).toArray(Value[]::new);
        return new ListValue(values);
    }

    public static Value value(final char val) {
        return new StringValue(String.valueOf(val));
    }

    public static Value value(final String val) {
        return new StringValue(val);
    }

    public static Value value(final long val) {
        return new IntegerValue(val);
    }

    public static Value value(final int val) {
        return new IntegerValue(val);
    }

    public static Value value(final double val) {
        return new FloatValue(val);
    }

    public static Value value(final boolean val) {
        return BooleanValue.fromBoolean(val);
    }

    public static Value value(final Map val) {
        Map asValues = newHashMapWithSize(val.size());
        for (Map.Entry entry : val.entrySet()) {
            asValues.put(entry.getKey(), value(entry.getValue()));
        }
        return new MapValue(asValues);
    }

    public static Value value(LocalDate localDate) {
        return new DateValue(localDate);
    }

    public static Value value(OffsetTime offsetTime) {
        return new TimeValue(offsetTime);
    }

    public static Value value(LocalTime localTime) {
        return new LocalTimeValue(localTime);
    }

    public static Value value(LocalDateTime localDateTime) {
        return new LocalDateTimeValue(localDateTime);
    }

    public static Value value(OffsetDateTime offsetDateTime) {
        return new DateTimeValue(offsetDateTime.toZonedDateTime());
    }

    public static Value value(ZonedDateTime zonedDateTime) {
        return new DateTimeValue(zonedDateTime);
    }

    public static Value value(Period period) {
        return value(new InternalIsoDuration(period));
    }

    public static Value value(Duration duration) {
        return value(new InternalIsoDuration(duration));
    }

    public static Value isoDuration(long months, long days, long seconds, int nanoseconds) {
        return value(new InternalIsoDuration(months, days, seconds, nanoseconds));
    }

    private static Value value(IsoDuration duration) {
        return new DurationValue(duration);
    }

    public static Value point(int srid, double x, double y) {
        return value(new InternalPoint2D(srid, x, y));
    }

    private static Value value(Point point) {
        return new PointValue(point);
    }

    public static Value point(int srid, double x, double y, double z) {
        return value(new InternalPoint3D(srid, x, y, z));
    }

    /**
     * Helper function for creating a map of parameters, this can be used when you {@link
     * QueryRunner#run(String, Value) run} queries.
     * 
    
     * Allowed parameter types are:
     * 
      
     * 
    • {@link Integer}
      • 
     * 
    • {@link Long}
      • 
     * 
    • {@link Boolean}
      • 
     * 
    • {@link Double}
      • 
     * 
    • {@link Float}
      • 
     * 
    • {@link String}
      • 
     * 
    • {@link Map} with String keys and values being any type in this list
      • 
     * 
    • {@link Collection} of any type in this list
      • 
     * 
    
     *
     * @param keysAndValues alternating sequence of keys and values
     * @return Map containing all parameters specified
     * @see QueryRunner#run(String, Value)
     */
    public static Value parameters(Object... keysAndValues) {
        if (keysAndValues.length % 2 != 0) {
            throw new ClientException("Parameters function requires an even number " + "of arguments, "
                    + "alternating key and value. Arguments were: "
                    + Arrays.toString(keysAndValues)
                    + ".");
        }
        HashMap map = newHashMapWithSize(keysAndValues.length / 2);
        for (int i = 0; i < keysAndValues.length; i += 2) {
            Object value = keysAndValues[i + 1];
            assertParameter(value);
            map.put(keysAndValues[i].toString(), value(value));
        }
        return value(map);
    }

    /**
     * The identity function for value conversion - returns the value untouched.
     *
     * @return a function that returns the value passed into it - the identity function
     */
    public static Function ofValue() {
        return val -> val;
    }

    /**
     * Converts values to objects using {@link Value#asObject()}.
     *
     * @return a function that returns {@link Value#asObject()} of a {@link Value}
     */
    public static Function ofObject() {
        return Value::asObject;
    }

    /**
     * Converts values to {@link Number}.
     *
     * @return a function that returns {@link Value#asNumber()} of a {@link Value}
     */
    public static Function ofNumber() {
        return Value::asNumber;
    }

    /**
     * Converts values to {@link String}.
     * 
    
     * If you want to access a string you've retrieved from the database, this is
     * the right choice. If you want to print any value for human consumption, for
     * instance in a log, {@link #ofToString()} is the right choice.
     *
     * @return a function that returns {@link Value#asString()} of a {@link Value}
     */
    public static Function ofString() {
        return Value::asString;
    }

    /**
     * Converts values using {@link Value#toString()}, a human-readable string
     * description of any value.
     * 
    
     * This is different from {@link #ofString()}, which returns a java
     * {@link String} value from a database {@link TypeSystem#STRING()}.
     * 
    
     * If you are wanting to print any value for human consumption, this is the
     * right choice. If you are wanting to access a string value stored in the
     * database, you should use {@link #ofString()}.
     *
     * @return a function that returns {@link Value#toString()} of a {@link Value}
     */
    public static Function ofToString() {
        return Value::toString;
    }

    /**
     * Converts values to {@link Integer}.
     *
     * @return a function that returns {@link Value#asInt()} of a {@link Value}
     */
    public static Function ofInteger() {
        return Value::asInt;
    }

    /**
     * Converts values to {@link Long}.
     *
     * @return a function that returns {@link Value#asLong()} of a {@link Value}
     */
    public static Function ofLong() {
        return Value::asLong;
    }

    /**
     * Converts values to {@link Float}.
     *
     * @return a function that returns {@link Value#asFloat()} of a {@link Value}
     */
    public static Function ofFloat() {
        return Value::asFloat;
    }

    /**
     * Converts values to {@link Double}.
     *
     * @return a function that returns {@link Value#asDouble()} of a {@link Value}
     */
    public static Function ofDouble() {
        return Value::asDouble;
    }

    /**
     * Converts values to {@link Boolean}.
     *
     * @return a function that returns {@link Value#asBoolean()} of a {@link Value}
     */
    public static Function ofBoolean() {
        return Value::asBoolean;
    }

    /**
     * Converts values to {@link Map}.
     *
     * @return a function that returns {@link Value#asMap()} of a {@link Value}
     */
    public static Function> ofMap() {
        return MapAccessor::asMap;
    }

    /**
     * Converts values to {@link Map}, with the map values further converted using
     * the provided converter.
     *
     * @param valueConverter converter to use for the values of the map
     * @param  the type of values in the returned map
     * @return a function that returns {@link Value#asMap(Function)} of a {@link Value}
     */
    public static  Function> ofMap(final Function valueConverter) {
        return val -> val.asMap(valueConverter);
    }

    /**
     * Converts values to {@link Entity}.
     *
     * @return a function that returns {@link Value#asEntity()} of a {@link Value}
     */
    public static Function ofEntity() {
        return Value::asEntity;
    }

    /**
     * Converts values to {@link Long entity id}.
     *
     * @return a function that returns the id an entity {@link Value}
     */
    public static Function ofEntityId() {
        return val -> val.asEntity().id();
    }

    /**
     * Converts values to {@link Node}.
     *
     * @return a function that returns {@link Value#asNode()} of a {@link Value}
     */
    public static Function ofNode() {
        return Value::asNode;
    }

    /**
     * Converts values to {@link Relationship}.
     *
     * @return a function that returns {@link Value#asRelationship()} of a {@link Value}
     */
    public static Function ofRelationship() {
        return Value::asRelationship;
    }

    /**
     * Converts values to {@link Path}.
     *
     * @return a function that returns {@link Value#asPath()} of a {@link Value}
     */
    public static Function ofPath() {
        return Value::asPath;
    }

    /**
     * Converts values to {@link LocalDate}.
     *
     * @return a function that returns {@link Value#asLocalDate()} of a {@link Value}
     */
    public static Function ofLocalDate() {
        return Value::asLocalDate;
    }

    /**
     * Converts values to {@link OffsetTime}.
     *
     * @return a function that returns {@link Value#asOffsetTime()} of a {@link Value}
     */
    public static Function ofOffsetTime() {
        return Value::asOffsetTime;
    }

    /**
     * Converts values to {@link LocalTime}.
     *
     * @return a function that returns {@link Value#asLocalTime()} of a {@link Value}
     */
    public static Function ofLocalTime() {
        return Value::asLocalTime;
    }

    /**
     * Converts values to {@link LocalDateTime}.
     *
     * @return a function that returns {@link Value#asLocalDateTime()} of a {@link Value}
     */
    public static Function ofLocalDateTime() {
        return Value::asLocalDateTime;
    }

    /**
     * Converts values to {@link OffsetDateTime}.
     *
     * @return a function that returns {@link Value#asOffsetDateTime()} of a {@link Value}
     */
    public static Function ofOffsetDateTime() {
        return Value::asOffsetDateTime;
    }

    /**
     * Converts values to {@link ZonedDateTime}.
     *
     * @return a function that returns {@link Value#asZonedDateTime()} of a {@link Value}
     */
    public static Function ofZonedDateTime() {
        return Value::asZonedDateTime;
    }

    /**
     * Converts values to {@link IsoDuration}.
     *
     * @return a function that returns {@link Value#asIsoDuration()} of a {@link Value}
     */
    public static Function ofIsoDuration() {
        return Value::asIsoDuration;
    }

    /**
     * Converts values to {@link Point}.
     *
     * @return a function that returns {@link Value#asPoint()} of a {@link Value}
     */
    public static Function ofPoint() {
        return Value::asPoint;
    }

    /**
     * Converts values to {@link List} of {@link Object}.
     *
     * @return a function that returns {@link Value#asList()} of a {@link Value}
     */
    public static Function> ofList() {
        return Value::asList;
    }

    /**
     * Converts values to {@link List} of {@code T}.
     *
     * @param innerMap converter for the values inside the list
     * @param  the type of values inside the list
     * @return a function that returns {@link Value#asList(Function)} of a {@link Value}
     */
    public static  Function> ofList(final Function innerMap) {
        return value -> value.asList(innerMap);
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy