error: 45, ok: 1974, output: 158
47 example(s) unexpectedly not ok.
Fix the example in the source file below, or, if it cannot pass, add it to tests/docs_examples/known_failures.txt with the reason.
AggregateFunction/exponentialMovingAverage#2 [output] src/AggregateFunctions/AggregateFunctionExponentialMovingAverage.cpp
| CREATE TABLE data
| ENGINE = Memory AS
| SELECT
| 10 AS value,
| toDateTime('2020-01-01') + (3600 * number) AS time
| FROM numbers_mt(10);
|
| -- Calculate timeunit using intDiv
| SELECT
| value,
| time,
| exponentialMovingAverage(1)(value, intDiv(toUInt32(time), 3600)) OVER (ORDER BY time ASC) AS res,
| intDiv(toUInt32(time), 3600) AS timeunit
| FROM data
| ORDER BY time ASC
documented response:
- ┌─value─┬────────────────time─┬─────────res─┬─timeunit─┐
- │ 10 │ 2020-01-01 00:00:00 │ 5 │ 438288 │
- │ 10 │ 2020-01-01 01:00:00 │ 7.5 │ 438289 │
- │ 10 │ 2020-01-01 02:00:00 │ 8.75 │ 438290 │
- │ 10 │ 2020-01-01 03:00:00 │ 9.375 │ 438291 │
- │ 10 │ 2020-01-01 04:00:00 │ 9.6875 │ 438292 │
- │ 10 │ 2020-01-01 05:00:00 │ 9.84375 │ 438293 │
- │ 10 │ 2020-01-01 06:00:00 │ 9.921875 │ 438294 │
- │ 10 │ 2020-01-01 07:00:00 │ 9.9609375 │ 438295 │
- │ 10 │ 2020-01-01 08:00:00 │ 9.98046875 │ 438296 │
- │ 10 │ 2020-01-01 09:00:00 │ 9.990234375 │ 438297 │
- └───────┴─────────────────────┴─────────────┴──────────┘
actual response:
+ ┌─value─┬────────────────time─┬─────────res─┬─timeunit─┐
+ │ 10 │ 2020-01-01 00:00:00 │ 5 │ 438287 │
+ │ 10 │ 2020-01-01 01:00:00 │ 7.5 │ 438288 │
+ │ 10 │ 2020-01-01 02:00:00 │ 8.75 │ 438289 │
+ │ 10 │ 2020-01-01 03:00:00 │ 9.375 │ 438290 │
+ │ 10 │ 2020-01-01 04:00:00 │ 9.6875 │ 438291 │
+ │ 10 │ 2020-01-01 05:00:00 │ 9.84375 │ 438292 │
+ │ 10 │ 2020-01-01 06:00:00 │ 9.921875 │ 438293 │
+ │ 10 │ 2020-01-01 07:00:00 │ 9.9609375 │ 438294 │
+ │ 10 │ 2020-01-01 08:00:00 │ 9.98046875 │ 438295 │
+ │ 10 │ 2020-01-01 09:00:00 │ 9.990234375 │ 438296 │
+ └───────┴─────────────────────┴─────────────┴──────────┘
AggregateFunction/sumMapWithOverflow#0 [output] src/AggregateFunctions/AggregateFunctionSumMap.cpp
| CREATE TABLE sum_map(
| date Date,
| timeslot DateTime,
| statusMap Nested(
| status UInt8,
| requests UInt8
| ),
| statusMapTuple Tuple(Array(Int8), Array(Int8))
| ) ENGINE = Memory;
|
| INSERT INTO sum_map VALUES
| ('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10], ([1, 2, 3], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10], ([3, 4, 5], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10], ([4, 5, 6], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10], ([6, 7, 8], [10, 10, 10]));
|
| SELECT
| timeslot,
| toTypeName(sumMap(statusMap.status, statusMap.requests)),
| toTypeName(sumMapWithOverflow(statusMap.status, statusMap.requests))
| FROM sum_map
| GROUP BY timeslot;
documented response:
- ┌────────────timeslot─┬─toTypeName(sumMap(statusMap.status, statusMap.requests))─┬─toTypeName(sumMapWithOverflow(statusMap.status, statusMap.requests))─┐
- │ 2000-01-01 00:00:00 │ Tuple(Array(UInt8), Array(UInt64)) │ Tuple(Array(UInt8), Array(UInt8)) │
- │ 2000-01-01 00:01:00 │ Tuple(Array(UInt8), Array(UInt64)) │ Tuple(Array(UInt8), Array(UInt8)) │
- └─────────────────────┴──────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────┘
actual response:
+ ┌────────────timeslot─┬─toTypeName(sumMap(statusMap.status, statusMap.requests))─┬─toTypeName(sumMapWithOverflow(statusMap.status, statusMap.requests))─┐
+ │ 2000-01-01 00:01:00 │ Tuple(Array(UInt8), Array(UInt64)) │ Tuple(Array(UInt8), Array(UInt8)) │
+ │ 2000-01-01 00:00:00 │ Tuple(Array(UInt8), Array(UInt64)) │ Tuple(Array(UInt8), Array(UInt8)) │
+ └─────────────────────┴──────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────┘
AggregateFunction/sumMapWithOverflow#1 [output] src/AggregateFunctions/AggregateFunctionSumMap.cpp
| SELECT
| timeslot,
| toTypeName(sumMap(statusMapTuple)),
| toTypeName(sumMapWithOverflow(statusMapTuple))
| FROM sum_map
| GROUP BY timeslot;
documented response:
- ┌────────────timeslot─┬─toTypeName(sumMap(statusMapTuple))─┬─toTypeName(sumMapWithOverflow(statusMapTuple))─┐
- │ 2000-01-01 00:00:00 │ Tuple(Array(Int8), Array(Int64)) │ Tuple(Array(Int8), Array(Int8)) │
- │ 2000-01-01 00:01:00 │ Tuple(Array(Int8), Array(Int64)) │ Tuple(Array(Int8), Array(Int8)) │
- └─────────────────────┴────────────────────────────────────┴────────────────────────────────────────────────┘
actual response:
+ ┌────────────timeslot─┬─toTypeName(sumMap(statusMapTuple))─┬─toTypeName(sumMapWithOverflow(statusMapTuple))─┐
+ │ 2000-01-01 00:01:00 │ Tuple(Array(Int8), Array(Int64)) │ Tuple(Array(Int8), Array(Int8)) │
+ │ 2000-01-01 00:00:00 │ Tuple(Array(Int8), Array(Int64)) │ Tuple(Array(Int8), Array(Int8)) │
+ └─────────────────────┴────────────────────────────────────┴────────────────────────────────────────────────┘
AggregateFunction/sumMappedArrays#0 [output] src/AggregateFunctions/AggregateFunctionSumMap.cpp
| CREATE TABLE sum_map(
| date Date,
| timeslot DateTime,
| statusMap Nested(
| status UInt16,
| requests UInt64
| ),
| statusMapTuple Tuple(Array(Int32), Array(Int32))
| ) ENGINE = Memory;
|
| INSERT INTO sum_map VALUES
| ('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10], ([1, 2, 3], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10], ([3, 4, 5], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10], ([4, 5, 6], [10, 10, 10])),
| ('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10], ([6, 7, 8], [10, 10, 10]));
|
| SELECT
| timeslot,
| sumMappedArrays(statusMap.status, statusMap.requests),
| sumMappedArrays(statusMapTuple)
| FROM sum_map
| GROUP BY timeslot;
documented response:
- ┌────────────timeslot─┬─sumMappedArrays(statusMap.status, statusMap.requests)─┬─sumMappedArrays(statusMapTuple)─┐
- │ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10]) │ ([1,2,3,4,5],[10,10,20,10,10]) │
- │ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10]) │ ([4,5,6,7,8],[10,10,20,10,10]) │
- └─────────────────────┴───────────────────────────────────────────────────────┴─────────────────────────────────┘
actual response:
+ ┌────────────timeslot─┬─sumMappedArrays(statusMap.status, statusMap.requests)─┬─sumMappedArrays(statusMapTuple)─┐
+ │ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10]) │ ([4,5,6,7,8],[10,10,20,10,10]) │
+ │ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10]) │ ([1,2,3,4,5],[10,10,20,10,10]) │
+ └─────────────────────┴───────────────────────────────────────────────────────┴─────────────────────────────────┘
Function/ULIDStringToDateTime#0 [output] src/Functions/ULIDStringToDateTime.cpp
| SELECT ULIDStringToDateTime('01GNB2S2FGN2P93QPXDNB4EN2R')
documented response:
- ┌─ULIDStringToDateTime('01GNB2S2FGN2P93QPXDNB4EN2R')─┐
- │ 2022-12-28 00:40:37.616 │
- └────────────────────────────────────────────────────┘
actual response:
+ ┌─ULIDStringToDateTime('01GNB2S2FGN2P93QPXDNB4EN2R')─┐
+ │ 2022-12-28 01:40:37.616 │
+ └────────────────────────────────────────────────────┘
Function/UUIDv7ToDateTime#0 [output] src/Functions/FunctionsCodingUUID.cpp
| SELECT UUIDv7ToDateTime(toUUID('018f05c9-4ab8-7b86-b64e-c9f03fbd45d1'))
documented response:
- ┌─UUIDv7ToDateTime(toUUID('018f05c9-4ab8-7b86-b64e-c9f03fbd45d1'))─┐
- │ 2024-04-22 12:30:29.048 │
- └──────────────────────────────────────────────────────────────────┘
actual response:
+ ┌─UUIDv7ToDateTime(toUUID('018f05c9-4ab8-7b86-b64e-c9f03fbd45d1'))─┐
+ │ 2024-04-22 14:30:29.048 │
+ └──────────────────────────────────────────────────────────────────┘
Function/cityHash64#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;
documented response:
- ┌─────────────CityHash─┬─type───┐
- │ 17177535963988450974 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌────────────CityHash─┬─type───┐
+ │ 6794535121701843825 │ UInt64 │
+ └─────────────────────┴────────┘
Function/dictGetDateTimeOrDefault#0 [output] src/Functions/FunctionsExternalDictionaries.cpp
| CREATE TABLE all_types_test (id UInt32, DateTime_value DateTime) ENGINE = MergeTree() ORDER BY id;
| INSERT INTO all_types_test VALUES (1, '2024-01-15 10:30:00');
| CREATE DICTIONARY all_types_dict (id UInt32, DateTime_value DateTime) PRIMARY KEY id SOURCE(CLICKHOUSE(TABLE 'all_types_test' DB currentDatabase())) LAYOUT(HASHED()) LIFETIME(MIN 300 MAX 600);
| -- for key which exists
| SELECT dictGetDateTime('all_types_dict', 'DateTime_value', 1);
|
| -- for key which does not exist, returns the provided default value
| SELECT dictGetDateTimeOrDefault('all_types_dict', 'DateTime_value', 999, toDateTime('1970-01-01 00:00:00'));
documented response:
- ┌─dictGetDateTime('all_types_dict', 'DateTime_value', 1)─┐
- │ 2024-01-15 10:30:00 │
- └────────────────────────────────────────────────────────┘
- ┌─dictGetDateTimeOrDefault('all_types_dict', 'DateTime_value', 999, toDateTime('1970-01-01 00:00:00'))─┐
- │ 1970-01-01 00:00:00 │
- └──────────────────────────────────────────────────────────────────────────────────────────────────────┘
actual response:
+ ┌─dictGetDateTime('all_types_dict', 'DateTime_value', 1)─┐
+ │ 2024-01-15 10:30:00 │
+ └────────────────────────────────────────────────────────┘
+ ┌─dictGetDateTimeOrDefault('all_types_dict', 'DateTime_value', 999, toDateTime('1970-01-01 00:00:00'))─┐
+ │ 1970-01-01 01:00:00 │
+ └──────────────────────────────────────────────────────────────────────────────────────────────────────┘
Function/emptyArrayToSingle#0 [output] src/Functions/array/emptyArrayToSingle.cpp
| CREATE TABLE test (
| a Array(Int32),
| b Array(String),
| c Array(DateTime)
| )
| ENGINE = MergeTree
| ORDER BY tuple();
|
| INSERT INTO test VALUES ([], [], []);
|
| SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;
documented response:
- ┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
- │ [0] │ [''] │ ['1970-01-01 00:00:00'] │
- └───────────────────────┴───────────────────────┴─────────────────────────┘
actual response:
+ ┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
+ │ [0] │ [''] │ ['1970-01-01 01:00:00'] │
+ └───────────────────────┴───────────────────────┴─────────────────────────┘
Function/farmFingerprint64#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;
documented response:
- ┌──────FarmFingerprint─┬─type───┐
- │ 16673609057812504858 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌─────FarmFingerprint─┬─type───┐
+ │ 5752020380710916328 │ UInt64 │
+ └─────────────────────┴────────┘
Function/farmHash64#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
documented response:
- ┌────────────FarmHash─┬─type───┐
- │ 2663412879246289891 │ UInt64 │
- └─────────────────────┴────────┘
actual response:
+ ┌─────────────FarmHash─┬─type───┐
+ │ 18125596431186471178 │ UInt64 │
+ └──────────────────────┴────────┘
Function/fromUnixTimestamp#0 [output] src/Functions/formatDateTime.cpp
| SELECT fromUnixTimestamp(423543535)
documented response:
- ┌─fromUnixTimestamp(423543535)─┐
- │ 1983-06-04 02:58:55 │
- └──────────────────────────────┘
actual response:
+ ┌─fromUnixTimestamp(423543535)─┐
+ │ 1983-06-04 04:58:55 │
+ └──────────────────────────────┘
Function/fromUnixTimestamp#1 [output] src/Functions/formatDateTime.cpp
| SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
documented response:
- ┌─DateTime────────────┐
- │ 2009-02-11 06:42:23 │
- └─────────────────────┘
actual response:
+ ┌─DateTime────────────┐
+ │ 2009-02-11 07:42:23 │
+ └─────────────────────┘
Function/fromUnixTimestamp64Micro#0 [output] src/Functions/fromUnixTimestamp64Micro.cpp
| SELECT fromUnixTimestamp64Micro(1640995200123456)
documented response:
- ┌─fromUnixTimestamp64Micro(1640995200123456)─┐
- │ 2022-01-01 00:00:00.123456 │
- └────────────────────────────────────────────┘
actual response:
+ ┌─fromUnixTimestamp64Micro(1640995200123456)─┐
+ │ 2022-01-01 01:00:00.123456 │
+ └────────────────────────────────────────────┘
Function/fromUnixTimestamp64Milli#0 [output] src/Functions/fromUnixTimestamp64Milli.cpp
| SELECT fromUnixTimestamp64Milli(1640995200123)
documented response:
- ┌─fromUnixTimestamp64Milli(1640995200123)─┐
- │ 2022-01-01 00:00:00.123 │
- └─────────────────────────────────────────┘
actual response:
+ ┌─fromUnixTimestamp64Milli(1640995200123)─┐
+ │ 2022-01-01 01:00:00.123 │
+ └─────────────────────────────────────────┘
Function/fromUnixTimestamp64Nano#0 [output] src/Functions/fromUnixTimestamp64Nano.cpp
| SELECT fromUnixTimestamp64Nano(1640995200123456789)
documented response:
- ┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
- │ 2022-01-01 00:00:00.123456789 │
- └──────────────────────────────────────────────┘
actual response:
+ ┌─fromUnixTimestamp64Nano(1640995200123456789)─┐
+ │ 2022-01-01 01:00:00.123456789 │
+ └──────────────────────────────────────────────┘
Function/fromUnixTimestamp64Second#0 [output] src/Functions/fromUnixTimestamp64Second.cpp
| SELECT fromUnixTimestamp64Second(1640995200)
documented response:
- ┌─fromUnixTimestamp64Second(1640995200)─┐
- │ 2022-01-01 00:00:00 │
- └───────────────────────────────────────┘
actual response:
+ ┌─fromUnixTimestamp64Second(1640995200)─┐
+ │ 2022-01-01 01:00:00 │
+ └───────────────────────────────────────┘
Function/getOSKernelVersion#0 [output] src/Functions/serverConstants.cpp
| SELECT getOSKernelVersion();
documented response:
- ┌─getOSKernelVersion()─┐
- │ Linux 7.0.0-1004-aws │
- └──────────────────────┘
actual response:
+ ┌─getOSKernelVersion()─┐
+ │ Linux 6.8.0-1055-aws │
+ └──────────────────────┘
Function/kafkaMurmurHash#0 [output] src/Functions/FunctionsHashingMurmur.cpp
| SELECT
| kafkaMurmurHash('foobar') AS res1,
| kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2
documented response:
- ┌───────res1─┬─────res2─┐
- │ 1357151166 │ 85479775 │
- └────────────┴──────────┘
actual response:
+ ┌───────res1─┬───res2─┐
+ │ 1357151166 │ 501558 │
+ └────────────┴────────┘
Function/metroHash64#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;
documented response:
- ┌────────────MetroHash─┬─type───┐
- │ 16292826582821303855 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌───────────MetroHash─┬─type───┐
+ │ 1714322551790756514 │ UInt64 │
+ └─────────────────────┴────────┘
Function/murmurHash2_32#0 [output] src/Functions/FunctionsHashingMurmur.cpp
| SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
documented response:
- ┌─MurmurHash2─┬─type───┐
- │ 2947095100 │ UInt32 │
- └─────────────┴────────┘
actual response:
+ ┌─MurmurHash2─┬─type───┐
+ │ 2617687781 │ UInt32 │
+ └─────────────┴────────┘
Function/murmurHash2_64#0 [output] src/Functions/FunctionsHashingMurmur.cpp
| SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
documented response:
- ┌──────────MurmurHash2─┬─type───┐
- │ 16479669305841206229 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌─────────MurmurHash2─┬─type───┐
+ │ 6016270718763512692 │ UInt64 │
+ └─────────────────────┴────────┘
Function/murmurHash3_32#0 [output] src/Functions/FunctionsHashingMurmur.cpp
| SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
documented response:
- ┌─MurmurHash3─┬─type───┐
- │ 317985299 │ UInt32 │
- └─────────────┴────────┘
actual response:
+ ┌─MurmurHash3─┬─type───┐
+ │ 71298094 │ UInt32 │
+ └─────────────┴────────┘
Function/murmurHash3_64#0 [output] src/Functions/FunctionsHashingMurmur.cpp
| SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
documented response:
- ┌──────────MurmurHash3─┬─type───┐
- │ 11285022984631508790 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌──────────MurmurHash3─┬─type───┐
+ │ 10279449592232202710 │ UInt64 │
+ └──────────────────────┴────────┘
Function/parseDateTime32BestEffort#2 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTime32BestEffort('1284101485')
| AS parseDateTime32BestEffort
documented response:
- ┌─parseDateTime32BestEffort─┐
- │ 2010-09-10 06:51:25 │
- └───────────────────────────┘
actual response:
+ ┌─parseDateTime32BestEffort─┐
+ │ 2010-09-10 08:51:25 │
+ └───────────────────────────┘
Function/parseDateTime32BestEffortOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT
| parseDateTime32BestEffortOrZero('23/10/2025 12:12:57') AS valid,
| parseDateTime32BestEffortOrZero('invalid date') AS invalid
documented response:
- ┌───────────────valid─┬─────────────invalid─┐
- │ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
- └─────────────────────┴─────────────────────┘
actual response:
+ ┌───────────────valid─┬─────────────invalid─┐
+ │ 2025-10-23 12:12:57 │ 1970-01-01 01:00:00 │
+ └─────────────────────┴─────────────────────┘
Function/parseDateTime64BestEffortOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTime64BestEffortOrZero('2025-01-01 01:01:00.123') AS valid,
| parseDateTime64BestEffortOrZero('invalid') AS invalid
documented response:
- ┌───────────────────valid─┬─────────────────invalid─┐
- │ 2025-01-01 01:01:00.123 │ 1970-01-01 00:00:00.000 │
- └─────────────────────────┴─────────────────────────┘
actual response:
+ ┌───────────────────valid─┬─────────────────invalid─┐
+ │ 2025-01-01 01:01:00.123 │ 1970-01-01 01:00:00.000 │
+ └─────────────────────────┴─────────────────────────┘
Function/parseDateTime64BestEffortUSOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTime64BestEffortUSOrZero('02/10/2025 12:30:45.123') AS valid_us,
| parseDateTime64BestEffortUSOrZero('invalid') AS invalid
documented response:
- ┌────────────────valid_us─┬─────────────────invalid─┐
- │ 2025-02-10 12:30:45.123 │ 1970-01-01 00:00:00.000 │
- └─────────────────────────┴─────────────────────────┘
actual response:
+ ┌────────────────valid_us─┬─────────────────invalid─┐
+ │ 2025-02-10 12:30:45.123 │ 1970-01-01 01:00:00.000 │
+ └─────────────────────────┴─────────────────────────┘
Function/parseDateTimeBestEffort#2 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTimeBestEffort('1735689600') AS parseDateTimeBestEffort
documented response:
- ┌─parseDateTimeBestEffort─┐
- │ 2025-01-01 00:00:00 │
- └─────────────────────────┘
actual response:
+ ┌─parseDateTimeBestEffort─┐
+ │ 2025-01-01 01:00:00 │
+ └─────────────────────────┘
Function/parseDateTimeBestEffortOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTimeBestEffortOrZero('23/10/2025 12:12:57') AS valid,
| parseDateTimeBestEffortOrZero('invalid') AS invalid
documented response:
- ┌───────────────valid─┬─────────────invalid─┐
- │ 2025-10-23 12:12:57 │ 1970-01-01 00:00:00 │
- └─────────────────────┴─────────────────────┘
actual response:
+ ┌───────────────valid─┬─────────────invalid─┐
+ │ 2025-10-23 12:12:57 │ 1970-01-01 01:00:00 │
+ └─────────────────────┴─────────────────────┘
Function/parseDateTimeBestEffortUSOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT parseDateTimeBestEffortUSOrZero('02/10/2025') AS valid_us,
| parseDateTimeBestEffortUSOrZero('invalid') AS invalid
documented response:
- ┌────────────valid_us─┬─────────────invalid─┐
- │ 2025-02-10 00:00:00 │ 1970-01-01 00:00:00 │
- └─────────────────────┴─────────────────────┘
actual response:
+ ┌────────────valid_us─┬─────────────invalid─┐
+ │ 2025-02-10 00:00:00 │ 1970-01-01 01:00:00 │
+ └─────────────────────┴─────────────────────┘
Function/reinterpretAsDateTime#0 [output] src/Functions/reinterpretAs.cpp
| SELECT reinterpretAsDateTime(65), reinterpretAsDateTime('A')
documented response:
- ┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
- │ 1970-01-01 00:01:05 │ 1970-01-01 00:01:05 │
- └───────────────────────────┴────────────────────────────┘
actual response:
+ ┌─reinterpretAsDateTime(65)─┬─reinterpretAsDateTime('A')─┐
+ │ 1970-01-01 01:01:05 │ 1970-01-01 01:01:05 │
+ └───────────────────────────┴────────────────────────────┘
Function/serverTimezone#0 [output] src/Functions/serverConstants.cpp
| SELECT serverTimeZone()
documented response:
- ┌─serverTimeZone()─┐
- │ Etc/UTC │
- └──────────────────┘
actual response:
+ ┌─serverTimeZone()─┐
+ │ Europe/Amsterdam │
+ └──────────────────┘
Function/sipHash64#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
documented response:
- ┌──────────────SipHash─┬─type───┐
- │ 11348918044846389429 │ UInt64 │
- └──────────────────────┴────────┘
actual response:
+ ┌──────────────SipHash─┬─type───┐
+ │ 11400366955626497465 │ UInt64 │
+ └──────────────────────┴────────┘
Function/sipHash64Keyed#0 [output] src/Functions/FunctionsHashingMisc.cpp
| SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
documented response:
- ┌─────────────SipHash─┬─type───┐
- │ 8194087499447867747 │ UInt64 │
- └─────────────────────┴────────┘
actual response:
+ ┌─────────────SipHash─┬─type───┐
+ │ 8017656310194184311 │ UInt64 │
+ └─────────────────────┴────────┘
Function/snowflakeIDToDateTime#0 [output] src/Functions/snowflakeIDToDateTime.cpp
| SELECT snowflakeIDToDateTime(7204436857747984384) AS res
documented response:
- ┌─────────────────res─┐
- │ 2024-06-06 10:59:58 │
- └─────────────────────┘
actual response:
+ ┌─────────────────res─┐
+ │ 2024-06-06 12:59:58 │
+ └─────────────────────┘
Function/snowflakeIDToDateTime64#0 [output] src/Functions/snowflakeIDToDateTime.cpp
| SELECT snowflakeIDToDateTime64(7204436857747984384) AS res
documented response:
- ┌─────────────────────res─┐
- │ 2024-06-06 10:59:58.851 │
- └─────────────────────────┘
actual response:
+ ┌─────────────────────res─┐
+ │ 2024-06-06 12:59:58.851 │
+ └─────────────────────────┘
Function/timezoneOf#0 [output] src/Functions/timezoneOf.cpp
| SELECT timezoneOf(now());
documented response:
- ┌─timezoneOf(now())─┐
- │ Etc/UTC │
- └───────────────────┘
actual response:
+ ┌─timezoneOf(now())─┐
+ │ Europe/Amsterdam │
+ └───────────────────┘
Function/toDateTime64#1 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT toDateTime64(1546300800.000, 3) AS value, toTypeName(value);
| -- Without the decimal point the value is still treated as Unix Timestamp in seconds
| SELECT toDateTime64(1546300800000, 3) AS value, toTypeName(value);
documented response:
- ┌───────────────────value─┬─toTypeName(value)─┐
- │ 2019-01-01 00:00:00.000 │ DateTime64(3) │
- └─────────────────────────┴───────────────────┘
- ┌───────────────────value─┬─toTypeName(value)─┐
- │ 9999-12-31 23:59:59.000 │ DateTime64(3) │
- └─────────────────────────┴───────────────────┘
actual response:
+ ┌───────────────────value─┬─toTypeName(value)─┐
+ │ 2019-01-01 01:00:00.000 │ DateTime64(3) │
+ └─────────────────────────┴───────────────────┘
+ ┌───────────────────value─┬─toTypeName(value)─┐
+ │ 9999-12-31 23:59:59.000 │ DateTime64(3) │
+ └─────────────────────────┴───────────────────┘
Function/toDateTime64OrDefault#1 [output] src/Functions/castOrDefault.cpp
| SELECT toDateTime64OrDefault('1976-10-18 00:00:00 30', 3, 'UTC', toDateTime64('2001-01-01 00:00:00.00',3))
documented response:
- 2001-01-01 00:00:00.000
actual response:
+ 2000-12-31 23:00:00.000
Function/toDateTime64OrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT toDateTime64OrZero('2025-12-30 13:44:17.123'), toDateTime64OrZero('invalid')
documented response:
- ┌─toDateTime64OrZero('2025-12-30 13:44:17.123')─┬─toDateTime64OrZero('invalid')─┐
- │ 2025-12-30 13:44:17.123 │ 1970-01-01 00:00:00.000 │
- └───────────────────────────────────────────────┴───────────────────────────────┘
actual response:
+ ┌─toDateTime64OrZero('2025-12-30 13:44:17.123')─┬─toDateTime64OrZero('invalid')─┐
+ │ 2025-12-30 13:44:17.123 │ 1970-01-01 01:00:00.000 │
+ └───────────────────────────────────────────────┴───────────────────────────────┘
Function/toDateTimeOrZero#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT toDateTimeOrZero('2025-12-30 13:44:17'), toDateTimeOrZero('invalid')
documented response:
- ┌─toDateTimeOrZero('2025-12-30 13:44:17')─┬─toDateTimeOrZero('invalid')─┐
- │ 2025-12-30 13:44:17 │ 1970-01-01 00:00:00 │
- └─────────────────────────────────────────┴─────────────────────────────┘
actual response:
+ ┌─toDateTimeOrZero('2025-12-30 13:44:17')─┬─toDateTimeOrZero('invalid')─┐
+ │ 2025-12-30 13:44:17 │ 1970-01-01 01:00:00 │
+ └─────────────────────────────────────────┴─────────────────────────────┘
Function/toStartOfMicrosecond#1 [output] src/Functions/toStartOfSubsecond.cpp
| WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
| SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
documented response:
- ┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
- │ 2020-01-01 13:20:30.999999000 │
- └─────────────────────────────────────────────┘
actual response:
+ ┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
+ │ 2020-01-01 12:20:30.999999000 │
+ └─────────────────────────────────────────────┘
Function/toStartOfMillisecond#1 [output] src/Functions/toStartOfSubsecond.cpp
| WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
| SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
documented response:
- ┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
- │ 2020-01-01 13:20:30.999000000 │
- └─────────────────────────────────────────────┘
actual response:
+ ┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
+ │ 2020-01-01 12:20:30.999000000 │
+ └─────────────────────────────────────────────┘
Function/toStartOfNanosecond#1 [output] src/Functions/toStartOfSubsecond.cpp
| WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
| SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
documented response:
- ┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
- │ 2020-01-01 13:20:30.999999999 │
- └────────────────────────────────────────────┘
actual response:
+ ┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
+ │ 2020-01-01 12:20:30.999999999 │
+ └────────────────────────────────────────────┘
Function/toStartOfSecond#1 [output] src/Functions/toStartOfSecond.cpp
| WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
| SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
documented response:
- ┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
- │ 2020-01-01 13:20:30.000 │
- └────────────────────────────────────────┘
actual response:
+ ┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
+ │ 2020-01-01 12:20:30.000 │
+ └────────────────────────────────────────┘
Function/toUnixTimestamp#0 [output] src/Functions/FunctionsConversion_reg.cpp
| SELECT
| '2017-11-05 08:07:47' AS dt_str,
| toUnixTimestamp(dt_str) AS from_str,
| toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
| toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
| toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
| toUnixTimestamp(toDate(dt_str)) AS from_date,
| toUnixTimestamp(toDate32(dt_str)) AS from_date32
| FORMAT Vertical;
documented response:
- Row 1:
- ──────
- dt_str: 2017-11-05 08:07:47
- from_str: 1509869267
- from_str_tokyo: 1509836867
- from_datetime: 1509869267
- from_datetime64: 1509869267
- from_date: 1509840000
- from_date32: 1509840000
actual response:
+ Row 1:
+ ──────
+ dt_str: 2017-11-05 08:07:47
+ from_str: 1509865667
+ from_str_tokyo: 1509836867
+ from_datetime: 1509865667
+ from_datetime64: 1509865667
+ from_date: 1509840000
+ from_date32: 1509840000
2 example(s) now pass and must be removed from tests/docs_examples/known_failures.txt:
Function/reinterpretAsString#0
Function/timezone#0