R version 4.3.0 (2023-04-21) -- "Already Tomorrow"
Copyright (C) 2023 The R Foundation for Statistical Computing
Platform: powerpc-apple-darwin10.8.0 (32-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> # This file is part of the standard setup for testthat.
> # It is recommended that you do not modify it.
> #
> # Where should you do additional test configuration?
> # Learn more about the roles of various files in:
> # * https://r-pkgs.org/tests.html
> # * https://testthat.r-lib.org/reference/test_package.html#special-files
> 
> library(testthat)
> library(duckplyr)

Attaching package: 'duckplyr'

The following objects are masked from 'package:stats':

    filter, lag

The following objects are masked from 'package:base':

    intersect, setdiff, setequal, union

> 
> test_check("duckplyr")
Deactivated cache.
[ FAIL 194 | WARN 1 | SKIP 321 | PASS 972 ]

══ Skipped tests (321) ═════════════════════════════════════════════════════════
• External vector? (5): 'test-as_duckplyr_df.R:1420:3',
  'test-as_duckplyr_df.R:1436:3', 'test-as_duckplyr_df.R:1452:3',
  'test-as_duckplyr_df.R:1468:3', 'test-as_duckplyr_df.R:1484:3'
• Grouped (1): 'test-as_duckplyr_df.R:1628:3'
• Hack (1): 'test-as_duckplyr_df.R:419:3'
• Installed duckdb is version 0.8.1.3; but 0.8.1-9000 is required (11):
  'test-as_duckplyr_df.R:314:3', 'test-as_duckplyr_df.R:329:3',
  'test-as_duckplyr_df.R:344:3', 'test-as_duckplyr_df.R:359:3',
  'test-as_duckplyr_df.R:374:3', 'test-as_duckplyr_df.R:389:3',
  'test-rel_api.R:1392:3', 'test-rel_api.R:1587:3', 'test-rel_api.R:1782:3',
  'test-rel_api.R:1977:3', 'test-rel_api.R:2172:3'
• Missing or empty names not allowed. (6): ???, ???, 'test-select.R:40:3',
  'test-select.R:136:3', 'test-select.R:145:3', ???
• Must pass a plain data frame or a tibble to `as_duckplyr_df()`. (158):
  'test-mutate.R:49:3', 'test-mutate.R:77:3', 'test-mutate.R:110:3',
  'test-mutate.R:170:3', 'test-mutate.R:243:3', 'test-mutate.R:257:3',
  'test-mutate.R:294:3', 'test-mutate.R:303:3', 'test-mutate.R:315:3',
  'test-mutate.R:330:3', 'test-mutate.R:361:3', 'test-mutate.R:367:3',
  'test-mutate.R:374:3', 'test-mutate.R:401:3', 'test-mutate.R:408:3',
  'test-mutate.R:426:3', 'test-mutate.R:455:3', 'test-mutate.R:465:3',
  'test-mutate.R:485:3', ???, ???, 'test-mutate.R:626:3',
  'test-mutate.R:635:3', 'test-mutate.R:664:3', 'test-mutate.R:673:3',
  'test-mutate.R:694:3', 'test-mutate.R:734:3', 'test-mutate.R:745:3',
  'test-mutate.R:759:3', 'test-mutate.R:770:3', 'test-mutate.R:776:3', ???,
  'test-filter.R:18:3', 'test-filter.R:27:3', 'test-filter.R:158:3',
  'test-filter.R:185:3', 'test-filter.R:223:3', 'test-filter.R:229:3',
  'test-filter.R:237:3', 'test-filter.R:303:3', 'test-filter.R:319:3',
  'test-filter.R:361:3', ???, 'test-filter.R:544:3', 'test-filter.R:567:3',
  'test-filter.R:578:3', 'test-filter.R:621:3', 'test-filter.R:633:3', ???,
  ???, 'test-count-tally.R:57:3', 'test-count-tally.R:66:3',
  'test-count-tally.R:77:3', 'test-count-tally.R:89:3',
  'test-count-tally.R:105:3', 'test-count-tally.R:145:3',
  'test-count-tally.R:158:3', 'test-count-tally.R:175:3', 'test-across.R:14:3',
  'test-across.R:21:3', 'test-across.R:323:3', 'test-across.R:333:3',
  'test-across.R:679:3', 'test-across.R:698:3', 'test-across.R:1048:3',
  'test-across.R:1107:3', ???, ???, 'test-across.R:1356:3',
  'test-across.R:1370:3', 'test-arrange.R:9:3', 'test-arrange.R:206:3',
  'test-arrange.R:213:3', 'test-arrange.R:219:3', 'test-arrange.R:288:3',
  'test-arrange.R:299:3', 'test-arrange.R:337:3', 'test-arrange.R:381:3',
  'test-colwise-select.R:38:3', 'test-colwise-select.R:93:3',
  'test-colwise-select.R:141:3', 'test-deprec-do.R:10:3',
  'test-deprec-do.R:18:3', 'test-deprec-do.R:33:3', 'test-deprec-do.R:42:3',
  'test-deprec-do.R:49:3', 'test-deprec-do.R:65:3', 'test-deprec-do.R:94:3',
  'test-deprec-do.R:105:3', 'test-deprec-do.R:178:3', 'test-deprec-do.R:183:3',
  ???, 'test-distinct.R:50:3', 'test-distinct.R:56:3', 'test-distinct.R:64:3',
  'test-distinct.R:115:3', 'test-distinct.R:156:3', 'test-generics.R:132:3',
  'test-group-map.R:6:3', 'test-group-map.R:40:3', 'test-group-map.R:72:3',
  'test-group-map.R:84:3', 'test-join.R:497:3', 'test-join.R:628:3',
  'test-join.R:650:3', 'test-join.R:673:3', 'test-join.R:683:3',
  'test-rename.R:9:3', 'test-rename.R:31:3', 'test-select.R:4:3', ???, ???,
  'test-select.R:87:3', 'test-select.R:106:3', ???, 'test-sets.R:38:3',
  'test-sets.R:46:3', 'test-slice.R:8:3', 'test-slice.R:21:3',
  'test-slice.R:31:3', 'test-slice.R:48:3', 'test-slice.R:79:3', ???,
  'test-slice.R:123:3', 'test-slice.R:135:3', ???, ???, 'test-slice.R:332:3',
  'test-slice.R:370:3', ???, 'test-slice.R:578:3', 'test-slice.R:604:3',
  'test-slice.R:625:3', 'test-summarise.R:19:3', 'test-summarise.R:45:3',
  'test-summarise.R:61:3', 'test-summarise.R:77:3', 'test-summarise.R:96:3',
  'test-summarise.R:131:3', 'test-summarise.R:189:3', 'test-summarise.R:207:3',
  'test-summarise.R:212:3', 'test-summarise.R:222:3', 'test-summarise.R:236:3',
  'test-summarise.R:242:3', 'test-summarise.R:256:3', 'test-summarise.R:273:3',
  'test-summarise.R:285:3', 'test-summarise.R:325:3', 'test-summarise.R:338:3',
  'test-summarise.R:346:3', ???, ???, 'test-transmute.R:2:3',
  'test-transmute.R:9:3', 'test-transmute.R:27:3', 'test-transmute.R:49:3',
  'test-transmute.R:82:3'
• Must pass data frame without row names to `as_duckplyr_df()`. (31):
  'test-mutate.R:17:3', 'test-mutate.R:716:3', ???, 'test-filter.R:53:3',
  'test-filter.R:102:3', 'test-filter.R:269:3', 'test-filter.R:311:3',
  'test-filter.R:383:3', 'test-filter.R:588:3', ???, ???, ???,
  'test-arrange.R:309:3', 'test-deprec-do.R:71:3', 'test-deprec-do.R:77:3',
  'test-deprec-do.R:88:3', 'test-relocate.R:37:3', 'test-rename.R:24:3',
  'test-select.R:48:3', 'test-select.R:58:3', 'test-select.R:115:3',
  'test-select.R:119:3', 'test-select.R:123:3', 'test-select.R:129:3', ???,
  ???, ???, 'test-summarise.R:89:3', 'test-summarise.R:426:3',
  'test-transmute.R:55:3', ???
• On CRAN (85): 'test-mutate.R:138:3', 'test-mutate.R:198:3',
  'test-filter.R:404:3', 'test-filter.R:422:3', 'test-filter.R:431:3',
  'test-filter.R:695:3', 'test-filter.R:721:3', 'test-count-tally.R:47:3',
  'test-count-tally.R:120:3', 'test-count-tally.R:219:3',
  'test-across.R:144:3', 'test-across.R:153:3', 'test-across.R:209:3',
  'test-across.R:222:3', 'test-across.R:618:3', 'test-across.R:768:3',
  'test-across.R:797:3', 'test-across.R:1131:3', 'test-across.R:1175:3',
  'test-across.R:1204:3', 'test-across.R:1269:3', 'test-across.R:1281:3',
  'test-all-equal.R:2:3', 'test-all-equal.R:27:3', 'test-all-equal.R:36:3',
  'test-all-equal.R:47:3', 'test-all-equal.R:61:3', 'test-all-equal.R:114:3',
  'test-all-equal.R:142:3', 'test-all-equal.R:155:3', 'test-all-equal.R:163:3',
  'test-all-equal.R:171:3', 'test-arrange.R:29:3', 'test-arrange.R:169:3',
  'test-arrange.R:178:3', 'test-arrange.R:192:3', 'test-arrange.R:321:3',
  'test-colwise-select.R:175:3', 'test-deprec-funs.R:119:3',
  'test-deprec-funs.R:127:3', 'test-distinct.R:180:3', 'test-duckplyr.R:18:3',
  'test-expr.R:4:3', 'test-group-map.R:121:3', 'test-join.R:151:3',
  'test-join.R:338:3', 'test-join.R:350:3', 'test-join.R:391:3',
  'test-join.R:470:3', 'test-join.R:518:3', 'test-join.R:555:3',
  'test-join.R:605:3', 'test-join.R:709:3', 'test-join.R:720:3',
  'test-join.R:731:3', 'test-join.R:754:3', 'test-join.R:768:3',
  'test-relational-rel.R:2:3', 'test-relational.R:4:3', 'test-relocate.R:30:3',
  'test-rename.R:75:3', 'test-rename.R:85:3', 'test-rename.R:94:3',
  'test-sets.R:59:3', 'test-sets.R:73:3', 'test-sets.R:83:3',
  'test-slice.R:40:3', 'test-slice.R:63:3', 'test-slice.R:71:3',
  'test-slice.R:109:3', 'test-slice.R:193:3', 'test-slice.R:219:3',
  'test-slice.R:230:3', 'test-slice.R:240:3', 'test-slice.R:248:3',
  'test-slice.R:299:3', 'test-slice.R:342:3', 'test-slice.R:396:3',
  'test-slice.R:508:3', 'test-slice.R:515:3', 'test-slice.R:550:3',
  'test-slice.R:562:3', 'test-summarise.R:158:3', 'test-summarise.R:397:3',
  'test-summarise.R:540:3'
• Random seed (2): 'test-as_duckplyr_df.R:1295:3',
  'test-as_duckplyr_df.R:1311:3'
• TODO duckdb (19): 'test-mutate.R:94:3', 'test-filter.R:89:3',
  'test-filter.R:599:3', 'test-across.R:601:3', 'test-across.R:932:3',
  'test-all-equal.R:180:3', 'test-group-map.R:64:3', 'test-join.R:59:3',
  'test-join.R:357:3', 'test-join.R:363:3', 'test-join.R:382:3',
  'test-join.R:420:3', 'test-join.R:446:3', 'test-join.R:456:3',
  'test-sets.R:123:3', 'test-summarise.R:30:3', 'test-summarise.R:197:3',
  'test-summarise.R:308:3', 'test-summarise.R:449:3'
• WAT (1): 'test-as_duckplyr_df.R:1045:3'
• Won't need (1): 'test-prom.R:2:3'

══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test-as_duckplyr_df.R:32:3'): as_duckplyr_df() and anti_join(join_by(a)) ──
Error: Error evaluating duckdb query: TransactionContext Error: cannot start a transaction within a transaction
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:32:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:57:3'): as_duckplyr_df() and arrange(a) ───────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:57:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:70:3'): as_duckplyr_df() and arrange(g) ───────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:70:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:83:3'): as_duckplyr_df() and arrange(g, a) ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:83:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:96:3'): as_duckplyr_df() and arrange(a, g) ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:96:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:178:3'): as_duckplyr_df() and count(a) ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:178:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:191:3'): as_duckplyr_df() and count(b) ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:191:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:204:3'): as_duckplyr_df() and count(g) ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:204:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:217:3'): as_duckplyr_df() and count(g, a) ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:217:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:230:3'): as_duckplyr_df() and count(b, g) ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:230:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:257:3'): as_duckplyr_df() and distinct() ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:257:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:270:3'): as_duckplyr_df() and distinct(a) ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:270:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:283:3'): as_duckplyr_df() and distinct(a, b) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:283:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:296:3'): as_duckplyr_df() and distinct(b, b) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:296:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:309:3'): as_duckplyr_df() and distinct(g) ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:309:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:480:3'): as_duckplyr_df() and full_join(join_by(a)) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:480:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:507:3'): as_duckplyr_df() and inner_join(join_by(a)) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:507:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:533:3'): as_duckplyr_df() and left_join(join_by(a)) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:533:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:571:3'): as_duckplyr_df() and mutate(a + 1, .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:571:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:623:3'): as_duckplyr_df() and mutate(sum(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:623:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:649:3'): as_duckplyr_df() and mutate(mean(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:649:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:675:3'): as_duckplyr_df() and mutate(sd(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:675:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:701:3'): as_duckplyr_df() and mutate(lag(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:701:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:727:3'): as_duckplyr_df() and mutate(lead(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:727:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:753:3'): as_duckplyr_df() and mutate(lag(a, 2), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:753:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:779:3'): as_duckplyr_df() and mutate(lead(a, 2), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:779:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:805:3'): as_duckplyr_df() and mutate(lag(a, 4), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:805:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:831:3'): as_duckplyr_df() and mutate(lead(a, 4), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:831:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:857:3'): as_duckplyr_df() and mutate(lag(a, default = 0), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:857:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:883:3'): as_duckplyr_df() and mutate(lead(a, default = 1000), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:883:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:909:3'): as_duckplyr_df() and mutate(min(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:909:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:935:3'): as_duckplyr_df() and mutate(max(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:935:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:961:3'): as_duckplyr_df() and mutate(first(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:961:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:987:3'): as_duckplyr_df() and mutate(last(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:987:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1013:3'): as_duckplyr_df() and mutate(nth(a, 2), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1013:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1199:3'): as_duckplyr_df() and right_join(join_by(a)) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1199:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1372:3'): as_duckplyr_df() and semi_join(join_by(a)) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1372:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1519:3'): as_duckplyr_df() and summarise(c = mean(a), .by = b) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1519:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1532:3'): as_duckplyr_df() and summarise(c = mean(a), .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1532:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1558:3'): as_duckplyr_df() and summarise(c = 1, .by = g) ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1558:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1651:3'): as_duckplyr_df() and union() ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1651:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-as_duckplyr_df.R:1664:3'): as_duckplyr_df() and union_all() ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(pre, post) at test-as_duckplyr_df.R:1664:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-mutate.R:6:3'): empty mutate returns input ─────────────────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(duckplyr_mutate(df, .by = x), df) at test-mutate.R:6:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-mutate.R:539:3'): can group transiently using `.by` ────────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_identical(out$g, df$g) at test-mutate.R:539:2
 2.   └─testthat:::expect_waldo_equal("identical", act, exp, info, ...)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-filter.R:112:3'): $ does not end call traversing. #502 ─────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
     ▆
  1. ├─... %>% ... at test-filter.R:112:2
  2. └─duckplyr:::duckplyr_mutate(., Outcome = (1:18%%c(5, 7, 11))/10)
  3.   ├─dplyr::mutate(.data, ...)
  4.   └─duckplyr:::mutate.duckplyr_df(.data, ...)
  5.     └─dplyr::mutate(...)
  6.       └─dplyr:::compute_by(...)
  7.         ├─dplyr::group_data(data)
  8.         ├─dplyr:::group_data.tbl_df(data)
  9.         ├─base::NextMethod()
 10.         └─dplyr:::group_data.data.frame(data)
 11.           └─base::nrow(.data)
 12.             ├─base::dim(x)
 13.             └─base::dim.data.frame(x)
 14.               └─base::.row_names_info(x, 2L)
── Error ('test-demo.R:4:3'): demo queries work ────────────────────────────────
`{ ... }` threw an unexpected error.
Message: object 'tips_by_day_hour' not found
Class:   simpleError/error/condition
── Error ('test-demo.R:18:3'): demo queries work ───────────────────────────────
`{ ... }` threw an unexpected error.
Message: object 'tips_by_passenger' not found
Class:   simpleError/error/condition
── Error ('test-demo.R:32:3'): demo queries work ───────────────────────────────
`{ ... }` threw an unexpected error.
Message: object 'popular_manhattan_cab_rides' not found
Class:   simpleError/error/condition
── Error ('test-demo.R:48:3'): demo queries work ───────────────────────────────
`{ ... }` threw an unexpected error.
Message: object 'num_zero_percent_trips' not found
Class:   simpleError/error/condition
── Failure ('test-distinct.R:170:3'): duckplyr_distinct() preserves attributes on bare data frames (#6318) ──
attr(out, "foo") (`actual`) not identical to "bar" (`expected`).

`actual` is NULL
`expected` is a character vector ('bar')
── Failure ('test-distinct.R:173:3'): duckplyr_distinct() preserves attributes on bare data frames (#6318) ──
attr(out, "foo") (`actual`) not identical to "bar" (`expected`).

`actual` is NULL
`expected` is a character vector ('bar')
── Failure ('test-duckplyr.R:16:3'): collect() works ───────────────────────────
`collect(z)` produced no output
── Failure ('test-duckplyr.R:31:3'): tbl_vars() works ──────────────────────────
`collect(z)` produced no output
── Error ('test-rel_api.R:69:3'): relational anti_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1L, b = 2)) at test-rel_api.R:69:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:107:3'): relational anti_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1L, b = 2)) at test-rel_api.R:107:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:142:3'): relational arrange(a) order-preserving ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:142:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:159:3'): relational arrange(g) order-preserving ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:159:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:176:3'): relational arrange(g, a) order-preserving ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:176:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:193:3'): relational arrange(a, g) order-preserving ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:193:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:216:3'): relational arrange() order-enforcing ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:216:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:237:3'): relational arrange(a) order-enforcing ───────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:237:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:258:3'): relational arrange(g) order-enforcing ───────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:258:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:279:3'): relational arrange(g, a) order-enforcing ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:279:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:300:3'): relational arrange(a, g) order-enforcing ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:300:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:374:3'): relational count(a) order-preserving ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:374:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:418:3'): relational count(b) order-preserving ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2, n = 6L)) at test-rel_api.R:418:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:462:3'): relational count(g) order-preserving ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3, n = 1:3)) at test-rel_api.R:462:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:516:3'): relational count(g, a) order-preserving ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:516:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:570:3'): relational count(b, g) order-preserving ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:570:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:601:3'): relational count() order-enforcing ──────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(n = 6L)) at test-rel_api.R:601:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:646:3'): relational count(a) order-enforcing ─────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:646:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:691:3'): relational count(b) order-enforcing ─────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2, n = 6L)) at test-rel_api.R:691:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:736:3'): relational count(g) order-enforcing ─────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3, n = 1:3)) at test-rel_api.R:736:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:794:3'): relational count(g, a) order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:794:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:852:3'): relational count(b, g) order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:852:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:981:3'): relational distinct() order-preserving ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:981:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:1078:3'): relational distinct(a) order-preserving ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = seq(1, 6, by = 1))) at test-rel_api.R:1078:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:1190:3'): relational distinct(a, b) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:1190:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:1287:3'): relational distinct(b, b) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2)) at test-rel_api.R:1287:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:1384:3'): relational distinct(g) order-preserving ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:1384:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2476:3'): relational distinct(g, .keep_all = TRUE) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:2476:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2499:3'): relational distinct() order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:2499:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2527:3'): relational distinct(a) order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = seq(1, 6, by = 1))) at test-rel_api.R:2527:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2560:3'): relational distinct(a, b) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:2560:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2588:3'): relational distinct(b, b) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2)) at test-rel_api.R:2588:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2616:3'): relational distinct(g) order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2616:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2648:3'): relational union_all(data.frame(a = 1L, b = 3, g = 2L)) %>% distinct(g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2648:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2680:3'): relational union_all(data.frame(a = 1L, b = 4, g = 2L)) %>% distinct(g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2680:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2712:3'): relational union_all(data.frame(a = 1L, b = 5, g = 2L)) %>% distinct(g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2712:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2744:3'): relational union_all(data.frame(a = 1L, b = 6, g = 2L)) %>% distinct(g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2744:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2776:3'): relational union_all(data.frame(a = 1L, b = 7, g = 2L)) %>% distinct(g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3)) at test-rel_api.R:2776:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:2897:3'): relational distinct(g, .keep_all = TRUE) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:2897:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3099:3'): relational filter(a == 1) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1, b = 2, g = 1L)) at test-rel_api.R:3099:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3164:3'): relational filter(a %in% 2:3, g == 2) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3164:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3235:3'): relational filter(a %in% 2:3 & g == 2) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3235:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3367:3'): relational full_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3367:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3459:3'): relational full_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3459:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3591:3'): relational inner_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3591:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3683:3'): relational inner_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3683:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3728:3'): relational intersect() order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 2:4, b = rep(2, 3L))) at test-rel_api.R:3728:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3860:3'): relational left_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3860:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:3952:3'): relational left_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:3952:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:4134:3'): relational mutate(a + 1, .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:4134:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:4397:3'): relational mutate(sum(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:4397:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:4547:3'): relational mutate(mean(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:4547:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:4697:3'): relational mutate(sd(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:4697:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:4867:3'): relational mutate(lag(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:4867:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5037:3'): relational mutate(lead(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5037:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5207:3'): relational mutate(lag(a, 2), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5207:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5377:3'): relational mutate(lead(a, 2), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5377:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5547:3'): relational mutate(lag(a, 4), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5547:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5717:3'): relational mutate(lead(a, 4), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5717:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:5895:3'): relational mutate(lag(a, default = 0), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:5895:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6073:3'): relational mutate(lead(a, default = 1000), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6073:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6223:3'): relational mutate(min(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6223:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6373:3'): relational mutate(max(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6373:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6523:3'): relational mutate(first(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6523:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6673:3'): relational mutate(last(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6673:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:6855:3'): relational mutate(nth(a, 2), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:6855:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7063:3'): relational mutate() order-enforcing ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7063:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7118:3'): relational mutate(a + 1) order-enforcing ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7118:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7179:3'): relational mutate(a + 1, .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7179:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7240:3'): relational mutate(c = a + 1) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7240:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7300:3'): relational mutate(`if` = a + 1) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7300:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7351:3'): relational mutate(sum(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7351:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7402:3'): relational mutate(sum(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7402:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7453:3'): relational mutate(mean(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7453:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7504:3'): relational mutate(mean(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7504:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7555:3'): relational mutate(sd(a)) order-enforcing ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7555:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7606:3'): relational mutate(sd(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7606:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7667:3'): relational mutate(lag(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7667:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7728:3'): relational mutate(lag(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7728:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7789:3'): relational mutate(lead(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7789:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7850:3'): relational mutate(lead(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7850:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7911:3'): relational mutate(lag(a, 2)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7911:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:7972:3'): relational mutate(lag(a, 2), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:7972:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8033:3'): relational mutate(lead(a, 2)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8033:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8094:3'): relational mutate(lead(a, 2), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8094:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8155:3'): relational mutate(lag(a, 4)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8155:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8216:3'): relational mutate(lag(a, 4), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8216:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8277:3'): relational mutate(lead(a, 4)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8277:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8338:3'): relational mutate(lead(a, 4), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8338:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8403:3'): relational mutate(lag(a, default = 0)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8403:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8468:3'): relational mutate(lag(a, default = 0), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8468:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8533:3'): relational mutate(lead(a, default = 1000)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8533:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8598:3'): relational mutate(lead(a, default = 1000), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8598:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8649:3'): relational mutate(min(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8649:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8700:3'): relational mutate(min(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8700:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8751:3'): relational mutate(max(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8751:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8802:3'): relational mutate(max(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8802:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8853:3'): relational mutate(first(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8853:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8904:3'): relational mutate(first(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8904:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:8955:3'): relational mutate(last(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:8955:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9006:3'): relational mutate(last(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9006:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9073:3'): relational mutate(nth(a, 2)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9073:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9140:3'): relational mutate(nth(a, 2), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9140:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9197:3'): relational mutate(a / b) order-enforcing ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9197:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9327:3'): relational mutate(c = 0, d = 0, e = c / d) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9327:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9522:3'): relational relocate(g) order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9522:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9562:3'): relational relocate(a) order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9562:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9602:3'): relational relocate(g, .before = b) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9602:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9642:3'): relational relocate(a:b, .after = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9642:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9758:3'): relational rename() order-enforcing ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9758:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9798:3'): relational rename(c = a) order-enforcing ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9798:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:9929:3'): relational right_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:9929:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10020:3'): relational right_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10020:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10144:3'): relational select(a) order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = seq(1, 6, by = 1))) at test-rel_api.R:10144:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10176:3'): relational select(-g) order-enforcing ─────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10176:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10216:3'): relational select(everything()) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10216:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10289:3'): relational semi_join(join_by(a)) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 2:4, b = rep(2, 3L))) at test-rel_api.R:10289:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10327:3'): relational semi_join(join_by(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 2:4, b = rep(2, 3L))) at test-rel_api.R:10327:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10372:3'): relational setdiff() order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1L, b = 2)) at test-rel_api.R:10372:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10475:3'): relational summarise(c = mean(a), .by = b) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2, c = 3.5)) at test-rel_api.R:10475:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10548:3'): relational summarise(c = mean(a), .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10548:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10657:3'): relational summarise(c = 1, .by = g) order-preserving ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3, c = rep(1, 3L))) at test-rel_api.R:10657:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10688:3'): relational summarise(c = mean(a)) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(c = 3.5)) at test-rel_api.R:10688:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10716:3'): relational summarise(c = mean(a), .by = b) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(b = 2, c = 3.5)) at test-rel_api.R:10716:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10744:3'): relational summarise(c = mean(a), .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10744:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10777:3'): relational summarise(c = 1) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(c = 1)) at test-rel_api.R:10777:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10809:3'): relational summarise(c = 1, .by = g) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(g = 1:3, c = rep(1, 3L))) at test-rel_api.R:10809:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10854:3'): relational symdiff() order-enforcing ──────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:10854:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:10917:3'): relational tally() order-enforcing ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(n = 6L)) at test-rel_api.R:10917:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11020:3'): relational transmute(c = a + 1) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(c = seq(2, 7, by = 1))) at test-rel_api.R:11020:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11047:3'): relational transmute(row = a) order-enforcing ──
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(row = seq(1, 6, by = 1))) at test-rel_api.R:11047:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11237:3'): relational union() order-preserving ───────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1:5, b = rep(2, 5L))) at test-rel_api.R:11237:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11261:3'): relational union() order-enforcing ────────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(out, data.frame(a = 1:5, b = rep(2, 5L))) at test-rel_api.R:11261:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11360:3'): relational union_all() order-preserving ───
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:11360:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-rel_api.R:11383:3'): relational union_all() order-enforcing ────
Error: Error evaluating duckdb query: Not implemented Error: Sorting is not supported on big endian architectures
Backtrace:
    ▆
 1. └─testthat::expect_equal(...) at test-rel_api.R:11383:2
 2.   └─testthat:::expect_waldo_equal("equal", act, exp, info, ..., tolerance = tolerance)
 3.     └─testthat:::waldo_compare(...)
 4.       └─waldo::compare(x, y, ..., x_arg = x_arg, y_arg = y_arg)
 5.         └─waldo:::compare_structure(x, y, paths = c(x_arg, y_arg), opts = opts)
 6.           └─waldo:::is_identical(x, y, opts)
