================================================================================================
one CASE WHEN of 2 branches
================================================================================================

largest method of the stages: 280 bytes split as needed, 280 bytes split always, 280 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 2 branches:              Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      66             79           8         30.2          33.1       1.0X
not split                                            51             59           6         39.3          25.5       1.3X
not split again                                      50             51           2         40.2          24.9       1.3X
split as needed again                                47             48           2         43.0          23.3       1.4X
split always                                         57             60           3         35.2          28.4       1.2X
whole stage codegen off                              93             93           0         21.5          46.5       0.7X


================================================================================================
one CASE WHEN of 4 branches
================================================================================================

largest method of the stages: 411 bytes split as needed, 280 bytes split always, 411 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 4 branches:              Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      60             62           2         33.5          29.9       1.0X
not split                                            58             59           2         34.5          29.0       1.0X
not split again                                      58             59           1         34.5          29.0       1.0X
split as needed again                                58             59           1         34.6          28.9       1.0X
split always                                         60             64           4         33.6          29.8       1.0X
whole stage codegen off                              94             95           1         21.2          47.1       0.6X


================================================================================================
one CASE WHEN of 8 branches
================================================================================================

largest method of the stages: 785 bytes split as needed, 280 bytes split always, 785 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 8 branches:              Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      58             62           4         34.3          29.2       1.0X
not split                                            58             62           4         34.7          28.9       1.0X
not split again                                      57             58           1         34.8          28.7       1.0X
split as needed again                                58             59           2         34.7          28.8       1.0X
split always                                         59             60           2         34.1          29.3       1.0X
whole stage codegen off                              99            100           2         20.2          49.5       0.6X


================================================================================================
one CASE WHEN of 16 branches
================================================================================================

largest method of the stages: 1537 bytes split as needed, 280 bytes split always, 1537 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 16 branches:             Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      60             60           1         33.6          29.8       1.0X
not split                                            59             60           2         33.8          29.6       1.0X
not split again                                      59             59           1         34.1          29.3       1.0X
split as needed again                                59             61           2         33.8          29.5       1.0X
split always                                         60             61           1         33.2          30.1       1.0X
whole stage codegen off                             120            123           5         16.6          60.1       0.5X


================================================================================================
one CASE WHEN of 32 branches
================================================================================================

largest method of the stages: 3041 bytes split as needed, 280 bytes split always, 3041 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 32 branches:             Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      82             84           4         24.4          41.0       1.0X
not split                                            81             83           3         24.7          40.4       1.0X
not split again                                      81             81           0         24.8          40.3       1.0X
split as needed again                                81             82           1         24.8          40.4       1.0X
split always                                         67             67           0         29.8          33.5       1.2X
whole stage codegen off                             152            154           4         13.2          75.8       0.5X


================================================================================================
one CASE WHEN of 64 branches
================================================================================================

largest method of the stages: 6049 bytes split as needed, 280 bytes split always, 6049 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 64 branches:             Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                      95             96           2         21.2          47.3       1.0X
not split                                            94             98           3         21.2          47.2       1.0X
not split again                                      94             98           5         21.2          47.2       1.0X
split as needed again                                94             96           3         21.2          47.1       1.0X
split always                                        100            108          12         20.0          50.1       0.9X
whole stage codegen off                             219            222           5          9.1         109.3       0.4X


================================================================================================
one CASE WHEN of 96 branches
================================================================================================

largest method of the stages: 280 bytes split as needed, 280 bytes split always, 9057 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 96 branches:             Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                     122            123           1         16.4          61.0       1.0X
not split                                          3717           3979         201          0.5        1858.6       0.0X
not split again                                    3132           3678         456          0.6        1566.2       0.0X
split as needed again                               123            128           5         16.3          61.4       1.0X
split always                                        115            118           3         17.4          57.4       1.1X
whole stage codegen off                             305            311           3          6.6         152.5       0.4X


================================================================================================
one CASE WHEN of 128 branches
================================================================================================

largest method of the stages: 280 bytes split as needed, 280 bytes split always, 12137 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 128 branches:            Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                     148            148           0         13.5          73.8       1.0X
not split                                          4215           4821         372          0.5        2107.5       0.0X
not split again                                    4421           4988         374          0.5        2210.4       0.0X
split as needed again                               157            159           3         12.7          78.5       0.9X
split always                                        146            147           0         13.7          73.1       1.0X
whole stage codegen off                             358            365           9          5.6         179.2       0.4X


================================================================================================
one CASE WHEN of 300 branches
================================================================================================

largest method of the stages: 280 bytes split as needed, 280 bytes split always, 32605 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
one CASE WHEN of 300 branches:            Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
------------------------------------------------------------------------------------------------------------------------
split as needed                                     227            229           2          8.8         113.6       1.0X
not split                                         12083          12655         431          0.2        6041.4       0.0X
not split again                                   11357          12342         816          0.2        5678.5       0.0X
split as needed again                               239            241           3          8.4         119.4       1.0X
split always                                        216            218           1          9.2         108.2       1.0X
whole stage codegen off                             951            959           7          2.1         475.6       0.2X


