Add a test

tests/queries/0_stateless/02841_with_clause_resolve.reference

@@ -0,0 +1,15 @@
+2.5
+2.5
+2.5
+2.5
+2.5
+(9399,2858)
+(7159,6972)
+(7456,3524)
+(12685,10191)
+(12598,4979)
+(9824,2699)
+(5655,7793)
+(14410,10296)
+(16211,7662)
+(9349,9053)

tests/queries/0_stateless/02841_with_clause_resolve.sql

@@ -0,0 +1,141 @@
+set allow_experimental_analyzer = 1;
+
+WITH
+    -- Input
+    44100 AS sample_frequency
+    , number AS tick
+    , tick / sample_frequency AS time
+    
+    -- Delay
+    , (time, wave, delay_, decay, count) -> arraySum(n1 -> wave(time - delay_ * n1), range(count)) AS delay
+
+    , delay(time, (time -> 0.5), 0.2, 0.5, 5) AS kick
+    
+SELECT
+
+    kick
+
+FROM system.numbers
+LIMIT 5;
+
+WITH
+    -- Input
+    44100 AS sample_frequency
+    , number AS tick
+    , tick / sample_frequency AS time
+    
+    -- Output control
+    , 1 AS master_volume
+    , level -> least(1.0, greatest(-1.0, level)) AS clamp
+    , level -> (clamp(level) * 0x7FFF * master_volume)::Int16 AS output
+    , x -> (x, x) AS mono
+    
+    -- Basic waves
+    , time -> sin(time * 2 * pi()) AS sine_wave
+    , time -> time::UInt64 % 2 * 2 - 1 AS square_wave
+    , time -> (time - floor(time)) * 2 - 1 AS sawtooth_wave
+    , time -> abs(sawtooth_wave(time)) * 2 - 1 AS triangle_wave
+    
+    -- Helpers
+    , (from, to, wave, time) -> from + ((wave(time) + 1) / 2) * (to - from) AS lfo
+    , (from, to, steps, time) -> from + floor((time - floor(time)) * steps) / steps * (to - from) AS step_lfo
+    , (from, to, steps, time) -> exp(step_lfo(log(from), log(to), steps, time)) AS exp_step_lfo
+    
+    -- Noise
+    , time -> cityHash64(time) / 0xFFFFFFFFFFFFFFFF AS uniform_noise
+    , time -> erf(uniform_noise(time)) AS white_noise
+    , time -> cityHash64(time) % 2 ? 1 : -1 AS bernoulli_noise
+    
+    -- Distortion
+    , (x, amount) -> clamp(x * amount) AS clipping
+    , (x, amount) -> clamp(x > 0 ? pow(x, amount) : -pow(-x, amount)) AS power_distortion
+    , (x, amount) -> round(x * exp2(amount)) / exp2(amount) AS bitcrush
+    , (time, sample_frequency) -> round(time * sample_frequency) / sample_frequency AS desample
+    , (time, wave, amount) -> (time - floor(time) < (1 - amount)) ? wave(time * (1 - amount)) : 0 AS thin
+    , (time, wave, amount) -> wave(floor(time) + pow(time - floor(time), amount)) AS skew
+    
+    -- Combining
+    , (a, b, weight) -> a * (1 - weight) + b * weight AS combine
+    
+    -- Envelopes
+    , (time, offset, attack, hold, release) ->
+        time < offset ? 0
+        : (time < offset + attack                  ? ((time - offset) / attack)
+        : (time < offset + attack + hold           ? 1
+        : (time < offset + attack + hold + release ? (offset + attack + hold + release - time) / release
+        : 0))) AS envelope
+    
+    , (bpm, time, offset, attack, hold, release) ->
+        envelope(
+            time * (bpm / 60) - floor(time * (bpm / 60)),
+            offset,
+            attack,
+            hold,
+            release) AS running_envelope
+    
+    -- Sequencers
+    , (sequence, time) -> sequence[1 + time::UInt64 % length(sequence)] AS sequencer
+    
+    -- Delay
+    , (time, wave, delay, decay, count) -> arraySum(n -> wave(time - delay * n) * pow(decay, n), range(count)) AS delay
+    
+    
+    , delay(time, (time -> power_distortion(sine_wave(time * 80 + sine_wave(time * 2)), lfo(0.5, 1, sine_wave, time / 16))
+            * running_envelope(60, time, 0, 0.0, 0.01, 0.1)),
+            0.2, 0.5, 5) AS kick
+    
+SELECT
+    
+    (output(
+        kick +
+        delay(time, (time ->
+            power_distortion(
+                sine_wave(time * 50 + 1 * sine_wave(time * 100 + 1/4))
+                    * running_envelope(60, time, 0, 0.01, 0.01, 0.1),
+                lfo(1, 0.75, triangle_wave, time / 8))),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, time / 7)
+    
+        + delay(time, (time ->
+            power_distortion(
+                sine_wave(time * sequencer([50, 100, 200, 400], time / 2) + 1 * sine_wave(time * sequencer([50, 100, 200], time / 4) + 1/4))
+                    * running_envelope(60, time, 0.5, 0.01, 0.01, 0.1),
+                lfo(1, 0.75, triangle_wave, time / 8))),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, 16 + time / 11)
+    
+        + delay(time, (time ->
+            white_noise(time) * running_envelope(60, time, 0.75, 0.01, 0.01, 0.1)),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, 24 + time / 13)
+    
+        + sine_wave(time * 100 + 1 * sine_wave(time * 10 + 1/4))
+            * running_envelope(120, time, 0, 0.01, 0.01, 0.1)
+    ),
+    
+    output(
+        kick +
+        delay(time + 0.01, (time ->
+            power_distortion(
+                sine_wave(time * 50 + 1 * sine_wave(time * 100 + 1/4))
+                    * running_envelope(60, time, 0, 0.01, 0.01, 0.1),
+                lfo(1, 0.75, triangle_wave, time / 8))),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, time / 7)
+    
+        + delay(time - 0.01, (time ->
+            power_distortion(
+                sine_wave(time * sequencer([50, 100, 200, 400], time / 2) + 1 * sine_wave(time * sequencer([50, 100, 200], time / 4) + 1/4))
+                    * running_envelope(60, time, 0.5, 0.01, 0.01, 0.1),
+                lfo(1, 0.75, triangle_wave, time / 8))),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, 16 + time / 11)
+    
+        + delay(time + 0.005, (time ->
+            white_noise(time) * running_envelope(60, time, 0.75, 0.01, 0.01, 0.1)),
+            0.2, 0.5, 10)
+        * lfo(0.5, 1, triangle_wave, 24 + time / 13)
+    ))
+    
+FROM system.numbers
+LIMIT 10;