should be it

external/duckdb/benchmark/micro/cast/cast_constant_string_to_enum.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_constant_string_to_enum.benchmark
+# description: Benchmark casting enums to varchar and the comparisons
+# group: [cast]
+
+name Cast VARCHAR -> ENUM
+group cast
+
+load
+create type integer_enum as enum('0', '1', '2', '3', '4');
+create table integers as select cast((i%5)::varchar as integer_enum) as enum_val, (i%7) as integer_val, (i%7)::varchar as string_val from range(100000000) t(i);
+
+# constant string value should cast to enum now.
+run
+select count(*) FROM integers WHERE enum_val='1';
+

external/duckdb/benchmark/micro/cast/cast_date_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_date_string.benchmark
+# description: Cast date values to string
+# group: [cast]
+
+name Cast DATE -> VARCHAR
+group cast
+
+load
+CREATE TABLE dates AS SELECT DATE '1992-01-01' + interval (i % 10000) days AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(d AS VARCHAR)) FROM dates
+
+result I
+1992-01-01 00:00:00

external/duckdb/benchmark/micro/cast/cast_decimal_double_1.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_decimal_double_1.benchmark
+# description: Cast string values to double, range 0-1e30, converted to DECIMAL(38,8), this means full range is full
+# group: [cast]
+
+name Cast DECIMAL -> DOUBLEA
+group cast
+
+load
+CREATE TABLE doubles AS SELECT (random()*1e30)::DECIMAL(38,8) AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT SUM(CAST(d AS DOUBLE)) > 0.0 FROM doubles
+
+result I
+true

external/duckdb/benchmark/micro/cast/cast_decimal_double_2.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_decimal_double_2.benchmark
+# description: Cast string values to double, range 0-1e15, converted to DECIMAL(38,8), top part of the range is empty
+# group: [cast]
+
+name Cast DECIMAL -> DOUBLE
+group cast
+
+load
+CREATE TABLE doubles AS SELECT (random()*1e15)::DECIMAL(38,8) AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT SUM(CAST(d AS DOUBLE)) > 0.0 FROM doubles
+
+result I
+true

external/duckdb/benchmark/micro/cast/cast_decimal_double_3.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_decimal_double_3.benchmark
+# description: Cast string values to double, range 0-1, converted to DECIMAL(38,8), range is mostly empty
+# group: [cast]
+
+name Cast DECIMAL -> DOUBLE
+group cast
+
+load
+CREATE TABLE doubles AS SELECT (random())::DECIMAL(38,8) AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT SUM(CAST(d AS DOUBLE)) > 0.0 FROM doubles
+
+result I
+true

external/duckdb/benchmark/micro/cast/cast_decimal_double_4.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_decimal_double_4.benchmark
+# description: Cast string values to double, range 0-1, converted to DECIMAL(38,8), range is mostly empty
+# group: [cast]
+
+name Cast DECIMAL -> DOUBLE
+group cast
+
+load
+CREATE TABLE doubles AS SELECT (random()*1e28)::DECIMAL(38,0) AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT SUM(CAST(d AS DOUBLE)) > 0.0 FROM doubles
+
+result I
+true

external/duckdb/benchmark/micro/cast/cast_double_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_double_string.benchmark
+# description: Cast double values to string
+# group: [cast]
+
+name Cast DOUBLE -> VARCHAR
+group cast
+
+load
+CREATE TABLE doubles AS SELECT (i*0.8)::DOUBLE d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(d AS VARCHAR)) FROM doubles
+
+result I
+0.0

external/duckdb/benchmark/micro/cast/cast_enum_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_enum_string.benchmark
+# description: Benchmark casting enums to varchar and the comparisons
+# group: [cast]
+
+name Cast ENUM -> VARCHAR
+group cast
+
+load
+create type integer_enum as enum('0', '1', '2', '3', '4');
+create table integers as select cast((i%5)::varchar as integer_enum) as enum_val, (i%7) as integer_val, (i%7)::varchar as string_val from range(100000000) t(i);
+
+
+# cast both should auto-cast to varchar
+run
+select count(*) FROM integers WHERE enum_val = integer_val;

