diff --git a/tests/testthat/_snaps/verb-arrange.md b/tests/testthat/_snaps/verb-arrange.md index eb10a31d4..79c409a87 100644 --- a/tests/testthat/_snaps/verb-arrange.md +++ b/tests/testthat/_snaps/verb-arrange.md @@ -7,3 +7,397 @@ FROM `test-verb-arrange` ORDER BY `y` +# arrange renders correctly (#373) + + Code + # # arrange renders correctly + Code + lf <- lazy_frame(a = 1:3, b = 3:1) + Code + # basic + Code + lf %>% arrange(a) + Output + + SELECT * + FROM `df` + ORDER BY `a` + Code + # double arrange + Code + lf %>% arrange(a) %>% arrange(b) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT * + FROM `df` + ORDER BY `b` + Code + # remove ordered by + Code + lf %>% arrange(a) %>% select(-a) + Output + + SELECT `b` + FROM `df` + ORDER BY `a` + Code + lf %>% arrange(a) %>% select(-a) %>% arrange(b) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `b` + FROM `df` + ORDER BY `b` + Code + # un-arrange + Code + lf %>% arrange(a) %>% arrange() + Output + + SELECT * + FROM `df` + ORDER BY `a` + Code + lf %>% arrange(a) %>% select(-a) %>% arrange() + Output + + SELECT `b` + FROM `df` + ORDER BY `a` + Code + # use order + Code + lf %>% arrange(a) %>% select(-a) %>% mutate(c = lag(b)) + Output + + SELECT `b`, LAG(`b`, 1, NULL) OVER (ORDER BY `a`) AS `c` + FROM `df` + ORDER BY `a` + +# arrange renders correctly for single-table verbs (#373) + + Code + lf <- lazy_frame(a = 1:3, b = 3:1) + Code + # head + Code + lf %>% head(1) %>% arrange(a) + Output + + SELECT * + FROM (SELECT * + FROM `df` + LIMIT 1) `q01` + ORDER BY `a` + Code + lf %>% arrange(a) %>% head(1) + Output + + SELECT * + FROM `df` + ORDER BY `a` + LIMIT 1 + Code + lf %>% arrange(a) %>% head(1) %>% arrange(b) + Output + + SELECT * + FROM (SELECT * + FROM `df` + ORDER BY `a` + LIMIT 1) `q01` + ORDER BY `b` + Code + # mutate + Code + lf %>% mutate(a = b) %>% arrange(a) + Output + + SELECT `b` AS `a`, `b` + FROM `df` + ORDER BY `a` + Code + # complex mutate + Code + lf %>% arrange(a) %>% mutate(a = b) %>% arrange(a) + Output + + SELECT `b` AS `a`, `b` + FROM `df` + ORDER BY `a` + Code + lf %>% arrange(a) %>% mutate(a = 1) %>% arrange(b) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT 1.0 AS `a`, `b` + FROM `df` + ORDER BY `b` + Code + lf %>% arrange(a) %>% mutate(b = a) %>% arrange(b) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `a`, `a` AS `b` + FROM `df` + ORDER BY `b` + Code + lf %>% arrange(a) %>% mutate(b = 1) %>% arrange(b) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `a`, 1.0 AS `b` + FROM `df` + ORDER BY `b` + Code + lf %>% mutate(a = -a) %>% arrange(a) %>% mutate(a = -a) + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT -`a` AS `a`, `b` + FROM (SELECT -`a` AS `a`, `b` + FROM `df`) `q01` + +# arrange renders correctly for joins (#373) + + Code + lf <- lazy_frame(a = 1:3, b = 3:1) + Code + rf <- lazy_frame(a = 1:3, c = 4:6) + Code + # join + Code + lf %>% arrange(a) %>% left_join(rf) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM (SELECT * + FROM `df`) `LHS` + LEFT JOIN `df` AS `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + + Code + lf %>% arrange(b) %>% left_join(rf) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM (SELECT * + FROM `df`) `LHS` + LEFT JOIN `df` AS `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + + Code + lf %>% left_join(rf) %>% arrange(a) + Message + Joining, by = "a" + Output + + SELECT * + FROM (SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM `df` AS `LHS` + LEFT JOIN `df` AS `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + ) `q01` + ORDER BY `a` + Code + lf %>% left_join(rf) %>% arrange(b) + Message + Joining, by = "a" + Output + + SELECT * + FROM (SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM `df` AS `LHS` + LEFT JOIN `df` AS `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + ) `q01` + ORDER BY `b` + Code + lf %>% left_join(rf %>% arrange(a)) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM `df` AS `LHS` + LEFT JOIN (SELECT * + FROM `df`) `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + + Code + lf %>% left_join(rf %>% arrange(c)) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` + FROM `df` AS `LHS` + LEFT JOIN (SELECT * + FROM `df`) `RHS` + ON (`LHS`.`a` = `RHS`.`a`) + + +# arrange renders correctly for semi-joins (#373) + + Code + lf <- lazy_frame(a = 1:3, b = 3:1) + Code + rf <- lazy_frame(a = 1:3, c = 4:6) + Code + # semi_join + Code + lf %>% arrange(a) %>% semi_join(rf) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT * FROM (SELECT * + FROM `df`) `LHS` + WHERE EXISTS ( + SELECT 1 FROM `df` AS `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + ) + Code + lf %>% arrange(b) %>% semi_join(rf) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT * FROM (SELECT * + FROM `df`) `LHS` + WHERE EXISTS ( + SELECT 1 FROM `df` AS `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + ) + Code + lf %>% semi_join(rf) %>% arrange(a) + Message + Joining, by = "a" + Output + + SELECT * + FROM (SELECT * FROM `df` AS `LHS` + WHERE EXISTS ( + SELECT 1 FROM `df` AS `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + )) `q01` + ORDER BY `a` + Code + lf %>% semi_join(rf) %>% arrange(b) + Message + Joining, by = "a" + Output + + SELECT * + FROM (SELECT * FROM `df` AS `LHS` + WHERE EXISTS ( + SELECT 1 FROM `df` AS `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + )) `q01` + ORDER BY `b` + Code + lf %>% semi_join(rf %>% arrange(a)) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT * FROM `df` AS `LHS` + WHERE EXISTS ( + SELECT 1 FROM (SELECT * + FROM `df`) `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + ) + Code + lf %>% semi_join(rf %>% arrange(c)) + Message + Joining, by = "a" + Warning + ORDER BY is ignored in subqueries without LIMIT + i Do you need to move arrange() later in the pipeline or use window_order() instead? + Output + + SELECT * FROM `df` AS `LHS` + WHERE EXISTS ( + SELECT 1 FROM (SELECT * + FROM `df`) `RHS` + WHERE (`LHS`.`a` = `RHS`.`a`) + ) + +# arrange renders correctly for set operations (#373) + + Code + lf <- lazy_frame(a = 1:3, b = 3:1) + Code + rf <- lazy_frame(a = 1:3, c = 4:6) + Code + # setop + Code + lf %>% union_all(rf) %>% arrange(a) + Output + + SELECT * + FROM ((SELECT `a`, `b`, NULL AS `c` + FROM `df`) + UNION ALL + (SELECT `a`, NULL AS `b`, `c` + FROM `df`)) `q01` + ORDER BY `a` + Code + lf %>% arrange(a) %>% union_all(rf) + Output + + (SELECT `a`, `b`, NULL AS `c` + FROM `df` + ORDER BY `a`) + UNION ALL + (SELECT `a`, NULL AS `b`, `c` + FROM `df`) + Code + lf %>% union_all(rf %>% arrange(a)) + Output + + (SELECT `a`, `b`, NULL AS `c` + FROM `df`) + UNION ALL + (SELECT `a`, NULL AS `b`, `c` + FROM `df` + ORDER BY `a`) + diff --git a/tests/testthat/_snaps/verb-select.md b/tests/testthat/_snaps/verb-select.md index bf85a82d4..e172aa9e0 100644 --- a/tests/testthat/_snaps/verb-select.md +++ b/tests/testthat/_snaps/verb-select.md @@ -43,397 +43,3 @@ SELECT `x` FROM `df` -# arrange renders correctly (#373) - - Code - # # arrange renders correctly - Code - lf <- lazy_frame(a = 1:3, b = 3:1) - Code - # basic - Code - lf %>% arrange(a) - Output - - SELECT * - FROM `df` - ORDER BY `a` - Code - # double arrange - Code - lf %>% arrange(a) %>% arrange(b) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT * - FROM `df` - ORDER BY `b` - Code - # remove ordered by - Code - lf %>% arrange(a) %>% select(-a) - Output - - SELECT `b` - FROM `df` - ORDER BY `a` - Code - lf %>% arrange(a) %>% select(-a) %>% arrange(b) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `b` - FROM `df` - ORDER BY `b` - Code - # un-arrange - Code - lf %>% arrange(a) %>% arrange() - Output - - SELECT * - FROM `df` - ORDER BY `a` - Code - lf %>% arrange(a) %>% select(-a) %>% arrange() - Output - - SELECT `b` - FROM `df` - ORDER BY `a` - Code - # use order - Code - lf %>% arrange(a) %>% select(-a) %>% mutate(c = lag(b)) - Output - - SELECT `b`, LAG(`b`, 1, NULL) OVER (ORDER BY `a`) AS `c` - FROM `df` - ORDER BY `a` - -# arrange renders correctly for single-table verbs (#373) - - Code - lf <- lazy_frame(a = 1:3, b = 3:1) - Code - # head - Code - lf %>% head(1) %>% arrange(a) - Output - - SELECT * - FROM (SELECT * - FROM `df` - LIMIT 1) `q01` - ORDER BY `a` - Code - lf %>% arrange(a) %>% head(1) - Output - - SELECT * - FROM `df` - ORDER BY `a` - LIMIT 1 - Code - lf %>% arrange(a) %>% head(1) %>% arrange(b) - Output - - SELECT * - FROM (SELECT * - FROM `df` - ORDER BY `a` - LIMIT 1) `q01` - ORDER BY `b` - Code - # mutate - Code - lf %>% mutate(a = b) %>% arrange(a) - Output - - SELECT `b` AS `a`, `b` - FROM `df` - ORDER BY `a` - Code - # complex mutate - Code - lf %>% arrange(a) %>% mutate(a = b) %>% arrange(a) - Output - - SELECT `b` AS `a`, `b` - FROM `df` - ORDER BY `a` - Code - lf %>% arrange(a) %>% mutate(a = 1) %>% arrange(b) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT 1.0 AS `a`, `b` - FROM `df` - ORDER BY `b` - Code - lf %>% arrange(a) %>% mutate(b = a) %>% arrange(b) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `a`, `a` AS `b` - FROM `df` - ORDER BY `b` - Code - lf %>% arrange(a) %>% mutate(b = 1) %>% arrange(b) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `a`, 1.0 AS `b` - FROM `df` - ORDER BY `b` - Code - lf %>% mutate(a = -a) %>% arrange(a) %>% mutate(a = -a) - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT -`a` AS `a`, `b` - FROM (SELECT -`a` AS `a`, `b` - FROM `df`) `q01` - -# arrange renders correctly for joins (#373) - - Code - lf <- lazy_frame(a = 1:3, b = 3:1) - Code - rf <- lazy_frame(a = 1:3, c = 4:6) - Code - # join - Code - lf %>% arrange(a) %>% left_join(rf) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM (SELECT * - FROM `df`) `LHS` - LEFT JOIN `df` AS `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - - Code - lf %>% arrange(b) %>% left_join(rf) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM (SELECT * - FROM `df`) `LHS` - LEFT JOIN `df` AS `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - - Code - lf %>% left_join(rf) %>% arrange(a) - Message - Joining, by = "a" - Output - - SELECT * - FROM (SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM `df` AS `LHS` - LEFT JOIN `df` AS `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - ) `q01` - ORDER BY `a` - Code - lf %>% left_join(rf) %>% arrange(b) - Message - Joining, by = "a" - Output - - SELECT * - FROM (SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM `df` AS `LHS` - LEFT JOIN `df` AS `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - ) `q01` - ORDER BY `b` - Code - lf %>% left_join(rf %>% arrange(a)) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM `df` AS `LHS` - LEFT JOIN (SELECT * - FROM `df`) `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - - Code - lf %>% left_join(rf %>% arrange(c)) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT `LHS`.`a` AS `a`, `LHS`.`b` AS `b`, `RHS`.`c` AS `c` - FROM `df` AS `LHS` - LEFT JOIN (SELECT * - FROM `df`) `RHS` - ON (`LHS`.`a` = `RHS`.`a`) - - -# arrange renders correctly for semi-joins (#373) - - Code - lf <- lazy_frame(a = 1:3, b = 3:1) - Code - rf <- lazy_frame(a = 1:3, c = 4:6) - Code - # semi_join - Code - lf %>% arrange(a) %>% semi_join(rf) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT * FROM (SELECT * - FROM `df`) `LHS` - WHERE EXISTS ( - SELECT 1 FROM `df` AS `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - ) - Code - lf %>% arrange(b) %>% semi_join(rf) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT * FROM (SELECT * - FROM `df`) `LHS` - WHERE EXISTS ( - SELECT 1 FROM `df` AS `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - ) - Code - lf %>% semi_join(rf) %>% arrange(a) - Message - Joining, by = "a" - Output - - SELECT * - FROM (SELECT * FROM `df` AS `LHS` - WHERE EXISTS ( - SELECT 1 FROM `df` AS `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - )) `q01` - ORDER BY `a` - Code - lf %>% semi_join(rf) %>% arrange(b) - Message - Joining, by = "a" - Output - - SELECT * - FROM (SELECT * FROM `df` AS `LHS` - WHERE EXISTS ( - SELECT 1 FROM `df` AS `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - )) `q01` - ORDER BY `b` - Code - lf %>% semi_join(rf %>% arrange(a)) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT * FROM `df` AS `LHS` - WHERE EXISTS ( - SELECT 1 FROM (SELECT * - FROM `df`) `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - ) - Code - lf %>% semi_join(rf %>% arrange(c)) - Message - Joining, by = "a" - Warning - ORDER BY is ignored in subqueries without LIMIT - i Do you need to move arrange() later in the pipeline or use window_order() instead? - Output - - SELECT * FROM `df` AS `LHS` - WHERE EXISTS ( - SELECT 1 FROM (SELECT * - FROM `df`) `RHS` - WHERE (`LHS`.`a` = `RHS`.`a`) - ) - -# arrange renders correctly for set operations (#373) - - Code - lf <- lazy_frame(a = 1:3, b = 3:1) - Code - rf <- lazy_frame(a = 1:3, c = 4:6) - Code - # setop - Code - lf %>% union_all(rf) %>% arrange(a) - Output - - SELECT * - FROM ((SELECT `a`, `b`, NULL AS `c` - FROM `df`) - UNION ALL - (SELECT `a`, NULL AS `b`, `c` - FROM `df`)) `q01` - ORDER BY `a` - Code - lf %>% arrange(a) %>% union_all(rf) - Output - - (SELECT `a`, `b`, NULL AS `c` - FROM `df` - ORDER BY `a`) - UNION ALL - (SELECT `a`, NULL AS `b`, `c` - FROM `df`) - Code - lf %>% union_all(rf %>% arrange(a)) - Output - - (SELECT `a`, `b`, NULL AS `c` - FROM `df`) - UNION ALL - (SELECT `a`, NULL AS `b`, `c` - FROM `df` - ORDER BY `a`) - diff --git a/tests/testthat/test-verb-arrange.R b/tests/testthat/test-verb-arrange.R index 85f6d940f..aea9bf915 100644 --- a/tests/testthat/test-verb-arrange.R +++ b/tests/testthat/test-verb-arrange.R @@ -16,6 +16,93 @@ test_that("quoting for rendering ordered grouped table", { expect_equal(collect(out), tibble(x = 1, y = 2)) }) +test_that("arrange renders correctly (#373)", { + expect_snapshot({ + "# arrange renders correctly" + lf <- lazy_frame(a = 1:3, b = 3:1) + + "basic" + lf %>% arrange(a) + + "double arrange" + lf %>% arrange(a) %>% arrange(b) + + "remove ordered by" + lf %>% arrange(a) %>% select(-a) + lf %>% arrange(a) %>% select(-a) %>% arrange(b) + + "un-arrange" + lf %>% arrange(a) %>% arrange() + lf %>% arrange(a) %>% select(-a) %>% arrange() + + "use order" + lf %>% arrange(a) %>% select(-a) %>% mutate(c = lag(b)) + }) +}) + +test_that("arrange renders correctly for single-table verbs (#373)", { + expect_snapshot({ + lf <- lazy_frame(a = 1:3, b = 3:1) + + "head" + lf %>% head(1) %>% arrange(a) + lf %>% arrange(a) %>% head(1) + lf %>% arrange(a) %>% head(1) %>% arrange(b) + + "mutate" + lf %>% mutate(a = b) %>% arrange(a) + + "complex mutate" + lf %>% arrange(a) %>% mutate(a = b) %>% arrange(a) + lf %>% arrange(a) %>% mutate(a = 1) %>% arrange(b) + lf %>% arrange(a) %>% mutate(b = a) %>% arrange(b) + lf %>% arrange(a) %>% mutate(b = 1) %>% arrange(b) + lf %>% mutate(a = -a) %>% arrange(a) %>% mutate(a = -a) + }) +}) + +test_that("arrange renders correctly for joins (#373)", { + expect_snapshot({ + lf <- lazy_frame(a = 1:3, b = 3:1) + rf <- lazy_frame(a = 1:3, c = 4:6) + + "join" + lf %>% arrange(a) %>% left_join(rf) + lf %>% arrange(b) %>% left_join(rf) + lf %>% left_join(rf) %>% arrange(a) + lf %>% left_join(rf) %>% arrange(b) + lf %>% left_join(rf %>% arrange(a)) + lf %>% left_join(rf %>% arrange(c)) + }) +}) + +test_that("arrange renders correctly for semi-joins (#373)", { + expect_snapshot({ + lf <- lazy_frame(a = 1:3, b = 3:1) + rf <- lazy_frame(a = 1:3, c = 4:6) + + "semi_join" + lf %>% arrange(a) %>% semi_join(rf) + lf %>% arrange(b) %>% semi_join(rf) + lf %>% semi_join(rf) %>% arrange(a) + lf %>% semi_join(rf) %>% arrange(b) + lf %>% semi_join(rf %>% arrange(a)) + lf %>% semi_join(rf %>% arrange(c)) + }) +}) + +test_that("arrange renders correctly for set operations (#373)", { + expect_snapshot({ + lf <- lazy_frame(a = 1:3, b = 3:1) + rf <- lazy_frame(a = 1:3, c = 4:6) + + "setop" + lf %>% union_all(rf) %>% arrange(a) + lf %>% arrange(a) %>% union_all(rf) + lf %>% union_all(rf %>% arrange(a)) + }) +}) + # sql_build --------------------------------------------------------------- test_that("arrange generates order_by", { diff --git a/tests/testthat/test-verb-select.R b/tests/testthat/test-verb-select.R index 7c6c51655..a35485fc1 100644 --- a/tests/testthat/test-verb-select.R +++ b/tests/testthat/test-verb-select.R @@ -90,93 +90,6 @@ test_that("mutate collapses over nested select", { expect_snapshot(lf %>% mutate(a = 1, b = 2) %>% select(x)) }) -test_that("arrange renders correctly (#373)", { - expect_snapshot({ - "# arrange renders correctly" - lf <- lazy_frame(a = 1:3, b = 3:1) - - "basic" - lf %>% arrange(a) - - "double arrange" - lf %>% arrange(a) %>% arrange(b) - - "remove ordered by" - lf %>% arrange(a) %>% select(-a) - lf %>% arrange(a) %>% select(-a) %>% arrange(b) - - "un-arrange" - lf %>% arrange(a) %>% arrange() - lf %>% arrange(a) %>% select(-a) %>% arrange() - - "use order" - lf %>% arrange(a) %>% select(-a) %>% mutate(c = lag(b)) - }) -}) - -test_that("arrange renders correctly for single-table verbs (#373)", { - expect_snapshot({ - lf <- lazy_frame(a = 1:3, b = 3:1) - - "head" - lf %>% head(1) %>% arrange(a) - lf %>% arrange(a) %>% head(1) - lf %>% arrange(a) %>% head(1) %>% arrange(b) - - "mutate" - lf %>% mutate(a = b) %>% arrange(a) - - "complex mutate" - lf %>% arrange(a) %>% mutate(a = b) %>% arrange(a) - lf %>% arrange(a) %>% mutate(a = 1) %>% arrange(b) - lf %>% arrange(a) %>% mutate(b = a) %>% arrange(b) - lf %>% arrange(a) %>% mutate(b = 1) %>% arrange(b) - lf %>% mutate(a = -a) %>% arrange(a) %>% mutate(a = -a) - }) -}) - -test_that("arrange renders correctly for joins (#373)", { - expect_snapshot({ - lf <- lazy_frame(a = 1:3, b = 3:1) - rf <- lazy_frame(a = 1:3, c = 4:6) - - "join" - lf %>% arrange(a) %>% left_join(rf) - lf %>% arrange(b) %>% left_join(rf) - lf %>% left_join(rf) %>% arrange(a) - lf %>% left_join(rf) %>% arrange(b) - lf %>% left_join(rf %>% arrange(a)) - lf %>% left_join(rf %>% arrange(c)) - }) -}) - -test_that("arrange renders correctly for semi-joins (#373)", { - expect_snapshot({ - lf <- lazy_frame(a = 1:3, b = 3:1) - rf <- lazy_frame(a = 1:3, c = 4:6) - - "semi_join" - lf %>% arrange(a) %>% semi_join(rf) - lf %>% arrange(b) %>% semi_join(rf) - lf %>% semi_join(rf) %>% arrange(a) - lf %>% semi_join(rf) %>% arrange(b) - lf %>% semi_join(rf %>% arrange(a)) - lf %>% semi_join(rf %>% arrange(c)) - }) -}) - -test_that("arrange renders correctly for set operations (#373)", { - expect_snapshot({ - lf <- lazy_frame(a = 1:3, b = 3:1) - rf <- lazy_frame(a = 1:3, c = 4:6) - - "setop" - lf %>% union_all(rf) %>% arrange(a) - lf %>% arrange(a) %>% union_all(rf) - lf %>% union_all(rf %>% arrange(a)) - }) -}) - # sql_build ------------------------------------------------------------- test_that("select picks variables", {