── Error ('test-relational-duckdb.R:31:3'): duckdb_rel_from_df() ───────────────
Error: TransactionContext Error: Current transaction is aborted (please ROLLBACK)
Backtrace:
     ▆
  1. ├─testthat::expect_silent(duckdb_rel_from_df(df)) at test-relational-duckdb.R:31:2
  2. │ └─testthat:::quasi_capture(enquo(object), NULL, evaluate_promise)
  3. │   ├─testthat (local) .capture(...)
  4. │   │ ├─withr::with_output_sink(...)
  5. │   │ │ └─base::force(code)
  6. │   │ ├─base::withCallingHandlers(...)
  7. │   │ └─base::withVisible(code)
  8. │   └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
  9. └─duckplyr::duckdb_rel_from_df(df)
 10.   └─duckdb$rel_from_df(con, df, experimental = experimental)
 11.     └─duckdb:::rapi_rel_from_df(con@conn_ref, as.data.frame(df), experimental)
── Error ('test-relational-duckdb.R:46:3'): duckdb_rel_from_df() and changing column names ──
Error: TransactionContext Error: Current transaction is aborted (please ROLLBACK)
Backtrace:
    ▆
 1. ├─data.frame(a = 1) %>% duckplyr_select(a) at test-relational-duckdb.R:46:2
 2. └─duckplyr:::duckplyr_select(., a)
 3.   ├─dplyr::select(.data, ...)
 4.   └─duckplyr:::select.duckplyr_df(.data, ...)
 5.     ├─duckplyr:::rel_try(...)
 6.     └─duckplyr::duckdb_rel_from_df(.data)
 7.       └─duckdb$rel_from_df(con, df, experimental = experimental)
 8.         └─duckdb:::rapi_rel_from_df(con@conn_ref, as.data.frame(df), experimental)