external/duckdb/benchmark/micro/cast/cast_huge_hugeint_string_benchmark.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_huge_hugeint_string_benchmark.benchmark
+# description: Cast HUYGE HUGEINT to string
+# group: [cast]
+
+name Cast HUGEINT -> VARCHAR (Big HUGEINT)
+group cast
+
+load
+CREATE TABLE integers AS SELECT '1e18'::HUGEINT*i::HUGEINT*i::HUGEINT AS i FROM range(0, 10000000, 1) tbl(i);
+
+run
+SELECT MAX(i::VARCHAR) FROM integers
+
+result I
+99999980000001000000000000000000

external/duckdb/benchmark/micro/cast/cast_huge_string_hugeint.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_huge_string_hugeint.benchmark
+# description: Cast HUYGE HUGEINT to string
+# group: [cast]
+
+name Cast VARCHAR -> HUGEINT (Big HUGEINT)
+group cast
+
+load
+CREATE TABLE strings AS SELECT ('1e18'::HUGEINT*i::HUGEINT*i::HUGEINT)::VARCHAR AS s FROM range(0, 10000000, 1) tbl(i);
+
+run
+SELECT MAX(s::HUGEINT) FROM strings
+
+result I
+99999980000001000000000000000000

external/duckdb/benchmark/micro/cast/cast_hugeint_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_hugeint_string.benchmark
+# description: Cast small HUGEINT values to string
+# group: [cast]
+
+name Cast HUGEINT -> VARCHAR
+group cast
+
+load
+CREATE TABLE integers AS SELECT i::HUGEINT AS i FROM range(0, 10000000, 1) tbl(i);
+
+run
+SELECT MAX(CAST(i AS VARCHAR)) FROM integers
+
+result I
+9999999

external/duckdb/benchmark/micro/cast/cast_int32_int64.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_int32_int64.benchmark
+# description: Cast INTEGER to BIGINT
+# group: [cast]
+
+name Cast INTEGER -> BIGINT
+group cast
+
+load
+CREATE TABLE integers AS SELECT i::INTEGER i FROM range(0, 50000000) tbl(i);
+
+run
+SELECT MAX(CAST(i AS BIGINT)) FROM integers
+
+result I
+49999999

external/duckdb/benchmark/micro/cast/cast_int64_int32.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_int64_int32.benchmark
+# description: Cast BIGINT to INTEGER
+# group: [cast]
+
+name Cast BIGINT -> INTEGER
+group cast
+
+load
+CREATE TABLE integers AS SELECT i::BIGINT i FROM range(0, 50000000) tbl(i);
+
+run
+SELECT MAX(CAST(i AS INTEGER)) FROM integers
+
+result I
+49999999

external/duckdb/benchmark/micro/cast/cast_int_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_int_string.benchmark
+# description: Cast integer values to string
+# group: [cast]
+
+name Cast INTEGER -> VARCHAR
+group cast
+
+load
+CREATE TABLE integers AS SELECT i::INTEGER i FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MAX(CAST(i AS VARCHAR)) FROM integers
+
+result I
+9999999

external/duckdb/benchmark/micro/cast/cast_lineitem_json_to_variant.benchmark

@@ -0,0 +1,19 @@
+# name: benchmark/micro/cast/cast_lineitem_json_to_variant.benchmark
+# description: Cast all columns of the lineitem table sf1 as a JSON column to a VARIANT column
+# group: [cast]
+
+name Lineitem JSON To Variant
+group tpch
+subgroup sf1
+
+require tpch
+
+require json
+
+load
+CALL dbgen(sf=1);
+CREATE TABLE lineitem_struct AS SELECT lineitem lineitem_struct FROM lineitem;
+CREATE TABLE lineitem_json AS SELECT lineitem::JSON lineitem_json FROM lineitem;
+
+run
+SELECT lineitem_json::VARIANT FROM lineitem_json

external/duckdb/benchmark/micro/cast/cast_list_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_list_string.benchmark
+# description: Cast list values to string
+# group: [cast]
+
+name Cast LIST -> VARCHAR
+group cast
+
+load
+CREATE TABLE lists AS SELECT [i, i+1, NULL, i+2] l FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(l AS VARCHAR)) FROM lists;
+
+result I
+[0, 1, NULL, 2]

