#!/usr/bin/env tarantool
local test = require("sqltester")
test:plan(160)

test:execsql([[
    DROP TABLE IF EXISTS t3;
    CREATE TABLE t3(a TEXT PRIMARY KEY);
    INSERT INTO t3 VALUES('a'), ('b'), ('c'), ('d'), ('e');
    INSERT INTO t3 VALUES('f'), ('g'), ('h'), ('i'), ('j');
]])

-- test:do_execsql_test(
--    "1.1",
--    [[
-- SELECT a, ntile(1) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 1, d, 1, e, 1, f, 1, g, 1, h, 1, i, 1, j, 1
-- })

-- test:do_execsql_test(
--    "1.2",
--    [[
-- SELECT a, ntile(2) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 1, d, 1, e, 1, f, 2, g, 2, h, 2, i, 2, j, 2
-- })

-- test:do_execsql_test(
--    "1.3",
--    [[
-- SELECT a, ntile(3) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 1, d, 1, e, 2, f, 2, g, 2, h, 3, i, 3, j, 3
-- })

-- test:do_execsql_test(
--    "1.4",
--    [[
-- SELECT a, ntile(4) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 1, d, 2, e, 2, f, 2, g, 3, h, 3, i, 4, j, 4
-- })

-- test:do_execsql_test(
--    "1.5",
--    [[
-- SELECT a, ntile(5) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 2, d, 2, e, 3, f, 3, g, 4, h, 4, i, 5, j, 5
-- })

-- test:do_execsql_test(
--    "1.6",
--    [[
-- SELECT a, ntile(6) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 2, d, 2, e, 3, f, 3, g, 4, h, 4, i, 5, j, 6
-- })

-- test:do_execsql_test(
--    "1.7",
--    [[
-- SELECT a, ntile(7) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 2, d, 2, e, 3, f, 3, g, 4, h, 5, i, 6, j, 7
-- })

-- test:do_execsql_test(
--    "1.8",
--    [[
-- SELECT a, ntile(8) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 2, d, 2, e, 3, f, 4, g, 5, h, 6, i, 7, j, 8
-- })

-- test:do_execsql_test(
--    "1.9",
--    [[
-- SELECT a, ntile(9) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 1, c, 2, d, 3, e, 4, f, 5, g, 6, h, 7, i, 8, j, 9
-- })

-- test:do_execsql_test(
--    "1.10",
--    [[
-- SELECT a, ntile(10) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.11",
--    [[
-- SELECT a, ntile(11) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.12",
--    [[
-- SELECT a, ntile(12) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.13",
--    [[
-- SELECT a, ntile(13) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.14",
--    [[
-- SELECT a, ntile(14) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.15",
--    [[
-- SELECT a, ntile(15) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.16",
--    [[
-- SELECT a, ntile(16) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.17",
--    [[
-- SELECT a, ntile(17) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.18",
--    [[
-- SELECT a, ntile(18) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

-- test:do_execsql_test(
--    "1.19",
--    [[
-- SELECT a, ntile(19) OVER (ORDER BY a) FROM t3
--    ]], {
--       a, 1, b, 2, c, 3, d, 4, e, 5, f, 6, g, 7, h, 8, i, 9, j, 10
-- })

test:execsql([[
    DROP TABLE IF EXISTS t4;
    CREATE TABLE t4(a INTEGER PRIMARY KEY, b TEXT, c INTEGER);
    INSERT INTO t4 VALUES(1, 'A', 9);
    INSERT INTO t4 VALUES(2, 'B', 3);
    INSERT INTO t4 VALUES(3, 'C', 2);
    INSERT INTO t4 VALUES(4, 'D', 10);
    INSERT INTO t4 VALUES(5, 'E', 5);
    INSERT INTO t4 VALUES(6, 'F', 1);
    INSERT INTO t4 VALUES(7, 'G', 1);
    INSERT INTO t4 VALUES(8, 'H', 2);
    INSERT INTO t4 VALUES(9, 'I', 10);
    INSERT INTO t4 VALUES(10, 'J', 4);
]])

-- test:do_execsql_test(
--    "2.1",
--    [[
-- SELECT a, nth_value(b, c) OVER (ORDER BY a) FROM t4
--    ]], {
--       1, "", 2, "", 3, B, 4, "", 5, E, 6, A, 7, A, 8, B, 9, "", 10, D
-- })

-- test:do_execsql_test(
--    "2.2.1",
--    [[
-- SELECT a, lead(b) OVER (ORDER BY a) FROM t4
--    ]], {
--       1, B, 2, C, 3, D, 4, E, 5, F, 6, G, 7, H, 8, I, 9, J, 10, ""
-- })

-- test:do_execsql_test(
--    "2.2.2",
--    [[
-- SELECT a, lead(b, 2) OVER (ORDER BY a) FROM t4
--    ]], {
--       1, C, 2, D, 3, E, 4, F, 5, G, 6, H, 7, I, 8, J, 9, "", 10, ""
-- })

-- test:do_execsql_test(
--    "2.2.3",
--    [[
-- SELECT a, lead(b, 3, 'abc') OVER (ORDER BY a) FROM t4
--    ]], {
--       1, D, 2, E, 3, F, 4, G, 5, H, 6, I, 7, J, 8, abc, 9, abc, 10, abc
-- })

-- test:do_execsql_test(
--    "2.3.1",
--    [[
-- SELECT a, lag(b) OVER (ORDER BY a) FROM t4
--    ]], {
--       1, "", 2, A, 3, B, 4, C, 5, D, 6, E, 7, F, 8, G, 9, H, 10, I
-- })

-- test:do_execsql_test(
--    "2.3.2",
--    [[
-- SELECT a, lag(b, 2) OVER (ORDER BY a) FROM t4
--    ]], {
--       1, "", 2, "", 3, A, 4, B, 5, C, 6, D, 7, E, 8, F, 9, G, 10, H
-- })

-- test:do_execsql_test(
--    "2.3.3",
--    [[
-- SELECT a, lag(b, 3, 'abc') OVER (ORDER BY a) FROM t4
--    ]], {
--       1, abc, 2, abc, 3, abc, 4, A, 5, B, 6, C, 7, D, 8, E, 9, F, 10, G
-- })

test:do_execsql_test(
    "2.4.1",
    [[
SELECT group_concat(b, '.') OVER (
ORDER BY a ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
) FROM t4
   ]],
    {
        "A.B.C.D.E.F.G.H.I.J",
        "B.C.D.E.F.G.H.I.J",
        "C.D.E.F.G.H.I.J",
        "D.E.F.G.H.I.J",
        "E.F.G.H.I.J",
        "F.G.H.I.J",
        "G.H.I.J",
        "H.I.J",
        "I.J",
        "J",
    }
)

test:execsql([[
    DROP TABLE IF EXISTS t5;
    CREATE TABLE t5(a INTEGER PRIMARY KEY, b TEXT, c TEXT, d INTEGER);
    INSERT INTO t5 VALUES(1, 'A', 'one',   5);
    INSERT INTO t5 VALUES(2, 'B', 'two',   4);
    INSERT INTO t5 VALUES(3, 'A', 'three', 3);
    INSERT INTO t5 VALUES(4, 'B', 'four',  2);
    INSERT INTO t5 VALUES(5, 'A', 'five',  1);
]])

-- test:do_execsql_test(
--    "3.1",
--    [[
-- SELECT a, nth_value(c, d) OVER (ORDER BY b) FROM t5
--    ]], {
--       1, "", 3, "five", 5, "one", 2, "two", 4, "three"
-- })

-- test:do_execsql_test(
--    "3.2",
--    [[
-- SELECT a, nth_value(c, d) OVER (PARTITION BY b ORDER BY a) FROM t5
--    ]], {
--       1, "", 3, "", 5, "one", 2, "", 4, "four"
-- })

test:do_execsql_test(
    "3.3",
    [[
SELECT a, count(*) OVER abc, count(*) OVER def FROM t5
WINDOW abc AS (ORDER BY a),
def AS (ORDER BY a DESC)
ORDER BY a;
   ]],
    {
        1,
        1,
        5,
        2,
        2,
        4,
        3,
        3,
        3,
        4,
        4,
        2,
        5,
        5,
        1,
    }
)

test:do_execsql_test(
    "3.4",
    [[
SELECT a, max(a) FILTER (WHERE (a%2)=0) OVER w FROM t5
WINDOW w AS (ORDER BY a)
   ]],
    {
        1,
        "",
        2,
        2,
        3,
        2,
        4,
        4,
        5,
        4,
    }
)

test:do_execsql_test(
    "3.5.1",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 1 PRECEDING AND 2 PRECEDING)
FROM t5
   ]],
    {
        1,
        "",
        2,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "3.5.2",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM t5
   ]],
    {
        1,
        "",
        2,
        "one",
        3,
        "two",
        4,
        "three",
        5,
        "four",
    }
)

test:do_execsql_test(
    "3.5.3",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 0 PRECEDING AND 0 PRECEDING)
FROM t5
   ]],
    {
        1,
        "one",
        2,
        "two",
        3,
        "three",
        4,
        "four",
        5,
        "five",
    }
)

test:do_execsql_test(
    "3.6.1",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 2 FOLLOWING AND 1 FOLLOWING)
FROM t5
   ]],
    {
        1,
        "",
        2,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "3.6.2",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 1 FOLLOWING)
FROM t5
   ]],
    {
        1,
        "two",
        2,
        "three",
        3,
        "four",
        4,
        "five",
        5,
        "",
    }
)

test:do_execsql_test(
    "3.6.3",
    [[
SELECT a, max(c) OVER (ORDER BY a ROWS BETWEEN 0 FOLLOWING AND 0 FOLLOWING)
FROM t5
   ]],
    {
        1,
        "one",
        2,
        "two",
        3,
        "three",
        4,
        "four",
        5,
        "five",
    }
)

test:execsql([[
    DROP TABLE IF EXISTS ttt;
    CREATE TABLE ttt(a INTEGER PRIMARY KEY, b INTEGER, c INTEGER);
    INSERT INTO ttt VALUES(1, 1, 1);
    INSERT INTO ttt VALUES(2, 2, 2);
    INSERT INTO ttt VALUES(3, 3, 3);

    INSERT INTO ttt VALUES(4, 1, 2);
    INSERT INTO ttt VALUES(5, 2, 3);
    INSERT INTO ttt VALUES(6, 3, 4);

    INSERT INTO ttt VALUES(7, 1, 3);
    INSERT INTO ttt VALUES(8, 2, 4);
    INSERT INTO ttt VALUES(9, 3, 5);
]])

test:do_execsql_test(
    "4.1",
    [[
SELECT max(c), max(b) OVER (ORDER BY b) FROM ttt GROUP BY b;
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.2",
    [[
SELECT max(b) OVER (ORDER BY max(c)) FROM ttt GROUP BY b;
   ]],
    {
        1,
        2,
        3,
    }
)

test:do_execsql_test(
    "4.3",
    [[
SELECT abs(max(b) OVER (ORDER BY b)) FROM ttt GROUP BY b;
   ]],
    {
        1,
        2,
        3,
    }
)

test:do_execsql_test(
    "4.4",
    [[
SELECT sum(b) OVER (
ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
) FROM ttt;
   ]],
    {
        18,
        17,
        15,
        12,
        11,
        9,
        6,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.1.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.1.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.2.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.2.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        2,
        5,
        3,
        7,
        4,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.3.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        1,
        3,
        1,
        2,
        1,
        3,
        1,
        4,
        1,
        3,
        1,
        4,
        1,
        5,
        1,
    }
)

test:do_execsql_test(
    "4.5.3.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        3,
        3,
        6,
        3,
        8,
        5,
        11,
        7,
        15,
        6,
        18,
        9,
        22,
        12,
        27,
    }
)

test:do_execsql_test(
    "4.5.4.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.4.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        2,
        5,
        3,
        7,
        4,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.5.1",
    [[
SELECT max(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.5.2",
    [[
SELECT sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        3,
        3,
        5,
        4,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.6.1",
    [[
SELECT max(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.6.2",
    [[
SELECT sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.7.1",
    [[
SELECT max(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        1,
        3,
        1,
        2,
        1,
        3,
        1,
        4,
        1,
        3,
        1,
        4,
        1,
        5,
        1,
    }
)

test:do_execsql_test(
    "4.5.7.2",
    [[
SELECT sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        3,
        3,
        6,
        2,
        8,
        3,
        11,
        4,
        15,
        3,
        18,
        4,
        22,
        5,
        27,
    }
)

test:do_execsql_test(
    "4.5.8.1",
    [[
SELECT max(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.8.2",
    [[
SELECT sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.9.1",
    [[
SELECT max(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        1,
        3,
        2,
        4,
        3,
        4,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.9.2",
    [[
SELECT sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        3,
        2,
        6,
        3,
        8,
        3,
        11,
        5,
        15,
        7,
        18,
        6,
        22,
        9,
        27,
        12,
    }
)

test:do_execsql_test(
    "4.5.10.1",
    [[
SELECT max(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        2,
        3,
        3,
        4,
        4,
        4,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.10.2",
    [[
SELECT sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        3,
        2,
        6,
        3,
        8,
        2,
        11,
        3,
        15,
        4,
        18,
        3,
        22,
        4,
        27,
        5,
    }
)

test:do_execsql_test(
    "4.5.11.1",
    [[
SELECT max(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        1,
        3,
        1,
        3,
        1,
        3,
        1,
        4,
        1,
        4,
        1,
        4,
        1,
        5,
        1,
    }
)

test:do_execsql_test(
    "4.5.11.2",
    [[
SELECT sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        3,
        3,
        6,
        6,
        8,
        8,
        11,
        11,
        15,
        15,
        18,
        18,
        22,
        22,
        27,
        27,
    }
)

test:do_execsql_test(
    "4.5.12.1",
    [[
SELECT max(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        2,
        3,
        3,
        4,
        4,
        4,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.12.2",
    [[
SELECT sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        3,
        2,
        6,
        3,
        8,
        2,
        11,
        3,
        15,
        4,
        18,
        3,
        22,
        4,
        27,
        5,
    }
)

test:do_execsql_test(
    "4.5.13.1",
    [[
SELECT max(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.13.2",
    [[
SELECT sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        3,
        3,
        5,
        4,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.14.1",
    [[
SELECT max(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.14.2",
    [[
SELECT sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b, a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.15.1",
    [[
SELECT max(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        1,
        3,
        1,
        2,
        1,
        3,
        1,
        4,
        1,
        3,
        1,
        4,
        1,
        5,
        1,
    }
)

test:do_execsql_test(
    "4.5.15.2",
    [[
SELECT sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER ( ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        3,
        3,
        6,
        2,
        8,
        3,
        11,
        4,
        15,
        3,
        18,
        4,
        22,
        5,
        27,
    }
)

test:do_execsql_test(
    "4.5.16.1",
    [[
SELECT max(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.16.2",
    [[
SELECT sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY a ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.17.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.17.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.18.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.18.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        6,
        5,
        9,
        7,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.19.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.19.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        2,
        5,
        3,
        7,
        4,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.20.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.20.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        5,
        5,
        7,
        7,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.21.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.21.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        3,
        9,
        5,
        12,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.22.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.22.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.23.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.23.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        2,
        9,
        3,
        12,
        4,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.24.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.24.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        5,
        9,
        7,
        12,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.25.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.25.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        3,
        3,
        5,
        4,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.26.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.26.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        2,
        6,
        3,
        9,
        4,
        12,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.27.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.27.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.28.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.28.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        2,
        5,
        3,
        7,
        4,
        9,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.29.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.29.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        5,
        3,
        7,
        5,
        9,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.30.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.30.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        5,
        6,
        7,
        9,
        9,
        12,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.31.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.31.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        5,
        2,
        7,
        3,
        9,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.32.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.32.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        5,
        5,
        7,
        7,
        9,
        9,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.33.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.33.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.34.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.34.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        6,
        5,
        9,
        7,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.35.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        2,
        "",
        3,
        "",
        4,
        "",
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
    }
)

test:do_execsql_test(
    "4.5.35.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        5,
        "",
        7,
        "",
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        2,
        9,
        3,
        12,
        4,
    }
)

test:do_execsql_test(
    "4.5.36.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        2,
        "",
        3,
        "",
        4,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "4.5.36.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        5,
        "",
        7,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
    }
)

test:do_execsql_test(
    "4.5.37.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "4.5.37.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        5,
        5,
        7,
        7,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
        6,
        "",
        9,
        "",
        12,
        "",
    }
)

test:do_execsql_test(
    "4.5.38.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.38.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        3,
        9,
        5,
        12,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.39.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.39.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.40.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
    }
)

test:do_execsql_test(
    "4.5.40.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        2,
        9,
        3,
        12,
        4,
    }
)

test:do_execsql_test(
    "4.5.41.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "4.5.41.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
    }
)

test:do_execsql_test(
    "4.5.42.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
        3,
        "",
        4,
        "",
        5,
        "",
    }
)

test:do_execsql_test(
    "4.5.42.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        6,
        5,
        9,
        7,
        12,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
        6,
        "",
        9,
        "",
        12,
        "",
    }
)

test:do_execsql_test(
    "4.5.43.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        1,
        "",
        2,
        "",
        3,
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
    }
)

test:do_execsql_test(
    "4.5.43.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        3,
        "",
        5,
        "",
        7,
        1,
        6,
        2,
        9,
        3,
        12,
        2,
        6,
        3,
        9,
        4,
        12,
    }
)

test:do_execsql_test(
    "4.5.44.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        1,
        "",
        2,
        "",
        3,
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
    }
)

test:do_execsql_test(
    "4.5.44.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        6,
        "",
        9,
        "",
        12,
        1,
        6,
        2,
        9,
        3,
        12,
        2,
        6,
        3,
        9,
        4,
        12,
    }
)

test:do_execsql_test(
    "4.5.45.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
    }
)

test:do_execsql_test(
    "4.5.45.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
    }
)

test:do_execsql_test(
    "4.5.46.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        2,
        "",
        3,
        "",
        4,
        "",
    }
)

test:do_execsql_test(
    "4.5.46.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        2,
        "",
        3,
        "",
        4,
        "",
    }
)

test:do_execsql_test(
    "4.5.47.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        2,
        "",
        3,
        "",
        4,
        1,
        3,
        2,
        4,
        3,
        5,
        2,
        "",
        3,
        "",
        4,
        "",
    }
)

test:do_execsql_test(
    "4.5.47.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        5,
        "",
        7,
        "",
        9,
        1,
        3,
        2,
        4,
        3,
        5,
        2,
        "",
        3,
        "",
        4,
        "",
    }
)

test:do_execsql_test(
    "4.5.48.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        1,
        "",
        2,
        "",
        3,
    }
)

test:do_execsql_test(
    "4.5.48.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        3,
        "",
        5,
        "",
        7,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
    }
)

test:do_execsql_test(
    "4.5.49.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        1,
        "",
        2,
        "",
        3,
    }
)

test:do_execsql_test(
    "4.5.49.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
        "",
        6,
        "",
        9,
        "",
        12,
    }
)

test:do_execsql_test(
    "4.5.50.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        2,
        "",
        3,
        "",
        4,
    }
)

test:do_execsql_test(
    "4.5.50.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        1,
        "",
        2,
        "",
        3,
        "",
        2,
        "",
        3,
        "",
        4,
    }
)

test:do_execsql_test(
    "4.5.51.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.51.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.52.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        2,
        "",
        3,
        "",
        4,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.52.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        "",
        5,
        "",
        7,
        "",
        9,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.53.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        "",
        1,
        "",
        2,
        "",
        3,
    }
)

test:do_execsql_test(
    "4.5.53.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 1 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        5,
        3,
        7,
        5,
        9,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
        "",
        6,
        "",
        9,
        "",
        12,
    }
)

test:do_execsql_test(
    "4.5.54.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        "",
        1,
        "",
        2,
        "",
        3,
    }
)

test:do_execsql_test(
    "4.5.54.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 3 PRECEDING AND 2 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        5,
        6,
        7,
        9,
        9,
        12,
        3,
        6,
        4,
        9,
        5,
        12,
        "",
        6,
        "",
        9,
        "",
        12,
    }
)

test:do_execsql_test(
    "4.5.55.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        1,
        4,
        2,
        5,
        3,
        "",
        2,
        "",
        3,
        "",
        4,
    }
)

test:do_execsql_test(
    "4.5.55.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        5,
        "",
        7,
        "",
        9,
        "",
        3,
        1,
        4,
        2,
        5,
        3,
        "",
        2,
        "",
        3,
        "",
        4,
    }
)

test:do_execsql_test(
    "4.5.56.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        "",
        4,
        "",
        5,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.56.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 0 PRECEDING AND 1 PRECEDING)
FROM ttt ORDER BY a
   ]],
    {
        5,
        "",
        7,
        "",
        9,
        "",
        3,
        "",
        4,
        "",
        5,
        "",
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.57.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
min(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.57.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING),
sum(c) OVER (PARTITION BY b ORDER BY a ROWS BETWEEN 1 FOLLOWING AND 500 FOLLOWING)
FROM ttt ORDER BY a
   ]],
    {
        5,
        5,
        7,
        7,
        9,
        9,
        3,
        3,
        4,
        4,
        5,
        5,
        "",
        "",
        "",
        "",
        "",
        "",
    }
)

test:do_execsql_test(
    "4.5.58.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.58.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.59.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.59.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        5,
        5,
        7,
        7,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.60.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.60.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        6,
        5,
        9,
        7,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.61.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.61.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.62.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.62.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        5,
        3,
        7,
        5,
        9,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.63.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.63.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        5,
        5,
        7,
        7,
        9,
        9,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.64.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.64.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        5,
        6,
        7,
        9,
        9,
        12,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.65.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.65.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        5,
        3,
        7,
        5,
        9,
        7,
        3,
        6,
        4,
        9,
        5,
        12,
    }
)

test:do_execsql_test(
    "4.5.66.1",
    [[
SELECT max(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.66.2",
    [[
SELECT sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        3,
        9,
        5,
        12,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.67.1",
    [[
SELECT max(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        2,
        4,
        3,
        5,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.67.2",
    [[
SELECT sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        5,
        9,
        7,
        12,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.68.1",
    [[
SELECT max(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.68.2",
    [[
SELECT sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.69.1",
    [[
SELECT max(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.69.2",
    [[
SELECT sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        6,
        1,
        9,
        2,
        12,
        3,
        6,
        3,
        9,
        5,
        12,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.70.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.70.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.71.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        2,
        3,
        3,
        4,
        4,
        3,
        3,
        4,
        4,
        5,
        5,
    }
)

test:do_execsql_test(
    "4.5.71.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY a DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        5,
        5,
        7,
        7,
        9,
        6,
        3,
        9,
        4,
        12,
        5,
    }
)

test:do_execsql_test(
    "4.5.72.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.72.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b
RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        6,
        2,
        9,
        3,
        12,
        3,
        6,
        5,
        9,
        7,
        12,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

test:do_execsql_test(
    "4.5.73.1",
    [[
SELECT max(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
min(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        2,
        1,
        3,
        2,
        4,
        3,
        3,
        1,
        4,
        2,
        5,
        3,
    }
)

test:do_execsql_test(
    "4.5.73.2",
    [[
SELECT sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW),
sum(c) OVER (PARTITION BY b ORDER BY b, a RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
FROM ttt ORDER BY a
   ]],
    {
        1,
        1,
        2,
        2,
        3,
        3,
        3,
        3,
        5,
        5,
        7,
        7,
        6,
        6,
        9,
        9,
        12,
        12,
    }
)

-- test:execsql([[
--     DROP TABLE IF EXISTS t1;
--     CREATE TABLE t1(x INTEGER PRIMARY KEY, y INTEGER);
--     INSERT INTO t1 VALUES(1, 2);
--     INSERT INTO t1 VALUES(3, 4);
--     INSERT INTO t1 VALUES(5, 6);
--     INSERT INTO t1 VALUES(7, 8);
--     INSERT INTO t1 VALUES(9, 10);
-- ]])

-- test:do_execsql_test(
--    "7.1",
--    [[
-- SELECT lead(y) OVER win FROM t1
-- WINDOW win AS (ORDER BY x)
--    ]], {
--       4, 6, 8, 10, ""
-- })

-- test:do_execsql_test(
--    "7.2",
--    [[
-- SELECT lead(y, 2) OVER win FROM t1
-- WINDOW win AS (ORDER BY x)
--    ]], {
--       6, 8, 10, "", ""
-- })

-- test:do_execsql_test(
--    "7.3",
--    [[
-- SELECT lead(y, 3, -1) OVER win FROM t1
-- WINDOW win AS (ORDER BY x)
--    ]], {
--       8, 10, -1, -1, -1
-- })

-- test:do_execsql_test(
--    "7.4",
--    [[
-- SELECT
-- lead(y) OVER win, lead(y) OVER win
-- FROM t1
-- WINDOW win AS (ORDER BY x)
--    ]], {
--       4, 4, 6, 6, 8, 8, 10, 10, "", ""
-- })

-- test:do_execsql_test(
--    "7.5",
--    [[
-- SELECT
-- lead(y) OVER win,
-- lead(y, 2) OVER win,
-- lead(y, 3, -1) OVER win
-- FROM t1
-- WINDOW win AS (ORDER BY x)
--    ]], {
--       4, 6, 8, 6, 8, 10, 8, 10, -1, 10, "", -1, "", "", -1
-- })

-- test:execsql([[
--     DROP TABLE IF EXISTS t1;
--     CREATE TABLE t1(a INTEGER PRIMARY KEY, b INTEGER, c INTEGER, d INTEGER);
--     INSERT INTO t1 VALUES(1, 2, 3, 4);
--     INSERT INTO t1 VALUES(5, 6, 7, 8);
--     INSERT INTO t1 VALUES(9, 10, 11, 12);
-- ]])

-- test:do_execsql_test(
--    "8.1",
--    [[
-- SELECT row_number() OVER win,
-- nth_value(d,2) OVER win,
-- lead(d) OVER win
-- FROM t1
-- WINDOW win AS (ORDER BY a)
--    ]], {
--       1, "", 8, 2, 8, 12, 3, 8, ""
-- })

-- test:do_execsql_test(
--    "8.2",
--    [[
-- SELECT row_number() OVER win,
-- rank() OVER win,
-- dense_rank() OVER win,
-- ntile(2) OVER win,
-- first_value(d) OVER win,
-- last_value(d) OVER win,
-- nth_value(d,2) OVER win,
-- lead(d) OVER win,
-- lag(d) OVER win,
-- max(d) OVER win,
-- min(d) OVER win
-- FROM t1
-- WINDOW win AS (ORDER BY a)
--    ]], {
--       1, 1, 1, 1, 4, 4, "", 8, "", 4, 4, 2, 2, 2, 1, 4, 8, 8, 12, 4, 8, 4,
--       3, 3, 3, 2, 4, 12, 8, "", 8, 12, 4
-- })

-- test:execsql([[
--     DROP TABLE IF EXISTS t2;
--     CREATE TABLE t2(x INTEGER PRIMARY KEY);
--     INSERT INTO t2 VALUES(1), (1), (1), (4), (4), (6), (7);
-- ]])

-- test:do_execsql_test(
--    "9.1",
--    [[
-- SELECT rank() OVER () FROM t2
--    ]], {
--       1, 1, 1, 1, 1, 1, 1
-- })

-- test:do_execsql_test(
--    "9.2",
--    [[
-- SELECT dense_rank() OVER (PARTITION BY x) FROM t2
--    ]], {
--       1, 1, 1, 1, 1, 1, 1
-- })

-- test:do_execsql_test(
--    "9.4",
--    [[
-- SELECT x, rank() OVER (ORDER BY x) FROM t2 ORDER BY 1,2
--    ]], {
--       1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 6, 6, 7, 7
-- })

-- test:do_execsql_test(
--    "9.5",
--    [[
-- SELECT DISTINCT x, rank() OVER (ORDER BY x) FROM t2 ORDER BY 1,2
--    ]], {
--       1, 1, 4, 4, 6, 6, 7, 7
-- })

test:execsql([[
DROP TABLE IF EXISTS t7;
CREATE TABLE t7(id INTEGER PRIMARY KEY, a INTEGER, b INTEGER);
INSERT INTO t7(id, a, b) VALUES
  (1, 1, 2), (2, 1, NULL), (3, 1, 4),
  (4, 3, NULL), (5, 3, 8), (6, 3, 1);
]])

test:do_execsql_test(
   "10.1",
   [[
SELECT id, min(b) OVER (PARTITION BY a ORDER BY id) FROM t7;
   ]], {
      1, 2, 2, 2, 3, 2, 4, "", 5, 8, 6, 1
})

test:finish_test()