── Error ('test-relational-duckdb.R:60:3'): rel_aggregate() ────────────────────
<packageNotFoundError/error/condition>
Error in `loadNamespace(x)`: there is no package called 'palmerpenguins'
Backtrace:
     ▆
  1. ├─... %>% ... at test-relational-duckdb.R:60:2
  2. ├─duckplyr::rel_aggregate(., list(expr_species), list(expr_aggregate))
  3. ├─duckplyr::duckdb_rel_from_df(.)
  4. │ ├─base::stopifnot(is.data.frame(df))
  5. │ └─base::is.data.frame(df)
  6. ├─duckplyr::as_duckplyr_df(.)
  7. ├─dplyr::mutate(., sex = as.character(sex))
  8. ├─dplyr::mutate(., island = as.character(island))
  9. ├─dplyr::mutate(., species = as.character(species))
 10. └─base::loadNamespace(x)
 11.   └─base::withRestarts(stop(cond), retry_loadNamespace = function() NULL)
 12.     └─base (local) withOneRestart(expr, restarts[[1L]])
 13.       └─base (local) doWithOneRestart(return(expr), restart)
── Error ('test-relational-duckdb.R:95:3'): duckdb_rel_from_df() uses materialized results ──
Error: TransactionContext Error: Current transaction is aborted (please ROLLBACK)
Backtrace:
    ▆
 1. ├─data.frame(a = 1) %>% duckplyr_filter(a == 1) at test-relational-duckdb.R:95:2
 2. └─duckplyr:::duckplyr_filter(., a == 1)
 3.   ├─dplyr::filter(.data, ...)
 4.   └─duckplyr:::filter.duckplyr_df(.data, ...)
 5.     ├─duckplyr:::rel_try(...)
 6.     └─duckplyr::duckdb_rel_from_df(.data)
 7.       └─duckdb$rel_from_df(con, df, experimental = experimental)
 8.         └─duckdb:::rapi_rel_from_df(con@conn_ref, as.data.frame(df), experimental)