external/duckdb/benchmark/micro/cast/cast_string_double.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_double.benchmark
+# description: Cast string values to double
+# group: [cast]
+
+name Cast VARCHAR -> DOUBLE
+group cast
+
+load
+CREATE TABLE doubles AS SELECT i::DOUBLE d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(d AS DOUBLE)) FROM doubles
+
+result I
+0

external/duckdb/benchmark/micro/cast/cast_string_hugeint.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_hugeint.benchmark
+# description: Cast HUGEINT to string
+# group: [cast]
+
+name Cast VARCHAR -> HUGEINT
+group cast
+
+load
+CREATE TABLE strings AS SELECT i::VARCHAR AS s FROM range(0, 10000000, 1) tbl(i);
+
+run
+SELECT MAX(s::HUGEINT) FROM strings
+
+result I
+9999999

external/duckdb/benchmark/micro/cast/cast_string_int.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_int.benchmark
+# description: Cast string values to integers
+# group: [cast]
+
+name Cast VARCHAR -> INTEGER
+group cast
+
+load
+CREATE TABLE varchars AS SELECT i::VARCHAR v FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MAX(CAST(v AS INTEGER)) FROM varchars
+
+result I
+9999999

external/duckdb/benchmark/micro/cast/cast_string_list.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_list.benchmark
+# description: Cast string values to list
+# group: [cast]
+
+name Cast VARCHAR -> INT LIST
+group cast
+
+load
+CREATE TABLE varchars AS SELECT [i, NULL, i+2]::VARCHAR col FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(col AS INT[])[1]) FROM varchars;
+
+result I
+0

external/duckdb/benchmark/micro/cast/cast_string_map.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_map.benchmark
+# description: Cast string values to map
+# group: [cast]
+
+name Cast VARCHAR -> MAP
+group cast
+
+load
+CREATE TABLE intMap AS SELECT map([i], [i+1])::VARCHAR col FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MAX(CAST(col AS MAP(INT, INT))) FROM intMap;
+
+result I
+{9999999=10000000}

external/duckdb/benchmark/micro/cast/cast_string_struct.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_struct.benchmark
+# description: Cast string values to struct
+# group: [cast]
+
+name Cast VARCHAR -> STRUCT
+group cast
+
+load
+CREATE TABLE structs AS SELECT {'key_A': i, 'key_B': i + 1}::VARCHAR v FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(v AS STRUCT(key_A INT, key_B INT))) FROM structs;
+
+result I
+{'key_A': 0, 'key_B': 1}

external/duckdb/benchmark/micro/cast/cast_string_struct_missing_val.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_string_struct_missing_val.benchmark
+# description: Cast string values to struct, with some missing values
+# group: [cast]
+
+name Cast VARCHAR -> STRUCT
+group cast
+
+load
+CREATE TABLE structs AS SELECT {'key_C': i, 'key_A': i + 1}::VARCHAR v FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(v AS STRUCT(key_A INT, key_B INT, key_C INT))) FROM structs;
+
+result I
+{'key_A': 1, 'key_B': NULL, 'key_C': 0}

external/duckdb/benchmark/micro/cast/cast_struct_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_struct_string.benchmark
+# description: Cast list values to string
+# group: [cast]
+
+name Cast STRUCT -> VARCHAR
+group cast
+
+load
+CREATE TABLE structs AS SELECT {'i': i} s FROM range(0, 100000000) tbl(i);
+
+run
+SELECT MIN(CAST(s AS VARCHAR)) FROM structs;
+
+result I
+{'i': 0}

external/duckdb/benchmark/micro/cast/cast_timestamp_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/cast_timestamp_string.benchmark
+# description: Cast timestamp values to string
+# group: [cast]
+
+name Cast TIMESTAMP -> VARCHAR
+group cast
+
+load
+CREATE TABLE timestamps AS SELECT TIMESTAMP '1992-01-01 12:00:00' + (i % 10000) * interval '1' day AS d FROM generate_series(0, 10000000, 1) tbl(i);
+
+run
+SELECT MIN(CAST(d AS STRING)) FROM timestamps;
+
+result I
+1992-01-01 12:00:00

