Examples with SqlType io.trino.spi.function.SqlType used on opensource projects

Example 26 with SqlType

use of io.trino.spi.function.SqlType in project trino by trinodb.

the class CurrentTimestamp method shortTimestamp.

@LiteralParameters("p")
@SqlType("timestamp(p) with time zone")
public static long shortTimestamp(@LiteralParameter("p") long precision, ConnectorSession session, // need a dummy value since the type inferencer can't bind type arguments exclusively from return type
@SqlNullable @SqlType("timestamp(p) with time zone") Long dummy) {
    Instant start = session.getStart();
    long epochMillis = start.toEpochMilli();
    if (precision < MAX_SHORT_PRECISION) {
        epochMillis = round(epochMillis, (int) (MAX_SHORT_PRECISION - precision));
    } else {
        long nanosOfMilli = start.getNano() % NANOSECONDS_PER_MILLISECOND;
        if (roundToNearest(nanosOfMilli, NANOSECONDS_PER_MILLISECOND) == NANOSECONDS_PER_MILLISECOND) {
            epochMillis++;
        }
    }
    return packDateTimeWithZone(epochMillis, session.getTimeZoneKey());
}

Example 27 with SqlType

use of io.trino.spi.function.SqlType in project trino by trinodb.

the class DateDiff method diff.

@LiteralParameters({ "x", "p" })
@SqlType(StandardTypes.BIGINT)
public static long diff(@SqlType("varchar(x)") Slice unit, @SqlType("timestamp(p) with time zone") LongTimestampWithTimeZone timestamp1, @SqlType("timestamp(p) with time zone") LongTimestampWithTimeZone timestamp2) {
    long epochMillis1 = timestamp1.getEpochMillis();
    long epochMillis2 = timestamp2.getEpochMillis();
    ISOChronology chronology = ISOChronology.getInstanceUTC();
    return getTimestampField(chronology, unit).getDifferenceAsLong(epochMillis2, epochMillis1);
}

Example 28 with SqlType

use of io.trino.spi.function.SqlType in project trino by trinodb.

the class StringFunctions method substring.

@Description("Substring of given length starting at an index")
@ScalarFunction(alias = "substr")
@LiteralParameters("x")
@SqlType("varchar(x)")
public static Slice substring(@SqlType("varchar(x)") Slice utf8, @SqlType(StandardTypes.BIGINT) long start, @SqlType(StandardTypes.BIGINT) long length) {
    if (start == 0 || (length <= 0) || (utf8.length() == 0)) {
        return Slices.EMPTY_SLICE;
    }
    int startCodePoint = Ints.saturatedCast(start);
    int lengthCodePoints = Ints.saturatedCast(length);
    if (startCodePoint > 0) {
        int indexStart = offsetOfCodePoint(utf8, startCodePoint - 1);
        if (indexStart < 0) {
            // before beginning of string
            return Slices.EMPTY_SLICE;
        }
        int indexEnd = offsetOfCodePoint(utf8, indexStart, lengthCodePoints);
        if (indexEnd < 0) {
            // after end of string
            indexEnd = utf8.length();
        }
        return utf8.slice(indexStart, indexEnd - indexStart);
    }
    // negative start is relative to end of string
    int codePoints = countCodePoints(utf8);
    startCodePoint += codePoints;
    // before beginning of string
    if (startCodePoint < 0) {
        return Slices.EMPTY_SLICE;
    }
    int indexStart = offsetOfCodePoint(utf8, startCodePoint);
    int indexEnd;
    if (startCodePoint + lengthCodePoints < codePoints) {
        indexEnd = offsetOfCodePoint(utf8, indexStart, lengthCodePoints);
    } else {
        indexEnd = utf8.length();
    }
    return utf8.slice(indexStart, indexEnd - indexStart);
}

Example 29 with SqlType

use of io.trino.spi.function.SqlType in project trino by trinodb.

the class StringFunctions method levenshteinDistance.

@Description("Computes Levenshtein distance between two strings")
@ScalarFunction
@LiteralParameters({ "x", "y" })
@SqlType(StandardTypes.BIGINT)
public static long levenshteinDistance(@SqlType("varchar(x)") Slice left, @SqlType("varchar(y)") Slice right) {
    int[] leftCodePoints = castToCodePoints(left);
    int[] rightCodePoints = castToCodePoints(right);
    if (leftCodePoints.length < rightCodePoints.length) {
        int[] tempCodePoints = leftCodePoints;
        leftCodePoints = rightCodePoints;
        rightCodePoints = tempCodePoints;
    }
    if (rightCodePoints.length == 0) {
        return leftCodePoints.length;
    }
    checkCondition((leftCodePoints.length * (rightCodePoints.length - 1)) <= 1_000_000, INVALID_FUNCTION_ARGUMENT, "The combined inputs for Levenshtein distance are too large");
    int[] distances = new int[rightCodePoints.length];
    for (int i = 0; i < rightCodePoints.length; i++) {
        distances[i] = i + 1;
    }
    for (int i = 0; i < leftCodePoints.length; i++) {
        int leftUpDistance = distances[0];
        if (leftCodePoints[i] == rightCodePoints[0]) {
            distances[0] = i;
        } else {
            distances[0] = Math.min(i, distances[0]) + 1;
        }
        for (int j = 1; j < rightCodePoints.length; j++) {
            int leftUpDistanceNext = distances[j];
            if (leftCodePoints[i] == rightCodePoints[j]) {
                distances[j] = leftUpDistance;
            } else {
                distances[j] = Math.min(distances[j - 1], Math.min(leftUpDistance, distances[j])) + 1;
            }
            leftUpDistance = leftUpDistanceNext;
        }
    }
    return distances[rightCodePoints.length - 1];
}

Example 30 with SqlType

use of io.trino.spi.function.SqlType in project trino by trinodb.

the class StringFunctions method translate.

@Description("Translate characters from the source string based on original and translations strings")
@ScalarFunction
@LiteralParameters({ "x", "y", "z" })
@SqlType(StandardTypes.VARCHAR)
public static Slice translate(@SqlType("varchar(x)") Slice source, @SqlType("varchar(y)") Slice from, @SqlType("varchar(z)") Slice to) {
    int[] fromCodePoints = castToCodePoints(from);
    int[] toCodePoints = castToCodePoints(to);
    Int2IntOpenHashMap map = new Int2IntOpenHashMap(fromCodePoints.length);
    for (int index = 0; index < fromCodePoints.length; index++) {
        int fromCodePoint = fromCodePoints[index];
        map.putIfAbsent(fromCodePoint, index < toCodePoints.length ? toCodePoints[index] : -1);
    }
    int[] sourceCodePoints = castToCodePoints(source);
    int[] targetCodePoints = new int[sourceCodePoints.length];
    int targetPositions = 0;
    int targetBytes = 0;
    for (int index = 0; index < sourceCodePoints.length; index++) {
        int codePoint = sourceCodePoints[index];
        if (map.containsKey(codePoint)) {
            int translatedCodePoint = map.get(codePoint);
            if (translatedCodePoint == -1) {
                continue;
            }
            codePoint = translatedCodePoint;
        }
        targetCodePoints[targetPositions++] = codePoint;
        targetBytes += lengthOfCodePoint(codePoint);
    }
    Slice target = Slices.allocate(targetBytes);
    int offset = 0;
    for (int index = 0; index < targetPositions; index++) {
        offset += setCodePointAt(targetCodePoints[index], target, offset);
    }
    return target;
}