From a66d7607cf73b15d6a0dba0c75f7d47d76e41e57 Mon Sep 17 00:00:00 2001 From: Andy Grove Date: Thu, 12 Nov 2026 17:41:05 -0700 Subject: [PATCH 1/2] test: replace arrow_cast with :: casts where a SQL type is equivalent Rewrite arrow_cast(x, 'T') as x::SQLTYPE in the sqllogictest files when DataFusion maps the SQL type to exactly the same Arrow type and Spark accepts the type name: Int8/16/32/64, Float32/64, Boolean, Binary, Date32, Utf8View (STRING), Decimal128(p, s) with p <= 38 and List(Int32) (ARRAY). Negative literals and expressions are parenthesized because :: binds tighter than unary minus. arrow_cast is kept for Utf8 (STRING maps to Utf8View), unsigned integers, timestamps with a precision or time zone, and Arrow types without a SQL name. Spark has no arrow_cast, so the PySpark runner can now run these queries instead of skipping them. --- .../sqllogictest/test_files/array/shuffle.slt | 2 +- .../test_files/bitmap/bitmap_bit_position.slt | 38 ++--- .../bitmap/bitmap_bucket_number.slt | 42 ++--- .../test_files/bitwise/bit_count.slt | 42 ++--- .../test_files/bitwise/bitwise_not.slt | 50 +++--- .../test_files/bitwise/shiftright.slt | 20 +-- .../test_files/bitwise/shiftrightunsigned.slt | 16 +- .../test_files/collection/size.slt | 4 +- .../conversion/cast_float_to_timestamp.slt | 28 ++-- .../conversion/cast_int_to_timestamp.slt | 34 ++-- .../test_files/datetime/date_add.slt | 4 +- .../test_files/datetime/date_sub.slt | 4 +- .../test_files/datetime/make_interval.slt | 2 +- .../test_files/datetime/next_day.slt | 10 +- .../sqllogictest/test_files/datetime/unix.slt | 2 +- .../test_files/generator/stack.slt | 2 +- crates/sqllogictest/test_files/hash/crc32.slt | 8 +- crates/sqllogictest/test_files/hash/sha.slt | 4 +- crates/sqllogictest/test_files/hash/sha1.slt | 6 +- crates/sqllogictest/test_files/hash/sha2.slt | 4 +- .../sqllogictest/test_files/hash/xxhash64.slt | 20 +-- crates/sqllogictest/test_files/math/bin.slt | 20 +-- crates/sqllogictest/test_files/math/csc.slt | 2 +- crates/sqllogictest/test_files/math/floor.slt | 26 +-- crates/sqllogictest/test_files/math/hex.slt | 2 +- crates/sqllogictest/test_files/math/mod.slt | 6 +- .../sqllogictest/test_files/math/negative.slt | 2 +- crates/sqllogictest/test_files/math/pmod.slt | 8 +- crates/sqllogictest/test_files/math/rint.slt | 10 +- crates/sqllogictest/test_files/math/round.slt | 22 +-- crates/sqllogictest/test_files/math/sec.slt | 2 +- .../test_files/math/shiftleft.slt | 16 +- crates/sqllogictest/test_files/math/unhex.slt | 2 +- .../test_files/math/width_bucket.slt | 6 +- .../test_files/predicate/ilike.slt | 2 +- .../test_files/predicate/like.slt | 2 +- .../sqllogictest/test_files/string/concat.slt | 12 +- .../test_files/string/concat_ws.slt | 2 +- .../sqllogictest/test_files/string/encode.slt | 4 +- .../test_files/string/find_in_set.slt | 4 +- .../test_files/string/format_string.slt | 154 +++++++++--------- .../test_files/string/is_valid_utf8.slt | 58 +++---- .../test_files/string/make_valid_utf8.slt | 24 +-- .../sqllogictest/test_files/string/quote.slt | 28 ++-- .../test_files/string/soundex.slt | 6 +- .../test_files/string/substring.slt | 54 +++--- .../test_files/url/try_url_decode.slt | 2 +- .../test_files/url/url_decode.slt | 2 +- .../test_files/url/url_encode.slt | 2 +- 49 files changed, 411 insertions(+), 411 deletions(-) diff --git a/crates/sqllogictest/test_files/array/shuffle.slt b/crates/sqllogictest/test_files/array/shuffle.slt index 018a6a1e..5e0d785d 100644 --- a/crates/sqllogictest/test_files/array/shuffle.slt +++ b/crates/sqllogictest/test_files/array/shuffle.slt @@ -34,7 +34,7 @@ NULL # Typed null lists have no child values to shuffle. query ?? -SELECT shuffle(arrow_cast(NULL, 'List(Int32)')), shuffle(arrow_cast(NULL, 'LargeList(Int32)')); +SELECT shuffle(NULL::ARRAY), shuffle(arrow_cast(NULL, 'LargeList(Int32)')); ---- NULL NULL diff --git a/crates/sqllogictest/test_files/bitmap/bitmap_bit_position.slt b/crates/sqllogictest/test_files/bitmap/bitmap_bit_position.slt index 072f07e3..a137dcbf 100644 --- a/crates/sqllogictest/test_files/bitmap/bitmap_bit_position.slt +++ b/crates/sqllogictest/test_files/bitmap/bitmap_bit_position.slt @@ -3,96 +3,96 @@ # SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements query I -SELECT bitmap_bit_position(arrow_cast(1, 'Int8')); +SELECT bitmap_bit_position(1::TINYINT); ---- 0 query I -SELECT bitmap_bit_position(arrow_cast(3, 'Int8')); +SELECT bitmap_bit_position(3::TINYINT); ---- 2 query I -SELECT bitmap_bit_position(arrow_cast(7, 'Int8')); +SELECT bitmap_bit_position(7::TINYINT); ---- 6 query I -SELECT bitmap_bit_position(arrow_cast(15, 'Int8')); +SELECT bitmap_bit_position(15::TINYINT); ---- 14 query I -SELECT bitmap_bit_position(arrow_cast(-1, 'Int8')); +SELECT bitmap_bit_position((-1)::TINYINT); ---- 1 query I -SELECT bitmap_bit_position(arrow_cast(256, 'Int16')); +SELECT bitmap_bit_position(256::SMALLINT); ---- 255 query I -SELECT bitmap_bit_position(arrow_cast(1024, 'Int16')); +SELECT bitmap_bit_position(1024::SMALLINT); ---- 1023 query I -SELECT bitmap_bit_position(arrow_cast(-32768, 'Int16')); +SELECT bitmap_bit_position((-32768)::SMALLINT); ---- 0 query I -SELECT bitmap_bit_position(arrow_cast(16384, 'Int16')); +SELECT bitmap_bit_position(16384::SMALLINT); ---- 16383 query I -SELECT bitmap_bit_position(arrow_cast(-1, 'Int16')); +SELECT bitmap_bit_position((-1)::SMALLINT); ---- 1 query I -SELECT bitmap_bit_position(arrow_cast(65536, 'Int32')); +SELECT bitmap_bit_position(65536::INT); ---- 32767 query I -SELECT bitmap_bit_position(arrow_cast(1048576, 'Int32')); +SELECT bitmap_bit_position(1048576::INT); ---- 32767 query I -SELECT bitmap_bit_position(arrow_cast(-2147483648, 'Int32')); +SELECT bitmap_bit_position((-2147483648)::INT); ---- 0 query I -SELECT bitmap_bit_position(arrow_cast(1073741824, 'Int32')); +SELECT bitmap_bit_position(1073741824::INT); ---- 32767 query I -SELECT bitmap_bit_position(arrow_cast(-1, 'Int32')); +SELECT bitmap_bit_position((-1)::INT); ---- 1 query I -SELECT bitmap_bit_position(arrow_cast(4294967296, 'Int64')); +SELECT bitmap_bit_position(4294967296::BIGINT); ---- 32767 query I -SELECT bitmap_bit_position(arrow_cast(-1, 'Int64')); +SELECT bitmap_bit_position((-1)::BIGINT); ---- 1 query I -SELECT bitmap_bit_position(arrow_cast(-9223372036854775808, 'Int64')); +SELECT bitmap_bit_position((-9223372036854775808)::BIGINT); ---- 0 query I -SELECT bitmap_bit_position(arrow_cast(9223372036854775807, 'Int64')); +SELECT bitmap_bit_position(9223372036854775807::BIGINT); ---- 32766 diff --git a/crates/sqllogictest/test_files/bitmap/bitmap_bucket_number.slt b/crates/sqllogictest/test_files/bitmap/bitmap_bucket_number.slt index 34b13e26..f988cb34 100644 --- a/crates/sqllogictest/test_files/bitmap/bitmap_bucket_number.slt +++ b/crates/sqllogictest/test_files/bitmap/bitmap_bucket_number.slt @@ -3,106 +3,106 @@ # SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements query I -SELECT bitmap_bucket_number(arrow_cast(1, 'Int8')); +SELECT bitmap_bucket_number(1::TINYINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(127, 'Int8')); +SELECT bitmap_bucket_number(127::TINYINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(-1, 'Int8')); +SELECT bitmap_bucket_number((-1)::TINYINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(-64, 'Int8')); +SELECT bitmap_bucket_number((-64)::TINYINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(-65, 'Int8')); +SELECT bitmap_bucket_number((-65)::TINYINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(1, 'Int16')); +SELECT bitmap_bucket_number(1::SMALLINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(257, 'Int16')); +SELECT bitmap_bucket_number(257::SMALLINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(32767, 'Int16')); +SELECT bitmap_bucket_number(32767::SMALLINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(-1, 'Int16')); +SELECT bitmap_bucket_number((-1)::SMALLINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(-256, 'Int16')); +SELECT bitmap_bucket_number((-256)::SMALLINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(1, 'Int32')); +SELECT bitmap_bucket_number(1::INT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(65537, 'Int32')); +SELECT bitmap_bucket_number(65537::INT); ---- 3 query I -SELECT bitmap_bucket_number(arrow_cast(2147483647, 'Int32')); +SELECT bitmap_bucket_number(2147483647::INT); ---- 65536 query I -SELECT bitmap_bucket_number(arrow_cast(-1, 'Int32')); +SELECT bitmap_bucket_number((-1)::INT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(-65536, 'Int32')); +SELECT bitmap_bucket_number((-65536)::INT); ---- -2 query I -SELECT bitmap_bucket_number(arrow_cast(1, 'Int64')); +SELECT bitmap_bucket_number(1::BIGINT); ---- 1 query I -SELECT bitmap_bucket_number(arrow_cast(4294967297, 'Int64')); +SELECT bitmap_bucket_number(4294967297::BIGINT); ---- 131073 query I -SELECT bitmap_bucket_number(arrow_cast(9223372036854775807, 'Int64')); +SELECT bitmap_bucket_number(9223372036854775807::BIGINT); ---- 281474976710656 query I -SELECT bitmap_bucket_number(arrow_cast(-1, 'Int64')); +SELECT bitmap_bucket_number((-1)::BIGINT); ---- 0 query I -SELECT bitmap_bucket_number(arrow_cast(-4294967296, 'Int64')); +SELECT bitmap_bucket_number((-4294967296)::BIGINT); ---- -131072 query I -SELECT bitmap_bucket_number(arrow_cast(-9223372036854775808, 'Int64')); +SELECT bitmap_bucket_number((-9223372036854775808)::BIGINT); ---- -281474976710656 diff --git a/crates/sqllogictest/test_files/bitwise/bit_count.slt b/crates/sqllogictest/test_files/bitwise/bit_count.slt index c86ed8df..380c2086 100644 --- a/crates/sqllogictest/test_files/bitwise/bit_count.slt +++ b/crates/sqllogictest/test_files/bitwise/bit_count.slt @@ -60,47 +60,47 @@ SELECT bit_count(-3::int); # Tests with different integer types query I -SELECT bit_count(arrow_cast(0, 'Int8')); +SELECT bit_count(0::TINYINT); ---- 0 query I -SELECT bit_count(arrow_cast(15, 'Int8')); +SELECT bit_count(15::TINYINT); ---- 4 query I -SELECT bit_count(arrow_cast(-1, 'Int8')); +SELECT bit_count((-1)::TINYINT); ---- 64 query I -SELECT bit_count(arrow_cast(0, 'Int16')); +SELECT bit_count(0::SMALLINT); ---- 0 query I -SELECT bit_count(arrow_cast(255, 'Int16')); +SELECT bit_count(255::SMALLINT); ---- 8 query I -SELECT bit_count(arrow_cast(-1, 'Int16')); +SELECT bit_count((-1)::SMALLINT); ---- 64 query I -SELECT bit_count(arrow_cast(0, 'Int64')); +SELECT bit_count(0::BIGINT); ---- 0 query I -SELECT bit_count(arrow_cast(255, 'Int64')); +SELECT bit_count(255::BIGINT); ---- 8 query I -SELECT bit_count(arrow_cast(-1, 'Int64')); +SELECT bit_count((-1)::BIGINT); ---- 64 @@ -147,12 +147,12 @@ SELECT bit_count(arrow_cast(18446744073709551615, 'UInt64')); # Tests with NULL values query I -SELECT bit_count(arrow_cast(NULL, 'Int32')); +SELECT bit_count(NULL::INT); ---- NULL query I -SELECT bit_count(arrow_cast(NULL, 'Int8')); +SELECT bit_count(NULL::TINYINT); ---- NULL @@ -163,53 +163,53 @@ NULL # Tests with edge cases query I -SELECT bit_count(arrow_cast(0, 'Int32')) as zero_count; +SELECT bit_count(0::INT) as zero_count; ---- 0 query I -SELECT bit_count(arrow_cast(1, 'Int32')) as one_count; +SELECT bit_count(1::INT) as one_count; ---- 1 query I -SELECT bit_count(arrow_cast(2, 'Int32')) as two_count; +SELECT bit_count(2::INT) as two_count; ---- 1 query I -SELECT bit_count(arrow_cast(3, 'Int32')) as three_count; +SELECT bit_count(3::INT) as three_count; ---- 2 query I -SELECT bit_count(arrow_cast(4, 'Int32')) as four_count; +SELECT bit_count(4::INT) as four_count; ---- 1 query I -SELECT bit_count(arrow_cast(5, 'Int32')) as five_count; +SELECT bit_count(5::INT) as five_count; ---- 2 # Tests with large numbers query I -SELECT bit_count(arrow_cast(2147483647, 'Int32')); +SELECT bit_count(2147483647::INT); ---- 31 query I -SELECT bit_count(arrow_cast(-2147483648, 'Int32')); +SELECT bit_count((-2147483648)::INT); ---- 33 query I -SELECT bit_count(arrow_cast(9223372036854775807, 'Int64')); +SELECT bit_count(9223372036854775807::BIGINT); ---- 63 query I -SELECT bit_count(arrow_cast(-9223372036854775808, 'Int64')); +SELECT bit_count((-9223372036854775808)::BIGINT); ---- 1 diff --git a/crates/sqllogictest/test_files/bitwise/bitwise_not.slt b/crates/sqllogictest/test_files/bitwise/bitwise_not.slt index cf1bdb25..03d83a49 100644 --- a/crates/sqllogictest/test_files/bitwise/bitwise_not.slt +++ b/crates/sqllogictest/test_files/bitwise/bitwise_not.slt @@ -60,129 +60,129 @@ SELECT bitwise_not(-3::int); # Tests with different integer types query I -SELECT bitwise_not(arrow_cast(0, 'Int8')); +SELECT bitwise_not(0::TINYINT); ---- -1 query I -SELECT bitwise_not(arrow_cast(15, 'Int8')); +SELECT bitwise_not(15::TINYINT); ---- -16 query I -SELECT bitwise_not(arrow_cast(-1, 'Int8')); +SELECT bitwise_not((-1)::TINYINT); ---- 0 query I -SELECT bitwise_not(arrow_cast(0, 'Int16')); +SELECT bitwise_not(0::SMALLINT); ---- -1 query I -SELECT bitwise_not(arrow_cast(255, 'Int16')); +SELECT bitwise_not(255::SMALLINT); ---- -256 query I -SELECT bitwise_not(arrow_cast(-1, 'Int16')); +SELECT bitwise_not((-1)::SMALLINT); ---- 0 query I -SELECT bitwise_not(arrow_cast(0, 'Int32')); +SELECT bitwise_not(0::INT); ---- -1 query I -SELECT bitwise_not(arrow_cast(255, 'Int32')); +SELECT bitwise_not(255::INT); ---- -256 query I -SELECT bitwise_not(arrow_cast(-1, 'Int32')); +SELECT bitwise_not((-1)::INT); ---- 0 query I -SELECT bitwise_not(arrow_cast(0, 'Int64')); +SELECT bitwise_not(0::BIGINT); ---- -1 query I -SELECT bitwise_not(arrow_cast(255, 'Int64')); +SELECT bitwise_not(255::BIGINT); ---- -256 query I -SELECT bitwise_not(arrow_cast(-1, 'Int64')); +SELECT bitwise_not((-1)::BIGINT); ---- 0 # Tests with NULL values query I -SELECT bitwise_not(arrow_cast(NULL, 'Int32')); +SELECT bitwise_not(NULL::INT); ---- NULL query I -SELECT bitwise_not(arrow_cast(NULL, 'Int8')); +SELECT bitwise_not(NULL::TINYINT); ---- NULL query I -SELECT bitwise_not(arrow_cast(NULL, 'Int64')); +SELECT bitwise_not(NULL::BIGINT); ---- NULL # Tests with edge cases query I -SELECT bitwise_not(arrow_cast(0, 'Int32')) as zero_not; +SELECT bitwise_not(0::INT) as zero_not; ---- -1 query I -SELECT bitwise_not(arrow_cast(1, 'Int32')) as one_not; +SELECT bitwise_not(1::INT) as one_not; ---- -2 query I -SELECT bitwise_not(arrow_cast(2, 'Int32')) as two_not; +SELECT bitwise_not(2::INT) as two_not; ---- -3 query I -SELECT bitwise_not(arrow_cast(3, 'Int32')) as three_not; +SELECT bitwise_not(3::INT) as three_not; ---- -4 query I -SELECT bitwise_not(arrow_cast(4, 'Int32')) as four_not; +SELECT bitwise_not(4::INT) as four_not; ---- -5 query I -SELECT bitwise_not(arrow_cast(5, 'Int32')) as five_not; +SELECT bitwise_not(5::INT) as five_not; ---- -6 # Tests with large numbers query I -SELECT bitwise_not(arrow_cast(2147483647, 'Int32')); +SELECT bitwise_not(2147483647::INT); ---- -2147483648 query I -SELECT bitwise_not(arrow_cast(-2147483648, 'Int32')); +SELECT bitwise_not((-2147483648)::INT); ---- 2147483647 query I -SELECT bitwise_not(arrow_cast(9223372036854775807, 'Int64')); +SELECT bitwise_not(9223372036854775807::BIGINT); ---- -9223372036854775808 query I -SELECT bitwise_not(arrow_cast(-9223372036854775808, 'Int64')); +SELECT bitwise_not((-9223372036854775808)::BIGINT); ---- 9223372036854775807 diff --git a/crates/sqllogictest/test_files/bitwise/shiftright.slt b/crates/sqllogictest/test_files/bitwise/shiftright.slt index 8d4d8d84..314b1a23 100644 --- a/crates/sqllogictest/test_files/bitwise/shiftright.slt +++ b/crates/sqllogictest/test_files/bitwise/shiftright.slt @@ -136,8 +136,8 @@ select shiftright(3::int,-32); # i32 + nulls query IT SELECT - shiftright(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftright(arrow_cast(value, 'Int32'), shift)) + shiftright(value::INT, shift), + arrow_typeof(shiftright(value::INT, shift)) FROM VALUES (4, 1), (8, 2), @@ -157,8 +157,8 @@ NULL Int32 # big shifts query IT SELECT - shiftright(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftright(arrow_cast(value, 'Int32'), shift)) + shiftright(value::INT, shift), + arrow_typeof(shiftright(value::INT, shift)) FROM VALUES (1, 32), (2, 33), @@ -172,8 +172,8 @@ t(value, shift) # negative shift query IT SELECT - shiftright(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftright(arrow_cast(value, 'Int32'), shift)) + shiftright(value::INT, shift), + arrow_typeof(shiftright(value::INT, shift)) FROM VALUES (4, -1), (8, -2), @@ -187,8 +187,8 @@ t(value, shift) # For signed integers, right shift preserves sign bit query IT SELECT - shiftright(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftright(arrow_cast(value, 'Int32'), shift)) + shiftright(value::INT, shift), + arrow_typeof(shiftright(value::INT, shift)) FROM VALUES (-4, 1), (-8, 2), @@ -202,8 +202,8 @@ t(value, shift) # i64 value query IT SELECT - shiftright(arrow_cast(value, 'Int64'), shift), - arrow_typeof(shiftright(arrow_cast(value, 'Int64'), shift)) + shiftright(value::BIGINT, shift), + arrow_typeof(shiftright(value::BIGINT, shift)) FROM VALUES (4, 1), (8, 2), (16, 3) t(value, shift) ---- 2 Int64 diff --git a/crates/sqllogictest/test_files/bitwise/shiftrightunsigned.slt b/crates/sqllogictest/test_files/bitwise/shiftrightunsigned.slt index 7d6df9df..1aa07339 100644 --- a/crates/sqllogictest/test_files/bitwise/shiftrightunsigned.slt +++ b/crates/sqllogictest/test_files/bitwise/shiftrightunsigned.slt @@ -137,8 +137,8 @@ select shiftrightunsigned(3::int,-32); # i32 + nulls query IT SELECT - shiftrightunsigned(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftrightunsigned(arrow_cast(value, 'Int32'), shift)) + shiftrightunsigned(value::INT, shift), + arrow_typeof(shiftrightunsigned(value::INT, shift)) FROM VALUES (4, 1), (8, 2), @@ -158,8 +158,8 @@ NULL Int32 # negative shift query IT SELECT - shiftrightunsigned(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftrightunsigned(arrow_cast(value, 'Int32'), shift)) + shiftrightunsigned(value::INT, shift), + arrow_typeof(shiftrightunsigned(value::INT, shift)) FROM VALUES (4, -1), (8, -2), @@ -176,8 +176,8 @@ t(value, shift) # -16 as u32 = 4294967280, 4294967280 >>> 3 = 536870910 query IT SELECT - shiftrightunsigned(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftrightunsigned(arrow_cast(value, 'Int32'), shift)) + shiftrightunsigned(value::INT, shift), + arrow_typeof(shiftrightunsigned(value::INT, shift)) FROM VALUES (-4, 1), (-8, 2), @@ -191,8 +191,8 @@ t(value, shift) # i64 value query IT SELECT - shiftrightunsigned(arrow_cast(value, 'Int64'), shift), - arrow_typeof(shiftrightunsigned(arrow_cast(value, 'Int64'), shift)) + shiftrightunsigned(value::BIGINT, shift), + arrow_typeof(shiftrightunsigned(value::BIGINT, shift)) FROM VALUES (4, 1), (8, 2), (16, 3) t(value, shift) ---- 2 Int64 diff --git a/crates/sqllogictest/test_files/collection/size.slt b/crates/sqllogictest/test_files/collection/size.slt index f444a9c7..29b390db 100644 --- a/crates/sqllogictest/test_files/collection/size.slt +++ b/crates/sqllogictest/test_files/collection/size.slt @@ -58,7 +58,7 @@ SELECT size(map(make_array('a'), make_array(1))); # Empty array query I -SELECT size(arrow_cast(make_array(), 'List(Int32)')); +SELECT size(make_array()::ARRAY); ---- 0 @@ -78,7 +78,7 @@ SELECT size(CAST(NULL AS ARRAY)); # Empty map query I -SELECT size(map(arrow_cast(make_array(), 'List(Utf8)'), arrow_cast(make_array(), 'List(Int32)'))); +SELECT size(map(arrow_cast(make_array(), 'List(Utf8)'), make_array()::ARRAY)); ---- 0 diff --git a/crates/sqllogictest/test_files/conversion/cast_float_to_timestamp.slt b/crates/sqllogictest/test_files/conversion/cast_float_to_timestamp.slt index f4361450..06714450 100644 --- a/crates/sqllogictest/test_files/conversion/cast_float_to_timestamp.slt +++ b/crates/sqllogictest/test_files/conversion/cast_float_to_timestamp.slt @@ -49,44 +49,44 @@ SELECT spark_cast(1704067200.123456, 'timestamp'); # Test spark_cast from float32 to timestamp query P -SELECT spark_cast(arrow_cast(0.0, 'Float32'), 'timestamp'); +SELECT spark_cast(0.0::FLOAT, 'timestamp'); ---- 1970-01-01T00:00:00Z query P -SELECT spark_cast(arrow_cast(1.5, 'Float32'), 'timestamp'); +SELECT spark_cast(1.5::FLOAT, 'timestamp'); ---- 1970-01-01T00:00:01.500Z query P -SELECT spark_cast(arrow_cast(-1.5, 'Float32'), 'timestamp'); +SELECT spark_cast((-1.5)::FLOAT, 'timestamp'); ---- 1969-12-31T23:59:58.500Z # Test NULL handling query P -SELECT spark_cast(arrow_cast(NULL, 'Float32'), 'timestamp'); +SELECT spark_cast(NULL::FLOAT, 'timestamp'); ---- NULL query P -SELECT spark_cast(arrow_cast(NULL, 'Float64'), 'timestamp'); +SELECT spark_cast(NULL::DOUBLE, 'timestamp'); ---- NULL # Test NaN and Infinity in non-ANSI mode (default) - should return NULL query P -SELECT spark_cast(arrow_cast('NaN', 'Float64'), 'timestamp'); +SELECT spark_cast('NaN'::DOUBLE, 'timestamp'); ---- NULL query P -SELECT spark_cast(arrow_cast('Infinity', 'Float64'), 'timestamp'); +SELECT spark_cast('Infinity'::DOUBLE, 'timestamp'); ---- NULL query P -SELECT spark_cast(arrow_cast('-Infinity', 'Float64'), 'timestamp'); +SELECT spark_cast('-Infinity'::DOUBLE, 'timestamp'); ---- NULL @@ -126,7 +126,7 @@ SET datafusion.execution.time_zone = 'UTC'; # Create test table with float columns statement ok CREATE TABLE float_test AS SELECT - arrow_cast(column1, 'Float32') as f32_col, + column1::FLOAT as f32_col, column2 as f64_col FROM (VALUES (NULL, NULL), @@ -152,9 +152,9 @@ CREATE TABLE float_special AS SELECT column1 as f64_col FROM (VALUES (1.0), - (arrow_cast('NaN', 'Float64')), - (arrow_cast('Infinity', 'Float64')), - (arrow_cast('-Infinity', 'Float64')), + ('NaN'::DOUBLE), + ('Infinity'::DOUBLE), + ('-Infinity'::DOUBLE), (2.0) ); @@ -193,11 +193,11 @@ SET datafusion.execution.enable_ansi_mode = true; # NaN should error in ANSI mode statement error \[CAST_INVALID_INPUT\] The value NaN of the type "DOUBLE" cannot be cast to "TIMESTAMP" because it is malformed -SELECT spark_cast(arrow_cast('NaN', 'Float64'), 'timestamp'); +SELECT spark_cast('NaN'::DOUBLE, 'timestamp'); # Infinity should error in ANSI mode statement error \[CAST_INVALID_INPUT\] The value Infinity of the type "DOUBLE" cannot be cast to "TIMESTAMP" -SELECT spark_cast(arrow_cast('Infinity', 'Float64'), 'timestamp'); +SELECT spark_cast('Infinity'::DOUBLE, 'timestamp'); # Very large value should error due to overflow statement error \[CAST_OVERFLOW\] The value 1.0E25D of the type "DOUBLE" cannot be cast to "BIGINT" due to an overflow diff --git a/crates/sqllogictest/test_files/conversion/cast_int_to_timestamp.slt b/crates/sqllogictest/test_files/conversion/cast_int_to_timestamp.slt index 22cf8dc3..5b6245f5 100644 --- a/crates/sqllogictest/test_files/conversion/cast_int_to_timestamp.slt +++ b/crates/sqllogictest/test_files/conversion/cast_int_to_timestamp.slt @@ -6,39 +6,39 @@ # Test spark_cast from int8 to timestamp query P -SELECT spark_cast(arrow_cast(0, 'Int8'), 'timestamp'); +SELECT spark_cast(0::TINYINT, 'timestamp'); ---- 1970-01-01T00:00:00Z query P -SELECT spark_cast(arrow_cast(1, 'Int8'), 'timestamp'); +SELECT spark_cast(1::TINYINT, 'timestamp'); ---- 1970-01-01T00:00:01Z query P -SELECT spark_cast(arrow_cast(-1, 'Int8'), 'timestamp'); +SELECT spark_cast((-1)::TINYINT, 'timestamp'); ---- 1969-12-31T23:59:59Z # Test spark_cast from int16 to timestamp query P -SELECT spark_cast(arrow_cast(0, 'Int16'), 'timestamp'); +SELECT spark_cast(0::SMALLINT, 'timestamp'); ---- 1970-01-01T00:00:00Z query P -SELECT spark_cast(arrow_cast(3600, 'Int16'), 'timestamp'); +SELECT spark_cast(3600::SMALLINT, 'timestamp'); ---- 1970-01-01T01:00:00Z # Test spark_cast from int32 to timestamp query P -SELECT spark_cast(arrow_cast(0, 'Int32'), 'timestamp'); +SELECT spark_cast(0::INT, 'timestamp'); ---- 1970-01-01T00:00:00Z query P -SELECT spark_cast(arrow_cast(1704067200, 'Int32'), 'timestamp'); +SELECT spark_cast(1704067200::INT, 'timestamp'); ---- 2024-01-01T00:00:00Z @@ -55,17 +55,17 @@ SELECT spark_cast(1704067200::bigint, 'timestamp'); # Test NULL handling query P -SELECT spark_cast(arrow_cast(NULL, 'Int8'), 'timestamp'); +SELECT spark_cast(NULL::TINYINT, 'timestamp'); ---- NULL query P -SELECT spark_cast(arrow_cast(NULL, 'Int16'), 'timestamp'); +SELECT spark_cast(NULL::SMALLINT, 'timestamp'); ---- NULL query P -SELECT spark_cast(arrow_cast(NULL, 'Int32'), 'timestamp'); +SELECT spark_cast(NULL::INT, 'timestamp'); ---- NULL @@ -82,23 +82,23 @@ NULL # Test Int8 boundary values query P -SELECT spark_cast(arrow_cast(127, 'Int8'), 'timestamp'); +SELECT spark_cast(127::TINYINT, 'timestamp'); ---- 1970-01-01T00:02:07Z query P -SELECT spark_cast(arrow_cast(-128, 'Int8'), 'timestamp'); +SELECT spark_cast((-128)::TINYINT, 'timestamp'); ---- 1969-12-31T23:57:52Z # Test Int16 boundary values query P -SELECT spark_cast(arrow_cast(32767, 'Int16'), 'timestamp'); +SELECT spark_cast(32767::SMALLINT, 'timestamp'); ---- 1970-01-01T09:06:07Z query P -SELECT spark_cast(arrow_cast(-32768, 'Int16'), 'timestamp'); +SELECT spark_cast((-32768)::SMALLINT, 'timestamp'); ---- 1969-12-31T14:53:52Z @@ -194,9 +194,9 @@ SET datafusion.execution.time_zone = 'UTC'; # Create test table with 4 int columns: null, min, max, regular value statement ok CREATE TABLE int_test AS SELECT - arrow_cast(column1, 'Int8') as i8_col, - arrow_cast(column2, 'Int16') as i16_col, - arrow_cast(column3, 'Int32') as i32_col, + column1::TINYINT as i8_col, + column2::SMALLINT as i16_col, + column3::INT as i32_col, column4::bigint as i64_col FROM (VALUES (NULL, NULL, NULL, NULL), diff --git a/crates/sqllogictest/test_files/datetime/date_add.slt b/crates/sqllogictest/test_files/datetime/date_add.slt index 385a4a23..d1e3c445 100644 --- a/crates/sqllogictest/test_files/datetime/date_add.slt +++ b/crates/sqllogictest/test_files/datetime/date_add.slt @@ -18,12 +18,12 @@ SELECT date_add('2016-07-30'::date, 1::int); 2016-07-31 query D -SELECT date_add('2016-07-30'::date, arrow_cast(1, 'Int8')); +SELECT date_add('2016-07-30'::date, 1::TINYINT); ---- 2016-07-31 query D -SELECT date_add('2016-07-30'::date, arrow_cast(1, 'Int8')); +SELECT date_add('2016-07-30'::date, 1::TINYINT); ---- 2016-07-31 diff --git a/crates/sqllogictest/test_files/datetime/date_sub.slt b/crates/sqllogictest/test_files/datetime/date_sub.slt index 11806234..1a8344ad 100644 --- a/crates/sqllogictest/test_files/datetime/date_sub.slt +++ b/crates/sqllogictest/test_files/datetime/date_sub.slt @@ -18,12 +18,12 @@ SELECT date_sub('2016-07-30'::date, 1::int); 2016-07-29 query D -SELECT date_sub('2016-07-30'::date, arrow_cast(1, 'Int8')); +SELECT date_sub('2016-07-30'::date, 1::TINYINT); ---- 2016-07-29 query D -SELECT date_sub('2016-07-30'::date, arrow_cast(1, 'Int16')); +SELECT date_sub('2016-07-30'::date, 1::SMALLINT); ---- 2016-07-29 diff --git a/crates/sqllogictest/test_files/datetime/make_interval.slt b/crates/sqllogictest/test_files/datetime/make_interval.slt index 5162003c..03a65408 100644 --- a/crates/sqllogictest/test_files/datetime/make_interval.slt +++ b/crates/sqllogictest/test_files/datetime/make_interval.slt @@ -37,7 +37,7 @@ SELECT y, m, w, d, h, mi, s, make_interval(y, m, w, d, h, mi, s) AS interval FROM VALUES - (0, 0, 0, 0, 0, 0, arrow_cast('NaN','Float64')) + (0, 0, 0, 0, 0, 0, 'NaN'::DOUBLE) AS v(y, m, w, d, h, mi, s); ---- 0 0 0 0 0 0 NaN NULL diff --git a/crates/sqllogictest/test_files/datetime/next_day.slt b/crates/sqllogictest/test_files/datetime/next_day.slt index 3fdf19c5..f9ca52cd 100644 --- a/crates/sqllogictest/test_files/datetime/next_day.slt +++ b/crates/sqllogictest/test_files/datetime/next_day.slt @@ -55,7 +55,7 @@ NULL # Preserve implicit weekday-to-string conversions. query D -SELECT next_day(DATE '2015-07-23', arrow_cast('Mon', 'Binary')); +SELECT next_day(DATE '2015-07-23', 'Mon'::BINARY); ---- 2015-07-27 @@ -92,12 +92,12 @@ NULL # arithmetic, rather than panicking. Cast the Date32 result to Int32 to assert # the epoch day directly (these dates are past the printable range). query I -SELECT arrow_cast(next_day(arrow_cast(95026236, 'Date32'), 'Mon'::string), 'Int32'); +SELECT next_day(95026236::DATE, 'Mon'::string)::INT; ---- 95026243 query I -SELECT arrow_cast(next_day(arrow_cast(95026230, 'Date32'), 'Tue'::string), 'Int32'); +SELECT next_day(95026230::DATE, 'Tue'::string)::INT; ---- 95026237 @@ -152,7 +152,7 @@ SELECT next_day(arrow_cast('2015-07-23', 'LargeUtf8'), 'Mon'); 2015-07-27 query D -SELECT next_day(arrow_cast('2015-07-23', 'Utf8View'), 'Mon'); +SELECT next_day('2015-07-23'::STRING, 'Mon'); ---- 2015-07-27 @@ -163,7 +163,7 @@ SELECT next_day('2015-07-23', arrow_cast('Mon', 'LargeUtf8')); 2015-07-27 query D -SELECT next_day('2015-07-23', arrow_cast('Mon', 'Utf8View')); +SELECT next_day('2015-07-23', 'Mon'::STRING); ---- 2015-07-27 diff --git a/crates/sqllogictest/test_files/datetime/unix.slt b/crates/sqllogictest/test_files/datetime/unix.slt index 0c93db63..05eb38af 100644 --- a/crates/sqllogictest/test_files/datetime/unix.slt +++ b/crates/sqllogictest/test_files/datetime/unix.slt @@ -128,7 +128,7 @@ CREATE TABLE unix_floor_us AS SELECT arrow_cast(column1, 'Timestamp(Microsecond, ); query III -SELECT arrow_cast(ts, 'Int64'), unix_millis(ts), unix_seconds(ts) FROM unix_floor_us; +SELECT ts::BIGINT, unix_millis(ts), unix_seconds(ts) FROM unix_floor_us; ---- -1 -1 -1 -1000 -1 -1 diff --git a/crates/sqllogictest/test_files/generator/stack.slt b/crates/sqllogictest/test_files/generator/stack.slt index 07e19b1f..85d62f27 100644 --- a/crates/sqllogictest/test_files/generator/stack.slt +++ b/crates/sqllogictest/test_files/generator/stack.slt @@ -91,7 +91,7 @@ SELECT stack(3, i, 'a', s, -1, NULL, 'b', i) FROM (VALUES (1, 's1'), (NULL, 's2' # Values of one Spark type with different Arrow types are cast to the first one query ??T -SELECT stack(2, 'a', v), stack(2, d, 'a'), arrow_typeof(stack(2, d, 'a')) FROM (VALUES (arrow_cast('b', 'Utf8View'), arrow_cast('b', 'Dictionary(Int32, Utf8)'))) AS t(v, d); +SELECT stack(2, 'a', v), stack(2, d, 'a'), arrow_typeof(stack(2, d, 'a')) FROM (VALUES ('b'::STRING, arrow_cast('b', 'Dictionary(Int32, Utf8)'))) AS t(v, d); ---- [{col0: a}, {col0: b}] [{col0: b}, {col0: a}] List(Struct("col0": Dictionary(Int32, Utf8))) diff --git a/crates/sqllogictest/test_files/hash/crc32.slt b/crates/sqllogictest/test_files/hash/crc32.slt index 9bd094cc..435cba7c 100644 --- a/crates/sqllogictest/test_files/hash/crc32.slt +++ b/crates/sqllogictest/test_files/hash/crc32.slt @@ -23,7 +23,7 @@ SELECT crc32(''); 0 query I -SELECT crc32(arrow_cast('', 'Binary')); +SELECT crc32(''::BINARY); ---- 0 @@ -39,7 +39,7 @@ SELECT crc32(arrow_cast('Spark', 'LargeUtf8')); 1557323817 query I -SELECT crc32(arrow_cast('Spark', 'Utf8View')); +SELECT crc32('Spark'::STRING); ---- 1557323817 @@ -49,12 +49,12 @@ SELECT crc32(arrow_cast('Spark', 'Utf8')); 1557323817 query I -SELECT crc32(arrow_cast('Spark', 'Binary')); +SELECT crc32('Spark'::BINARY); ---- 1557323817 query I -SELECT crc32(arrow_cast(arrow_cast('Spark', 'Binary'), 'FixedSizeBinary(5)')); +SELECT crc32(arrow_cast('Spark'::BINARY, 'FixedSizeBinary(5)')); ---- 1557323817 diff --git a/crates/sqllogictest/test_files/hash/sha.slt b/crates/sqllogictest/test_files/hash/sha.slt index db17161d..24d9b44a 100644 --- a/crates/sqllogictest/test_files/hash/sha.slt +++ b/crates/sqllogictest/test_files/hash/sha.slt @@ -35,13 +35,13 @@ SELECT sha(arrow_cast('Spark', 'LargeUtf8')); # Test with Utf8View (using CAST to ensure type) query T -SELECT sha(arrow_cast('Spark', 'Utf8View')); +SELECT sha('Spark'::STRING); ---- 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c # Test with Binary query T -SELECT sha(arrow_cast('Spark', 'Binary')); +SELECT sha('Spark'::BINARY); ---- 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c diff --git a/crates/sqllogictest/test_files/hash/sha1.slt b/crates/sqllogictest/test_files/hash/sha1.slt index c4917774..a173fed0 100644 --- a/crates/sqllogictest/test_files/hash/sha1.slt +++ b/crates/sqllogictest/test_files/hash/sha1.slt @@ -39,7 +39,7 @@ SELECT sha1(arrow_cast('Spark', 'LargeUtf8')); 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c query T -SELECT sha1(arrow_cast('Spark', 'Utf8View')); +SELECT sha1('Spark'::STRING); ---- 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c @@ -49,12 +49,12 @@ SELECT sha1(arrow_cast('Spark', 'Utf8')); 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c query T -SELECT sha1(arrow_cast('Spark', 'Binary')); +SELECT sha1('Spark'::BINARY); ---- 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c query T -SELECT sha1(arrow_cast(arrow_cast('Spark', 'Binary'), 'FixedSizeBinary(5)')); +SELECT sha1(arrow_cast('Spark'::BINARY, 'FixedSizeBinary(5)')); ---- 85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c diff --git a/crates/sqllogictest/test_files/hash/sha2.slt b/crates/sqllogictest/test_files/hash/sha2.slt index 6426c6d1..6108bfd4 100644 --- a/crates/sqllogictest/test_files/hash/sha2.slt +++ b/crates/sqllogictest/test_files/hash/sha2.slt @@ -77,14 +77,14 @@ SELECT sha2(arrow_cast('foo', 'LargeUtf8'), bit_length) FROM VALUES (224::INT), 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae query T -SELECT sha2(arrow_cast('foo', 'Utf8View'), bit_length) FROM VALUES (224::INT), (256::INT) AS t(bit_length); +SELECT sha2('foo'::STRING, bit_length) FROM VALUES (224::INT), (256::INT) AS t(bit_length); ---- 0808f64e60d58979fcb676c96ec938270dea42445aeefcd3a4e6f8db 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae # All binary types query T -SELECT sha2(arrow_cast('foo', 'Binary'), bit_length) FROM VALUES (224::INT), (256::INT) AS t(bit_length); +SELECT sha2('foo'::BINARY, bit_length) FROM VALUES (224::INT), (256::INT) AS t(bit_length); ---- 0808f64e60d58979fcb676c96ec938270dea42445aeefcd3a4e6f8db 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae diff --git a/crates/sqllogictest/test_files/hash/xxhash64.slt b/crates/sqllogictest/test_files/hash/xxhash64.slt index 75e8a7ed..27e37861 100644 --- a/crates/sqllogictest/test_files/hash/xxhash64.slt +++ b/crates/sqllogictest/test_files/hash/xxhash64.slt @@ -26,22 +26,22 @@ SELECT xxhash64(-1); # Boundary values query I -SELECT xxhash64(arrow_cast(2147483647, 'Int32')); +SELECT xxhash64(2147483647::INT); ---- 1508894993788531228 query I -SELECT xxhash64(arrow_cast(-2147483648, 'Int32')); +SELECT xxhash64((-2147483648)::INT); ---- 2073849959933241805 query I -SELECT xxhash64(arrow_cast(9223372036854775807, 'Int64')); +SELECT xxhash64(9223372036854775807::BIGINT); ---- -3246596055638297850 query I -SELECT xxhash64(arrow_cast(-9223372036854775808, 'Int64')); +SELECT xxhash64((-9223372036854775808)::BIGINT); ---- -8619748838626508300 @@ -98,12 +98,12 @@ SELECT xxhash64(1, 'hello'); # Int64 tests query I -SELECT xxhash64(arrow_cast(1, 'Int64')); +SELECT xxhash64(1::BIGINT); ---- -7001672635703045582 query I -SELECT xxhash64(arrow_cast(0, 'Int64')); +SELECT xxhash64(0::BIGINT); ---- -5252525462095825812 @@ -132,7 +132,7 @@ SELECT xxhash64(-1.0); -8296228499959607521 query I -SELECT xxhash64(arrow_cast(1.0E20, 'Float64')); +SELECT xxhash64(1.0E20::DOUBLE); ---- -1089066926670605926 @@ -149,13 +149,13 @@ SELECT xxhash64(false); # Binary tests query I -SELECT xxhash64(arrow_cast('hello', 'Binary')); +SELECT xxhash64('hello'::BINARY); ---- -4367754540140381902 # Date tests query I -SELECT xxhash64(arrow_cast('2023-01-15', 'Date32')); +SELECT xxhash64('2023-01-15'::DATE); ---- 290591839883576215 @@ -169,7 +169,7 @@ SELECT xxhash64(named_struct('a', 1, 'b', 2)); # Array/List hashing - Spark chains hashes across list elements: # hash(elem_n, hash(elem_n-1, ... hash(elem_0, seed) ...)) query I -SELECT xxhash64(arrow_cast(make_array(1, 2, 3), 'List(Int32)')); +SELECT xxhash64(make_array(1, 2, 3)::ARRAY); ---- 8592097078962733837 diff --git a/crates/sqllogictest/test_files/math/bin.slt b/crates/sqllogictest/test_files/math/bin.slt index f8819aa3..5ee34384 100644 --- a/crates/sqllogictest/test_files/math/bin.slt +++ b/crates/sqllogictest/test_files/math/bin.slt @@ -3,17 +3,17 @@ # SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements query T -SELECT bin(arrow_cast(NULL, 'Int8')); +SELECT bin(NULL::TINYINT); ---- NULL query T -SELECT bin(arrow_cast(0, 'Int8')); +SELECT bin(0::TINYINT); ---- 0 query T -SELECT bin(arrow_cast(13, 'Int8')); +SELECT bin(13::TINYINT); ---- 1101 @@ -28,36 +28,36 @@ SELECT bin(13.3::decimal(3,1)); 1101 query T -SELECT bin(arrow_cast(-13, 'Int8')); +SELECT bin((-13)::TINYINT); ---- 1111111111111111111111111111111111111111111111111111111111110011 query T -SELECT bin(arrow_cast(256, 'Int16')); +SELECT bin(256::SMALLINT); ---- 100000000 query T -SELECT bin(arrow_cast(-32768, 'Int16')); +SELECT bin((-32768)::SMALLINT); ---- 1111111111111111111111111111111111111111111111111000000000000000 query T -SELECT bin(arrow_cast(-2147483648, 'Int32')); +SELECT bin((-2147483648)::INT); ---- 1111111111111111111111111111111110000000000000000000000000000000 query T -SELECT bin(arrow_cast(1073741824, 'Int32')); +SELECT bin(1073741824::INT); ---- 1000000000000000000000000000000 query T -SELECT bin(arrow_cast(-9223372036854775808, 'Int64')); +SELECT bin((-9223372036854775808)::BIGINT); ---- 1000000000000000000000000000000000000000000000000000000000000000 query T -SELECT bin(arrow_cast(9223372036854775807, 'Int64')); +SELECT bin(9223372036854775807::BIGINT); ---- 111111111111111111111111111111111111111111111111111111111111111 diff --git a/crates/sqllogictest/test_files/math/csc.slt b/crates/sqllogictest/test_files/math/csc.slt index 02244146..5c71dfe4 100644 --- a/crates/sqllogictest/test_files/math/csc.slt +++ b/crates/sqllogictest/test_files/math/csc.slt @@ -25,7 +25,7 @@ Infinity NULL query R -SELECT csc(a) FROM (VALUES (pi()), (-pi()), (pi()/2) , (arrow_cast('NAN','Float32'))) AS t(a); +SELECT csc(a) FROM (VALUES (pi()), (-pi()), (pi()/2) , ('NAN'::FLOAT)) AS t(a); ---- 8165619676597685 -8165619676597685 diff --git a/crates/sqllogictest/test_files/math/floor.slt b/crates/sqllogictest/test_files/math/floor.slt index 86ddad7f..9c7ae7f4 100644 --- a/crates/sqllogictest/test_files/math/floor.slt +++ b/crates/sqllogictest/test_files/math/floor.slt @@ -24,51 +24,51 @@ SELECT floor(0.0), arrow_typeof(floor(0.0)); # Float32 tests - returns Int64 query IT -SELECT floor(arrow_cast(1.5, 'Float32')), arrow_typeof(floor(arrow_cast(1.5, 'Float32'))); +SELECT floor(1.5::FLOAT), arrow_typeof(floor(1.5::FLOAT)); ---- 1 Int64 query IT -SELECT floor(arrow_cast(-1.5, 'Float32')), arrow_typeof(floor(arrow_cast(-1.5, 'Float32'))); +SELECT floor((-1.5)::FLOAT), arrow_typeof(floor((-1.5)::FLOAT)); ---- -2 Int64 # Integer tests - returns Int64 query IT -SELECT floor(arrow_cast(5, 'Int8')), arrow_typeof(floor(arrow_cast(5, 'Int8'))); +SELECT floor(5::TINYINT), arrow_typeof(floor(5::TINYINT)); ---- 5 Int64 query IT -SELECT floor(arrow_cast(-5, 'Int16')), arrow_typeof(floor(arrow_cast(-5, 'Int16'))); +SELECT floor((-5)::SMALLINT), arrow_typeof(floor((-5)::SMALLINT)); ---- -5 Int64 query IT -SELECT floor(arrow_cast(1000, 'Int32')), arrow_typeof(floor(arrow_cast(1000, 'Int32'))); +SELECT floor(1000::INT), arrow_typeof(floor(1000::INT)); ---- 1000 Int64 query IT -SELECT floor(arrow_cast(-1000, 'Int64')), arrow_typeof(floor(arrow_cast(-1000, 'Int64'))); +SELECT floor((-1000)::BIGINT), arrow_typeof(floor((-1000)::BIGINT)); ---- -1000 Int64 # Decimal128 tests - returns Decimal128(p-s+1, 0) # Decimal(5,2) -> Decimal(4,0) query RT -SELECT floor(arrow_cast(123.45, 'Decimal128(5,2)')), arrow_typeof(floor(arrow_cast(123.45, 'Decimal128(5,2)'))); +SELECT floor(123.45::DECIMAL(5, 2)), arrow_typeof(floor(123.45::DECIMAL(5, 2))); ---- 123 Decimal128(4, 0) query RT -SELECT floor(arrow_cast(-123.45, 'Decimal128(5,2)')), arrow_typeof(floor(arrow_cast(-123.45, 'Decimal128(5,2)'))); +SELECT floor((-123.45)::DECIMAL(5, 2)), arrow_typeof(floor((-123.45)::DECIMAL(5, 2))); ---- -124 Decimal128(4, 0) # Decimal with scale 0 - unchanged precision query RT -SELECT floor(arrow_cast(123, 'Decimal128(10,0)')), arrow_typeof(floor(arrow_cast(123, 'Decimal128(10,0)'))); +SELECT floor(123::DECIMAL(10, 0)), arrow_typeof(floor(123::DECIMAL(10, 0))); ---- 123 Decimal128(10, 0) @@ -162,13 +162,13 @@ SELECT floor(1.9::FLOAT), floor(-1.9::FLOAT); # Int8 boundaries (i8::MAX, i8::MIN) pass through as Int64 # Note: i8::MIN written via arrow_cast to dodge the -(128) parse issue (128 > i8::MAX) query III -SELECT floor(arrow_cast(127, 'Int8')), floor(arrow_cast(-128, 'Int8')), floor(NULL::TINYINT); +SELECT floor(127::TINYINT), floor((-128)::TINYINT), floor(NULL::TINYINT); ---- 127 -128 NULL # Int64 boundary values pass through unchanged query II -SELECT floor(arrow_cast(9223372036854775807, 'Int64')), floor(arrow_cast(-9223372036854775808, 'Int64')); +SELECT floor(9223372036854775807::BIGINT), floor((-9223372036854775808)::BIGINT); ---- 9223372036854775807 -9223372036854775808 @@ -236,14 +236,14 @@ NULL # Int16 boundaries (i16::MAX, i16::MIN) pass through as Int64 # Note: i16::MIN via arrow_cast to dodge the -(32768) parse issue query III -SELECT floor(arrow_cast(32767, 'Int16')), floor(arrow_cast(-32768, 'Int16')), floor(NULL::SMALLINT); +SELECT floor(32767::SMALLINT), floor((-32768)::SMALLINT), floor(NULL::SMALLINT); ---- 32767 -32768 NULL # Int32 boundaries (i32::MAX, i32::MIN) pass through as Int64 # Note: i32::MIN via arrow_cast to dodge the -(2147483648) parse issue query III -SELECT floor(arrow_cast(2147483647, 'Int32')), floor(arrow_cast(-2147483648, 'Int32')), floor(NULL::INT); +SELECT floor(2147483647::INT), floor((-2147483648)::INT), floor(NULL::INT); ---- 2147483647 -2147483648 NULL diff --git a/crates/sqllogictest/test_files/math/hex.slt b/crates/sqllogictest/test_files/math/hex.slt index 1b0100d7..d8ef317a 100644 --- a/crates/sqllogictest/test_files/math/hex.slt +++ b/crates/sqllogictest/test_files/math/hex.slt @@ -27,7 +27,7 @@ NULL 666F6F62617262617A statement ok -CREATE TABLE t_utf8view as VALUES (arrow_cast('foo', 'Utf8View')), (NULL), (arrow_cast('foobarbaz', 'Utf8View')); +CREATE TABLE t_utf8view as VALUES ('foo'::STRING), (NULL), ('foobarbaz'::STRING); query T SELECT hex(column1) FROM t_utf8view; diff --git a/crates/sqllogictest/test_files/math/mod.slt b/crates/sqllogictest/test_files/math/mod.slt index 1fedc914..028c2191 100644 --- a/crates/sqllogictest/test_files/math/mod.slt +++ b/crates/sqllogictest/test_files/math/mod.slt @@ -250,17 +250,17 @@ SELECT MOD(10::int8, 3::int8) as mod_int8; 1 query I -SELECT MOD(arrow_cast(10, 'Int16'), arrow_cast(3, 'Int16')) as mod_int16; +SELECT MOD(10::SMALLINT, 3::SMALLINT) as mod_int16; ---- 1 query I -SELECT MOD(arrow_cast(10, 'Int32'), arrow_cast(3, 'Int32')) as mod_int32; +SELECT MOD(10::INT, 3::INT) as mod_int32; ---- 1 query I -SELECT MOD(arrow_cast(10, 'Int64'), arrow_cast(3, 'Int64')) as mod_int64; +SELECT MOD(10::BIGINT, 3::BIGINT) as mod_int64; ---- 1 diff --git a/crates/sqllogictest/test_files/math/negative.slt b/crates/sqllogictest/test_files/math/negative.slt index 9688e76d..d68c2aee 100644 --- a/crates/sqllogictest/test_files/math/negative.slt +++ b/crates/sqllogictest/test_files/math/negative.slt @@ -102,7 +102,7 @@ CREATE TABLE decimal_negative AS SELECT arrow_cast(column1, 'Decimal32(7, 2)') AS d32, arrow_cast(column1, 'Decimal64(10, 2)') AS d64, - arrow_cast(column1, 'Decimal128(10, 2)') AS d128, + column1::DECIMAL(10, 2) AS d128, arrow_cast(column1, 'Decimal256(42, 2)') AS d256 FROM (VALUES (1.23), (-4.50), (0.00), (NULL)); diff --git a/crates/sqllogictest/test_files/math/pmod.slt b/crates/sqllogictest/test_files/math/pmod.slt index 7a7b4e63..fb80423e 100644 --- a/crates/sqllogictest/test_files/math/pmod.slt +++ b/crates/sqllogictest/test_files/math/pmod.slt @@ -373,22 +373,22 @@ SELECT pmod(-10::int8, 3::int8) as pmod_int8_2; 2 query I -SELECT pmod(arrow_cast(10, 'Int16'), arrow_cast(3, 'Int16')) as pmod_int16_1; +SELECT pmod(10::SMALLINT, 3::SMALLINT) as pmod_int16_1; ---- 1 query I -SELECT pmod(arrow_cast(-10, 'Int16'), arrow_cast(3, 'Int16')) as pmod_int16_2; +SELECT pmod((-10)::SMALLINT, 3::SMALLINT) as pmod_int16_2; ---- 2 query I -SELECT pmod(arrow_cast(10, 'Int64'), arrow_cast(3, 'Int64')) as pmod_int64_1; +SELECT pmod(10::BIGINT, 3::BIGINT) as pmod_int64_1; ---- 1 query I -SELECT pmod(arrow_cast(-10, 'Int64'), arrow_cast(3, 'Int64')) as pmod_int64_2; +SELECT pmod((-10)::BIGINT, 3::BIGINT) as pmod_int64_2; ---- 2 diff --git a/crates/sqllogictest/test_files/math/rint.slt b/crates/sqllogictest/test_files/math/rint.slt index 0752a186..8a9151df 100644 --- a/crates/sqllogictest/test_files/math/rint.slt +++ b/crates/sqllogictest/test_files/math/rint.slt @@ -22,7 +22,7 @@ SELECT rint(-12.3456); -12 query R -SELECT rint(arrow_cast(-12.3456, 'Float32')); +SELECT rint((-12.3456)::FLOAT); ---- -12 @@ -33,7 +33,7 @@ SELECT rint(arrow_cast(12, 'UInt8')); 12 query R -SELECT rint(arrow_cast(-12, 'Int8')); +SELECT rint((-12)::TINYINT); ---- -12 @@ -43,7 +43,7 @@ SELECT rint(arrow_cast(12, 'UInt16')); 12 query R -SELECT rint(arrow_cast(-12, 'Int16')); +SELECT rint((-12)::SMALLINT); ---- -12 @@ -53,7 +53,7 @@ SELECT rint(arrow_cast(12, 'UInt32')); 12 query R -SELECT rint(arrow_cast(-12, 'Int32')); +SELECT rint((-12)::INT); ---- -12 @@ -63,7 +63,7 @@ SELECT rint(arrow_cast(12, 'UInt64')); 12 query R -SELECT rint(arrow_cast(-12, 'Int64')); +SELECT rint((-12)::BIGINT); ---- -12 diff --git a/crates/sqllogictest/test_files/math/round.slt b/crates/sqllogictest/test_files/math/round.slt index 075980e1..22c158e3 100644 --- a/crates/sqllogictest/test_files/math/round.slt +++ b/crates/sqllogictest/test_files/math/round.slt @@ -59,24 +59,24 @@ SELECT round(123.456::double, 1::int); # round(float) query R -SELECT round(arrow_cast(2.5, 'Float32')); +SELECT round(2.5::FLOAT); ---- 3 query R -SELECT round(arrow_cast(-2.5, 'Float32')); +SELECT round((-2.5)::FLOAT); ---- -3 # round(float) with scale query R -SELECT round(arrow_cast(2.345, 'Float32'), 2::int); +SELECT round(2.345::FLOAT, 2::int); ---- 2.35 # round(float32) with negative scale query R -SELECT round(arrow_cast(125.0, 'Float32'), -1::int); +SELECT round(125.0::FLOAT, -1::int); ---- 130 @@ -211,13 +211,13 @@ SELECT round(25::bigint, -1::int); # round(bigint) should preserve exact values above Float64's exact integer range query IT -SELECT round(arrow_cast(9007199254740993, 'Int64')), arrow_typeof(round(arrow_cast(9007199254740993, 'Int64'))); +SELECT round(9007199254740993::BIGINT), arrow_typeof(round(9007199254740993::BIGINT)); ---- 9007199254740993 Int64 # round(bigint, positive scale) should also preserve exact values above Float64's exact integer range query IT -SELECT round(arrow_cast(9007199254740993, 'Int64'), 2::int), arrow_typeof(round(arrow_cast(9007199254740993, 'Int64'), 2::int)); +SELECT round(9007199254740993::BIGINT, 2::int), arrow_typeof(round(9007199254740993::BIGINT, 2::int)); ---- 9007199254740993 Int64 @@ -229,7 +229,7 @@ SELECT round(25::smallint, -1::int); # round(tinyint, -1) query I -SELECT round(arrow_cast(25, 'Int8'), -1::int); +SELECT round(25::TINYINT, -1::int); ---- 30 @@ -516,13 +516,13 @@ SELECT round(3.14159::double, 2::int) + 1.0; # round(127::tinyint, -1) → 130, wraps as i8 → -126 query I -SELECT round(arrow_cast(127, 'Int8'), -1::int); +SELECT round(127::TINYINT, -1::int); ---- -126 # round(32767::smallint, -1) → 32770, wraps as i16 → -32766 query I -SELECT round(arrow_cast(32767, 'Int16'), -1::int); +SELECT round(32767::SMALLINT, -1::int); ---- -32766 @@ -589,11 +589,11 @@ SELECT round(2147483647::int, -1::int); # ANSI mode: Int16 overflow should error query error DataFusion error: Execution error: Int16 overflow on round -SELECT round(arrow_cast(32767, 'Int16'), -1::int); +SELECT round(32767::SMALLINT, -1::int); # ANSI mode: Int8 overflow should error query error DataFusion error: Execution error: Int8 overflow on round -SELECT round(arrow_cast(127, 'Int8'), -1::int); +SELECT round(127::TINYINT, -1::int); # Reset ANSI mode statement ok diff --git a/crates/sqllogictest/test_files/math/sec.slt b/crates/sqllogictest/test_files/math/sec.slt index f011de5f..a6a151b3 100644 --- a/crates/sqllogictest/test_files/math/sec.slt +++ b/crates/sqllogictest/test_files/math/sec.slt @@ -24,7 +24,7 @@ SELECT sec(a) FROM (VALUES (0::INT), (1::INT), (-1::INT), (null)) AS t(a); NULL query R -SELECT sec(a) FROM (VALUES (pi()), (3 * pi()/2), (pi()/2) , (arrow_cast('NAN','Float32'))) AS t(a); +SELECT sec(a) FROM (VALUES (pi()), (3 * pi()/2), (pi()/2) , ('NAN'::FLOAT)) AS t(a); ---- -1 -5443746451065123 diff --git a/crates/sqllogictest/test_files/math/shiftleft.slt b/crates/sqllogictest/test_files/math/shiftleft.slt index 18b267b9..8ac214e8 100644 --- a/crates/sqllogictest/test_files/math/shiftleft.slt +++ b/crates/sqllogictest/test_files/math/shiftleft.slt @@ -135,8 +135,8 @@ select shiftleft(3::int,-32); # i32 + nulls query IT SELECT - shiftleft(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftleft(arrow_cast(value, 'Int32'), shift)) + shiftleft(value::INT, shift), + arrow_typeof(shiftleft(value::INT, shift)) FROM VALUES (1, 1), (2, 2), @@ -156,8 +156,8 @@ NULL Int32 # big shifts query IT SELECT - shiftleft(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftleft(arrow_cast(value, 'Int32'), shift)) + shiftleft(value::INT, shift), + arrow_typeof(shiftleft(value::INT, shift)) FROM VALUES (1, 32), (2, 33), @@ -171,8 +171,8 @@ t(value, shift) # negative shift query IT SELECT - shiftleft(arrow_cast(value, 'Int32'), shift), - arrow_typeof(shiftleft(arrow_cast(value, 'Int32'), shift)) + shiftleft(value::INT, shift), + arrow_typeof(shiftleft(value::INT, shift)) FROM VALUES (4, -1), (8, -2), @@ -186,8 +186,8 @@ t(value, shift) # i64 value query IT SELECT - shiftleft(arrow_cast(value, 'Int64'), shift), - arrow_typeof(shiftleft(arrow_cast(value, 'Int64'), shift)) + shiftleft(value::BIGINT, shift), + arrow_typeof(shiftleft(value::BIGINT, shift)) FROM VALUES (1, 1), (2, 2), (3, 3) t(value, shift) ---- 2 Int64 diff --git a/crates/sqllogictest/test_files/math/unhex.slt b/crates/sqllogictest/test_files/math/unhex.slt index 64e24e3b..bd98f0c5 100644 --- a/crates/sqllogictest/test_files/math/unhex.slt +++ b/crates/sqllogictest/test_files/math/unhex.slt @@ -76,7 +76,7 @@ NULL # Utf8View type statement ok -CREATE TABLE t_utf8view AS VALUES (arrow_cast('414243', 'Utf8View')), (NULL); +CREATE TABLE t_utf8view AS VALUES ('414243'::STRING), (NULL); query ? SELECT unhex(column1) FROM t_utf8view; diff --git a/crates/sqllogictest/test_files/math/width_bucket.slt b/crates/sqllogictest/test_files/math/width_bucket.slt index e87993ff..7ca89cff 100644 --- a/crates/sqllogictest/test_files/math/width_bucket.slt +++ b/crates/sqllogictest/test_files/math/width_bucket.slt @@ -77,17 +77,17 @@ SELECT width_bucket(5.0, 0.0, 10.0, 0); NULL query I -SELECT width_bucket(arrow_cast('NaN','Float64'),5.0, 0.0, 5) +SELECT width_bucket('NaN'::DOUBLE,5.0, 0.0, 5) ---- NULL query I -SELECT width_bucket(5.0, arrow_cast('NaN','Float64'), 0.0, 5) +SELECT width_bucket(5.0, 'NaN'::DOUBLE, 0.0, 5) ---- NULL query I -SELECT width_bucket(5.0, 0.0, arrow_cast('NaN','Float64'), 5) +SELECT width_bucket(5.0, 0.0, 'NaN'::DOUBLE, 5) ---- NULL diff --git a/crates/sqllogictest/test_files/predicate/ilike.slt b/crates/sqllogictest/test_files/predicate/ilike.slt index c959ac26..c8ca4546 100644 --- a/crates/sqllogictest/test_files/predicate/ilike.slt +++ b/crates/sqllogictest/test_files/predicate/ilike.slt @@ -21,7 +21,7 @@ SELECT ilike('Spark', arrow_cast('_Park', 'LargeUtf8')); true query B -SELECT ilike(arrow_cast('Spark', 'Utf8View'), arrow_cast('_Park', 'LargeUtf8')); +SELECT ilike('Spark'::STRING, arrow_cast('_Park', 'LargeUtf8')); ---- true diff --git a/crates/sqllogictest/test_files/predicate/like.slt b/crates/sqllogictest/test_files/predicate/like.slt index 57f71e9a..25d6729b 100644 --- a/crates/sqllogictest/test_files/predicate/like.slt +++ b/crates/sqllogictest/test_files/predicate/like.slt @@ -21,7 +21,7 @@ SELECT ilike('Spark', arrow_cast('_park', 'LargeUtf8')); true query B -SELECT ilike(arrow_cast('Spark', 'Utf8View'), arrow_cast('_park', 'LargeUtf8')); +SELECT ilike('Spark'::STRING, arrow_cast('_park', 'LargeUtf8')); ---- true diff --git a/crates/sqllogictest/test_files/string/concat.slt b/crates/sqllogictest/test_files/string/concat.slt index 53bebe86..a09f93ca 100644 --- a/crates/sqllogictest/test_files/string/concat.slt +++ b/crates/sqllogictest/test_files/string/concat.slt @@ -9,7 +9,7 @@ SparkSQL # Test two Utf8View inputs: value and return type query TT -SELECT concat(arrow_cast('Spark', 'Utf8View'), arrow_cast('SQL', 'Utf8View')), arrow_typeof(concat(arrow_cast('Spark', 'Utf8View'), arrow_cast('SQL', 'Utf8View'))); +SELECT concat('Spark'::STRING, 'SQL'::STRING), arrow_typeof(concat('Spark'::STRING, 'SQL'::STRING)); ---- SparkSQL Utf8View @@ -43,7 +43,7 @@ NULL # Test mixed types: Utf8View + Utf8 query TT -SELECT concat(arrow_cast('hello', 'Utf8View'), ' world'), arrow_typeof(concat(arrow_cast('hello', 'Utf8View'), ' world')); +SELECT concat('hello'::STRING, ' world'), arrow_typeof(concat('hello'::STRING, ' world')); ---- hello world Utf8View @@ -55,25 +55,25 @@ ab LargeUtf8 # Test all three types mixed together query TT -SELECT concat('a', arrow_cast('b', 'LargeUtf8'), arrow_cast('c', 'Utf8View')), arrow_typeof(concat('a', arrow_cast('b', 'LargeUtf8'), arrow_cast('c', 'Utf8View'))); +SELECT concat('a', arrow_cast('b', 'LargeUtf8'), 'c'::STRING), arrow_typeof(concat('a', arrow_cast('b', 'LargeUtf8'), 'c'::STRING)); ---- abc Utf8View # Test mixed types: Utf8 + Binary query TT -SELECT concat(arrow_cast('hello', 'Utf8'), arrow_cast(' world', 'Binary')), arrow_typeof(concat(arrow_cast('hello', 'Utf8'), arrow_cast(' world', 'Binary'))); +SELECT concat(arrow_cast('hello', 'Utf8'), ' world'::BINARY), arrow_typeof(concat(arrow_cast('hello', 'Utf8'), ' world'::BINARY)); ---- hello world Utf8 # Test mixed types: Utf8View + Binary query TT -SELECT concat(arrow_cast('hello', 'Utf8View'), arrow_cast(' world', 'Binary')), arrow_typeof(concat(arrow_cast('hello', 'Utf8View'), arrow_cast(' world', 'Binary'))); +SELECT concat('hello'::STRING, ' world'::BINARY), arrow_typeof(concat('hello'::STRING, ' world'::BINARY)); ---- hello world Utf8View # Test Binary + Binary query ?T -SELECT concat(arrow_cast('hello', 'Binary'), arrow_cast(' world', 'Binary')), arrow_typeof(concat(arrow_cast('hello', 'Binary'), arrow_cast(' world', 'Binary'))); +SELECT concat('hello'::BINARY, ' world'::BINARY), arrow_typeof(concat('hello'::BINARY, ' world'::BINARY)); ---- 68656c6c6f20776f726c64 Binary diff --git a/crates/sqllogictest/test_files/string/concat_ws.slt b/crates/sqllogictest/test_files/string/concat_ws.slt index 17def584..8326a53b 100644 --- a/crates/sqllogictest/test_files/string/concat_ws.slt +++ b/crates/sqllogictest/test_files/string/concat_ws.slt @@ -164,7 +164,7 @@ a - b - c ## Utf8View separator query TT -SELECT concat_ws(arrow_cast(',', 'Utf8View'), 'a', 'b'), arrow_typeof(concat_ws(arrow_cast(',', 'Utf8View'), 'a', 'b')); +SELECT concat_ws(','::STRING, 'a', 'b'), arrow_typeof(concat_ws(','::STRING, 'a', 'b')); ---- a,b Utf8 diff --git a/crates/sqllogictest/test_files/string/encode.slt b/crates/sqllogictest/test_files/string/encode.slt index b15f0211..1d7cb951 100644 --- a/crates/sqllogictest/test_files/string/encode.slt +++ b/crates/sqllogictest/test_files/string/encode.slt @@ -100,14 +100,14 @@ SELECT encode('😀'::string, 'utf-32'::string); # Utf8View column input query ? -SELECT encode(arrow_cast(s, 'Utf8View'), 'utf-8'::string) FROM (VALUES ('foo'::string), ('bar'::string)) AS t(s); +SELECT encode(s::STRING, 'utf-8'::string) FROM (VALUES ('foo'::string), ('bar'::string)) AS t(s); ---- 666f6f 626172 # Binary input is decoded as UTF-8 (lossily), then re-encoded with the charset query ? -SELECT encode(arrow_cast('Hello', 'Binary'), 'utf-8'::string); +SELECT encode('Hello'::BINARY, 'utf-8'::string); ---- 48656c6c6f diff --git a/crates/sqllogictest/test_files/string/find_in_set.slt b/crates/sqllogictest/test_files/string/find_in_set.slt index bae2a4bc..5fee1607 100644 --- a/crates/sqllogictest/test_files/string/find_in_set.slt +++ b/crates/sqllogictest/test_files/string/find_in_set.slt @@ -198,12 +198,12 @@ SELECT find_in_set(a, 'a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16 NULL query I -SELECT find_in_set(arrow_cast('ab', 'Utf8View'), arrow_cast('abc,b,ab,c,def', 'Utf8View')); +SELECT find_in_set('ab'::STRING, 'abc,b,ab,c,def'::STRING); ---- 3 query I -SELECT find_in_set(arrow_cast(a, 'Utf8View'), arrow_cast('abc,b,ab,c,def', 'Utf8View')) FROM (VALUES ('ab'::string), (''::string), (NULL::string)) AS t(a); +SELECT find_in_set(a::STRING, 'abc,b,ab,c,def'::STRING) FROM (VALUES ('ab'::string), (''::string), (NULL::string)) AS t(a); ---- 3 0 diff --git a/crates/sqllogictest/test_files/string/format_string.slt b/crates/sqllogictest/test_files/string/format_string.slt index 99affcf4..2f6658b1 100644 --- a/crates/sqllogictest/test_files/string/format_string.slt +++ b/crates/sqllogictest/test_files/string/format_string.slt @@ -24,7 +24,7 @@ SELECT format_string(arrow_cast('Hello World %s', 'LargeUtf8'), 'DataFusion'); Hello World DataFusion query T -SELECT format_string(arrow_cast('Hello World %s', 'Utf8View'), 'DataFusion'); +SELECT format_string('Hello World %s'::STRING, 'DataFusion'); ---- Hello World DataFusion @@ -825,7 +825,7 @@ SELECT format_string(arrow_cast(NULL, 'LargeUtf8'), 'test'); NULL query T -SELECT format_string(arrow_cast(NULL, 'Utf8View'), 'test'); +SELECT format_string(NULL::STRING, 'test'); ---- NULL @@ -868,97 +868,97 @@ Upper: NULL ## NULL argument with string format query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Utf8View')); +SELECT format_string('Value: %s', NULL::STRING); ---- Value: null ## NULL with string format (uppercase) query T -SELECT format_string('Upper: %S', arrow_cast(NULL, 'Utf8View')); +SELECT format_string('Upper: %S', NULL::STRING); ---- Upper: NULL ## NULL with integer format using arrow_cast query T -SELECT format_string('Integer: %d', arrow_cast(NULL, 'Int32')); +SELECT format_string('Integer: %d', NULL::INT); ---- Integer: null ## NULL with hex format (lowercase) using arrow_cast query T -SELECT format_string('Hex: %x', arrow_cast(NULL, 'Int32')); +SELECT format_string('Hex: %x', NULL::INT); ---- Hex: null ## NULL with hex format (uppercase) using arrow_cast query T -SELECT format_string('Hex: %X', arrow_cast(NULL, 'Int32')); +SELECT format_string('Hex: %X', NULL::INT); ---- Hex: NULL ## NULL with octal format using arrow_cast query T -SELECT format_string('Octal: %o', arrow_cast(NULL, 'Int32')); +SELECT format_string('Octal: %o', NULL::INT); ---- Octal: null ## NULL with float format using arrow_cast query T -SELECT format_string('Float: %f', arrow_cast(NULL, 'Float64')); +SELECT format_string('Float: %f', NULL::DOUBLE); ---- Float: null ## NULL with float and precision using arrow_cast query T -SELECT format_string('Float: %.2f', arrow_cast(NULL, 'Float64')); +SELECT format_string('Float: %.2f', NULL::DOUBLE); ---- Float: nu ## NULL with scientific notation (lowercase) using arrow_cast query T -SELECT format_string('Scientific: %e', arrow_cast(NULL, 'Float64')); +SELECT format_string('Scientific: %e', NULL::DOUBLE); ---- Scientific: null ## NULL with scientific notation (uppercase) using arrow_cast query T -SELECT format_string('Scientific: %E', arrow_cast(NULL, 'Float64')); +SELECT format_string('Scientific: %E', NULL::DOUBLE); ---- Scientific: NULL ## NULL with compact float (lowercase) using arrow_cast query T -SELECT format_string('Compact: %g', arrow_cast(NULL, 'Float64')); +SELECT format_string('Compact: %g', NULL::DOUBLE); ---- Compact: null ## NULL with compact float and precision (lowercase) using arrow_cast query T -SELECT format_string('Float: %.3g', arrow_cast(NULL, 'Float64')); +SELECT format_string('Float: %.3g', NULL::DOUBLE); ---- Float: nul ## NULL with compact float (uppercase) using arrow_cast query T -SELECT format_string('Compact: %G', arrow_cast(NULL, 'Float64')); +SELECT format_string('Compact: %G', NULL::DOUBLE); ---- Compact: NULL ## NULL with compact float and precision (uppercase) using arrow_cast query T -SELECT format_string('Float: %.3G', arrow_cast(NULL, 'Float64')); +SELECT format_string('Float: %.3G', NULL::DOUBLE); ---- Float: NUL ## NULL with hex float (lowercase) using arrow_cast query T -SELECT format_string('Hex float: %a', arrow_cast(NULL, 'Float64')); +SELECT format_string('Hex float: %a', NULL::DOUBLE); ---- Hex float: null ## NULL with hex float (uppercase) using arrow_cast query T -SELECT format_string('Hex float: %A', arrow_cast(NULL, 'Float64')); +SELECT format_string('Hex float: %A', NULL::DOUBLE); ---- Hex float: NULL @@ -970,25 +970,25 @@ Hex float: NULL ## NULL with boolean format (lowercase) using arrow_cast query T -SELECT format_string('Bool: %b', arrow_cast(NULL, 'Boolean')); +SELECT format_string('Bool: %b', NULL::BOOLEAN); ---- Bool: false ## NULL with boolean format (uppercase) using arrow_cast query T -SELECT format_string('Bool: %B', arrow_cast(NULL, 'Boolean')); +SELECT format_string('Bool: %B', NULL::BOOLEAN); ---- Bool: FALSE ## NULL with character format (lowercase) using arrow_cast query T -SELECT format_string('Char: %c', arrow_cast(NULL, 'Int32')); +SELECT format_string('Char: %c', NULL::INT); ---- Char: null ## NULL with character format (uppercase) using arrow_cast query T -SELECT format_string('Char: %C', arrow_cast(NULL, 'Int32')); +SELECT format_string('Char: %C', NULL::INT); ---- Char: NULL @@ -1054,25 +1054,25 @@ Month: null ## NULL with decimal format using arrow_cast query T -SELECT format_string('Decimal: %f', arrow_cast(NULL, 'Decimal128(10, 2)')); +SELECT format_string('Decimal: %f', NULL::DECIMAL(10, 2)); ---- Decimal: null ## NULL Int8 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Int8')); +SELECT format_string('Value: %s', NULL::TINYINT); ---- Value: null ## NULL Int16 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Int16')); +SELECT format_string('Value: %s', NULL::SMALLINT); ---- Value: null ## NULL Int64 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Int64')); +SELECT format_string('Value: %s', NULL::BIGINT); ---- Value: null @@ -1102,13 +1102,13 @@ Value: null ## NULL Float32 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Float32')); +SELECT format_string('Value: %s', NULL::FLOAT); ---- Value: null ## NULL Float64 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Float64')); +SELECT format_string('Value: %s', NULL::DOUBLE); ---- Value: null @@ -1120,7 +1120,7 @@ Value: null ## NULL Date32 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Date32')); +SELECT format_string('Value: %s', NULL::DATE); ---- Value: null @@ -1132,7 +1132,7 @@ Value: null ## NULL Decimal128 with string format using arrow_cast query T -SELECT format_string('Value: %s', arrow_cast(NULL, 'Decimal128(10, 2)')); +SELECT format_string('Value: %s', NULL::DECIMAL(10, 2)); ---- Value: null @@ -1251,7 +1251,7 @@ Float: 2 3.14159 NULL query T -SELECT format_string(arrow_cast(fmt, 'Utf8View'), val1, val2) FROM test_format; +SELECT format_string(fmt::STRING, val1, val2) FROM test_format; ---- Hello World 1 Float: 2 3.14159 @@ -1272,7 +1272,7 @@ Float: 2 3.14159 NULL query T -SELECT format_string(fmt, arrow_cast(val1, 'Utf8View'), val2) FROM test_format; +SELECT format_string(fmt, val1::STRING, val2) FROM test_format; ---- Hello World 1 Float: 2 3.14159 @@ -1293,7 +1293,7 @@ Hello 3.14159 2 Hello 3.14159 3 query T -SELECT format_string(arrow_cast('Hello %s %d', 'Utf8View'), val1, val2) FROM test_format; +SELECT format_string('Hello %s %d'::STRING, val1, val2) FROM test_format; ---- Hello World 1 Hello 3.14159 2 @@ -1308,43 +1308,43 @@ DROP TABLE test_format; ## Boolean with string formats query T -SELECT format_string('Value: %s', arrow_cast(true, 'Boolean')); +SELECT format_string('Value: %s', true::BOOLEAN); ---- Value: true query T -SELECT format_string('Value: %S', arrow_cast(false, 'Boolean')); +SELECT format_string('Value: %S', false::BOOLEAN); ---- Value: FALSE ## Int8 with various formats query T -SELECT format_string('Decimal: %d', arrow_cast(127, 'Int8')); +SELECT format_string('Decimal: %d', 127::TINYINT); ---- Decimal: 127 query T -SELECT format_string('Hex: %x', arrow_cast(127, 'Int8')); +SELECT format_string('Hex: %x', 127::TINYINT); ---- Hex: 7f query T -SELECT format_string('Hex: %X', arrow_cast(127, 'Int8')); +SELECT format_string('Hex: %X', 127::TINYINT); ---- Hex: 7F query T -SELECT format_string('Octal: %o', arrow_cast(127, 'Int8')); +SELECT format_string('Octal: %o', 127::TINYINT); ---- Octal: 177 query T -SELECT format_string('Char: %c', arrow_cast(65, 'Int8')); +SELECT format_string('Char: %c', 65::TINYINT); ---- Char: A query T -SELECT format_string('Char: %C', arrow_cast(97, 'Int8')); +SELECT format_string('Char: %C', 97::TINYINT); ---- Char: A @@ -1369,12 +1369,12 @@ SELECT format_string('Char: %C', arrow_cast(97, 'UInt64')); Char: A query T -SELECT format_string('String: %s', arrow_cast(127, 'Int8')); +SELECT format_string('String: %s', 127::TINYINT); ---- String: 127 query T -SELECT format_string('String: %S', arrow_cast(127, 'Int8')); +SELECT format_string('String: %S', 127::TINYINT); ---- String: 127 @@ -1399,12 +1399,12 @@ SELECT format_string('String: %S', arrow_cast(127, 'UInt16')); String: 127 query T -SELECT format_string('String: %s', arrow_cast(127, 'Int32')); +SELECT format_string('String: %s', 127::INT); ---- String: 127 query T -SELECT format_string('String: %S', arrow_cast(127, 'Int32')); +SELECT format_string('String: %S', 127::INT); ---- String: 127 @@ -1420,32 +1420,32 @@ String: 127 ## Int16 with various formats query T -SELECT format_string('Decimal: %d', arrow_cast(32767, 'Int16')); +SELECT format_string('Decimal: %d', 32767::SMALLINT); ---- Decimal: 32767 query T -SELECT format_string('Hex: %x', arrow_cast(32767, 'Int16')); +SELECT format_string('Hex: %x', 32767::SMALLINT); ---- Hex: 7fff query T -SELECT format_string('Hex: %X', arrow_cast(32767, 'Int16')); +SELECT format_string('Hex: %X', 32767::SMALLINT); ---- Hex: 7FFF query T -SELECT format_string('Octal: %o', arrow_cast(32767, 'Int16')); +SELECT format_string('Octal: %o', 32767::SMALLINT); ---- Octal: 77777 query T -SELECT format_string('Char: %c', arrow_cast(8364, 'Int16')); +SELECT format_string('Char: %c', 8364::SMALLINT); ---- Char: € query T -SELECT format_string('String: %s', arrow_cast(32767, 'Int16')); +SELECT format_string('String: %s', 32767::SMALLINT); ---- String: 32767 @@ -1481,22 +1481,22 @@ Infinity: -INFINITY ## Int32 with various formats query T -SELECT format_string('Decimal: %d', arrow_cast(2147483647, 'Int32')); +SELECT format_string('Decimal: %d', 2147483647::INT); ---- Decimal: 2147483647 query T -SELECT format_string('Hex: %x', arrow_cast(255, 'Int32')); +SELECT format_string('Hex: %x', 255::INT); ---- Hex: ff query T -SELECT format_string('Octal: %o', arrow_cast(511, 'Int32')); +SELECT format_string('Octal: %o', 511::INT); ---- Octal: 777 query T -SELECT format_string('Char: %c', arrow_cast(128512, 'Int32')); +SELECT format_string('Char: %c', 128512::INT); ---- Char: 😀 @@ -1612,88 +1612,88 @@ Hex float: 0X1.92P1 ## Float32 with various formats query T -SELECT format_string('Float: %f', arrow_cast(3.14159, 'Float32')); +SELECT format_string('Float: %f', 3.14159::FLOAT); ---- Float: 3.141590 query T -SELECT format_string('Scientific: %e', arrow_cast(1234.5, 'Float32')); +SELECT format_string('Scientific: %e', 1234.5::FLOAT); ---- Scientific: 1.234500e+03 # xfail spark: %g strips trailing zeros, Java keeps six significant digits (https://github.com/apache/datafusion-spark/issues/39) query T -SELECT format_string('Compact: %g', arrow_cast(1234.5, 'Float32')); +SELECT format_string('Compact: %g', 1234.5::FLOAT); ---- Compact: 1234.5 query T -SELECT format_string('String: %s', arrow_cast(3.14159, 'Float32')); +SELECT format_string('String: %s', 3.14159::FLOAT); ---- String: 3.14159 query T -SELECT format_string('Hex float: %a', arrow_cast(3.14, 'Float32')); +SELECT format_string('Hex float: %a', 3.14::FLOAT); ---- Hex float: 0x1.91eb86p1 query T -SELECT format_string('Hex float: %A', arrow_cast(3.14, 'Float32')); +SELECT format_string('Hex float: %A', 3.14::FLOAT); ---- Hex float: 0X1.91EB86P1 ## Float64 with various formats query T -SELECT format_string('String: %s', arrow_cast(3.14159, 'Float64')); +SELECT format_string('String: %s', 3.14159::DOUBLE); ---- String: 3.14159 query T -SELECT format_string('String: %S', arrow_cast(3.14159, 'Float64')); +SELECT format_string('String: %S', 3.14159::DOUBLE); ---- String: 3.14159 ## Decimal128 with various formats # xfail spark: Spark errors for %f/%e/%g/%a of a DECIMAL (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Float: %f', arrow_cast(123.456, 'Decimal128(10, 3)')); +SELECT format_string('Float: %f', 123.456::DECIMAL(10, 3)); ---- Float: 123.456000 # xfail spark: Spark errors for %f/%e/%g/%a of a DECIMAL (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Scientific: %e', arrow_cast(1234.5, 'Decimal128(10, 2)')); +SELECT format_string('Scientific: %e', 1234.5::DECIMAL(10, 2)); ---- Scientific: 1.234500e+03 # xfail spark: Spark errors for %f/%e/%g/%a of a DECIMAL (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Scientific: %E', arrow_cast(1234.5, 'Decimal128(10, 2)')); +SELECT format_string('Scientific: %E', 1234.5::DECIMAL(10, 2)); ---- Scientific: 1.234500E+03 # xfail spark: Spark errors for %f/%e/%g/%a of a DECIMAL (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Compact: %g', arrow_cast(1234.5, 'Decimal128(10, 2)')); +SELECT format_string('Compact: %g', 1234.5::DECIMAL(10, 2)); ---- Compact: 1234.5 # xfail spark: Spark errors for %f/%e/%g/%a of a DECIMAL (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Compact: %G', arrow_cast(1234.5, 'Decimal128(10, 2)')); +SELECT format_string('Compact: %G', 1234.5::DECIMAL(10, 2)); ---- Compact: 1234.5 # xfail spark: %s of a DECIMAL prints the unscaled value, Spark prints it with its scale (https://github.com/apache/datafusion-spark/issues/39) query T -SELECT format_string('String: %s', arrow_cast(123.456, 'Decimal128(10, 3)')); +SELECT format_string('String: %s', 123.456::DECIMAL(10, 3)); ---- String: 123456 # xfail spark: %s of a DECIMAL prints the unscaled value, Spark prints it with its scale (https://github.com/apache/datafusion-spark/issues/39) query T -SELECT format_string('String: %S', arrow_cast(123.456, 'Decimal128(10, 3)')); +SELECT format_string('String: %S', 123.456::DECIMAL(10, 3)); ---- String: 123456 @@ -1849,23 +1849,23 @@ String: 1577926871123456789 ## Date32 with time formats # xfail spark: Spark errors for %t of a DATE, which it passes as Integer days (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Year: %tY', arrow_cast(19716, 'Date32')); +SELECT format_string('Year: %tY', 19716::DATE); ---- Year: 2023 # xfail spark: Spark errors for %t of a DATE, which it passes as Integer days (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Month: %tB', arrow_cast(19716, 'Date32')); +SELECT format_string('Month: %tB', 19716::DATE); ---- Month: December query T -SELECT format_string('String: %s', arrow_cast(19716, 'Date32')); +SELECT format_string('String: %s', 19716::DATE); ---- String: 19716 query T -SELECT format_string('String: %S', arrow_cast(19716, 'Date32')); +SELECT format_string('String: %S', 19716::DATE); ---- String: 19716 @@ -2246,9 +2246,9 @@ SELECT format_string('[%(012.2f]', -1234.50::DECIMAL(10, 2)); ## Zero padding is ignored for non-finite floating-point values query TTT SELECT - format_string('[%010.2f]', arrow_cast('NaN', 'Float64')), - format_string('[%010.2f]', arrow_cast('Infinity', 'Float64')), - format_string('[%010.2f]', arrow_cast('-Infinity', 'Float64')); + format_string('[%010.2f]', 'NaN'::DOUBLE), + format_string('[%010.2f]', 'Infinity'::DOUBLE), + format_string('[%010.2f]', '-Infinity'::DOUBLE); ---- [ NaN] [ Infinity] [ -Infinity] diff --git a/crates/sqllogictest/test_files/string/is_valid_utf8.slt b/crates/sqllogictest/test_files/string/is_valid_utf8.slt index 73f070ce..c6ac0bd6 100644 --- a/crates/sqllogictest/test_files/string/is_valid_utf8.slt +++ b/crates/sqllogictest/test_files/string/is_valid_utf8.slt @@ -45,146 +45,146 @@ SELECT is_valid_utf8('ASCII only 123 !@#'::string); true query B -SELECT is_valid_utf8(arrow_cast(x'C2A9', 'Binary')); +SELECT is_valid_utf8(x'C2A9'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'C2AE', 'Binary')); +SELECT is_valid_utf8(x'C2AE'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'E282AC', 'Binary')); +SELECT is_valid_utf8(x'E282AC'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'E284A2', 'Binary')); +SELECT is_valid_utf8(x'E284A2'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'F09F9880', 'Binary')); +SELECT is_valid_utf8(x'F09F9880'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'F09F8E89', 'Binary')); +SELECT is_valid_utf8(x'F09F8E89'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'80', 'Binary')); +SELECT is_valid_utf8(x'80'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'BF', 'Binary')); +SELECT is_valid_utf8(x'BF'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'808080', 'Binary')); +SELECT is_valid_utf8(x'808080'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'C2', 'Binary')); +SELECT is_valid_utf8(x'C2'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'E2', 'Binary')); +SELECT is_valid_utf8(x'E2'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'F0', 'Binary')); +SELECT is_valid_utf8(x'F0'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'E282', 'Binary')); +SELECT is_valid_utf8(x'E282'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'C081', 'Binary')); +SELECT is_valid_utf8(x'C081'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'E08080', 'Binary')); +SELECT is_valid_utf8(x'E08080'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'F0808080', 'Binary')); +SELECT is_valid_utf8(x'F0808080'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'FE', 'Binary')); +SELECT is_valid_utf8(x'FE'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'FF', 'Binary')); +SELECT is_valid_utf8(x'FF'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'61C262', 'Binary')); +SELECT is_valid_utf8(x'61C262'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'41BF42', 'Binary')); +SELECT is_valid_utf8(x'41BF42'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'ED9FBF', 'Binary')); +SELECT is_valid_utf8(x'ED9FBF'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'EDA080', 'Binary')); +SELECT is_valid_utf8(x'EDA080'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'EDBFBF', 'Binary')); +SELECT is_valid_utf8(x'EDBFBF'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'F48FBFBF', 'Binary')); +SELECT is_valid_utf8(x'F48FBFBF'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'F4908080', 'Binary')); +SELECT is_valid_utf8(x'F4908080'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'6162C2A963', 'Binary')); +SELECT is_valid_utf8(x'6162C2A963'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'6162806364', 'Binary')); +SELECT is_valid_utf8(x'6162806364'::BINARY); ---- false query B -SELECT is_valid_utf8(arrow_cast(x'610062', 'Binary')); +SELECT is_valid_utf8(x'610062'::BINARY); ---- true query B -SELECT is_valid_utf8(arrow_cast(x'', 'Binary')); +SELECT is_valid_utf8(x''::BINARY); ---- true diff --git a/crates/sqllogictest/test_files/string/make_valid_utf8.slt b/crates/sqllogictest/test_files/string/make_valid_utf8.slt index 9701eca3..e7016388 100644 --- a/crates/sqllogictest/test_files/string/make_valid_utf8.slt +++ b/crates/sqllogictest/test_files/string/make_valid_utf8.slt @@ -18,61 +18,61 @@ SELECT make_valid_utf8(NULL::string); NULL query T -SELECT make_valid_utf8(arrow_cast(x'C3A9', 'Binary')); +SELECT make_valid_utf8(x'C3A9'::BINARY); ---- é query T -SELECT make_valid_utf8(arrow_cast(x'F0908C80', 'Binary')); +SELECT make_valid_utf8(x'F0908C80'::BINARY); ---- 𐌀 query T -SELECT make_valid_utf8(arrow_cast(x'ED9FBF', 'Binary')); +SELECT make_valid_utf8(x'ED9FBF'::BINARY); ---- ퟿ query T -SELECT make_valid_utf8(arrow_cast(x'FF', 'Binary')); +SELECT make_valid_utf8(x'FF'::BINARY); ---- � query T -SELECT make_valid_utf8(arrow_cast(x'C0AF', 'Binary')); +SELECT make_valid_utf8(x'C0AF'::BINARY); ---- �� query T -SELECT make_valid_utf8(arrow_cast(x'F4808080', 'Binary')); +SELECT make_valid_utf8(x'F4808080'::BINARY); ---- 􀀀 query T -SELECT make_valid_utf8(arrow_cast(x'EDA0BDEDB2A9', 'Binary')); +SELECT make_valid_utf8(x'EDA0BDEDB2A9'::BINARY); ---- ������ query T -SELECT make_valid_utf8(arrow_cast(x'F0', 'Binary')); +SELECT make_valid_utf8(x'F0'::BINARY); ---- � query T -SELECT make_valid_utf8(arrow_cast(x'E0', 'Binary')); +SELECT make_valid_utf8(x'E0'::BINARY); ---- � query T -SELECT make_valid_utf8(arrow_cast(x'F0808080', 'Binary')); +SELECT make_valid_utf8(x'F0808080'::BINARY); ---- ���� query T -SELECT make_valid_utf8(arrow_cast(x'61', 'Binary')); +SELECT make_valid_utf8(x'61'::BINARY); ---- a query T -SELECT make_valid_utf8(arrow_cast(x'61C262', 'Binary')); +SELECT make_valid_utf8(x'61C262'::BINARY); ---- a�b diff --git a/crates/sqllogictest/test_files/string/quote.slt b/crates/sqllogictest/test_files/string/quote.slt index c2cfec99..daaf102b 100644 --- a/crates/sqllogictest/test_files/string/quote.slt +++ b/crates/sqllogictest/test_files/string/quote.slt @@ -3,52 +3,52 @@ # SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements query T -SELECT quote(arrow_cast(127, 'Int8')); +SELECT quote(127::TINYINT); ---- '127' query T -SELECT quote(arrow_cast(-128, 'Int8')); +SELECT quote((-128)::TINYINT); ---- '-128' query T -SELECT quote(arrow_cast(32767, 'Int16')); +SELECT quote(32767::SMALLINT); ---- '32767' query T -SELECT quote(arrow_cast(-32768, 'Int16')); +SELECT quote((-32768)::SMALLINT); ---- '-32768' query T -SELECT quote(arrow_cast(2147483647, 'Int32')); +SELECT quote(2147483647::INT); ---- '2147483647' query T -SELECT quote(arrow_cast(-2147483648, 'Int32')); +SELECT quote((-2147483648)::INT); ---- '-2147483648' query T -SELECT quote(arrow_cast(9223372036854775807, 'Int64')); +SELECT quote(9223372036854775807::BIGINT); ---- '9223372036854775807' query T -SELECT quote(arrow_cast(-9223372036854775808, 'Int64')); +SELECT quote((-9223372036854775808)::BIGINT); ---- '-9223372036854775808' query T -SELECT quote(arrow_cast(3.14, 'Float32')); +SELECT quote(3.14::FLOAT); ---- '3.14' query T -SELECT quote(arrow_cast(2.718281828459045, 'Float64')); +SELECT quote(2.718281828459045::DOUBLE); ---- '2.718281828459045' @@ -118,7 +118,7 @@ SELECT quote('emoji: 😀🎉❤️🚀'); 'emoji: 😀🎉❤️🚀' query T -SELECT quote(arrow_cast('2024-01-15', 'Date32')); +SELECT quote('2024-01-15'::DATE); ---- '2024-01-15' @@ -171,12 +171,12 @@ SELECT quote(arrow_cast('', 'LargeUtf8')); '' query T -SELECT quote(arrow_cast('it''s', 'Utf8View')); +SELECT quote('it''s'::STRING); ---- 'it\'s' query T -SELECT quote(arrow_cast('', 'Utf8View')); +SELECT quote(''::STRING); ---- '' @@ -201,7 +201,7 @@ NULL # Mixes values that are inlined in the views (<= 12 bytes) with values held in a # data buffer, since the two are measured differently for the capacity hint. query T -SELECT quote(arrow_cast(c, 'Utf8View')) +SELECT quote(c::STRING) FROM VALUES ('a'), ('it''s'), (NULL), ('a value that is longer than twelve bytes and has an '' embedded quote') AS t(c); ---- 'a' diff --git a/crates/sqllogictest/test_files/string/soundex.slt b/crates/sqllogictest/test_files/string/soundex.slt index 09ad5641..6764e66f 100644 --- a/crates/sqllogictest/test_files/string/soundex.slt +++ b/crates/sqllogictest/test_files/string/soundex.slt @@ -200,12 +200,12 @@ SELECT soundex(arrow_cast('123', 'LargeUtf8')); 123 query T -SELECT soundex(arrow_cast('Miller', 'Utf8View')); +SELECT soundex('Miller'::STRING); ---- M460 query T -SELECT soundex(arrow_cast('123', 'Utf8View')); +SELECT soundex('123'::STRING); ---- 123 @@ -234,7 +234,7 @@ NULL R163 query T -SELECT soundex(arrow_cast(c, 'Utf8View')) FROM VALUES ('Miller'), (NULL), ('Ñoño') AS t(c); +SELECT soundex(c::STRING) FROM VALUES ('Miller'), (NULL), ('Ñoño') AS t(c); ---- M460 NULL diff --git a/crates/sqllogictest/test_files/string/substring.slt b/crates/sqllogictest/test_files/string/substring.slt index 153575f6..a6da8712 100644 --- a/crates/sqllogictest/test_files/string/substring.slt +++ b/crates/sqllogictest/test_files/string/substring.slt @@ -210,88 +210,88 @@ FROM VALUES # Binary: basic substring with only pos query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 5::int); +SELECT substring('Spark SQL'::BINARY, 5::int); ---- 6b2053514c # Binary: substring with pos and length query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 3::int, 1::int); +SELECT substring('Spark SQL'::BINARY, 3::int, 1::int); ---- 61 # Binary: zero pos is treated as 1 query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 0::int); +SELECT substring('Spark SQL'::BINARY, 0::int); ---- 537061726b2053514c # Binary: negative pos counts from the end query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), -3::int); +SELECT substring('Spark SQL'::BINARY, -3::int); ---- 53514c query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), -3::int, 2::int); +SELECT substring('Spark SQL'::BINARY, -3::int, 2::int); ---- 5351 # Binary: length exceeding input length query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 2::int, 700::int); +SELECT substring('Spark SQL'::BINARY, 2::int, 700::int); ---- 7061726b2053514c # Binary: pos beyond end returns empty binary query I -SELECT character_length(substring(arrow_cast('Spark SQL', 'Binary'), 30::int)); +SELECT character_length(substring('Spark SQL'::BINARY, 30::int)); ---- 0 # Binary: large negative pos returns the full value query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), -30::int); +SELECT substring('Spark SQL'::BINARY, -30::int); ---- 537061726b2053514c # Binary: negative length returns empty binary query I -SELECT character_length(substring(arrow_cast('Spark SQL', 'Binary'), 3::int, -1::int)); +SELECT character_length(substring('Spark SQL'::BINARY, 3::int, -1::int)); ---- 0 # Binary: zero length returns empty binary query I -SELECT character_length(substring(arrow_cast('Spark SQL', 'Binary'), 3::int, 0::int)); +SELECT character_length(substring('Spark SQL'::BINARY, 3::int, 0::int)); ---- 0 # Binary: NULL handling query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), NULL::int); +SELECT substring('Spark SQL'::BINARY, NULL::int); ---- NULL query ? -SELECT substring(arrow_cast(NULL, 'Binary'), 5::int); +SELECT substring(NULL::BINARY, 5::int); ---- NULL query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), NULL::int, 1::int); +SELECT substring('Spark SQL'::BINARY, NULL::int, 1::int); ---- NULL query ? -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 3::int, NULL::int); +SELECT substring('Spark SQL'::BINARY, 3::int, NULL::int); ---- NULL # Binary: return type matches input type query ?T -SELECT substring(arrow_cast('Spark SQL', 'Binary'), 3::int, 2::int), - arrow_typeof(substring(arrow_cast('Spark SQL', 'Binary'), 3::int, 2::int)); +SELECT substring('Spark SQL'::BINARY, 3::int, 2::int), + arrow_typeof(substring('Spark SQL'::BINARY, 3::int, 2::int)); ---- 6172 Binary @@ -323,7 +323,7 @@ SELECT substring(X'ff00aabb1122', -2::int, 2::int); # substr alias works with binary input query ? -SELECT substr(arrow_cast('Spark SQL', 'Binary'), 5::int); +SELECT substr('Spark SQL'::BINARY, 5::int); ---- 6b2053514c @@ -339,16 +339,16 @@ query ?I SELECT substring(column1, column2, column3), character_length(substring(column1, column2, column3)) FROM VALUES -(arrow_cast('Spark SQL', 'Binary'), -3::int, 2::int), -(arrow_cast('Spark SQL', 'Binary'), 3::int, 1::int), -(arrow_cast('Spark SQL', 'Binary'), 3::int, 700::int), -(arrow_cast('Spark SQL', 'Binary'), 3::int, -1::int), -(arrow_cast('Spark SQL', 'Binary'), 3::int, 0::int), -(arrow_cast('Spark SQL', 'Binary'), 300::int, 3::int), -(arrow_cast('Spark SQL', 'Binary'), -300::int, 3::int), -(arrow_cast(NULL, 'Binary'), 3::int, 1::int), -(arrow_cast('Spark SQL', 'Binary'), NULL::int, 1::int), -(arrow_cast('Spark SQL', 'Binary'), 3::int, NULL::int); +('Spark SQL'::BINARY, -3::int, 2::int), +('Spark SQL'::BINARY, 3::int, 1::int), +('Spark SQL'::BINARY, 3::int, 700::int), +('Spark SQL'::BINARY, 3::int, -1::int), +('Spark SQL'::BINARY, 3::int, 0::int), +('Spark SQL'::BINARY, 300::int, 3::int), +('Spark SQL'::BINARY, -300::int, 3::int), +(NULL::BINARY, 3::int, 1::int), +('Spark SQL'::BINARY, NULL::int, 1::int), +('Spark SQL'::BINARY, 3::int, NULL::int); ---- 5351 2 61 1 diff --git a/crates/sqllogictest/test_files/url/try_url_decode.slt b/crates/sqllogictest/test_files/url/try_url_decode.slt index 81a7d065..6709198f 100644 --- a/crates/sqllogictest/test_files/url/try_url_decode.slt +++ b/crates/sqllogictest/test_files/url/try_url_decode.slt @@ -15,7 +15,7 @@ https://spark.apache.org # Test with Utf8View query T -SELECT try_url_decode(arrow_cast('https%3A%2F%2Fspark.apache.org', 'Utf8View')); +SELECT try_url_decode('https%3A%2F%2Fspark.apache.org'::STRING); ---- https://spark.apache.org diff --git a/crates/sqllogictest/test_files/url/url_decode.slt b/crates/sqllogictest/test_files/url/url_decode.slt index cf8fe0c6..13870eff 100644 --- a/crates/sqllogictest/test_files/url/url_decode.slt +++ b/crates/sqllogictest/test_files/url/url_decode.slt @@ -15,7 +15,7 @@ https://spark.apache.org # Test with Utf8View query T -SELECT url_decode(arrow_cast('https%3A%2F%2Fspark.apache.org', 'Utf8View')); +SELECT url_decode('https%3A%2F%2Fspark.apache.org'::STRING); ---- https://spark.apache.org diff --git a/crates/sqllogictest/test_files/url/url_encode.slt b/crates/sqllogictest/test_files/url/url_encode.slt index bb23e97a..ac49c209 100644 --- a/crates/sqllogictest/test_files/url/url_encode.slt +++ b/crates/sqllogictest/test_files/url/url_encode.slt @@ -15,7 +15,7 @@ https%3A%2F%2Fspark.apache.org # Test with Utf8View query T -SELECT url_encode(arrow_cast('https://spark.apache.org', 'Utf8View')); +SELECT url_encode('https://spark.apache.org'::STRING); ---- https%3A%2F%2Fspark.apache.org From cc2249fdf19dbb4059f8bfbc874727d2f00bff62 Mon Sep 17 00:00:00 2001 From: Andy Grove Date: Wed, 18 Nov 2026 15:11:50 -0700 Subject: [PATCH 2/2] test: convert arrow_cast calls added since, and build DATE values with date_from_unix_date Spark cannot cast an integer to DATE, so integer day counts now go through date_from_unix_date, and DATE results go back to day counts with unix_date. --- .../test_files/array/array_insert.slt | 4 +- .../conversion/cast_target_type.slt | 2 +- .../datetime/date_from_unix_date.slt | 4 +- .../test_files/datetime/next_day.slt | 6 +-- crates/sqllogictest/test_files/hash/hash.slt | 48 ++++++++--------- .../test_files/json/json_array_length.slt | 4 +- .../sqllogictest/test_files/json/to_json.slt | 4 +- .../sqllogictest/test_files/math/divide.slt | 2 +- crates/sqllogictest/test_files/math/pmod.slt | 54 +++++++++---------- .../sqllogictest/test_files/string/base64.slt | 14 ++--- .../test_files/string/contains.slt | 4 +- .../test_files/string/format_string.slt | 8 +-- 12 files changed, 77 insertions(+), 77 deletions(-) diff --git a/crates/sqllogictest/test_files/array/array_insert.slt b/crates/sqllogictest/test_files/array/array_insert.slt index d7d5f768..95612f14 100644 --- a/crates/sqllogictest/test_files/array/array_insert.slt +++ b/crates/sqllogictest/test_files/array/array_insert.slt @@ -102,7 +102,7 @@ SELECT array_insert(make_array(0, NULL, 0), 1, NULL); # NULL array or NULL position gives NULL query ? -SELECT array_insert(arrow_cast(NULL, 'List(Int32)'), 1, 5); +SELECT array_insert(NULL::ARRAY, 1, 5); ---- NULL @@ -305,7 +305,7 @@ SELECT array_insert(make_array(make_array(1)), -3, make_array(2)); # The item widens to the common numeric type query ? -SELECT array_insert(make_array(arrow_cast(1, 'Int32')), 1, arrow_cast(3000000000, 'Int64')); +SELECT array_insert(make_array(1::INT), 1, 3000000000::BIGINT); ---- [3000000000, 1] diff --git a/crates/sqllogictest/test_files/conversion/cast_target_type.slt b/crates/sqllogictest/test_files/conversion/cast_target_type.slt index eb48cd54..2ea312c3 100644 --- a/crates/sqllogictest/test_files/conversion/cast_target_type.slt +++ b/crates/sqllogictest/test_files/conversion/cast_target_type.slt @@ -84,7 +84,7 @@ SELECT spark_cast('1', 'int'); # Spark has no cast from DATE to BINARY statement error Spark-compatible cast from DATE to BINARY is not supported -SELECT spark_cast(arrow_cast(1, 'Date32'), 'binary'); +SELECT spark_cast(date_from_unix_date(1), 'binary'); # xfail spark: spark_cast does not implement this cast yet (https://github.com/apache/datafusion-spark/issues/88) statement error Spark-compatible cast from BIGINT to INT in Legacy mode is not implemented yet diff --git a/crates/sqllogictest/test_files/datetime/date_from_unix_date.slt b/crates/sqllogictest/test_files/datetime/date_from_unix_date.slt index 3dcb2519..7b63eca3 100644 --- a/crates/sqllogictest/test_files/datetime/date_from_unix_date.slt +++ b/crates/sqllogictest/test_files/datetime/date_from_unix_date.slt @@ -40,12 +40,12 @@ true true # Other integer types are cast to INT query D -SELECT date_from_unix_date(arrow_cast(100, 'Int8')); +SELECT date_from_unix_date(100::TINYINT); ---- 1970-04-11 query D -SELECT date_from_unix_date(arrow_cast(1000, 'Int64')); +SELECT date_from_unix_date(1000::BIGINT); ---- 1972-09-27 diff --git a/crates/sqllogictest/test_files/datetime/next_day.slt b/crates/sqllogictest/test_files/datetime/next_day.slt index f9ca52cd..0574099b 100644 --- a/crates/sqllogictest/test_files/datetime/next_day.slt +++ b/crates/sqllogictest/test_files/datetime/next_day.slt @@ -92,12 +92,12 @@ NULL # arithmetic, rather than panicking. Cast the Date32 result to Int32 to assert # the epoch day directly (these dates are past the printable range). query I -SELECT next_day(95026236::DATE, 'Mon'::string)::INT; +SELECT unix_date(next_day(date_from_unix_date(95026236), 'Mon'::string)); ---- 95026243 query I -SELECT next_day(95026230::DATE, 'Tue'::string)::INT; +SELECT unix_date(next_day(date_from_unix_date(95026230), 'Tue'::string)); ---- 95026237 @@ -229,7 +229,7 @@ query error \[ILLEGAL_DAY_OF_WEEK\] Illegal input for day of week: invalid_day\. SELECT next_day('2024-01-01', arrow_cast('invalid_day', 'LargeUtf8')); query error \[ILLEGAL_DAY_OF_WEEK\] Illegal input for day of week: invalid_day\. SQLSTATE: 22009 -SELECT next_day('2024-01-01', arrow_cast('invalid_day', 'Utf8View')); +SELECT next_day('2024-01-01', 'invalid_day'::STRING); # Unicode day names folding via Unicode case folding (Spark DateTimeUtils.toUpperCase(Locale.ROOT)) query D diff --git a/crates/sqllogictest/test_files/hash/hash.slt b/crates/sqllogictest/test_files/hash/hash.slt index 9a019258..47d2a379 100644 --- a/crates/sqllogictest/test_files/hash/hash.slt +++ b/crates/sqllogictest/test_files/hash/hash.slt @@ -9,98 +9,98 @@ # Int32 query I -SELECT hash(arrow_cast(1, 'Int32')); +SELECT hash(1::INT); ---- -559580957 query I -SELECT hash(arrow_cast(0, 'Int32')); +SELECT hash(0::INT); ---- 933211791 query I -SELECT hash(arrow_cast(-1, 'Int32')); +SELECT hash((-1)::INT); ---- -1604776387 query I -SELECT hash(arrow_cast(2147483647, 'Int32')); +SELECT hash(2147483647::INT); ---- 133916647 query I -SELECT hash(arrow_cast(-2147483648, 'Int32')); +SELECT hash((-2147483648)::INT); ---- 723455942 # Int64 query I -SELECT hash(arrow_cast(1, 'Int64')); +SELECT hash(1::BIGINT); ---- -1712319331 query I -SELECT hash(arrow_cast(0, 'Int64')); +SELECT hash(0::BIGINT); ---- -1670924195 query I -SELECT hash(arrow_cast(-1, 'Int64')); +SELECT hash((-1)::BIGINT); ---- -939490007 query I -SELECT hash(arrow_cast(9223372036854775807, 'Int64')); +SELECT hash(9223372036854775807::BIGINT); ---- -1604625029 query I -SELECT hash(arrow_cast(-9223372036854775808, 'Int64')); +SELECT hash((-9223372036854775808)::BIGINT); ---- -853646085 # Float64: -0.0 hashes like 0.0 query I -SELECT hash(arrow_cast(1.0, 'Float64')); +SELECT hash(1.0::DOUBLE); ---- -460888942 query I -SELECT hash(arrow_cast(0.0, 'Float64')); +SELECT hash(0.0::DOUBLE); ---- -1670924195 query I -SELECT hash(arrow_cast(-0.0, 'Float64')); +SELECT hash((-0.0)::DOUBLE); ---- -1670924195 query I -SELECT hash(arrow_cast(-1.0, 'Float64')); +SELECT hash((-1.0)::DOUBLE); ---- 332927831 # Float32: -0.0 hashes like 0.0 query I -SELECT hash(arrow_cast(1.0, 'Float32')); +SELECT hash(1.0::FLOAT); ---- -466301895 query I -SELECT hash(arrow_cast(0.0, 'Float32')); +SELECT hash(0.0::FLOAT); ---- 933211791 query I -SELECT hash(arrow_cast(-0.0, 'Float32')); +SELECT hash((-0.0)::FLOAT); ---- 933211791 query I -SELECT hash(arrow_cast(-1.0, 'Float32')); +SELECT hash((-1.0)::FLOAT); ---- -603084565 @@ -163,7 +163,7 @@ SELECT hash(NULL); 42 query I -SELECT hash(arrow_cast(NULL, 'Int32')); +SELECT hash(NULL::INT); ---- 42 @@ -306,12 +306,12 @@ SELECT hash([CAST(1 AS INT), NULL, CAST(3 AS INT)]); 1066699649 query I -SELECT hash(arrow_cast([], 'List(Int32)')); +SELECT hash([]::ARRAY); ---- 42 query I -SELECT hash(arrow_cast(NULL, 'List(Int32)')); +SELECT hash(NULL::ARRAY); ---- 42 @@ -458,7 +458,7 @@ SELECT hash(arrow_cast('hello', 'LargeUtf8')); -1008564952 query I -SELECT hash(arrow_cast('hello', 'Utf8View')); +SELECT hash('hello'::STRING); ---- -1008564952 @@ -584,7 +584,7 @@ SELECT hash(column2) FROM hash_t; # Column inputs with NULL rows, which take the null-aware loops query I -SELECT hash(column1) FROM (VALUES ([CAST(1 AS INT), CAST(2 AS INT)]), (NULL), ([NULL, CAST(3 AS INT)]), (arrow_cast([], 'List(Int32)'))); +SELECT hash(column1) FROM (VALUES ([CAST(1 AS INT), CAST(2 AS INT)]), (NULL), ([NULL, CAST(3 AS INT)]), ([]::ARRAY)); ---- -222940379 42 @@ -592,7 +592,7 @@ SELECT hash(column1) FROM (VALUES ([CAST(1 AS INT), CAST(2 AS INT)]), (NULL), ([ 42 query I -SELECT hash(column1) FROM (VALUES ([[CAST(1 AS INT), CAST(2 AS INT)], [CAST(3 AS INT)]]), ([arrow_cast(NULL, 'List(Int32)')]), (NULL)); +SELECT hash(column1) FROM (VALUES ([[CAST(1 AS INT), CAST(2 AS INT)], [CAST(3 AS INT)]]), ([NULL::ARRAY]), (NULL)); ---- -912918097 42 diff --git a/crates/sqllogictest/test_files/json/json_array_length.slt b/crates/sqllogictest/test_files/json/json_array_length.slt index f6aee7a7..f4e23274 100644 --- a/crates/sqllogictest/test_files/json/json_array_length.slt +++ b/crates/sqllogictest/test_files/json/json_array_length.slt @@ -211,7 +211,7 @@ statement error Function 'json_array_length' requires String, but received Boole SELECT json_array_length(true); statement error Function 'json_array_length' requires String, but received Binary -SELECT json_array_length(arrow_cast('[1,2]', 'Binary')); +SELECT json_array_length('[1,2]'::BINARY); # ANSI mode does not change the result statement ok @@ -269,7 +269,7 @@ NULL NULL query I -SELECT json_array_length(arrow_cast(column1, 'Utf8View')) FROM json_array_length_t; +SELECT json_array_length(column1::STRING) FROM json_array_length_t; ---- 3 NULL diff --git a/crates/sqllogictest/test_files/json/to_json.slt b/crates/sqllogictest/test_files/json/to_json.slt index f011673f..c61483f2 100644 --- a/crates/sqllogictest/test_files/json/to_json.slt +++ b/crates/sqllogictest/test_files/json/to_json.slt @@ -134,7 +134,7 @@ SELECT to_json(named_struct('b', X'0001FF')); {"b":"AAH/"} query T -SELECT to_json(named_struct('b', arrow_cast('abc', 'Binary'))); +SELECT to_json(named_struct('b', 'abc'::BINARY)); ---- {"b":"YWJj"} @@ -149,7 +149,7 @@ SELECT to_json(named_struct('b', arrow_cast('abc', 'BinaryView'))); {"b":"YWJj"} query T -SELECT to_json(named_struct('l', [arrow_cast('abc', 'Binary'), arrow_cast(NULL, 'Binary')])); +SELECT to_json(named_struct('l', ['abc'::BINARY, NULL::BINARY])); ---- {"l":["YWJj",null]} diff --git a/crates/sqllogictest/test_files/math/divide.slt b/crates/sqllogictest/test_files/math/divide.slt index 936a08dc..a3b8b13a 100644 --- a/crates/sqllogictest/test_files/math/divide.slt +++ b/crates/sqllogictest/test_files/math/divide.slt @@ -32,7 +32,7 @@ SELECT a / b FROM (VALUES (1, 2), (3, 4)) t(a, b); 0.75 query RT -SELECT arrow_cast(1, 'Float32') / arrow_cast(2, 'Float32') AS r, arrow_typeof(arrow_cast(1, 'Float32') / arrow_cast(2, 'Float32')) AS t; +SELECT 1::FLOAT / 2::FLOAT AS r, arrow_typeof(1::FLOAT / 2::FLOAT) AS t; ---- 0.5 Float64 diff --git a/crates/sqllogictest/test_files/math/pmod.slt b/crates/sqllogictest/test_files/math/pmod.slt index fb80423e..611361c9 100644 --- a/crates/sqllogictest/test_files/math/pmod.slt +++ b/crates/sqllogictest/test_files/math/pmod.slt @@ -396,77 +396,77 @@ SELECT pmod((-10)::BIGINT, 3::BIGINT) as pmod_int64_2; # Spark evaluates `(r + n) % n` with Java arithmetic: `byte` and `short` are # promoted to `int` and never overflow, while `int` and `long` wrap around. query I -SELECT pmod(arrow_cast(-1, 'Int32'), arrow_cast(-2147483648, 'Int32')); +SELECT pmod((-1)::INT, (-2147483648)::INT); ---- 2147483647 query I -SELECT pmod(arrow_cast(-2, 'Int32'), arrow_cast(-2147483648, 'Int32')); +SELECT pmod((-2)::INT, (-2147483648)::INT); ---- 2147483646 query I -SELECT pmod(arrow_cast(2147483647, 'Int32'), arrow_cast(-2147483648, 'Int32')); +SELECT pmod(2147483647::INT, (-2147483648)::INT); ---- 2147483647 query I -SELECT pmod(arrow_cast(-2147483648, 'Int32'), arrow_cast(-1, 'Int32')); +SELECT pmod((-2147483648)::INT, (-1)::INT); ---- 0 query I -SELECT pmod(arrow_cast(-2147483648, 'Int32'), arrow_cast(3, 'Int32')); +SELECT pmod((-2147483648)::INT, 3::INT); ---- 1 query I -SELECT pmod(arrow_cast(-1, 'Int64'), arrow_cast(-9223372036854775808, 'Int64')); +SELECT pmod((-1)::BIGINT, (-9223372036854775808)::BIGINT); ---- 9223372036854775807 query I -SELECT pmod(arrow_cast(-9223372036854775808, 'Int64'), arrow_cast(-1, 'Int64')); +SELECT pmod((-9223372036854775808)::BIGINT, (-1)::BIGINT); ---- 0 query I -SELECT pmod(arrow_cast(2, 'Int64'), arrow_cast(9223372036854775807, 'Int64')); +SELECT pmod(2::BIGINT, 9223372036854775807::BIGINT); ---- 2 query I -SELECT pmod(arrow_cast(-1, 'Int8'), arrow_cast(-128, 'Int8')); +SELECT pmod((-1)::TINYINT, (-128)::TINYINT); ---- -1 query I -SELECT pmod(arrow_cast(-128, 'Int8'), arrow_cast(-1, 'Int8')); +SELECT pmod((-128)::TINYINT, (-1)::TINYINT); ---- 0 query I -SELECT pmod(arrow_cast(-1, 'Int16'), arrow_cast(-32768, 'Int16')); +SELECT pmod((-1)::SMALLINT, (-32768)::SMALLINT); ---- -1 query I -SELECT pmod(arrow_cast(-32768, 'Int16'), arrow_cast(-1, 'Int16')); +SELECT pmod((-32768)::SMALLINT, (-1)::SMALLINT); ---- 0 query I -SELECT pmod(arrow_cast(128, 'Int16'), arrow_cast(-32768, 'Int16')); +SELECT pmod(128::SMALLINT, (-32768)::SMALLINT); ---- 128 # The same boundary cases on array inputs query II -SELECT a, pmod(a, arrow_cast(-2147483648, 'Int32')) FROM (VALUES - (arrow_cast(-1, 'Int32')), - (arrow_cast(-2, 'Int32')), - (arrow_cast(2147483647, 'Int32')), - (arrow_cast(NULL, 'Int32')) +SELECT a, pmod(a, (-2147483648)::INT) FROM (VALUES + ((-1)::INT), + ((-2)::INT), + (2147483647::INT), + (NULL::INT) ) AS t(a); ---- -1 2147483647 @@ -480,31 +480,31 @@ statement ok set datafusion.execution.enable_ansi_mode = true; query I -SELECT pmod(arrow_cast(-1, 'Int32'), arrow_cast(-2147483648, 'Int32')); +SELECT pmod((-1)::INT, (-2147483648)::INT); ---- 2147483647 query I -SELECT pmod(arrow_cast(-1, 'Int64'), arrow_cast(-9223372036854775808, 'Int64')); +SELECT pmod((-1)::BIGINT, (-9223372036854775808)::BIGINT); ---- 9223372036854775807 query I -SELECT pmod(arrow_cast(-1, 'Int8'), arrow_cast(-128, 'Int8')); +SELECT pmod((-1)::TINYINT, (-128)::TINYINT); ---- -1 query I -SELECT pmod(arrow_cast(-1, 'Int16'), arrow_cast(-32768, 'Int16')); +SELECT pmod((-1)::SMALLINT, (-32768)::SMALLINT); ---- -1 query II -SELECT a, pmod(a, arrow_cast(-2147483648, 'Int32')) FROM (VALUES - (arrow_cast(-1, 'Int32')), - (arrow_cast(-2, 'Int32')), - (arrow_cast(2147483647, 'Int32')), - (arrow_cast(NULL, 'Int32')) +SELECT a, pmod(a, (-2147483648)::INT) FROM (VALUES + ((-1)::INT), + ((-2)::INT), + (2147483647::INT), + (NULL::INT) ) AS t(a); ---- -1 2147483647 diff --git a/crates/sqllogictest/test_files/string/base64.slt b/crates/sqllogictest/test_files/string/base64.slt index e2abef40..f5469434 100644 --- a/crates/sqllogictest/test_files/string/base64.slt +++ b/crates/sqllogictest/test_files/string/base64.slt @@ -154,7 +154,7 @@ SELECT unbase64(12::integer); # Utf8View, LargeUtf8, BinaryView and LargeBinary inputs, including NULLs query T -SELECT arrow_cast(unbase64(arrow_cast('U3BhcmsgU1FM', 'Utf8View')), 'Utf8'); +SELECT arrow_cast(unbase64('U3BhcmsgU1FM'::STRING), 'Utf8'); ---- Spark SQL @@ -174,12 +174,12 @@ SELECT arrow_cast(unbase64(arrow_cast('U3BhcmsgU1FM', 'LargeBinary')), 'Utf8'); Spark SQL query TTTT -SELECT arrow_typeof(unbase64(arrow_cast('YQ==', 'Utf8View'))), arrow_typeof(unbase64(arrow_cast('YQ==', 'LargeUtf8'))), arrow_typeof(unbase64(arrow_cast('YQ==', 'BinaryView'))), arrow_typeof(unbase64(arrow_cast('YQ==', 'LargeBinary'))); +SELECT arrow_typeof(unbase64('YQ=='::STRING)), arrow_typeof(unbase64(arrow_cast('YQ==', 'LargeUtf8'))), arrow_typeof(unbase64(arrow_cast('YQ==', 'BinaryView'))), arrow_typeof(unbase64(arrow_cast('YQ==', 'LargeBinary'))); ---- Binary LargeBinary Binary LargeBinary query ? -SELECT unbase64(arrow_cast(NULL, 'Utf8View')); +SELECT unbase64(NULL::STRING); ---- NULL @@ -201,9 +201,9 @@ NULL query T SELECT arrow_cast(unbase64(column1), 'Utf8') FROM VALUES -(arrow_cast('U3BhcmsgU1FM', 'Utf8View')), -(arrow_cast('U3BhcmsgU1E=', 'Utf8View')), -(arrow_cast(NULL, 'Utf8View')); +('U3BhcmsgU1FM'::STRING), +('U3BhcmsgU1E='::STRING), +(NULL::STRING); ---- Spark SQL Spark SQ @@ -269,7 +269,7 @@ SELECT hex(unbase64('YQ-_'::bytea)); 61 query T -SELECT hex(unbase64(arrow_cast('YQ-_', 'Utf8View'))); +SELECT hex(unbase64('YQ-_'::STRING)); ---- 61 diff --git a/crates/sqllogictest/test_files/string/contains.slt b/crates/sqllogictest/test_files/string/contains.slt index ade7a622..d104cbe0 100644 --- a/crates/sqllogictest/test_files/string/contains.slt +++ b/crates/sqllogictest/test_files/string/contains.slt @@ -158,7 +158,7 @@ SELECT contains(1.5::double, '.'); ## Arrow string and binary variants query BBB -SELECT contains(arrow_cast('Spark SQL', 'LargeUtf8'), 'SQL'::string), contains(arrow_cast('Spark SQL', 'Utf8View'), arrow_cast('k S', 'Utf8View')), contains(arrow_cast('Spark SQL', 'Utf8View'), arrow_cast('x', 'LargeUtf8')); +SELECT contains(arrow_cast('Spark SQL', 'LargeUtf8'), 'SQL'::string), contains('Spark SQL'::STRING, 'k S'::STRING), contains('Spark SQL'::STRING, arrow_cast('x', 'LargeUtf8')); ---- true true false @@ -168,7 +168,7 @@ SELECT contains(arrow_cast(X'00FF01', 'LargeBinary'), X'FF01'), contains(arrow_c true true false query B -SELECT contains(arrow_cast(s, 'Utf8View'), arrow_cast(p, 'LargeUtf8')) FROM VALUES ('hello world', 'world'), ('hello', ''), (NULL, 'a'), ('abc', NULL), ('abc', 'd') AS t(s, p); +SELECT contains(s::STRING, arrow_cast(p, 'LargeUtf8')) FROM VALUES ('hello world', 'world'), ('hello', ''), (NULL, 'a'), ('abc', NULL), ('abc', 'd') AS t(s, p); ---- true true diff --git a/crates/sqllogictest/test_files/string/format_string.slt b/crates/sqllogictest/test_files/string/format_string.slt index 2f6658b1..b0930963 100644 --- a/crates/sqllogictest/test_files/string/format_string.slt +++ b/crates/sqllogictest/test_files/string/format_string.slt @@ -1849,23 +1849,23 @@ String: 1577926871123456789 ## Date32 with time formats # xfail spark: Spark errors for %t of a DATE, which it passes as Integer days (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Year: %tY', 19716::DATE); +SELECT format_string('Year: %tY', date_from_unix_date(19716)); ---- Year: 2023 # xfail spark: Spark errors for %t of a DATE, which it passes as Integer days (https://github.com/apache/datafusion-spark/issues/95) query T -SELECT format_string('Month: %tB', 19716::DATE); +SELECT format_string('Month: %tB', date_from_unix_date(19716)); ---- Month: December query T -SELECT format_string('String: %s', 19716::DATE); +SELECT format_string('String: %s', date_from_unix_date(19716)); ---- String: 19716 query T -SELECT format_string('String: %S', 19716::DATE); +SELECT format_string('String: %S', date_from_unix_date(19716)); ---- String: 19716