external/duckdb/benchmark/micro/cast/cast_varcharlist_string.benchmark

@@ -0,0 +1,17 @@
+# name: benchmark/micro/cast/cast_varcharlist_string.benchmark
+# description: Cast list values to string
+# group: [cast]
+
+name Cast VARCHAR[] -> VARCHAR
+group cast
+
+load
+CREATE TABLE lists AS SELECT ['red', 'green', '  test  ', 'blue', NULL, 'null'] l FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(l AS VARCHAR)) FROM lists;
+
+#[red, green,   test  , blue, NULL, null]
+
+result I
+[red, green, '  test  ', blue, NULL, 'null']

external/duckdb/benchmark/micro/cast/cast_varcharmap_string.benchmark

@@ -0,0 +1,18 @@
+# name: benchmark/micro/cast/cast_varcharmap_string.benchmark
+# description: Cast map values to string
+# group: [cast]
+
+name Cast MAP<VARCHAR,VARCHAR> -> VARCHAR
+group cast
+
+load
+CREATE TABLE maps AS SELECT MAP(
+    ['simple', 'needs space', 'has,comma', 'null', 'has:colon', 'quoted'],
+    ['red', '  needs quotes  ', 'no,escape needed', NULL, 'null', 'contains''quote']
+) m FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(m AS VARCHAR)) FROM maps;
+
+result I
+{simple=red, needs space='  needs quotes  ', 'has,comma'='no,escape needed', 'null'=NULL, 'has:colon'='null', quoted='contains\'quote'}

external/duckdb/benchmark/micro/cast/cast_varcharstruct_string.benchmark

@@ -0,0 +1,22 @@
+# name: benchmark/micro/cast/cast_varcharstruct_string.benchmark
+# description: Cast struct values with varchar fields to string
+# group: [cast]
+
+name Cast STRUCT<VARCHAR> -> VARCHAR
+group cast
+
+load
+CREATE TABLE structs AS SELECT {
+    'simple': 'red',
+    'needs_space': '  leading space  ',
+    'null_field': NULL,
+    'null_text': 'null',
+    'special:char': 'value:with:colons',
+    'quoted''field': 'text with ''quotes'''
+} s FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(CAST(s AS VARCHAR)) FROM structs;
+
+result I
+{'simple': red, 'needs_space': '  leading space  ', 'null_field': NULL, 'null_text': 'null', 'special:char': 'value:with:colons', 'quoted\'field': 'text with \'quotes\''}

external/duckdb/benchmark/micro/cast/format_int_string.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/format_int_string.benchmark
+# description: Use format to convert integer values to string
+# group: [cast]
+
+name Format INTEGER -> VARCHAR
+group cast
+
+load
+CREATE TABLE integers AS SELECT i::INTEGER i FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MAX(format('{}', i)) FROM integers
+
+result I
+9999999

external/duckdb/benchmark/micro/cast/strftime.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/strftime.benchmark
+# description: Use strftime to convert dates to strings
+# group: [cast]
+
+name StrfTime for DATE -> STRING
+group cast
+
+load
+CREATE TABLE dates AS SELECT DATE '1992-01-01' + i::INTEGER AS d FROM range(0, 10000000) tbl(i);
+
+run
+SELECT MIN(strftime(d, '%Y/%m/%d')) FROM dates
+
+result I
+10000/01/01

external/duckdb/benchmark/micro/cast/strptime.benchmark

@@ -0,0 +1,15 @@
+# name: benchmark/micro/cast/strptime.benchmark
+# description: Use strptime to convert strings to dates
+# group: [cast]
+
+name StrpTime for STRING -> DATE
+group cast
+
+load
+CREATE TABLE dates AS SELECT strftime(DATE '1992-01-01' + i::INTEGER, '%Y/%m/%d') AS d FROM range(0, 1000000) tbl(i);
+
+run
+SELECT MIN(strptime(d, '%Y/%m/%d')) FROM dates
+
+result I
+1992-01-01