================================================================================================
four CASE WHENs of 64 branches in one projection
================================================================================================

largest method of the stages: 532 bytes split as needed, 532 bytes split always, 25014 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
four CASE WHENs of 64 branches in one projection:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
--------------------------------------------------------------------------------------------------------------------------------
split as needed                                             256            259           3          7.8         127.9       1.0X
not split                                                  9174           9809         511          0.2        4587.2       0.0X
not split again                                            9040           9816         743          0.2        4519.8       0.0X
split as needed again                                       257            262           4          7.8         128.4       1.0X
split always                                                235            241           8          8.5         117.4       1.1X
whole stage codegen off                                     807            814          10          2.5         403.3       0.3X


================================================================================================
four CASE WHENs of 300 branches in one projection
================================================================================================

largest method of the stages: 488 bytes split as needed, 488 bytes split always, a stage past 64KB, which falls back, not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
four CASE WHENs of 300 branches in one projection:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
---------------------------------------------------------------------------------------------------------------------------------
split as needed                                              868            886          18          2.3         434.0       1.0X
not split                                                   5173           5196          15          0.4        2586.7       0.2X
not split again                                             5182           5191          14          0.4        2590.9       0.2X
split as needed again                                        869            883           9          2.3         434.5       1.0X
split always                                                 760            767           5          2.6         380.1       1.1X
whole stage codegen off                                     5172           5180          11          0.4        2585.9       0.2X


================================================================================================
string CASE WHEN of 64 branches, ELSE a column read once
================================================================================================

largest method of the stages: 4098 bytes split as needed, 384 bytes split always, 4098 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
string CASE WHEN of 64 branches, ELSE a column read once:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
----------------------------------------------------------------------------------------------------------------------------------------
split as needed                                                     180            188           5         11.1          90.2       1.0X
not split                                                           155            159           4         12.9          77.6       1.2X
not split again                                                     153            160           7         13.1          76.5       1.2X
split as needed again                                               156            160           2         12.8          78.2       1.2X
split always                                                        144            150           6         13.9          71.9       1.3X
whole stage codegen off                                             328            351          47          6.1         164.0       0.5X


================================================================================================
string CASE WHEN of 300 branches, ELSE a column read once
================================================================================================

largest method of the stages: 305 bytes split as needed, 305 bytes split always, 20727 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
string CASE WHEN of 300 branches, ELSE a column read once:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
-----------------------------------------------------------------------------------------------------------------------------------------
split as needed                                                      270            277          11          7.4         134.9       1.0X
not split                                                          12923          13635         698          0.2        6461.4       0.0X
not split again                                                    12900          13771         690          0.2        6450.1       0.0X
split as needed again                                                279            282           3          7.2         139.6       1.0X
split always                                                         265            268           4          7.6         132.3       1.0X
whole stage codegen off                                             1048           1055           6          1.9         524.0       0.3X


================================================================================================
a CASE WHEN of 64 branches in a keyed aggregate
================================================================================================

largest method of the stages: 6313 bytes split as needed, 286 bytes split always, 6313 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
a CASE WHEN of 64 branches in a keyed aggregate:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
-------------------------------------------------------------------------------------------------------------------------------
split as needed                                            134            138           3         15.0          66.8       1.0X
not split                                                  129            133           3         15.4          64.7       1.0X
not split again                                            130            133           4         15.4          64.9       1.0X
split as needed again                                      129            130           2         15.5          64.3       1.0X
split always                                               129            132           3         15.5          64.7       1.0X
whole stage codegen off                                    501            509           7          4.0         250.6       0.3X


================================================================================================
a CASE WHEN of 300 branches in a keyed aggregate
================================================================================================

largest method of the stages: 280 bytes split as needed, 280 bytes split always, 33499 bytes not split
OpenJDK 64-Bit Server VM 21.0.12+8-LTS on Linux 6.17.0-1022-azure
AMD EPYC 9V74 80-Core Processor
a CASE WHEN of 300 branches in a keyed aggregate:  Best Time(ms)   Avg Time(ms)   Stdev(ms)    Rate(M/s)   Per Row(ns)   Relative
--------------------------------------------------------------------------------------------------------------------------------
split as needed                                             270            287          19          7.4         135.2       1.0X
not split                                                 11943          13361        1421          0.2        5971.5       0.0X
not split again                                           11381          11992         457          0.2        5690.6       0.0X
split as needed again                                       265            269           6          7.6         132.3       1.0X
split always                                                234            245          15          8.5         117.1       1.2X
whole stage codegen off                                    2358           2364           5          0.8        1179.1       0.1X