── Failure ('test-relocate.R:109:3'): attributes of bare data frames are retained (#6341) ──
attr(out, "foo") (`actual`) not identical to "bar" (`expected`).

`actual` is NULL
`expected` is a character vector ('bar')
── Failure ('test-select.R:154:3'): duckplyr_select() keeps attributes of raw data frames (#5831) ──
attr(duckplyr_select(df, x), "a") (`actual`) not equal to "b" (`expected`).

`actual` is NULL
`expected` is a character vector ('b')

[ FAIL 194 | WARN 1 | SKIP 321 | PASS 972 ]
Error: Test failures
In addition: There were 50 or more warnings (use warnings() to see the first 50)

🛠: 877
🔨: 735
🦆: 142
add_count, anti_join, arrange, compute, count, cross_join, distinct, do, eval, filter, full_join, inner_join, intersect, left_join, mutate, nest_join, pull, reframe, relocate, rename, rename_with, right_join, rows_append, rows_delete, rows_insert, rows_patch, rows_update, rows_upsert, select, semi_join, setdiff, setequal, slice, slice_head, slice_tail, summarise, symdiff, transmute, ungroup, union_all

00:03:08.807927
Execution halted
Warning messages:
1: Connection is garbage-collected, use dbDisconnect() to avoid this. 
2: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
3: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
4: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
5: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
6: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
7: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
8: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
9: Database is garbage-collected, use dbDisconnect(con, shutdown=TRUE) or duckdb::duckdb_shutdown(drv) to avoid this. 
10: Connection already closed.