diff --git a/src/query/functions/tests/it/main.rs b/src/query/functions/tests/it/main.rs index e8c6121e6af8e..6198543a2677b 100644 --- a/src/query/functions/tests/it/main.rs +++ b/src/query/functions/tests/it/main.rs @@ -21,3 +21,4 @@ // We can generate new test files via using `env REGENERATE_GOLDENFILES=1 cargo test` and `git diff` to show differs mod aggregates; mod scalars; +mod type_check; diff --git a/src/query/functions/tests/it/type_check.rs b/src/query/functions/tests/it/type_check.rs new file mode 100644 index 0000000000000..9273972561791 --- /dev/null +++ b/src/query/functions/tests/it/type_check.rs @@ -0,0 +1,149 @@ +// Copyright 2021 Datafuse Labs +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use databend_common_expression::types::*; +use databend_common_expression::FromData; +use goldenfile::Mint; + +use crate::scalars::run_ast; + +#[test] +fn test_type_check() { + let mut mint = Mint::new("tests/it/type_check/testdata"); + + let columns = [ + ("s", StringType::from_data(vec!["s"])), + ("n_s", StringType::from_data(vec!["s"]).wrap_nullable(None)), + ("i8", Int8Type::from_data(vec![0])), + ("n_i8", Int8Type::from_data(vec![0]).wrap_nullable(None)), + ("u8", UInt8Type::from_data(vec![0])), + ("n_u8", UInt8Type::from_data(vec![0]).wrap_nullable(None)), + ("i16", Int16Type::from_data(vec![0])), + ("n_i16", Int16Type::from_data(vec![0]).wrap_nullable(None)), + ("u16", UInt16Type::from_data(vec![0])), + ("n_u16", UInt16Type::from_data(vec![0]).wrap_nullable(None)), + ("i32", Int32Type::from_data(vec![0])), + ("n_i32", Int32Type::from_data(vec![0]).wrap_nullable(None)), + ("u32", UInt32Type::from_data(vec![0])), + ("n_u32", UInt32Type::from_data(vec![0]).wrap_nullable(None)), + ("i64", Int64Type::from_data(vec![0])), + ("n_i64", Int64Type::from_data(vec![0]).wrap_nullable(None)), + ("u64", UInt64Type::from_data(vec![0])), + ("n_u64", UInt64Type::from_data(vec![0]).wrap_nullable(None)), + ("f32", Float32Type::from_data(vec![0.0])), + ( + "n_f32", + Float32Type::from_data(vec![0.0]).wrap_nullable(None), + ), + ("f64", Float64Type::from_data(vec![0.0])), + ( + "n_f64", + Float64Type::from_data(vec![0.0]).wrap_nullable(None), + ), + ("b", BooleanType::from_data(vec![true])), + ( + "n_b", + BooleanType::from_data(vec![true]).wrap_nullable(None), + ), + ("d", DateType::from_data(vec![0])), + ("n_d", DateType::from_data(vec![0]).wrap_nullable(None)), + ("ts", TimestampType::from_data(vec![0])), + ( + "n_ts", + TimestampType::from_data(vec![0]).wrap_nullable(None), + ), + // BinaryColumn != BinaryColumn + // ("j", VariantType::from_data(vec![b"{}".into()])), + // ( + // "n_j", + // VariantType::from_data(vec![b"{}".into()]).wrap_nullable(None), + // ), + ("d128", Decimal128Type::from_data(vec![0_i128])), + ( + "n_d128", + Decimal128Type::from_data(vec![0_i128]).wrap_nullable(None), + ), + ("d256", Decimal256Type::from_data(vec![ethnum::I256::ZERO])), + ( + "n_d256", + Decimal256Type::from_data(vec![ethnum::I256::ZERO]).wrap_nullable(None), + ), + ]; + + // 8 and 16 are just smaller 32. + let size = ["32", "64"]; + + let signed = size.iter().map(|s| format!("i{}", s)).collect::>(); + let unsigned = size.iter().map(|s| format!("u{}", s)).collect::>(); + let nullable_signed = size.iter().map(|s| format!("n_i{}", s)).collect::>(); + let nullable_unsigned = size.iter().map(|s| format!("n_u{}", s)).collect::>(); + let float = size + .iter() + .flat_map(|s| [format!("f{s}"), format!("n_f{s}")].into_iter()) + .collect::>(); + let decimal = ["d128", "n_d128", "d256", "n_d256"] + .into_iter() + .map(String::from) + .collect::>(); + + let all_num = signed + .iter() + .chain(unsigned.iter()) + .chain(nullable_signed.iter()) + .chain(nullable_unsigned.iter()) + .chain(float.iter()) + .chain(decimal.iter()) + .collect::>(); + + for (name, types) in [ + ("signed", &signed), + ("unsigned", &unsigned), + ("nullable_signed", &nullable_signed), + ("nullable_unsigned", &nullable_unsigned), + ("float", &float), + ("decimal", &decimal), + ] { + let file = &mut mint.new_goldenfile(format!("{name}.txt")).unwrap(); + let pair = types + .iter() + .flat_map(|lhs| all_num.iter().map(move |rhs| (lhs, *rhs))) + .collect::>(); + for (lhs, rhs) in pair { + run_ast(file, format!("{lhs} > {rhs}"), &columns); + run_ast(file, format!("{lhs} = {rhs}"), &columns); + } + + for ty in types { + run_ast(file, format!("{ty} > 1"), &columns); + run_ast(file, format!("{ty} = 1"), &columns); + run_ast(file, format!("1 > {ty}"), &columns); + run_ast(file, format!("1 = {ty}"), &columns); + + run_ast(file, format!("{ty} > 1.0"), &columns); + run_ast(file, format!("{ty} = 1.0"), &columns); + run_ast(file, format!("1.0 > {ty}"), &columns); + run_ast(file, format!("1.0 = {ty}"), &columns); + + run_ast(file, format!("{ty} > '1'"), &columns); + run_ast(file, format!("{ty} = '1'"), &columns); + run_ast(file, format!("'1' > {ty}"), &columns); + run_ast(file, format!("'1' = {ty}"), &columns); + + run_ast(file, format!("{ty} > 1::uint64"), &columns); + run_ast(file, format!("{ty} = 1::uint64"), &columns); + run_ast(file, format!("1::uint64 > {ty}"), &columns); + run_ast(file, format!("1::uint64 = {ty}"), &columns); + } + } +} diff --git a/src/query/functions/tests/it/type_check/testdata/decimal.txt b/src/query/functions/tests/it/type_check/testdata/decimal.txt new file mode 100644 index 0000000000000..05426aef3c2cd --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/decimal.txt @@ -0,0 +1,4096 @@ +ast : d128 > i32 +raw expr : gt(d128::Decimal(38, 0), i32::Int32) +checked expr : gt(d128, to_decimal(10, 0)(i32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = i32 +raw expr : eq(d128::Decimal(38, 0), i32::Int32) +checked expr : eq(d128, to_decimal(10, 0)(i32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > i64 +raw expr : gt(d128::Decimal(38, 0), i64::Int64) +checked expr : gt(d128, to_decimal(19, 0)(i64)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = i64 +raw expr : eq(d128::Decimal(38, 0), i64::Int64) +checked expr : eq(d128, to_decimal(19, 0)(i64)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > u32 +raw expr : gt(d128::Decimal(38, 0), u32::UInt32) +checked expr : gt(d128, to_decimal(10, 0)(u32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = u32 +raw expr : eq(d128::Decimal(38, 0), u32::UInt32) +checked expr : eq(d128, to_decimal(10, 0)(u32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > u64 +raw expr : gt(d128::Decimal(38, 0), u64::UInt64) +checked expr : gt(d128, to_decimal(20, 0)(u64)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = u64 +raw expr : eq(d128::Decimal(38, 0), u64::UInt64) +checked expr : eq(d128, to_decimal(20, 0)(u64)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > n_i32 +raw expr : gt(d128::Decimal(38, 0), n_i32::Int32 NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_i32 +raw expr : eq(d128::Decimal(38, 0), n_i32::Int32 NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > n_i64 +raw expr : gt(d128::Decimal(38, 0), n_i64::Int64 NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_i64 +raw expr : eq(d128::Decimal(38, 0), n_i64::Int64 NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > n_u32 +raw expr : gt(d128::Decimal(38, 0), n_u32::UInt32 NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_u32 +raw expr : eq(d128::Decimal(38, 0), n_u32::UInt32 NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > n_u64 +raw expr : gt(d128::Decimal(38, 0), n_u64::UInt64 NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_u64 +raw expr : eq(d128::Decimal(38, 0), n_u64::UInt64 NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > f32 +raw expr : gt(d128::Decimal(38, 0), f32::Float32) +checked expr : gt(to_float64(d128), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = f32 +raw expr : eq(d128::Decimal(38, 0), f32::Float32) +checked expr : eq(to_float64(d128), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > n_f32 +raw expr : gt(d128::Decimal(38, 0), n_f32::Float32 NULL) +checked expr : gt(CAST(d128 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_f32 +raw expr : eq(d128::Decimal(38, 0), n_f32::Float32 NULL) +checked expr : eq(CAST(d128 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > f64 +raw expr : gt(d128::Decimal(38, 0), f64::Float64) +checked expr : gt(to_float64(d128), f64) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = f64 +raw expr : eq(d128::Decimal(38, 0), f64::Float64) +checked expr : eq(to_float64(d128), f64) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > n_f64 +raw expr : gt(d128::Decimal(38, 0), n_f64::Float64 NULL) +checked expr : gt(CAST(d128 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_f64 +raw expr : eq(d128::Decimal(38, 0), n_f64::Float64 NULL) +checked expr : eq(CAST(d128 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > d128 +raw expr : gt(d128::Decimal(38, 0), d128::Decimal(38, 0)) +checked expr : gt(d128, d128) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = d128 +raw expr : eq(d128::Decimal(38, 0), d128::Decimal(38, 0)) +checked expr : eq(d128, d128) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > n_d128 +raw expr : gt(d128::Decimal(38, 0), n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d128 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_d128 +raw expr : eq(d128::Decimal(38, 0), n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d128 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > d256 +raw expr : gt(d128::Decimal(38, 0), d256::Decimal(76, 0)) +checked expr : gt(d128, d256) +optimized expr : false +evaluation: ++--------+----------------+----------------+---------+ +| | d128 | d256 | Output | ++--------+----------------+----------------+---------+ +| Type | Decimal(38, 0) | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = d256 +raw expr : eq(d128::Decimal(38, 0), d256::Decimal(76, 0)) +checked expr : eq(d128, d256) +optimized expr : true +evaluation: ++--------+----------------+----------------+---------+ +| | d128 | d256 | Output | ++--------+----------------+----------------+---------+ +| Type | Decimal(38, 0) | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d128 > n_d256 +raw expr : gt(d128::Decimal(38, 0), n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(d128 AS Decimal(38, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 = n_d256 +raw expr : eq(d128::Decimal(38, 0), n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(d128 AS Decimal(38, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > i32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, i32::Int32) +checked expr : gt(n_d128, CAST(i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = i32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, i32::Int32) +checked expr : eq(n_d128, CAST(i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > i64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, i64::Int64) +checked expr : gt(n_d128, CAST(i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = i64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, i64::Int64) +checked expr : eq(n_d128, CAST(i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > u32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, u32::UInt32) +checked expr : gt(n_d128, CAST(u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = u32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, u32::UInt32) +checked expr : eq(n_d128, CAST(u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > u64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, u64::UInt64) +checked expr : gt(n_d128, CAST(u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = u64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, u64::UInt64) +checked expr : eq(n_d128, CAST(u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_i32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_i32::Int32 NULL) +checked expr : gt(n_d128, CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_i32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_i32::Int32 NULL) +checked expr : eq(n_d128, CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_i64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_i64::Int64 NULL) +checked expr : gt(n_d128, CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_i64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_i64::Int64 NULL) +checked expr : eq(n_d128, CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_u32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_u32::UInt32 NULL) +checked expr : gt(n_d128, CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_u32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_u32::UInt32 NULL) +checked expr : eq(n_d128, CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_u64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_u64::UInt64 NULL) +checked expr : gt(n_d128, CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_u64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_u64::UInt64 NULL) +checked expr : eq(n_d128, CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > f32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, f32::Float32) +checked expr : gt(CAST(n_d128 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = f32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, f32::Float32) +checked expr : eq(CAST(n_d128 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_f32 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_d128 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_f32 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_d128 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > f64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, f64::Float64) +checked expr : gt(CAST(n_d128 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = f64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, f64::Float64) +checked expr : eq(CAST(n_d128 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_f64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_d128 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_f64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_d128 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > d128 +raw expr : gt(n_d128::Decimal(38, 0) NULL, d128::Decimal(38, 0)) +checked expr : gt(n_d128, CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d128 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = d128 +raw expr : eq(n_d128::Decimal(38, 0) NULL, d128::Decimal(38, 0)) +checked expr : eq(n_d128, CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d128 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_d128 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(n_d128, n_d128) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_d128 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(n_d128, n_d128) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > d256 +raw expr : gt(n_d128::Decimal(38, 0) NULL, d256::Decimal(76, 0)) +checked expr : gt(n_d128, CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+----------------+--------------+ +| | n_d128 | d256 | Output | ++--------+---------------------+----------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = d256 +raw expr : eq(n_d128::Decimal(38, 0) NULL, d256::Decimal(76, 0)) +checked expr : eq(n_d128, CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------------------+----------------+--------------+ +| | n_d128 | d256 | Output | ++--------+---------------------+----------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > n_d256 +raw expr : gt(n_d128::Decimal(38, 0) NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(n_d128, n_d256) +optimized expr : false +evaluation: ++--------+---------------------+---------------------+--------------+ +| | n_d128 | n_d256 | Output | ++--------+---------------------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = n_d256 +raw expr : eq(n_d128::Decimal(38, 0) NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(n_d128, n_d256) +optimized expr : true +evaluation: ++--------+---------------------+---------------------+--------------+ +| | n_d128 | n_d256 | Output | ++--------+---------------------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > i32 +raw expr : gt(d256::Decimal(76, 0), i32::Int32) +checked expr : gt(d256, to_decimal(10, 0)(i32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = i32 +raw expr : eq(d256::Decimal(76, 0), i32::Int32) +checked expr : eq(d256, to_decimal(10, 0)(i32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > i64 +raw expr : gt(d256::Decimal(76, 0), i64::Int64) +checked expr : gt(d256, to_decimal(19, 0)(i64)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = i64 +raw expr : eq(d256::Decimal(76, 0), i64::Int64) +checked expr : eq(d256, to_decimal(19, 0)(i64)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > u32 +raw expr : gt(d256::Decimal(76, 0), u32::UInt32) +checked expr : gt(d256, to_decimal(10, 0)(u32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = u32 +raw expr : eq(d256::Decimal(76, 0), u32::UInt32) +checked expr : eq(d256, to_decimal(10, 0)(u32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > u64 +raw expr : gt(d256::Decimal(76, 0), u64::UInt64) +checked expr : gt(d256, to_decimal(20, 0)(u64)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = u64 +raw expr : eq(d256::Decimal(76, 0), u64::UInt64) +checked expr : eq(d256, to_decimal(20, 0)(u64)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > n_i32 +raw expr : gt(d256::Decimal(76, 0), n_i32::Int32 NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_i32 +raw expr : eq(d256::Decimal(76, 0), n_i32::Int32 NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > n_i64 +raw expr : gt(d256::Decimal(76, 0), n_i64::Int64 NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_i64 +raw expr : eq(d256::Decimal(76, 0), n_i64::Int64 NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > n_u32 +raw expr : gt(d256::Decimal(76, 0), n_u32::UInt32 NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_u32 +raw expr : eq(d256::Decimal(76, 0), n_u32::UInt32 NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > n_u64 +raw expr : gt(d256::Decimal(76, 0), n_u64::UInt64 NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_u64 +raw expr : eq(d256::Decimal(76, 0), n_u64::UInt64 NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > f32 +raw expr : gt(d256::Decimal(76, 0), f32::Float32) +checked expr : gt(to_float64(d256), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = f32 +raw expr : eq(d256::Decimal(76, 0), f32::Float32) +checked expr : eq(to_float64(d256), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > n_f32 +raw expr : gt(d256::Decimal(76, 0), n_f32::Float32 NULL) +checked expr : gt(CAST(d256 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_f32 +raw expr : eq(d256::Decimal(76, 0), n_f32::Float32 NULL) +checked expr : eq(CAST(d256 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > f64 +raw expr : gt(d256::Decimal(76, 0), f64::Float64) +checked expr : gt(to_float64(d256), f64) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = f64 +raw expr : eq(d256::Decimal(76, 0), f64::Float64) +checked expr : eq(to_float64(d256), f64) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > n_f64 +raw expr : gt(d256::Decimal(76, 0), n_f64::Float64 NULL) +checked expr : gt(CAST(d256 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_f64 +raw expr : eq(d256::Decimal(76, 0), n_f64::Float64 NULL) +checked expr : eq(CAST(d256 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > d128 +raw expr : gt(d256::Decimal(76, 0), d128::Decimal(38, 0)) +checked expr : gt(d256, d128) +optimized expr : false +evaluation: ++--------+----------------+----------------+---------+ +| | d128 | d256 | Output | ++--------+----------------+----------------+---------+ +| Type | Decimal(38, 0) | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = d128 +raw expr : eq(d256::Decimal(76, 0), d128::Decimal(38, 0)) +checked expr : eq(d256, d128) +optimized expr : true +evaluation: ++--------+----------------+----------------+---------+ +| | d128 | d256 | Output | ++--------+----------------+----------------+---------+ +| Type | Decimal(38, 0) | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > n_d128 +raw expr : gt(d256::Decimal(76, 0), n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------------------+----------------+--------------+ +| | n_d128 | d256 | Output | ++--------+---------------------+----------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_d128 +raw expr : eq(d256::Decimal(76, 0), n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------------------+----------------+--------------+ +| | n_d128 | d256 | Output | ++--------+---------------------+----------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > d256 +raw expr : gt(d256::Decimal(76, 0), d256::Decimal(76, 0)) +checked expr : gt(d256, d256) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = d256 +raw expr : eq(d256::Decimal(76, 0), d256::Decimal(76, 0)) +checked expr : eq(d256, d256) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : d256 > n_d256 +raw expr : gt(d256::Decimal(76, 0), n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(d256 AS Decimal(76, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d256 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(76, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d256 | Decimal256([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 = n_d256 +raw expr : eq(d256::Decimal(76, 0), n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(d256 AS Decimal(76, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d256 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(76, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d256 | Decimal256([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > i32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, i32::Int32) +checked expr : gt(n_d256, CAST(i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = i32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, i32::Int32) +checked expr : eq(n_d256, CAST(i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > i64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, i64::Int64) +checked expr : gt(n_d256, CAST(i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = i64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, i64::Int64) +checked expr : eq(n_d256, CAST(i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > u32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, u32::UInt32) +checked expr : gt(n_d256, CAST(u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = u32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, u32::UInt32) +checked expr : eq(n_d256, CAST(u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > u64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, u64::UInt64) +checked expr : gt(n_d256, CAST(u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = u64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, u64::UInt64) +checked expr : eq(n_d256, CAST(u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_i32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_i32::Int32 NULL) +checked expr : gt(n_d256, CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_i32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_i32::Int32 NULL) +checked expr : eq(n_d256, CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_i64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_i64::Int64 NULL) +checked expr : gt(n_d256, CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_i64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_i64::Int64 NULL) +checked expr : eq(n_d256, CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_u32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_u32::UInt32 NULL) +checked expr : gt(n_d256, CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_u32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_u32::UInt32 NULL) +checked expr : eq(n_d256, CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_u64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_u64::UInt64 NULL) +checked expr : gt(n_d256, CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_u64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_u64::UInt64 NULL) +checked expr : eq(n_d256, CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > f32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, f32::Float32) +checked expr : gt(CAST(n_d256 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = f32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, f32::Float32) +checked expr : eq(CAST(n_d256 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_f32 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_d256 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_f32 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_d256 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > f64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, f64::Float64) +checked expr : gt(CAST(n_d256 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = f64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, f64::Float64) +checked expr : eq(CAST(n_d256 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_f64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_d256 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_f64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_d256 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > d128 +raw expr : gt(n_d256::Decimal(76, 0) NULL, d128::Decimal(38, 0)) +checked expr : gt(n_d256, CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = d128 +raw expr : eq(n_d256::Decimal(76, 0) NULL, d128::Decimal(38, 0)) +checked expr : eq(n_d256, CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d128 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(38, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d128 | Decimal128([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_d128 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(n_d256, n_d128) +optimized expr : false +evaluation: ++--------+---------------------+---------------------+--------------+ +| | n_d128 | n_d256 | Output | ++--------+---------------------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_d128 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(n_d256, n_d128) +optimized expr : true +evaluation: ++--------+---------------------+---------------------+--------------+ +| | n_d128 | n_d256 | Output | ++--------+---------------------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > d256 +raw expr : gt(n_d256::Decimal(76, 0) NULL, d256::Decimal(76, 0)) +checked expr : gt(n_d256, CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+----------------+---------------------+--------------+ +| | d256 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(76, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d256 | Decimal256([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = d256 +raw expr : eq(n_d256::Decimal(76, 0) NULL, d256::Decimal(76, 0)) +checked expr : eq(n_d256, CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+----------------+---------------------+--------------+ +| | d256 | n_d256 | Output | ++--------+----------------+---------------------+--------------+ +| Type | Decimal(76, 0) | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+----------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| d256 | Decimal256([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > n_d256 +raw expr : gt(n_d256::Decimal(76, 0) NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(n_d256, n_d256) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = n_d256 +raw expr : eq(n_d256::Decimal(76, 0) NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(n_d256, n_d256) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d128 > 1 +raw expr : gt(d128::Decimal(38, 0), 1) +checked expr : gt(d128, to_decimal(3, 0)(1_u8)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = 1 +raw expr : eq(d128::Decimal(38, 0), 1) +checked expr : eq(d128, to_decimal(3, 0)(1_u8)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > d128 +raw expr : gt(1, d128::Decimal(38, 0)) +checked expr : gt(to_decimal(3, 0)(1_u8), d128) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = d128 +raw expr : eq(1, d128::Decimal(38, 0)) +checked expr : eq(to_decimal(3, 0)(1_u8), d128) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 > 1.0 +raw expr : gt(d128::Decimal(38, 0), 1.0) +checked expr : gt(d128, 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = 1.0 +raw expr : eq(d128::Decimal(38, 0), 1.0) +checked expr : eq(d128, 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > d128 +raw expr : gt(1.0, d128::Decimal(38, 0)) +checked expr : gt(1.0_d128(2,1), d128) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = d128 +raw expr : eq(1.0, d128::Decimal(38, 0)) +checked expr : eq(1.0_d128(2,1), d128) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:6 + | +1 | d128 > '1' + | ^ no function matches signature `gt(Decimal(38, 0), String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Decimal(38, 0)` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Decimal(38, 0)` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(38, 0)` with `String` +... and 33 more + + + +ast : d128 = '1' +raw expr : eq(d128::Decimal(38, 0), '1') +checked expr : eq(to_float64(d128), to_float64("1")) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > d128 + | ^ no function matches signature `gt(String, Decimal(38, 0))`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(38, 0)` with `String` +... and 33 more + + + +ast : '1' = d128 +raw expr : eq('1', d128::Decimal(38, 0)) +checked expr : eq(to_float64("1"), to_float64(d128)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 > 1::uint64 +raw expr : gt(d128::Decimal(38, 0), CAST(1 AS UInt64)) +checked expr : gt(d128, to_decimal(20, 0)(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d128 = 1::uint64 +raw expr : eq(d128::Decimal(38, 0), CAST(1 AS UInt64)) +checked expr : eq(d128, to_decimal(20, 0)(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > d128 +raw expr : gt(CAST(1 AS UInt64), d128::Decimal(38, 0)) +checked expr : gt(to_decimal(20, 0)(to_uint64(1_u8)), d128) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = d128 +raw expr : eq(CAST(1 AS UInt64), d128::Decimal(38, 0)) +checked expr : eq(to_decimal(20, 0)(to_uint64(1_u8)), d128) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d128 | Output | ++--------+----------------+---------+ +| Type | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : n_d128 > 1 +raw expr : gt(n_d128::Decimal(38, 0) NULL, 1) +checked expr : gt(n_d128, CAST(1_u8 AS Decimal(3, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = 1 +raw expr : eq(n_d128::Decimal(38, 0) NULL, 1) +checked expr : eq(n_d128, CAST(1_u8 AS Decimal(3, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_d128 +raw expr : gt(1, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(1_u8 AS Decimal(3, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_d128 +raw expr : eq(1, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(1_u8 AS Decimal(3, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > 1.0 +raw expr : gt(n_d128::Decimal(38, 0) NULL, 1.0) +checked expr : gt(n_d128, CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = 1.0 +raw expr : eq(n_d128::Decimal(38, 0) NULL, 1.0) +checked expr : eq(n_d128, CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_d128 +raw expr : gt(1.0, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_d128 +raw expr : eq(1.0, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:8 + | +1 | n_d128 > '1' + | ^ no function matches signature `gt(Decimal(38, 0) NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Decimal(38, 0) NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Decimal(38, 0)` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(38, 0) NULL` with `String` +... and 33 more + + + +ast : n_d128 = '1' +raw expr : eq(n_d128::Decimal(38, 0) NULL, '1') +checked expr : eq(CAST(n_d128 AS Float64 NULL), CAST("1" AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_d128 + | ^ no function matches signature `gt(String, Decimal(38, 0) NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(38, 0) NULL` with `String` +... and 33 more + + + +ast : '1' = n_d128 +raw expr : eq('1', n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST("1" AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 > 1::uint64 +raw expr : gt(n_d128::Decimal(38, 0) NULL, CAST(1 AS UInt64)) +checked expr : gt(n_d128, CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d128 = 1::uint64 +raw expr : eq(n_d128::Decimal(38, 0) NULL, CAST(1 AS UInt64)) +checked expr : eq(n_d128, CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_d128 +raw expr : gt(CAST(1 AS UInt64), n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_d128 +raw expr : eq(CAST(1 AS UInt64), n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d128 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : d256 > 1 +raw expr : gt(d256::Decimal(76, 0), 1) +checked expr : gt(d256, to_decimal(3, 0)(1_u8)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = 1 +raw expr : eq(d256::Decimal(76, 0), 1) +checked expr : eq(d256, to_decimal(3, 0)(1_u8)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > d256 +raw expr : gt(1, d256::Decimal(76, 0)) +checked expr : gt(to_decimal(3, 0)(1_u8), d256) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = d256 +raw expr : eq(1, d256::Decimal(76, 0)) +checked expr : eq(to_decimal(3, 0)(1_u8), d256) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 > 1.0 +raw expr : gt(d256::Decimal(76, 0), 1.0) +checked expr : gt(d256, 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = 1.0 +raw expr : eq(d256::Decimal(76, 0), 1.0) +checked expr : eq(d256, 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > d256 +raw expr : gt(1.0, d256::Decimal(76, 0)) +checked expr : gt(1.0_d128(2,1), d256) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = d256 +raw expr : eq(1.0, d256::Decimal(76, 0)) +checked expr : eq(1.0_d128(2,1), d256) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:6 + | +1 | d256 > '1' + | ^ no function matches signature `gt(Decimal(76, 0), String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Decimal(76, 0)` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Decimal(76, 0)` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(76, 0)` with `String` +... and 33 more + + + +ast : d256 = '1' +raw expr : eq(d256::Decimal(76, 0), '1') +checked expr : eq(to_float64(d256), to_float64("1")) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > d256 + | ^ no function matches signature `gt(String, Decimal(76, 0))`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(76, 0)` with `String` +... and 33 more + + + +ast : '1' = d256 +raw expr : eq('1', d256::Decimal(76, 0)) +checked expr : eq(to_float64("1"), to_float64(d256)) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 > 1::uint64 +raw expr : gt(d256::Decimal(76, 0), CAST(1 AS UInt64)) +checked expr : gt(d256, to_decimal(20, 0)(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : d256 = 1::uint64 +raw expr : eq(d256::Decimal(76, 0), CAST(1 AS UInt64)) +checked expr : eq(d256, to_decimal(20, 0)(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > d256 +raw expr : gt(CAST(1 AS UInt64), d256::Decimal(76, 0)) +checked expr : gt(to_decimal(20, 0)(to_uint64(1_u8)), d256) +optimized expr : true +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = d256 +raw expr : eq(CAST(1 AS UInt64), d256::Decimal(76, 0)) +checked expr : eq(to_decimal(20, 0)(to_uint64(1_u8)), d256) +optimized expr : false +evaluation: ++--------+----------------+---------+ +| | d256 | Output | ++--------+----------------+---------+ +| Type | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : n_d256 > 1 +raw expr : gt(n_d256::Decimal(76, 0) NULL, 1) +checked expr : gt(n_d256, CAST(1_u8 AS Decimal(3, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = 1 +raw expr : eq(n_d256::Decimal(76, 0) NULL, 1) +checked expr : eq(n_d256, CAST(1_u8 AS Decimal(3, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_d256 +raw expr : gt(1, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(1_u8 AS Decimal(3, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_d256 +raw expr : eq(1, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(1_u8 AS Decimal(3, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > 1.0 +raw expr : gt(n_d256::Decimal(76, 0) NULL, 1.0) +checked expr : gt(n_d256, CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = 1.0 +raw expr : eq(n_d256::Decimal(76, 0) NULL, 1.0) +checked expr : eq(n_d256, CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_d256 +raw expr : gt(1.0, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_d256 +raw expr : eq(1.0, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:8 + | +1 | n_d256 > '1' + | ^ no function matches signature `gt(Decimal(76, 0) NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Decimal(76, 0) NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Decimal(76, 0)` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(76, 0) NULL` with `String` +... and 33 more + + + +ast : n_d256 = '1' +raw expr : eq(n_d256::Decimal(76, 0) NULL, '1') +checked expr : eq(CAST(n_d256 AS Float64 NULL), CAST("1" AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_d256 + | ^ no function matches signature `gt(String, Decimal(76, 0) NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Decimal(76, 0) NULL` with `String` +... and 33 more + + + +ast : '1' = n_d256 +raw expr : eq('1', n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST("1" AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 > 1::uint64 +raw expr : gt(n_d256::Decimal(76, 0) NULL, CAST(1 AS UInt64)) +checked expr : gt(n_d256, CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_d256 = 1::uint64 +raw expr : eq(n_d256::Decimal(76, 0) NULL, CAST(1 AS UInt64)) +checked expr : eq(n_d256, CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_d256 +raw expr : gt(CAST(1 AS UInt64), n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_d256 +raw expr : eq(CAST(1 AS UInt64), n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Decimal(20, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------------------+--------------+ +| | n_d256 | Output | ++--------+---------------------+--------------+ +| Type | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + diff --git a/src/query/functions/tests/it/type_check/testdata/float.txt b/src/query/functions/tests/it/type_check/testdata/float.txt new file mode 100644 index 0000000000000..8be0305992ceb --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/float.txt @@ -0,0 +1,4096 @@ +ast : f32 > i32 +raw expr : gt(f32::Float32, i32::Int32) +checked expr : gt(to_float64(f32), to_float64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = i32 +raw expr : eq(f32::Float32, i32::Int32) +checked expr : eq(to_float64(f32), to_float64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > i64 +raw expr : gt(f32::Float32, i64::Int64) +checked expr : gt(to_float64(f32), to_float64(i64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = i64 +raw expr : eq(f32::Float32, i64::Int64) +checked expr : eq(to_float64(f32), to_float64(i64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > u32 +raw expr : gt(f32::Float32, u32::UInt32) +checked expr : gt(to_float64(f32), to_float64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = u32 +raw expr : eq(f32::Float32, u32::UInt32) +checked expr : eq(to_float64(f32), to_float64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > u64 +raw expr : gt(f32::Float32, u64::UInt64) +checked expr : gt(to_float64(f32), to_float64(u64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = u64 +raw expr : eq(f32::Float32, u64::UInt64) +checked expr : eq(to_float64(f32), to_float64(u64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > n_i32 +raw expr : gt(f32::Float32, n_i32::Int32 NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_i32 +raw expr : eq(f32::Float32, n_i32::Int32 NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > n_i64 +raw expr : gt(f32::Float32, n_i64::Int64 NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_i64 +raw expr : eq(f32::Float32, n_i64::Int64 NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > n_u32 +raw expr : gt(f32::Float32, n_u32::UInt32 NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_u32 +raw expr : eq(f32::Float32, n_u32::UInt32 NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > n_u64 +raw expr : gt(f32::Float32, n_u64::UInt64 NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_u64 +raw expr : eq(f32::Float32, n_u64::UInt64 NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > f32 +raw expr : gt(f32::Float32, f32::Float32) +checked expr : gt(f32, f32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = f32 +raw expr : eq(f32::Float32, f32::Float32) +checked expr : eq(f32, f32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > n_f32 +raw expr : gt(f32::Float32, n_f32::Float32 NULL) +checked expr : gt(CAST(f32 AS Float32 NULL), n_f32) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_f32 +raw expr : eq(f32::Float32, n_f32::Float32 NULL) +checked expr : eq(CAST(f32 AS Float32 NULL), n_f32) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > f64 +raw expr : gt(f32::Float32, f64::Float64) +checked expr : gt(to_float64(f32), f64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | f32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Float32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = f64 +raw expr : eq(f32::Float32, f64::Float64) +checked expr : eq(to_float64(f32), f64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | f32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Float32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > n_f64 +raw expr : gt(f32::Float32, n_f64::Float64 NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_f64 +raw expr : eq(f32::Float32, n_f64::Float64 NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > d128 +raw expr : gt(f32::Float32, d128::Decimal(38, 0)) +checked expr : gt(to_float64(f32), to_float64(d128)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = d128 +raw expr : eq(f32::Float32, d128::Decimal(38, 0)) +checked expr : eq(to_float64(f32), to_float64(d128)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > n_d128 +raw expr : gt(f32::Float32, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_d128 +raw expr : eq(f32::Float32, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > d256 +raw expr : gt(f32::Float32, d256::Decimal(76, 0)) +checked expr : gt(to_float64(f32), to_float64(d256)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = d256 +raw expr : eq(f32::Float32, d256::Decimal(76, 0)) +checked expr : eq(to_float64(f32), to_float64(d256)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f32 > n_d256 +raw expr : gt(f32::Float32, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(f32 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 = n_d256 +raw expr : eq(f32::Float32, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(f32 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > i32 +raw expr : gt(n_f32::Float32 NULL, i32::Int32) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = i32 +raw expr : eq(n_f32::Float32 NULL, i32::Int32) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > i64 +raw expr : gt(n_f32::Float32 NULL, i64::Int64) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = i64 +raw expr : eq(n_f32::Float32 NULL, i64::Int64) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > u32 +raw expr : gt(n_f32::Float32 NULL, u32::UInt32) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = u32 +raw expr : eq(n_f32::Float32 NULL, u32::UInt32) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > u64 +raw expr : gt(n_f32::Float32 NULL, u64::UInt64) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = u64 +raw expr : eq(n_f32::Float32 NULL, u64::UInt64) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_i32 +raw expr : gt(n_f32::Float32 NULL, n_i32::Int32 NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_i32 +raw expr : eq(n_f32::Float32 NULL, n_i32::Int32 NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_i64 +raw expr : gt(n_f32::Float32 NULL, n_i64::Int64 NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_i64 +raw expr : eq(n_f32::Float32 NULL, n_i64::Int64 NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_u32 +raw expr : gt(n_f32::Float32 NULL, n_u32::UInt32 NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_u32 +raw expr : eq(n_f32::Float32 NULL, n_u32::UInt32 NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_u64 +raw expr : gt(n_f32::Float32 NULL, n_u64::UInt64 NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_u64 +raw expr : eq(n_f32::Float32 NULL, n_u64::UInt64 NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > f32 +raw expr : gt(n_f32::Float32 NULL, f32::Float32) +checked expr : gt(n_f32, CAST(f32 AS Float32 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = f32 +raw expr : eq(n_f32::Float32 NULL, f32::Float32) +checked expr : eq(n_f32, CAST(f32 AS Float32 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_f32 +raw expr : gt(n_f32::Float32 NULL, n_f32::Float32 NULL) +checked expr : gt(n_f32, n_f32) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_f32 +raw expr : eq(n_f32::Float32 NULL, n_f32::Float32 NULL) +checked expr : eq(n_f32, n_f32) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > f64 +raw expr : gt(n_f32::Float32 NULL, f64::Float64) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------+--------------+ +| | n_f32 | f64 | Output | ++--------+--------------+---------+--------------+ +| Type | Float32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = f64 +raw expr : eq(n_f32::Float32 NULL, f64::Float64) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------+--------------+ +| | n_f32 | f64 | Output | ++--------+--------------+---------+--------------+ +| Type | Float32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_f64 +raw expr : gt(n_f32::Float32 NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+--------------+ +| | n_f32 | n_f64 | Output | ++--------+--------------+--------------+--------------+ +| Type | Float32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_f64 +raw expr : eq(n_f32::Float32 NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+--------------+--------------+ +| | n_f32 | n_f64 | Output | ++--------+--------------+--------------+--------------+ +| Type | Float32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > d128 +raw expr : gt(n_f32::Float32 NULL, d128::Decimal(38, 0)) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = d128 +raw expr : eq(n_f32::Float32 NULL, d128::Decimal(38, 0)) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_d128 +raw expr : gt(n_f32::Float32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_d128 +raw expr : eq(n_f32::Float32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > d256 +raw expr : gt(n_f32::Float32 NULL, d256::Decimal(76, 0)) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = d256 +raw expr : eq(n_f32::Float32 NULL, d256::Decimal(76, 0)) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f32 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > n_d256 +raw expr : gt(n_f32::Float32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = n_d256 +raw expr : eq(n_f32::Float32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f32 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > i32 +raw expr : gt(f64::Float64, i32::Int32) +checked expr : gt(f64, to_float64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = i32 +raw expr : eq(f64::Float64, i32::Int32) +checked expr : eq(f64, to_float64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > i64 +raw expr : gt(f64::Float64, i64::Int64) +checked expr : gt(f64, to_float64(i64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = i64 +raw expr : eq(f64::Float64, i64::Int64) +checked expr : eq(f64, to_float64(i64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > u32 +raw expr : gt(f64::Float64, u32::UInt32) +checked expr : gt(f64, to_float64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = u32 +raw expr : eq(f64::Float64, u32::UInt32) +checked expr : eq(f64, to_float64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > u64 +raw expr : gt(f64::Float64, u64::UInt64) +checked expr : gt(f64, to_float64(u64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = u64 +raw expr : eq(f64::Float64, u64::UInt64) +checked expr : eq(f64, to_float64(u64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > n_i32 +raw expr : gt(f64::Float64, n_i32::Int32 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_i32 +raw expr : eq(f64::Float64, n_i32::Int32 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > n_i64 +raw expr : gt(f64::Float64, n_i64::Int64 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_i64 +raw expr : eq(f64::Float64, n_i64::Int64 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > n_u32 +raw expr : gt(f64::Float64, n_u32::UInt32 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_u32 +raw expr : eq(f64::Float64, n_u32::UInt32 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > n_u64 +raw expr : gt(f64::Float64, n_u64::UInt64 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_u64 +raw expr : eq(f64::Float64, n_u64::UInt64 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > f32 +raw expr : gt(f64::Float64, f32::Float32) +checked expr : gt(f64, to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | f32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Float32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = f32 +raw expr : eq(f64::Float64, f32::Float32) +checked expr : eq(f64, to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | f32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Float32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > n_f32 +raw expr : gt(f64::Float64, n_f32::Float32 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------+--------------+ +| | n_f32 | f64 | Output | ++--------+--------------+---------+--------------+ +| Type | Float32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_f32 +raw expr : eq(f64::Float64, n_f32::Float32 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------+--------------+ +| | n_f32 | f64 | Output | ++--------+--------------+---------+--------------+ +| Type | Float32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > f64 +raw expr : gt(f64::Float64, f64::Float64) +checked expr : gt(f64, f64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = f64 +raw expr : eq(f64::Float64, f64::Float64) +checked expr : eq(f64, f64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > n_f64 +raw expr : gt(f64::Float64, n_f64::Float64 NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_f64 +raw expr : eq(f64::Float64, n_f64::Float64 NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > d128 +raw expr : gt(f64::Float64, d128::Decimal(38, 0)) +checked expr : gt(f64, to_float64(d128)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = d128 +raw expr : eq(f64::Float64, d128::Decimal(38, 0)) +checked expr : eq(f64, to_float64(d128)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > n_d128 +raw expr : gt(f64::Float64, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_d128 +raw expr : eq(f64::Float64, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > d256 +raw expr : gt(f64::Float64, d256::Decimal(76, 0)) +checked expr : gt(f64, to_float64(d256)) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = d256 +raw expr : eq(f64::Float64, d256::Decimal(76, 0)) +checked expr : eq(f64, to_float64(d256)) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | f64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Float64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : f64 > n_d256 +raw expr : gt(f64::Float64, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(f64 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 = n_d256 +raw expr : eq(f64::Float64, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(f64 AS Float64 NULL), CAST(n_d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | f64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Float64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > i32 +raw expr : gt(n_f64::Float64 NULL, i32::Int32) +checked expr : gt(n_f64, CAST(i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = i32 +raw expr : eq(n_f64::Float64 NULL, i32::Int32) +checked expr : eq(n_f64, CAST(i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > i64 +raw expr : gt(n_f64::Float64 NULL, i64::Int64) +checked expr : gt(n_f64, CAST(i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = i64 +raw expr : eq(n_f64::Float64 NULL, i64::Int64) +checked expr : eq(n_f64, CAST(i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > u32 +raw expr : gt(n_f64::Float64 NULL, u32::UInt32) +checked expr : gt(n_f64, CAST(u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = u32 +raw expr : eq(n_f64::Float64 NULL, u32::UInt32) +checked expr : eq(n_f64, CAST(u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > u64 +raw expr : gt(n_f64::Float64 NULL, u64::UInt64) +checked expr : gt(n_f64, CAST(u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = u64 +raw expr : eq(n_f64::Float64 NULL, u64::UInt64) +checked expr : eq(n_f64, CAST(u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_i32 +raw expr : gt(n_f64::Float64 NULL, n_i32::Int32 NULL) +checked expr : gt(n_f64, CAST(n_i32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_i32 +raw expr : eq(n_f64::Float64 NULL, n_i32::Int32 NULL) +checked expr : eq(n_f64, CAST(n_i32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_i64 +raw expr : gt(n_f64::Float64 NULL, n_i64::Int64 NULL) +checked expr : gt(n_f64, CAST(n_i64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_i64 +raw expr : eq(n_f64::Float64 NULL, n_i64::Int64 NULL) +checked expr : eq(n_f64, CAST(n_i64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_u32 +raw expr : gt(n_f64::Float64 NULL, n_u32::UInt32 NULL) +checked expr : gt(n_f64, CAST(n_u32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_u32 +raw expr : eq(n_f64::Float64 NULL, n_u32::UInt32 NULL) +checked expr : eq(n_f64, CAST(n_u32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_u64 +raw expr : gt(n_f64::Float64 NULL, n_u64::UInt64 NULL) +checked expr : gt(n_f64, CAST(n_u64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_u64 +raw expr : eq(n_f64::Float64 NULL, n_u64::UInt64 NULL) +checked expr : eq(n_f64, CAST(n_u64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > f32 +raw expr : gt(n_f64::Float64 NULL, f32::Float32) +checked expr : gt(n_f64, CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = f32 +raw expr : eq(n_f64::Float64 NULL, f32::Float32) +checked expr : eq(n_f64, CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f32 | Float32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_f32 +raw expr : gt(n_f64::Float64 NULL, n_f32::Float32 NULL) +checked expr : gt(n_f64, CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+--------------+ +| | n_f32 | n_f64 | Output | ++--------+--------------+--------------+--------------+ +| Type | Float32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_f32 +raw expr : eq(n_f64::Float64 NULL, n_f32::Float32 NULL) +checked expr : eq(n_f64, CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+--------------+--------------+ +| | n_f32 | n_f64 | Output | ++--------+--------------+--------------+--------------+ +| Type | Float32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > f64 +raw expr : gt(n_f64::Float64 NULL, f64::Float64) +checked expr : gt(n_f64, CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | f64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = f64 +raw expr : eq(n_f64::Float64 NULL, f64::Float64) +checked expr : eq(n_f64, CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | f64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Float64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| f64 | Float64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_f64 +raw expr : gt(n_f64::Float64 NULL, n_f64::Float64 NULL) +checked expr : gt(n_f64, n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_f64 +raw expr : eq(n_f64::Float64 NULL, n_f64::Float64 NULL) +checked expr : eq(n_f64, n_f64) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > d128 +raw expr : gt(n_f64::Float64 NULL, d128::Decimal(38, 0)) +checked expr : gt(n_f64, CAST(d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = d128 +raw expr : eq(n_f64::Float64 NULL, d128::Decimal(38, 0)) +checked expr : eq(n_f64, CAST(d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d128 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_d128 +raw expr : gt(n_f64::Float64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(n_f64, CAST(n_d128 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_d128 +raw expr : eq(n_f64::Float64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(n_f64, CAST(n_d128 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d128 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > d256 +raw expr : gt(n_f64::Float64 NULL, d256::Decimal(76, 0)) +checked expr : gt(n_f64, CAST(d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = d256 +raw expr : eq(n_f64::Float64 NULL, d256::Decimal(76, 0)) +checked expr : eq(n_f64, CAST(d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+----------------+--------------+ +| | n_f64 | d256 | Output | ++--------+--------------+----------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > n_d256 +raw expr : gt(n_f64::Float64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(n_f64, CAST(n_d256 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = n_d256 +raw expr : eq(n_f64::Float64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(n_f64, CAST(n_d256 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+---------------------+--------------+ +| | n_f64 | n_d256 | Output | ++--------+--------------+---------------------+--------------+ +| Type | Float64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+--------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f32 > 1 +raw expr : gt(f32::Float32, 1) +checked expr : gt(f32, to_float32(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = 1 +raw expr : eq(f32::Float32, 1) +checked expr : eq(f32, to_float32(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > f32 +raw expr : gt(1, f32::Float32) +checked expr : gt(to_float32(1_u8), f32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = f32 +raw expr : eq(1, f32::Float32) +checked expr : eq(to_float32(1_u8), f32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 > 1.0 +raw expr : gt(f32::Float32, 1.0) +checked expr : gt(to_float64(f32), to_float64(1.0_d128(2,1))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = 1.0 +raw expr : eq(f32::Float32, 1.0) +checked expr : eq(to_float64(f32), to_float64(1.0_d128(2,1))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > f32 +raw expr : gt(1.0, f32::Float32) +checked expr : gt(to_float64(1.0_d128(2,1)), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = f32 +raw expr : eq(1.0, f32::Float32) +checked expr : eq(to_float64(1.0_d128(2,1)), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | f32 > '1' + | ^ no function matches signature `gt(Float32, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Float32` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Float32` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float32` with `String` +... and 33 more + + + +ast : f32 = '1' +raw expr : eq(f32::Float32, '1') +checked expr : eq(f32, to_float32("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > f32 + | ^ no function matches signature `gt(String, Float32)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float32` with `String` +... and 33 more + + + +ast : '1' = f32 +raw expr : eq('1', f32::Float32) +checked expr : eq(to_float32("1"), f32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 > 1::uint64 +raw expr : gt(f32::Float32, CAST(1 AS UInt64)) +checked expr : gt(to_float64(f32), to_float64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f32 = 1::uint64 +raw expr : eq(f32::Float32, CAST(1 AS UInt64)) +checked expr : eq(to_float64(f32), to_float64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > f32 +raw expr : gt(CAST(1 AS UInt64), f32::Float32) +checked expr : gt(to_float64(to_uint64(1_u8)), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = f32 +raw expr : eq(CAST(1 AS UInt64), f32::Float32) +checked expr : eq(to_float64(to_uint64(1_u8)), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f32 | Output | ++--------+---------+---------+ +| Type | Float32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : n_f32 > 1 +raw expr : gt(n_f32::Float32 NULL, 1) +checked expr : gt(n_f32, CAST(1_u8 AS Float32 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = 1 +raw expr : eq(n_f32::Float32 NULL, 1) +checked expr : eq(n_f32, CAST(1_u8 AS Float32 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_f32 +raw expr : gt(1, n_f32::Float32 NULL) +checked expr : gt(CAST(1_u8 AS Float32 NULL), n_f32) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_f32 +raw expr : eq(1, n_f32::Float32 NULL) +checked expr : eq(CAST(1_u8 AS Float32 NULL), n_f32) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > 1.0 +raw expr : gt(n_f32::Float32 NULL, 1.0) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(1.0_d128(2,1) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = 1.0 +raw expr : eq(n_f32::Float32 NULL, 1.0) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(1.0_d128(2,1) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_f32 +raw expr : gt(1.0, n_f32::Float32 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_f32 +raw expr : eq(1.0, n_f32::Float32 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_f32 > '1' + | ^ no function matches signature `gt(Float32 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Float32 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Float32` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float32 NULL` with `String` +... and 33 more + + + +ast : n_f32 = '1' +raw expr : eq(n_f32::Float32 NULL, '1') +checked expr : eq(n_f32, CAST("1" AS Float32 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_f32 + | ^ no function matches signature `gt(String, Float32 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float32 NULL` with `String` +... and 33 more + + + +ast : '1' = n_f32 +raw expr : eq('1', n_f32::Float32 NULL) +checked expr : eq(CAST("1" AS Float32 NULL), n_f32) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 > 1::uint64 +raw expr : gt(n_f32::Float32 NULL, CAST(1 AS UInt64)) +checked expr : gt(CAST(n_f32 AS Float64 NULL), CAST(to_uint64(1_u8) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f32 = 1::uint64 +raw expr : eq(n_f32::Float32 NULL, CAST(1 AS UInt64)) +checked expr : eq(CAST(n_f32 AS Float64 NULL), CAST(to_uint64(1_u8) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_f32 +raw expr : gt(CAST(1 AS UInt64), n_f32::Float32 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_f32 +raw expr : eq(CAST(1 AS UInt64), n_f32::Float32 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f32 | Output | ++--------+--------------+--------------+ +| Type | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : f64 > 1 +raw expr : gt(f64::Float64, 1) +checked expr : gt(f64, to_float64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = 1 +raw expr : eq(f64::Float64, 1) +checked expr : eq(f64, to_float64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > f64 +raw expr : gt(1, f64::Float64) +checked expr : gt(to_float64(1_u8), f64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = f64 +raw expr : eq(1, f64::Float64) +checked expr : eq(to_float64(1_u8), f64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 > 1.0 +raw expr : gt(f64::Float64, 1.0) +checked expr : gt(f64, to_float64(1.0_d128(2,1))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = 1.0 +raw expr : eq(f64::Float64, 1.0) +checked expr : eq(f64, to_float64(1.0_d128(2,1))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > f64 +raw expr : gt(1.0, f64::Float64) +checked expr : gt(to_float64(1.0_d128(2,1)), f64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = f64 +raw expr : eq(1.0, f64::Float64) +checked expr : eq(to_float64(1.0_d128(2,1)), f64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | f64 > '1' + | ^ no function matches signature `gt(Float64, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Float64` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Float64` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float64` with `String` +... and 33 more + + + +ast : f64 = '1' +raw expr : eq(f64::Float64, '1') +checked expr : eq(f64, to_float64("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > f64 + | ^ no function matches signature `gt(String, Float64)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float64` with `String` +... and 33 more + + + +ast : '1' = f64 +raw expr : eq('1', f64::Float64) +checked expr : eq(to_float64("1"), f64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 > 1::uint64 +raw expr : gt(f64::Float64, CAST(1 AS UInt64)) +checked expr : gt(f64, to_float64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : f64 = 1::uint64 +raw expr : eq(f64::Float64, CAST(1 AS UInt64)) +checked expr : eq(f64, to_float64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > f64 +raw expr : gt(CAST(1 AS UInt64), f64::Float64) +checked expr : gt(to_float64(to_uint64(1_u8)), f64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = f64 +raw expr : eq(CAST(1 AS UInt64), f64::Float64) +checked expr : eq(to_float64(to_uint64(1_u8)), f64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | f64 | Output | ++--------+---------+---------+ +| Type | Float64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : n_f64 > 1 +raw expr : gt(n_f64::Float64 NULL, 1) +checked expr : gt(n_f64, CAST(1_u8 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = 1 +raw expr : eq(n_f64::Float64 NULL, 1) +checked expr : eq(n_f64, CAST(1_u8 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_f64 +raw expr : gt(1, n_f64::Float64 NULL) +checked expr : gt(CAST(1_u8 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_f64 +raw expr : eq(1, n_f64::Float64 NULL) +checked expr : eq(CAST(1_u8 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > 1.0 +raw expr : gt(n_f64::Float64 NULL, 1.0) +checked expr : gt(n_f64, CAST(1.0_d128(2,1) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = 1.0 +raw expr : eq(n_f64::Float64 NULL, 1.0) +checked expr : eq(n_f64, CAST(1.0_d128(2,1) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_f64 +raw expr : gt(1.0, n_f64::Float64 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_f64 +raw expr : eq(1.0, n_f64::Float64 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_f64 > '1' + | ^ no function matches signature `gt(Float64 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Float64 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Float64` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float64 NULL` with `String` +... and 33 more + + + +ast : n_f64 = '1' +raw expr : eq(n_f64::Float64 NULL, '1') +checked expr : eq(n_f64, CAST("1" AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_f64 + | ^ no function matches signature `gt(String, Float64 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Float64 NULL` with `String` +... and 33 more + + + +ast : '1' = n_f64 +raw expr : eq('1', n_f64::Float64 NULL) +checked expr : eq(CAST("1" AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 > 1::uint64 +raw expr : gt(n_f64::Float64 NULL, CAST(1 AS UInt64)) +checked expr : gt(n_f64, CAST(to_uint64(1_u8) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_f64 = 1::uint64 +raw expr : eq(n_f64::Float64 NULL, CAST(1 AS UInt64)) +checked expr : eq(n_f64, CAST(to_uint64(1_u8) AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_f64 +raw expr : gt(CAST(1 AS UInt64), n_f64::Float64 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_f64 +raw expr : eq(CAST(1 AS UInt64), n_f64::Float64 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+--------------+--------------+ +| | n_f64 | Output | ++--------+--------------+--------------+ +| Type | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + diff --git a/src/query/functions/tests/it/type_check/testdata/nullable_signed.txt b/src/query/functions/tests/it/type_check/testdata/nullable_signed.txt new file mode 100644 index 0000000000000..822f2023f65eb --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/nullable_signed.txt @@ -0,0 +1,2048 @@ +ast : n_i32 > i32 +raw expr : gt(n_i32::Int32 NULL, i32::Int32) +checked expr : gt(n_i32, CAST(i32 AS Int32 NULL)) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i32 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = i32 +raw expr : eq(n_i32::Int32 NULL, i32::Int32) +checked expr : eq(n_i32, CAST(i32 AS Int32 NULL)) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i32 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > i64 +raw expr : gt(n_i32::Int32 NULL, i64::Int64) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | i64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = i64 +raw expr : eq(n_i32::Int32 NULL, i64::Int64) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | i64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > u32 +raw expr : gt(n_i32::Int32 NULL, u32::UInt32) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u32 | UInt32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = u32 +raw expr : eq(n_i32::Int32 NULL, u32::UInt32) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u32 | UInt32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > u64 +raw expr : gt(n_i32::Int32 NULL, u64::UInt64) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = u64 +raw expr : eq(n_i32::Int32 NULL, u64::UInt64) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_i32 +raw expr : gt(n_i32::Int32 NULL, n_i32::Int32 NULL) +checked expr : gt(n_i32, n_i32) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_i32 +raw expr : eq(n_i32::Int32 NULL, n_i32::Int32 NULL) +checked expr : eq(n_i32, n_i32) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_i64 +raw expr : gt(n_i32::Int32 NULL, n_i64::Int64 NULL) +checked expr : gt(CAST(n_i32 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+------------+--------------+ +| | n_i32 | n_i64 | Output | ++--------+------------+------------+--------------+ +| Type | Int32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_i64 +raw expr : eq(n_i32::Int32 NULL, n_i64::Int64 NULL) +checked expr : eq(CAST(n_i32 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+------------+------------+--------------+ +| | n_i32 | n_i64 | Output | ++--------+------------+------------+--------------+ +| Type | Int32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_u32 +raw expr : gt(n_i32::Int32 NULL, n_u32::UInt32 NULL) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u32 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_u32 +raw expr : eq(n_i32::Int32 NULL, n_u32::UInt32 NULL) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u32 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_u64 +raw expr : gt(n_i32::Int32 NULL, n_u64::UInt64 NULL) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_u64 +raw expr : eq(n_i32::Int32 NULL, n_u64::UInt64 NULL) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > f32 +raw expr : gt(n_i32::Int32 NULL, f32::Float32) +checked expr : gt(CAST(n_i32 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = f32 +raw expr : eq(n_i32::Int32 NULL, f32::Float32) +checked expr : eq(CAST(n_i32 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_f32 +raw expr : gt(n_i32::Int32 NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_i32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_f32 +raw expr : eq(n_i32::Int32 NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_i32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > f64 +raw expr : gt(n_i32::Int32 NULL, f64::Float64) +checked expr : gt(CAST(n_i32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = f64 +raw expr : eq(n_i32::Int32 NULL, f64::Float64) +checked expr : eq(CAST(n_i32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_f64 +raw expr : gt(n_i32::Int32 NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_i32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_f64 +raw expr : eq(n_i32::Int32 NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_i32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i32 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > d128 +raw expr : gt(n_i32::Int32 NULL, d128::Decimal(38, 0)) +checked expr : gt(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = d128 +raw expr : eq(n_i32::Int32 NULL, d128::Decimal(38, 0)) +checked expr : eq(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_d128 +raw expr : gt(n_i32::Int32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(n_i32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_d128 +raw expr : eq(n_i32::Int32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(n_i32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > d256 +raw expr : gt(n_i32::Int32 NULL, d256::Decimal(76, 0)) +checked expr : gt(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = d256 +raw expr : eq(n_i32::Int32 NULL, d256::Decimal(76, 0)) +checked expr : eq(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i32 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > n_d256 +raw expr : gt(n_i32::Int32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(n_i32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = n_d256 +raw expr : eq(n_i32::Int32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(n_i32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i32 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > i32 +raw expr : gt(n_i64::Int64 NULL, i32::Int32) +checked expr : gt(n_i64, CAST(i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = i32 +raw expr : eq(n_i64::Int64 NULL, i32::Int32) +checked expr : eq(n_i64, CAST(i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > i64 +raw expr : gt(n_i64::Int64 NULL, i64::Int64) +checked expr : gt(n_i64, CAST(i64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i64 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int64 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = i64 +raw expr : eq(n_i64::Int64 NULL, i64::Int64) +checked expr : eq(n_i64, CAST(i64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i64 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int64 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > u32 +raw expr : gt(n_i64::Int64 NULL, u32::UInt32) +checked expr : gt(n_i64, CAST(u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | u32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | UInt32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = u32 +raw expr : eq(n_i64::Int64 NULL, u32::UInt32) +checked expr : eq(n_i64, CAST(u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | u32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | UInt32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > u64 +raw expr : gt(n_i64::Int64 NULL, u64::UInt64) +checked expr : gt(n_i64, CAST(u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = u64 +raw expr : eq(n_i64::Int64 NULL, u64::UInt64) +checked expr : eq(n_i64, CAST(u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_i32 +raw expr : gt(n_i64::Int64 NULL, n_i32::Int32 NULL) +checked expr : gt(n_i64, CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+------------+--------------+ +| | n_i32 | n_i64 | Output | ++--------+------------+------------+--------------+ +| Type | Int32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_i32 +raw expr : eq(n_i64::Int64 NULL, n_i32::Int32 NULL) +checked expr : eq(n_i64, CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+------------+--------------+ +| | n_i32 | n_i64 | Output | ++--------+------------+------------+--------------+ +| Type | Int32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_i64 +raw expr : gt(n_i64::Int64 NULL, n_i64::Int64 NULL) +checked expr : gt(n_i64, n_i64) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_i64 +raw expr : eq(n_i64::Int64 NULL, n_i64::Int64 NULL) +checked expr : eq(n_i64, n_i64) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_u32 +raw expr : gt(n_i64::Int64 NULL, n_u32::UInt32 NULL) +checked expr : gt(n_i64, CAST(n_u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+------------+--------------+ +| | n_u32 | n_i64 | Output | ++--------+-------------+------------+--------------+ +| Type | UInt32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_u32 +raw expr : eq(n_i64::Int64 NULL, n_u32::UInt32 NULL) +checked expr : eq(n_i64, CAST(n_u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+------------+--------------+ +| | n_u32 | n_i64 | Output | ++--------+-------------+------------+--------------+ +| Type | UInt32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_u64 +raw expr : gt(n_i64::Int64 NULL, n_u64::UInt64 NULL) +checked expr : gt(n_i64, CAST(n_u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i64 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int64 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_u64 +raw expr : eq(n_i64::Int64 NULL, n_u64::UInt64 NULL) +checked expr : eq(n_i64, CAST(n_u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i64 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int64 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > f32 +raw expr : gt(n_i64::Int64 NULL, f32::Float32) +checked expr : gt(CAST(n_i64 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = f32 +raw expr : eq(n_i64::Int64 NULL, f32::Float32) +checked expr : eq(CAST(n_i64 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f32 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_f32 +raw expr : gt(n_i64::Int64 NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_i64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_f32 +raw expr : eq(n_i64::Int64 NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_i64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f32 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > f64 +raw expr : gt(n_i64::Int64 NULL, f64::Float64) +checked expr : gt(CAST(n_i64 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = f64 +raw expr : eq(n_i64::Int64 NULL, f64::Float64) +checked expr : eq(CAST(n_i64 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | f64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_f64 +raw expr : gt(n_i64::Int64 NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_i64 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_f64 +raw expr : eq(n_i64::Int64 NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_i64 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+------------+--------------+--------------+ +| | n_i64 | n_f64 | Output | ++--------+------------+--------------+--------------+ +| Type | Int64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > d128 +raw expr : gt(n_i64::Int64 NULL, d128::Decimal(38, 0)) +checked expr : gt(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = d128 +raw expr : eq(n_i64::Int64 NULL, d128::Decimal(38, 0)) +checked expr : eq(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d128 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_d128 +raw expr : gt(n_i64::Int64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(n_i64 AS Decimal(19, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_d128 +raw expr : eq(n_i64::Int64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(n_i64 AS Decimal(19, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d128 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > d256 +raw expr : gt(n_i64::Int64 NULL, d256::Decimal(76, 0)) +checked expr : gt(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = d256 +raw expr : eq(n_i64::Int64 NULL, d256::Decimal(76, 0)) +checked expr : eq(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+----------------+--------------+ +| | n_i64 | d256 | Output | ++--------+------------+----------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > n_d256 +raw expr : gt(n_i64::Int64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(n_i64 AS Decimal(19, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = n_d256 +raw expr : eq(n_i64::Int64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(n_i64 AS Decimal(19, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+------------+---------------------+--------------+ +| | n_i64 | n_d256 | Output | ++--------+------------+---------------------+--------------+ +| Type | Int64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > 1 +raw expr : gt(n_i32::Int32 NULL, 1) +checked expr : gt(n_i32, CAST(1_u8 AS Int32 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = 1 +raw expr : eq(n_i32::Int32 NULL, 1) +checked expr : eq(n_i32, CAST(1_i32 AS Int32 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_i32 +raw expr : gt(1, n_i32::Int32 NULL) +checked expr : gt(CAST(1_u8 AS Int32 NULL), n_i32) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_i32 +raw expr : eq(1, n_i32::Int32 NULL) +checked expr : eq(CAST(1_i32 AS Int32 NULL), n_i32) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > 1.0 +raw expr : gt(n_i32::Int32 NULL, 1.0) +checked expr : gt(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = 1.0 +raw expr : eq(n_i32::Int32 NULL, 1.0) +checked expr : eq(CAST(n_i32 AS Decimal(10, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_i32 +raw expr : gt(1.0, n_i32::Int32 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_i32 +raw expr : eq(1.0, n_i32::Int32 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_i32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_i32 > '1' + | ^ no function matches signature `gt(Int32 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Int32 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Int32` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int32 NULL` with `String` +... and 33 more + + + +ast : n_i32 = '1' +raw expr : eq(n_i32::Int32 NULL, '1') +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST("1" AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_i32 + | ^ no function matches signature `gt(String, Int32 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int32 NULL` with `String` +... and 33 more + + + +ast : '1' = n_i32 +raw expr : eq('1', n_i32::Int32 NULL) +checked expr : eq(CAST("1" AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 > 1::uint64 +raw expr : gt(n_i32::Int32 NULL, CAST(1 AS UInt64)) +checked expr : gt(CAST(n_i32 AS Int64 NULL), CAST(to_uint64(1_u8) AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i32 = 1::uint64 +raw expr : eq(n_i32::Int32 NULL, CAST(1 AS UInt64)) +checked expr : eq(CAST(n_i32 AS Int64 NULL), CAST(to_uint64(1_u8) AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_i32 +raw expr : gt(CAST(1 AS UInt64), n_i32::Int32 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_i32 +raw expr : eq(CAST(1 AS UInt64), n_i32::Int32 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i32 | Output | ++--------+------------+--------------+ +| Type | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > 1 +raw expr : gt(n_i64::Int64 NULL, 1) +checked expr : gt(n_i64, CAST(1_u8 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = 1 +raw expr : eq(n_i64::Int64 NULL, 1) +checked expr : eq(n_i64, CAST(1_i64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_i64 +raw expr : gt(1, n_i64::Int64 NULL) +checked expr : gt(CAST(1_u8 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_i64 +raw expr : eq(1, n_i64::Int64 NULL) +checked expr : eq(CAST(1_i64 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > 1.0 +raw expr : gt(n_i64::Int64 NULL, 1.0) +checked expr : gt(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = 1.0 +raw expr : eq(n_i64::Int64 NULL, 1.0) +checked expr : eq(CAST(n_i64 AS Decimal(19, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_i64 +raw expr : gt(1.0, n_i64::Int64 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_i64 +raw expr : eq(1.0, n_i64::Int64 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_i64 AS Decimal(19, 0) NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_i64 > '1' + | ^ no function matches signature `gt(Int64 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Int64 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Int64` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int64 NULL` with `String` +... and 33 more + + + +ast : n_i64 = '1' +raw expr : eq(n_i64::Int64 NULL, '1') +checked expr : eq(n_i64, CAST("1" AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_i64 + | ^ no function matches signature `gt(String, Int64 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int64 NULL` with `String` +... and 33 more + + + +ast : '1' = n_i64 +raw expr : eq('1', n_i64::Int64 NULL) +checked expr : eq(CAST("1" AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 > 1::uint64 +raw expr : gt(n_i64::Int64 NULL, CAST(1 AS UInt64)) +checked expr : gt(n_i64, CAST(to_uint64(1_u8) AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_i64 = 1::uint64 +raw expr : eq(n_i64::Int64 NULL, CAST(1 AS UInt64)) +checked expr : eq(n_i64, CAST(to_uint64(1_u8) AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_i64 +raw expr : gt(CAST(1 AS UInt64), n_i64::Int64 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_i64 +raw expr : eq(CAST(1 AS UInt64), n_i64::Int64 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+--------------+ +| | n_i64 | Output | ++--------+------------+--------------+ +| Type | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + diff --git a/src/query/functions/tests/it/type_check/testdata/nullable_unsigned.txt b/src/query/functions/tests/it/type_check/testdata/nullable_unsigned.txt new file mode 100644 index 0000000000000..a10112507cee2 --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/nullable_unsigned.txt @@ -0,0 +1,2048 @@ +ast : n_u32 > i32 +raw expr : gt(n_u32::UInt32 NULL, i32::Int32) +checked expr : gt(CAST(n_u32 AS Int64 NULL), CAST(i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = i32 +raw expr : eq(n_u32::UInt32 NULL, i32::Int32) +checked expr : eq(CAST(n_u32 AS Int64 NULL), CAST(i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > i64 +raw expr : gt(n_u32::UInt32 NULL, i64::Int64) +checked expr : gt(CAST(n_u32 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | i64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = i64 +raw expr : eq(n_u32::UInt32 NULL, i64::Int64) +checked expr : eq(CAST(n_u32 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | i64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > u32 +raw expr : gt(n_u32::UInt32 NULL, u32::UInt32) +checked expr : gt(n_u32, CAST(u32 AS UInt32 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = u32 +raw expr : eq(n_u32::UInt32 NULL, u32::UInt32) +checked expr : eq(n_u32, CAST(u32 AS UInt32 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > u64 +raw expr : gt(n_u32::UInt32 NULL, u64::UInt64) +checked expr : gt(CAST(n_u32 AS UInt64 NULL), CAST(u64 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | u64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = u64 +raw expr : eq(n_u32::UInt32 NULL, u64::UInt64) +checked expr : eq(CAST(n_u32 AS UInt64 NULL), CAST(u64 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | u64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_i32 +raw expr : gt(n_u32::UInt32 NULL, n_i32::Int32 NULL) +checked expr : gt(CAST(n_u32 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u32 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_i32 +raw expr : eq(n_u32::UInt32 NULL, n_i32::Int32 NULL) +checked expr : eq(CAST(n_u32 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u32 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_i64 +raw expr : gt(n_u32::UInt32 NULL, n_i64::Int64 NULL) +checked expr : gt(CAST(n_u32 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+-------------+------------+--------------+ +| | n_u32 | n_i64 | Output | ++--------+-------------+------------+--------------+ +| Type | UInt32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_i64 +raw expr : eq(n_u32::UInt32 NULL, n_i64::Int64 NULL) +checked expr : eq(CAST(n_u32 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+-------------+------------+--------------+ +| | n_u32 | n_i64 | Output | ++--------+-------------+------------+--------------+ +| Type | UInt32 NULL | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_u32 +raw expr : gt(n_u32::UInt32 NULL, n_u32::UInt32 NULL) +checked expr : gt(n_u32, n_u32) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_u32 +raw expr : eq(n_u32::UInt32 NULL, n_u32::UInt32 NULL) +checked expr : eq(n_u32, n_u32) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_u64 +raw expr : gt(n_u32::UInt32 NULL, n_u64::UInt64 NULL) +checked expr : gt(CAST(n_u32 AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+-------------+-------------+--------------+ +| | n_u32 | n_u64 | Output | ++--------+-------------+-------------+--------------+ +| Type | UInt32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_u64 +raw expr : eq(n_u32::UInt32 NULL, n_u64::UInt64 NULL) +checked expr : eq(CAST(n_u32 AS UInt64 NULL), n_u64) +optimized expr : true +evaluation: ++--------+-------------+-------------+--------------+ +| | n_u32 | n_u64 | Output | ++--------+-------------+-------------+--------------+ +| Type | UInt32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > f32 +raw expr : gt(n_u32::UInt32 NULL, f32::Float32) +checked expr : gt(CAST(n_u32 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = f32 +raw expr : eq(n_u32::UInt32 NULL, f32::Float32) +checked expr : eq(CAST(n_u32 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_f32 +raw expr : gt(n_u32::UInt32 NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_u32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_f32 +raw expr : eq(n_u32::UInt32 NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_u32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > f64 +raw expr : gt(n_u32::UInt32 NULL, f64::Float64) +checked expr : gt(CAST(n_u32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = f64 +raw expr : eq(n_u32::UInt32 NULL, f64::Float64) +checked expr : eq(CAST(n_u32 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_f64 +raw expr : gt(n_u32::UInt32 NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_u32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_f64 +raw expr : eq(n_u32::UInt32 NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_u32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u32 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt32 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > d128 +raw expr : gt(n_u32::UInt32 NULL, d128::Decimal(38, 0)) +checked expr : gt(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = d128 +raw expr : eq(n_u32::UInt32 NULL, d128::Decimal(38, 0)) +checked expr : eq(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_d128 +raw expr : gt(n_u32::UInt32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(n_u32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_d128 +raw expr : eq(n_u32::UInt32 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(n_u32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > d256 +raw expr : gt(n_u32::UInt32 NULL, d256::Decimal(76, 0)) +checked expr : gt(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = d256 +raw expr : eq(n_u32::UInt32 NULL, d256::Decimal(76, 0)) +checked expr : eq(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u32 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > n_d256 +raw expr : gt(n_u32::UInt32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(n_u32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = n_d256 +raw expr : eq(n_u32::UInt32 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(n_u32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u32 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt32 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > i32 +raw expr : gt(n_u64::UInt64 NULL, i32::Int32) +checked expr : gt(CAST(n_u64 AS Int64 NULL), CAST(i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = i32 +raw expr : eq(n_u64::UInt64 NULL, i32::Int32) +checked expr : eq(CAST(n_u64 AS Int64 NULL), CAST(i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > i64 +raw expr : gt(n_u64::UInt64 NULL, i64::Int64) +checked expr : gt(CAST(n_u64 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = i64 +raw expr : eq(n_u64::UInt64 NULL, i64::Int64) +checked expr : eq(CAST(n_u64 AS Int64 NULL), CAST(i64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > u32 +raw expr : gt(n_u64::UInt64 NULL, u32::UInt32) +checked expr : gt(n_u64, CAST(u32 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = u32 +raw expr : eq(n_u64::UInt64 NULL, u32::UInt32) +checked expr : eq(n_u64, CAST(u32 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > u64 +raw expr : gt(n_u64::UInt64 NULL, u64::UInt64) +checked expr : gt(n_u64, CAST(u64 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = u64 +raw expr : eq(n_u64::UInt64 NULL, u64::UInt64) +checked expr : eq(n_u64, CAST(u64 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_i32 +raw expr : gt(n_u64::UInt64 NULL, n_i32::Int32 NULL) +checked expr : gt(CAST(n_u64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_i32 +raw expr : eq(n_u64::UInt64 NULL, n_i32::Int32 NULL) +checked expr : eq(CAST(n_u64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i32 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_i64 +raw expr : gt(n_u64::UInt64 NULL, n_i64::Int64 NULL) +checked expr : gt(CAST(n_u64 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+-------------+--------------+ +| | n_i64 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int64 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_i64 +raw expr : eq(n_u64::UInt64 NULL, n_i64::Int64 NULL) +checked expr : eq(CAST(n_u64 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+------------+-------------+--------------+ +| | n_i64 | n_u64 | Output | ++--------+------------+-------------+--------------+ +| Type | Int64 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_u32 +raw expr : gt(n_u64::UInt64 NULL, n_u32::UInt32 NULL) +checked expr : gt(n_u64, CAST(n_u32 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+-------------+--------------+ +| | n_u32 | n_u64 | Output | ++--------+-------------+-------------+--------------+ +| Type | UInt32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_u32 +raw expr : eq(n_u64::UInt64 NULL, n_u32::UInt32 NULL) +checked expr : eq(n_u64, CAST(n_u32 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+-------------+--------------+ +| | n_u32 | n_u64 | Output | ++--------+-------------+-------------+--------------+ +| Type | UInt32 NULL | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_u64 +raw expr : gt(n_u64::UInt64 NULL, n_u64::UInt64 NULL) +checked expr : gt(n_u64, n_u64) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_u64 +raw expr : eq(n_u64::UInt64 NULL, n_u64::UInt64 NULL) +checked expr : eq(n_u64, n_u64) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > f32 +raw expr : gt(n_u64::UInt64 NULL, f32::Float32) +checked expr : gt(CAST(n_u64 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = f32 +raw expr : eq(n_u64::UInt64 NULL, f32::Float32) +checked expr : eq(CAST(n_u64 AS Float64 NULL), CAST(f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f32 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f32 | Float32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_f32 +raw expr : gt(n_u64::UInt64 NULL, n_f32::Float32 NULL) +checked expr : gt(CAST(n_u64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_f32 +raw expr : eq(n_u64::UInt64 NULL, n_f32::Float32 NULL) +checked expr : eq(CAST(n_u64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f32 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > f64 +raw expr : gt(n_u64::UInt64 NULL, f64::Float64) +checked expr : gt(CAST(n_u64 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = f64 +raw expr : eq(n_u64::UInt64 NULL, f64::Float64) +checked expr : eq(CAST(n_u64 AS Float64 NULL), CAST(f64 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u64 | f64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt64 NULL | Float64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| f64 | Float64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_f64 +raw expr : gt(n_u64::UInt64 NULL, n_f64::Float64 NULL) +checked expr : gt(CAST(n_u64 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_f64 +raw expr : eq(n_u64::UInt64 NULL, n_f64::Float64 NULL) +checked expr : eq(CAST(n_u64 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+-------------+--------------+--------------+ +| | n_u64 | n_f64 | Output | ++--------+-------------+--------------+--------------+ +| Type | UInt64 NULL | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > d128 +raw expr : gt(n_u64::UInt64 NULL, d128::Decimal(38, 0)) +checked expr : gt(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = d128 +raw expr : eq(n_u64::UInt64 NULL, d128::Decimal(38, 0)) +checked expr : eq(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(d128 AS Decimal(38, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d128 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d128 | Decimal128([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_d128 +raw expr : gt(n_u64::UInt64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(n_u64 AS Decimal(20, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_d128 +raw expr : eq(n_u64::UInt64 NULL, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(n_u64 AS Decimal(20, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d128 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > d256 +raw expr : gt(n_u64::UInt64 NULL, d256::Decimal(76, 0)) +checked expr : gt(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = d256 +raw expr : eq(n_u64::UInt64 NULL, d256::Decimal(76, 0)) +checked expr : eq(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(d256 AS Decimal(76, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+----------------+--------------+ +| | n_u64 | d256 | Output | ++--------+-------------+----------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+----------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| d256 | Decimal256([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > n_d256 +raw expr : gt(n_u64::UInt64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(n_u64 AS Decimal(20, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = n_d256 +raw expr : eq(n_u64::UInt64 NULL, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(n_u64 AS Decimal(20, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+-------------+---------------------+--------------+ +| | n_u64 | n_d256 | Output | ++--------+-------------+---------------------+--------------+ +| Type | UInt64 NULL | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > 1 +raw expr : gt(n_u32::UInt32 NULL, 1) +checked expr : gt(n_u32, CAST(1_u8 AS UInt32 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = 1 +raw expr : eq(n_u32::UInt32 NULL, 1) +checked expr : eq(n_u32, CAST(1_u32 AS UInt32 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_u32 +raw expr : gt(1, n_u32::UInt32 NULL) +checked expr : gt(CAST(1_u8 AS UInt32 NULL), n_u32) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_u32 +raw expr : eq(1, n_u32::UInt32 NULL) +checked expr : eq(CAST(1_u32 AS UInt32 NULL), n_u32) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > 1.0 +raw expr : gt(n_u32::UInt32 NULL, 1.0) +checked expr : gt(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = 1.0 +raw expr : eq(n_u32::UInt32 NULL, 1.0) +checked expr : eq(CAST(n_u32 AS Decimal(10, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_u32 +raw expr : gt(1.0, n_u32::UInt32 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_u32 +raw expr : eq(1.0, n_u32::UInt32 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_u32 AS Decimal(10, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_u32 > '1' + | ^ no function matches signature `gt(UInt32 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `UInt32 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `UInt32` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt32 NULL` with `String` +... and 33 more + + + +ast : n_u32 = '1' +raw expr : eq(n_u32::UInt32 NULL, '1') +checked expr : eq(CAST(n_u32 AS UInt64 NULL), CAST("1" AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_u32 + | ^ no function matches signature `gt(String, UInt32 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt32 NULL` with `String` +... and 33 more + + + +ast : '1' = n_u32 +raw expr : eq('1', n_u32::UInt32 NULL) +checked expr : eq(CAST("1" AS UInt64 NULL), CAST(n_u32 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 > 1::uint64 +raw expr : gt(n_u32::UInt32 NULL, CAST(1 AS UInt64)) +checked expr : gt(CAST(n_u32 AS UInt64 NULL), CAST(to_uint64(1_u8) AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u32 = 1::uint64 +raw expr : eq(n_u32::UInt32 NULL, CAST(1 AS UInt64)) +checked expr : eq(CAST(n_u32 AS UInt64 NULL), CAST(to_uint64(1_u8) AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_u32 +raw expr : gt(CAST(1 AS UInt64), n_u32::UInt32 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS UInt64 NULL), CAST(n_u32 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_u32 +raw expr : eq(CAST(1 AS UInt64), n_u32::UInt32 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS UInt64 NULL), CAST(n_u32 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u32 | Output | ++--------+-------------+--------------+ +| Type | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > 1 +raw expr : gt(n_u64::UInt64 NULL, 1) +checked expr : gt(n_u64, CAST(1_u8 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = 1 +raw expr : eq(n_u64::UInt64 NULL, 1) +checked expr : eq(n_u64, CAST(1_u64 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 > n_u64 +raw expr : gt(1, n_u64::UInt64 NULL) +checked expr : gt(CAST(1_u8 AS UInt64 NULL), n_u64) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1 = n_u64 +raw expr : eq(1, n_u64::UInt64 NULL) +checked expr : eq(CAST(1_u64 AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > 1.0 +raw expr : gt(n_u64::UInt64 NULL, 1.0) +checked expr : gt(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = 1.0 +raw expr : eq(n_u64::UInt64 NULL, 1.0) +checked expr : eq(CAST(n_u64 AS Decimal(20, 0) NULL), CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 > n_u64 +raw expr : gt(1.0, n_u64::UInt64 NULL) +checked expr : gt(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1.0 = n_u64 +raw expr : eq(1.0, n_u64::UInt64 NULL) +checked expr : eq(CAST(1.0_d128(2,1) AS Decimal(2, 1) NULL), CAST(n_u64 AS Decimal(20, 0) NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:7 + | +1 | n_u64 > '1' + | ^ no function matches signature `gt(UInt64 NULL, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `UInt64 NULL` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `UInt64` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt64 NULL` with `String` +... and 33 more + + + +ast : n_u64 = '1' +raw expr : eq(n_u64::UInt64 NULL, '1') +checked expr : eq(n_u64, CAST("1" AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > n_u64 + | ^ no function matches signature `gt(String, UInt64 NULL)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt64 NULL` with `String` +... and 33 more + + + +ast : '1' = n_u64 +raw expr : eq('1', n_u64::UInt64 NULL) +checked expr : eq(CAST("1" AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 > 1::uint64 +raw expr : gt(n_u64::UInt64 NULL, CAST(1 AS UInt64)) +checked expr : gt(n_u64, CAST(to_uint64(1_u8) AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : n_u64 = 1::uint64 +raw expr : eq(n_u64::UInt64 NULL, CAST(1 AS UInt64)) +checked expr : eq(n_u64, CAST(to_uint64(1_u8) AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 > n_u64 +raw expr : gt(CAST(1 AS UInt64), n_u64::UInt64 NULL) +checked expr : gt(CAST(to_uint64(1_u8) AS UInt64 NULL), n_u64) +optimized expr : true +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : 1::uint64 = n_u64 +raw expr : eq(CAST(1 AS UInt64), n_u64::UInt64 NULL) +checked expr : eq(CAST(to_uint64(1_u8) AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+-------------+--------------+ +| | n_u64 | Output | ++--------+-------------+--------------+ +| Type | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + diff --git a/src/query/functions/tests/it/type_check/testdata/signed.txt b/src/query/functions/tests/it/type_check/testdata/signed.txt new file mode 100644 index 0000000000000..1e4dd413b7492 --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/signed.txt @@ -0,0 +1,2048 @@ +ast : i32 > i32 +raw expr : gt(i32::Int32, i32::Int32) +checked expr : gt(i32, i32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = i32 +raw expr : eq(i32::Int32, i32::Int32) +checked expr : eq(i32, i32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > i64 +raw expr : gt(i32::Int32, i64::Int64) +checked expr : gt(to_int64(i32), i64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = i64 +raw expr : eq(i32::Int32, i64::Int64) +checked expr : eq(to_int64(i32), i64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > u32 +raw expr : gt(i32::Int32, u32::UInt32) +checked expr : gt(to_int64(i32), to_int64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | u32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = u32 +raw expr : eq(i32::Int32, u32::UInt32) +checked expr : eq(to_int64(i32), to_int64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | u32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > u64 +raw expr : gt(i32::Int32, u64::UInt64) +checked expr : gt(to_int64(i32), to_int64(u64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = u64 +raw expr : eq(i32::Int32, u64::UInt64) +checked expr : eq(to_int64(i32), to_int64(u64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > n_i32 +raw expr : gt(i32::Int32, n_i32::Int32 NULL) +checked expr : gt(CAST(i32 AS Int32 NULL), n_i32) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i32 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_i32 +raw expr : eq(i32::Int32, n_i32::Int32 NULL) +checked expr : eq(CAST(i32 AS Int32 NULL), n_i32) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i32 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > n_i64 +raw expr : gt(i32::Int32, n_i64::Int64 NULL) +checked expr : gt(CAST(i32 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_i64 +raw expr : eq(i32::Int32, n_i64::Int64 NULL) +checked expr : eq(CAST(i32 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > n_u32 +raw expr : gt(i32::Int32, n_u32::UInt32 NULL) +checked expr : gt(CAST(i32 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_u32 +raw expr : eq(i32::Int32, n_u32::UInt32 NULL) +checked expr : eq(CAST(i32 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > n_u64 +raw expr : gt(i32::Int32, n_u64::UInt64 NULL) +checked expr : gt(CAST(i32 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_u64 +raw expr : eq(i32::Int32, n_u64::UInt64 NULL) +checked expr : eq(CAST(i32 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > f32 +raw expr : gt(i32::Int32, f32::Float32) +checked expr : gt(to_float64(i32), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = f32 +raw expr : eq(i32::Int32, f32::Float32) +checked expr : eq(to_float64(i32), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > n_f32 +raw expr : gt(i32::Int32, n_f32::Float32 NULL) +checked expr : gt(CAST(i32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_f32 +raw expr : eq(i32::Int32, n_f32::Float32 NULL) +checked expr : eq(CAST(i32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > f64 +raw expr : gt(i32::Int32, f64::Float64) +checked expr : gt(to_float64(i32), f64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = f64 +raw expr : eq(i32::Int32, f64::Float64) +checked expr : eq(to_float64(i32), f64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > n_f64 +raw expr : gt(i32::Int32, n_f64::Float64 NULL) +checked expr : gt(CAST(i32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_f64 +raw expr : eq(i32::Int32, n_f64::Float64 NULL) +checked expr : eq(CAST(i32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > d128 +raw expr : gt(i32::Int32, d128::Decimal(38, 0)) +checked expr : gt(to_decimal(10, 0)(i32), d128) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = d128 +raw expr : eq(i32::Int32, d128::Decimal(38, 0)) +checked expr : eq(to_decimal(10, 0)(i32), d128) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > n_d128 +raw expr : gt(i32::Int32, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(i32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_d128 +raw expr : eq(i32::Int32, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(i32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > d256 +raw expr : gt(i32::Int32, d256::Decimal(76, 0)) +checked expr : gt(to_decimal(10, 0)(i32), d256) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = d256 +raw expr : eq(i32::Int32, d256::Decimal(76, 0)) +checked expr : eq(to_decimal(10, 0)(i32), d256) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i32 > n_d256 +raw expr : gt(i32::Int32, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(i32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 = n_d256 +raw expr : eq(i32::Int32, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(i32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i32 | Int32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > i32 +raw expr : gt(i64::Int64, i32::Int32) +checked expr : gt(i64, to_int64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = i32 +raw expr : eq(i64::Int64, i32::Int32) +checked expr : eq(i64, to_int64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > i64 +raw expr : gt(i64::Int64, i64::Int64) +checked expr : gt(i64, i64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = i64 +raw expr : eq(i64::Int64, i64::Int64) +checked expr : eq(i64, i64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > u32 +raw expr : gt(i64::Int64, u32::UInt32) +checked expr : gt(i64, to_int64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = u32 +raw expr : eq(i64::Int64, u32::UInt32) +checked expr : eq(i64, to_int64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > u64 +raw expr : gt(i64::Int64, u64::UInt64) +checked expr : gt(i64, to_int64(u64)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = u64 +raw expr : eq(i64::Int64, u64::UInt64) +checked expr : eq(i64, to_int64(u64)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > n_i32 +raw expr : gt(i64::Int64, n_i32::Int32 NULL) +checked expr : gt(CAST(i64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | i64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_i32 +raw expr : eq(i64::Int64, n_i32::Int32 NULL) +checked expr : eq(CAST(i64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | i64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > n_i64 +raw expr : gt(i64::Int64, n_i64::Int64 NULL) +checked expr : gt(CAST(i64 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | i64 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int64 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_i64 +raw expr : eq(i64::Int64, n_i64::Int64 NULL) +checked expr : eq(CAST(i64 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | i64 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | Int64 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > n_u32 +raw expr : gt(i64::Int64, n_u32::UInt32 NULL) +checked expr : gt(CAST(i64 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | i64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_u32 +raw expr : eq(i64::Int64, n_u32::UInt32 NULL) +checked expr : eq(CAST(i64 AS Int64 NULL), CAST(n_u32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | i64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | Int64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| i64 | Int64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > n_u64 +raw expr : gt(i64::Int64, n_u64::UInt64 NULL) +checked expr : gt(CAST(i64 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | i64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_u64 +raw expr : eq(i64::Int64, n_u64::UInt64 NULL) +checked expr : eq(CAST(i64 AS Int64 NULL), CAST(n_u64 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | i64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | Int64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > f32 +raw expr : gt(i64::Int64, f32::Float32) +checked expr : gt(to_float64(i64), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = f32 +raw expr : eq(i64::Int64, f32::Float32) +checked expr : eq(to_float64(i64), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > n_f32 +raw expr : gt(i64::Int64, n_f32::Float32 NULL) +checked expr : gt(CAST(i64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_f32 +raw expr : eq(i64::Int64, n_f32::Float32 NULL) +checked expr : eq(CAST(i64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > f64 +raw expr : gt(i64::Int64, f64::Float64) +checked expr : gt(to_float64(i64), f64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = f64 +raw expr : eq(i64::Int64, f64::Float64) +checked expr : eq(to_float64(i64), f64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > n_f64 +raw expr : gt(i64::Int64, n_f64::Float64 NULL) +checked expr : gt(CAST(i64 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_f64 +raw expr : eq(i64::Int64, n_f64::Float64 NULL) +checked expr : eq(CAST(i64 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | i64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | Int64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > d128 +raw expr : gt(i64::Int64, d128::Decimal(38, 0)) +checked expr : gt(to_decimal(19, 0)(i64), d128) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = d128 +raw expr : eq(i64::Int64, d128::Decimal(38, 0)) +checked expr : eq(to_decimal(19, 0)(i64), d128) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > n_d128 +raw expr : gt(i64::Int64, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(i64 AS Decimal(19, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_d128 +raw expr : eq(i64::Int64, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(i64 AS Decimal(19, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 > d256 +raw expr : gt(i64::Int64, d256::Decimal(76, 0)) +checked expr : gt(to_decimal(19, 0)(i64), d256) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = d256 +raw expr : eq(i64::Int64, d256::Decimal(76, 0)) +checked expr : eq(to_decimal(19, 0)(i64), d256) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | i64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | Int64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : i64 > n_d256 +raw expr : gt(i64::Int64, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(i64 AS Decimal(19, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i64 = n_d256 +raw expr : eq(i64::Int64, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(i64 AS Decimal(19, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | i64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | Int64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| i64 | Int64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : i32 > 1 +raw expr : gt(i32::Int32, 1) +checked expr : gt(i32, to_int32(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = 1 +raw expr : eq(i32::Int32, 1) +checked expr : eq(i32, 1_i32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > i32 +raw expr : gt(1, i32::Int32) +checked expr : gt(to_int32(1_u8), i32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = i32 +raw expr : eq(1, i32::Int32) +checked expr : eq(1_i32, i32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 > 1.0 +raw expr : gt(i32::Int32, 1.0) +checked expr : gt(to_decimal(10, 0)(i32), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = 1.0 +raw expr : eq(i32::Int32, 1.0) +checked expr : eq(to_decimal(10, 0)(i32), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > i32 +raw expr : gt(1.0, i32::Int32) +checked expr : gt(1.0_d128(2,1), to_decimal(10, 0)(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = i32 +raw expr : eq(1.0, i32::Int32) +checked expr : eq(1.0_d128(2,1), to_decimal(10, 0)(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | i32 > '1' + | ^ no function matches signature `gt(Int32, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Int32` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Int32` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int32` with `String` +... and 33 more + + + +ast : i32 = '1' +raw expr : eq(i32::Int32, '1') +checked expr : eq(to_int64(i32), to_int64("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > i32 + | ^ no function matches signature `gt(String, Int32)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int32` with `String` +... and 33 more + + + +ast : '1' = i32 +raw expr : eq('1', i32::Int32) +checked expr : eq(to_int64("1"), to_int64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 > 1::uint64 +raw expr : gt(i32::Int32, CAST(1 AS UInt64)) +checked expr : gt(to_int64(i32), to_int64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i32 = 1::uint64 +raw expr : eq(i32::Int32, CAST(1 AS UInt64)) +checked expr : eq(to_int64(i32), to_int64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > i32 +raw expr : gt(CAST(1 AS UInt64), i32::Int32) +checked expr : gt(to_int64(to_uint64(1_u8)), to_int64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = i32 +raw expr : eq(CAST(1 AS UInt64), i32::Int32) +checked expr : eq(to_int64(to_uint64(1_u8)), to_int64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i32 | Output | ++--------+---------+---------+ +| Type | Int32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 > 1 +raw expr : gt(i64::Int64, 1) +checked expr : gt(i64, to_int64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = 1 +raw expr : eq(i64::Int64, 1) +checked expr : eq(i64, 1_i64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > i64 +raw expr : gt(1, i64::Int64) +checked expr : gt(to_int64(1_u8), i64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = i64 +raw expr : eq(1, i64::Int64) +checked expr : eq(1_i64, i64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 > 1.0 +raw expr : gt(i64::Int64, 1.0) +checked expr : gt(to_decimal(19, 0)(i64), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = 1.0 +raw expr : eq(i64::Int64, 1.0) +checked expr : eq(to_decimal(19, 0)(i64), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > i64 +raw expr : gt(1.0, i64::Int64) +checked expr : gt(1.0_d128(2,1), to_decimal(19, 0)(i64)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = i64 +raw expr : eq(1.0, i64::Int64) +checked expr : eq(1.0_d128(2,1), to_decimal(19, 0)(i64)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | i64 > '1' + | ^ no function matches signature `gt(Int64, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `Int64` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `Int64` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int64` with `String` +... and 33 more + + + +ast : i64 = '1' +raw expr : eq(i64::Int64, '1') +checked expr : eq(i64, to_int64("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > i64 + | ^ no function matches signature `gt(String, Int64)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `Int64` with `String` +... and 33 more + + + +ast : '1' = i64 +raw expr : eq('1', i64::Int64) +checked expr : eq(to_int64("1"), i64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 > 1::uint64 +raw expr : gt(i64::Int64, CAST(1 AS UInt64)) +checked expr : gt(i64, to_int64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : i64 = 1::uint64 +raw expr : eq(i64::Int64, CAST(1 AS UInt64)) +checked expr : eq(i64, to_int64(to_uint64(1_u8))) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > i64 +raw expr : gt(CAST(1 AS UInt64), i64::Int64) +checked expr : gt(to_int64(to_uint64(1_u8)), i64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = i64 +raw expr : eq(CAST(1 AS UInt64), i64::Int64) +checked expr : eq(to_int64(to_uint64(1_u8)), i64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | i64 | Output | ++--------+---------+---------+ +| Type | Int64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + diff --git a/src/query/functions/tests/it/type_check/testdata/unsigned.txt b/src/query/functions/tests/it/type_check/testdata/unsigned.txt new file mode 100644 index 0000000000000..bc1077c16ccca --- /dev/null +++ b/src/query/functions/tests/it/type_check/testdata/unsigned.txt @@ -0,0 +1,2048 @@ +ast : u32 > i32 +raw expr : gt(u32::UInt32, i32::Int32) +checked expr : gt(to_int64(u32), to_int64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | u32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = i32 +raw expr : eq(u32::UInt32, i32::Int32) +checked expr : eq(to_int64(u32), to_int64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | u32 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > i64 +raw expr : gt(u32::UInt32, i64::Int64) +checked expr : gt(to_int64(u32), i64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = i64 +raw expr : eq(u32::UInt32, i64::Int64) +checked expr : eq(to_int64(u32), i64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | i64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Int64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| i64 | Int64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > u32 +raw expr : gt(u32::UInt32, u32::UInt32) +checked expr : gt(u32, u32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = u32 +raw expr : eq(u32::UInt32, u32::UInt32) +checked expr : eq(u32, u32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > u64 +raw expr : gt(u32::UInt32, u64::UInt64) +checked expr : gt(to_uint64(u32), u64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = u64 +raw expr : eq(u32::UInt32, u64::UInt64) +checked expr : eq(to_uint64(u32), u64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > n_i32 +raw expr : gt(u32::UInt32, n_i32::Int32 NULL) +checked expr : gt(CAST(u32 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u32 | UInt32([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_i32 +raw expr : eq(u32::UInt32, n_i32::Int32 NULL) +checked expr : eq(CAST(u32 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u32 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt32 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u32 | UInt32([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > n_i64 +raw expr : gt(u32::UInt32, n_i64::Int64 NULL) +checked expr : gt(CAST(u32 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+---------+------------+--------------+ +| | u32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | UInt32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_i64 +raw expr : eq(u32::UInt32, n_i64::Int64 NULL) +checked expr : eq(CAST(u32 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+---------+------------+--------------+ +| | u32 | n_i64 | Output | ++--------+---------+------------+--------------+ +| Type | UInt32 | Int64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > n_u32 +raw expr : gt(u32::UInt32, n_u32::UInt32 NULL) +checked expr : gt(CAST(u32 AS UInt32 NULL), n_u32) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_u32 +raw expr : eq(u32::UInt32, n_u32::UInt32 NULL) +checked expr : eq(CAST(u32 AS UInt32 NULL), n_u32) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u32 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > n_u64 +raw expr : gt(u32::UInt32, n_u64::UInt64 NULL) +checked expr : gt(CAST(u32 AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_u64 +raw expr : eq(u32::UInt32, n_u64::UInt64 NULL) +checked expr : eq(CAST(u32 AS UInt64 NULL), n_u64) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u32 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt32 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > f32 +raw expr : gt(u32::UInt32, f32::Float32) +checked expr : gt(to_float64(u32), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = f32 +raw expr : eq(u32::UInt32, f32::Float32) +checked expr : eq(to_float64(u32), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > n_f32 +raw expr : gt(u32::UInt32, n_f32::Float32 NULL) +checked expr : gt(CAST(u32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_f32 +raw expr : eq(u32::UInt32, n_f32::Float32 NULL) +checked expr : eq(CAST(u32 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > f64 +raw expr : gt(u32::UInt32, f64::Float64) +checked expr : gt(to_float64(u32), f64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = f64 +raw expr : eq(u32::UInt32, f64::Float64) +checked expr : eq(to_float64(u32), f64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > n_f64 +raw expr : gt(u32::UInt32, n_f64::Float64 NULL) +checked expr : gt(CAST(u32 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_f64 +raw expr : eq(u32::UInt32, n_f64::Float64 NULL) +checked expr : eq(CAST(u32 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u32 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt32 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > d128 +raw expr : gt(u32::UInt32, d128::Decimal(38, 0)) +checked expr : gt(to_decimal(10, 0)(u32), d128) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = d128 +raw expr : eq(u32::UInt32, d128::Decimal(38, 0)) +checked expr : eq(to_decimal(10, 0)(u32), d128) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > n_d128 +raw expr : gt(u32::UInt32, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(u32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_d128 +raw expr : eq(u32::UInt32, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(u32 AS Decimal(10, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > d256 +raw expr : gt(u32::UInt32, d256::Decimal(76, 0)) +checked expr : gt(to_decimal(10, 0)(u32), d256) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = d256 +raw expr : eq(u32::UInt32, d256::Decimal(76, 0)) +checked expr : eq(to_decimal(10, 0)(u32), d256) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u32 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt32 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u32 > n_d256 +raw expr : gt(u32::UInt32, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(u32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 = n_d256 +raw expr : eq(u32::UInt32, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(u32 AS Decimal(10, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u32 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt32 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u32 | UInt32([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > i32 +raw expr : gt(u64::UInt64, i32::Int32) +checked expr : gt(to_int64(u64), to_int64(i32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = i32 +raw expr : eq(u64::UInt64, i32::Int32) +checked expr : eq(to_int64(u64), to_int64(i32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i32 | Int32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > i64 +raw expr : gt(u64::UInt64, i64::Int64) +checked expr : gt(to_int64(u64), i64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | i64 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = i64 +raw expr : eq(u64::UInt64, i64::Int64) +checked expr : eq(to_int64(u64), i64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | i64 | u64 | Output | ++--------+---------+---------+---------+ +| Type | Int64 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| i64 | Int64([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > u32 +raw expr : gt(u64::UInt64, u32::UInt32) +checked expr : gt(u64, to_uint64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = u32 +raw expr : eq(u64::UInt64, u32::UInt32) +checked expr : eq(u64, to_uint64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u32 | u64 | Output | ++--------+---------+---------+---------+ +| Type | UInt32 | UInt64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > u64 +raw expr : gt(u64::UInt64, u64::UInt64) +checked expr : gt(u64, u64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = u64 +raw expr : eq(u64::UInt64, u64::UInt64) +checked expr : eq(u64, u64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > n_i32 +raw expr : gt(u64::UInt64, n_i32::Int32 NULL) +checked expr : gt(CAST(u64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_i32 +raw expr : eq(u64::UInt64, n_i32::Int32 NULL) +checked expr : eq(CAST(u64 AS Int64 NULL), CAST(n_i32 AS Int64 NULL)) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i32 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i32 | NullableColumn { column: Int32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > n_i64 +raw expr : gt(u64::UInt64, n_i64::Int64 NULL) +checked expr : gt(CAST(u64 AS Int64 NULL), n_i64) +optimized expr : false +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_i64 +raw expr : eq(u64::UInt64, n_i64::Int64 NULL) +checked expr : eq(CAST(u64 AS Int64 NULL), n_i64) +optimized expr : true +evaluation: ++--------+------------+---------+--------------+ +| | n_i64 | u64 | Output | ++--------+------------+---------+--------------+ +| Type | Int64 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_i64 | NullableColumn { column: Int64([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > n_u32 +raw expr : gt(u64::UInt64, n_u32::UInt32 NULL) +checked expr : gt(CAST(u64 AS UInt64 NULL), CAST(n_u32 AS UInt64 NULL)) +optimized expr : false +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | u64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_u32 +raw expr : eq(u64::UInt64, n_u32::UInt32 NULL) +checked expr : eq(CAST(u64 AS UInt64 NULL), CAST(n_u32 AS UInt64 NULL)) +optimized expr : true +evaluation: ++--------+-------------+---------+--------------+ +| | n_u32 | u64 | Output | ++--------+-------------+---------+--------------+ +| Type | UInt32 NULL | UInt64 | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+-------------+---------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| n_u32 | NullableColumn { column: UInt32([0]), validity: [0b_______1] } | +| u64 | UInt64([0]) | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > n_u64 +raw expr : gt(u64::UInt64, n_u64::UInt64 NULL) +checked expr : gt(CAST(u64 AS UInt64 NULL), n_u64) +optimized expr : false +evaluation: ++--------+---------+-------------+--------------+ +| | u64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_u64 +raw expr : eq(u64::UInt64, n_u64::UInt64 NULL) +checked expr : eq(CAST(u64 AS UInt64 NULL), n_u64) +optimized expr : true +evaluation: ++--------+---------+-------------+--------------+ +| | u64 | n_u64 | Output | ++--------+---------+-------------+--------------+ +| Type | UInt64 | UInt64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+-------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_u64 | NullableColumn { column: UInt64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > f32 +raw expr : gt(u64::UInt64, f32::Float32) +checked expr : gt(to_float64(u64), to_float64(f32)) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = f32 +raw expr : eq(u64::UInt64, f32::Float32) +checked expr : eq(to_float64(u64), to_float64(f32)) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u64 | f32 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float32 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f32 | Float32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > n_f32 +raw expr : gt(u64::UInt64, n_f32::Float32 NULL) +checked expr : gt(CAST(u64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_f32 +raw expr : eq(u64::UInt64, n_f32::Float32 NULL) +checked expr : eq(CAST(u64 AS Float64 NULL), CAST(n_f32 AS Float64 NULL)) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f32 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float32 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f32 | NullableColumn { column: Float32([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > f64 +raw expr : gt(u64::UInt64, f64::Float64) +checked expr : gt(to_float64(u64), f64) +optimized expr : false +evaluation: ++--------+---------+---------+---------+ +| | u64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = f64 +raw expr : eq(u64::UInt64, f64::Float64) +checked expr : eq(to_float64(u64), f64) +optimized expr : true +evaluation: ++--------+---------+---------+---------+ +| | u64 | f64 | Output | ++--------+---------+---------+---------+ +| Type | UInt64 | Float64 | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| f64 | Float64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > n_f64 +raw expr : gt(u64::UInt64, n_f64::Float64 NULL) +checked expr : gt(CAST(u64 AS Float64 NULL), n_f64) +optimized expr : false +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_f64 +raw expr : eq(u64::UInt64, n_f64::Float64 NULL) +checked expr : eq(CAST(u64 AS Float64 NULL), n_f64) +optimized expr : true +evaluation: ++--------+---------+--------------+--------------+ +| | u64 | n_f64 | Output | ++--------+---------+--------------+--------------+ +| Type | UInt64 | Float64 NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+--------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_f64 | NullableColumn { column: Float64([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > d128 +raw expr : gt(u64::UInt64, d128::Decimal(38, 0)) +checked expr : gt(to_decimal(20, 0)(u64), d128) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = d128 +raw expr : eq(u64::UInt64, d128::Decimal(38, 0)) +checked expr : eq(to_decimal(20, 0)(u64), d128) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d128 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(38, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d128 | Decimal128([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > n_d128 +raw expr : gt(u64::UInt64, n_d128::Decimal(38, 0) NULL) +checked expr : gt(CAST(u64 AS Decimal(20, 0) NULL), n_d128) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_d128 +raw expr : eq(u64::UInt64, n_d128::Decimal(38, 0) NULL) +checked expr : eq(CAST(u64 AS Decimal(20, 0) NULL), n_d128) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d128 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(38, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d128 | NullableColumn { column: Decimal128([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 > d256 +raw expr : gt(u64::UInt64, d256::Decimal(76, 0)) +checked expr : gt(to_decimal(20, 0)(u64), d256) +optimized expr : false +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = d256 +raw expr : eq(u64::UInt64, d256::Decimal(76, 0)) +checked expr : eq(to_decimal(20, 0)(u64), d256) +optimized expr : true +evaluation: ++--------+---------+----------------+---------+ +| | u64 | d256 | Output | ++--------+---------+----------------+---------+ +| Type | UInt64 | Decimal(76, 0) | Boolean | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+----------------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| d256 | Decimal256([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : u64 > n_d256 +raw expr : gt(u64::UInt64, n_d256::Decimal(76, 0) NULL) +checked expr : gt(CAST(u64 AS Decimal(20, 0) NULL), n_d256) +optimized expr : false +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {FALSE} | +| Row 0 | 0 | 0 | false | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______0]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u64 = n_d256 +raw expr : eq(u64::UInt64, n_d256::Decimal(76, 0) NULL) +checked expr : eq(CAST(u64 AS Decimal(20, 0) NULL), n_d256) +optimized expr : true +evaluation: ++--------+---------+---------------------+--------------+ +| | u64 | n_d256 | Output | ++--------+---------+---------------------+--------------+ +| Type | UInt64 | Decimal(76, 0) NULL | Boolean NULL | +| Domain | {0..=0} | {0..=0} | {TRUE} | +| Row 0 | 0 | 0 | true | ++--------+---------+---------------------+--------------+ +evaluation (internal): ++--------+--------------------------------------------------------------------------+ +| Column | Data | ++--------+--------------------------------------------------------------------------+ +| u64 | UInt64([0]) | +| n_d256 | NullableColumn { column: Decimal256([0]), validity: [0b_______1] } | +| Output | NullableColumn { column: Boolean([0b_______1]), validity: [0b_______1] } | ++--------+--------------------------------------------------------------------------+ + + +ast : u32 > 1 +raw expr : gt(u32::UInt32, 1) +checked expr : gt(u32, to_uint32(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = 1 +raw expr : eq(u32::UInt32, 1) +checked expr : eq(u32, 1_u32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > u32 +raw expr : gt(1, u32::UInt32) +checked expr : gt(to_uint32(1_u8), u32) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = u32 +raw expr : eq(1, u32::UInt32) +checked expr : eq(1_u32, u32) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 > 1.0 +raw expr : gt(u32::UInt32, 1.0) +checked expr : gt(to_decimal(10, 0)(u32), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = 1.0 +raw expr : eq(u32::UInt32, 1.0) +checked expr : eq(to_decimal(10, 0)(u32), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > u32 +raw expr : gt(1.0, u32::UInt32) +checked expr : gt(1.0_d128(2,1), to_decimal(10, 0)(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = u32 +raw expr : eq(1.0, u32::UInt32) +checked expr : eq(1.0_d128(2,1), to_decimal(10, 0)(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | u32 > '1' + | ^ no function matches signature `gt(UInt32, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `UInt32` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `UInt32` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt32` with `String` +... and 33 more + + + +ast : u32 = '1' +raw expr : eq(u32::UInt32, '1') +checked expr : eq(to_uint64(u32), to_uint64("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > u32 + | ^ no function matches signature `gt(String, UInt32)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt32` with `String` +... and 33 more + + + +ast : '1' = u32 +raw expr : eq('1', u32::UInt32) +checked expr : eq(to_uint64("1"), to_uint64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 > 1::uint64 +raw expr : gt(u32::UInt32, CAST(1 AS UInt64)) +checked expr : gt(to_uint64(u32), to_uint64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u32 = 1::uint64 +raw expr : eq(u32::UInt32, CAST(1 AS UInt64)) +checked expr : eq(to_uint64(u32), to_uint64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > u32 +raw expr : gt(CAST(1 AS UInt64), u32::UInt32) +checked expr : gt(to_uint64(1_u8), to_uint64(u32)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = u32 +raw expr : eq(CAST(1 AS UInt64), u32::UInt32) +checked expr : eq(to_uint64(1_u8), to_uint64(u32)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u32 | Output | ++--------+---------+---------+ +| Type | UInt32 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u32 | UInt32([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 > 1 +raw expr : gt(u64::UInt64, 1) +checked expr : gt(u64, to_uint64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = 1 +raw expr : eq(u64::UInt64, 1) +checked expr : eq(u64, 1_u64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1 > u64 +raw expr : gt(1, u64::UInt64) +checked expr : gt(to_uint64(1_u8), u64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1 = u64 +raw expr : eq(1, u64::UInt64) +checked expr : eq(1_u64, u64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 > 1.0 +raw expr : gt(u64::UInt64, 1.0) +checked expr : gt(to_decimal(20, 0)(u64), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = 1.0 +raw expr : eq(u64::UInt64, 1.0) +checked expr : eq(to_decimal(20, 0)(u64), 1.0_d128(2,1)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1.0 > u64 +raw expr : gt(1.0, u64::UInt64) +checked expr : gt(1.0_d128(2,1), to_decimal(20, 0)(u64)) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1.0 = u64 +raw expr : eq(1.0, u64::UInt64) +checked expr : eq(1.0_d128(2,1), to_decimal(20, 0)(u64)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | u64 > '1' + | ^ no function matches signature `gt(UInt64, String)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `UInt64` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `UInt64` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt64` with `String` +... and 33 more + + + +ast : u64 = '1' +raw expr : eq(u64::UInt64, '1') +checked expr : eq(u64, to_uint64("1")) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +error: + --> SQL:1:5 + | +1 | '1' > u64 + | ^ no function matches signature `gt(String, UInt64)`, you might need to add explicit type casts. + +candidate functions: + gt(Variant, Variant) :: Boolean : unable to unify `String` with `Variant` + gt(Variant NULL, Variant NULL) :: Boolean NULL : unable to unify `String` with `Variant` + gt(String, String) :: Boolean : unable to unify `UInt64` with `String` +... and 33 more + + + +ast : '1' = u64 +raw expr : eq('1', u64::UInt64) +checked expr : eq(to_uint64("1"), u64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 > 1::uint64 +raw expr : gt(u64::UInt64, CAST(1 AS UInt64)) +checked expr : gt(u64, to_uint64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : u64 = 1::uint64 +raw expr : eq(u64::UInt64, CAST(1 AS UInt64)) +checked expr : eq(u64, to_uint64(1_u8)) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + + +ast : 1::uint64 > u64 +raw expr : gt(CAST(1 AS UInt64), u64::UInt64) +checked expr : gt(to_uint64(1_u8), u64) +optimized expr : true +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {TRUE} | +| Row 0 | 0 | true | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______1]) | ++--------+-----------------------+ + + +ast : 1::uint64 = u64 +raw expr : eq(CAST(1 AS UInt64), u64::UInt64) +checked expr : eq(to_uint64(1_u8), u64) +optimized expr : false +evaluation: ++--------+---------+---------+ +| | u64 | Output | ++--------+---------+---------+ +| Type | UInt64 | Boolean | +| Domain | {0..=0} | {FALSE} | +| Row 0 | 0 | false | ++--------+---------+---------+ +evaluation (internal): ++--------+-----------------------+ +| Column | Data | ++--------+-----------------------+ +| u64 | UInt64([0]) | +| Output | Boolean([0b_______0]) | ++--------+-----------------------+ + +