Package evaluation of TidierDB on Julia 1.11.4 (a71dd056e0*) started at 2025-04-08T16:49:13.893 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.4s ################################################################################ # Installation # Installing TidierDB... Resolving package versions... Updating `~/.julia/environments/v1.11/Project.toml` [86993f9b] + TidierDB v0.8.2 Updating `~/.julia/environments/v1.11/Manifest.toml` [69666777] + Arrow v2.8.0 [31f734f8] + ArrowTypes v2.3.0 [d1d4a3ce] + BitFlags v0.1.9 [c3b6d118] + BitIntegers v0.3.5 [336ed68f] + CSV v0.10.15 [8be319e6] + Chain v0.6.0 [5ba52731] + CodecLz4 v0.4.6 [944b1d66] + CodecZlib v0.7.8 [6b39b394] + CodecZstd v0.8.6 [34da2185] + Compat v4.16.0 [f0e56b4a] + ConcurrentUtilities v2.5.0 [a8cc5b0e] + Crayons v4.1.1 [a10d1c49] + DBInterface v2.6.1 [9a962f9c] + DataAPI v1.16.0 [a93c6f00] + DataFrames v1.7.0 [864edb3b] + DataStructures v0.18.22 [e2d170a0] + DataValueInterfaces v1.0.0 [d2f5444f] + DuckDB v1.2.1 [4e289a0a] + EnumX v1.0.5 [460bff9d] + ExceptionUnwrapping v0.1.11 [e2ba6199] + ExprTools v0.1.10 [48062228] + FilePathsBase v0.9.24 [fb4d412d] + FixedPointDecimals v0.6.3 [92fee26a] + GZip v0.6.2 [cd3eb016] + HTTP v1.10.15 [842dd82b] + InlineStrings v1.4.3 [41ab1584] + InvertedIndices v1.3.1 [82899510] + IteratorInterfaceExtensions v1.0.0 [692b3bcd] + JLLWrappers v1.7.0 [0f8b85d8] + JSON3 v1.14.2 [b964fa9f] + LaTeXStrings v1.4.0 [e6f89c97] + LoggingExtras v1.1.0 [1914dd2f] + MacroTools v0.5.15 [739be429] + MbedTLS v1.1.9 [e1d29d7a] + Missings v1.2.0 [78c3b35d] + Mocking v0.8.1 [4d8831e6] + OpenSSL v1.4.3 [bac558e1] + OrderedCollections v1.8.0 [69de0a69] + Parsers v2.8.1 [2dfb63ee] + PooledArrays v1.4.3 ⌅ [aea7be01] + PrecompileTools v1.2.1 [21216c6a] + Preferences v1.4.3 [08abe8d2] + PrettyTables v2.4.0 [189a3867] + Reexport v1.2.2 [6c6a2e73] + Scratch v1.2.1 [91c51154] + SentinelArrays v1.4.8 [777ac1f9] + SimpleBufferStream v1.2.0 [a2af1166] + SortingAlgorithms v1.2.1 [10745b16] + Statistics v1.11.1 [892a3eda] + StringManipulation v0.4.1 [354b36f9] + StringViews v1.3.4 [856f2bd8] + StructTypes v1.11.0 [dc5dba14] + TZJData v1.5.0+2025b [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.0 [86993f9b] + TidierDB v0.8.2 [f269a46b] + TimeZones v1.21.3 [3bb67fe8] + TranscodingStreams v0.11.3 [5c2747f8] + URIs v1.5.2 [ea10d353] + WeakRefStrings v1.4.2 [76eceee3] + WorkerUtilities v1.6.1 [2cbbab25] + DuckDB_jll v1.2.1+0 [5ced341a] + Lz4_jll v1.10.1+0 [458c3c95] + OpenSSL_jll v3.0.16+0 [3161d3a3] + Zstd_jll v1.5.7+1 [0dad84c5] + ArgTools v1.1.2 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [f43a241f] + Downloads v1.6.0 [7b1f6079] + FileWatching v1.11.0 [9fa8497b] + Future v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [b27032c2] + LibCURL v0.6.4 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.11.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [a63ad114] + Mmap v1.11.0 [ca575930] + NetworkOptions v1.2.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [6462fe0b] + Sockets v1.11.0 [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.1.1+0 [deac9b47] + LibCURL_jll v8.6.0+0 [29816b5a] + LibSSH2_jll v1.11.0+1 [c8ffd9c3] + MbedTLS_jll v2.28.6+0 [14a3606d] + MozillaCACerts_jll v2023.12.12 [4536629a] + OpenBLAS_jll v0.3.27+1 [83775a58] + Zlib_jll v1.2.13+1 [8e850b90] + libblastrampoline_jll v5.11.0+0 [8e850ede] + nghttp2_jll v1.59.0+0 [3f19e933] + p7zip_jll v17.4.0+2 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 2.25s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 54.21s ################################################################################ # Testing # Testing TidierDB Status `/tmp/jl_6kv7eU/Project.toml` [e30172f5] Documenter v1.10.1 [86993f9b] TidierDB v0.8.2 [fe2206b3] TidierData v0.17.0 [20186a3f] TidierDates v0.4.1 [248e6834] TidierStrings v0.3.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_6kv7eU/Manifest.toml` [a4c015fc] ANSIColoredPrinters v0.0.1 [1520ce14] AbstractTrees v0.4.5 [66dad0bd] AliasTables v1.1.3 [69666777] Arrow v2.8.0 [31f734f8] ArrowTypes v2.3.0 [d1d4a3ce] BitFlags v0.1.9 [c3b6d118] BitIntegers v0.3.5 [336ed68f] CSV v0.10.15 [8be319e6] Chain v0.6.0 [caabdcdb] Cleaner v1.1.1 [5ba52731] CodecLz4 v0.4.6 [944b1d66] CodecZlib v0.7.8 [6b39b394] CodecZstd v0.8.6 [34da2185] Compat v4.16.0 [f0e56b4a] ConcurrentUtilities v2.5.0 [a8cc5b0e] Crayons v4.1.1 [a10d1c49] DBInterface v2.6.1 [9a962f9c] DataAPI v1.16.0 [a93c6f00] DataFrames v1.7.0 [864edb3b] DataStructures v0.18.22 [e2d170a0] DataValueInterfaces v1.0.0 [ffbed154] DocStringExtensions v0.9.4 [e30172f5] Documenter v1.10.1 [d2f5444f] DuckDB v1.2.1 [4e289a0a] EnumX v1.0.5 [460bff9d] ExceptionUnwrapping v0.1.11 [e2ba6199] ExprTools v0.1.10 [48062228] FilePathsBase v0.9.24 [fb4d412d] FixedPointDecimals v0.6.3 [92fee26a] GZip v0.6.2 [d7ba0133] Git v1.3.1 [cd3eb016] HTTP v1.10.15 [b5f81e59] IOCapture v0.2.5 [842dd82b] InlineStrings v1.4.3 [41ab1584] InvertedIndices v1.3.1 [92d709cd] IrrationalConstants v0.2.4 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.7.0 [682c06a0] JSON v0.21.4 [0f8b85d8] JSON3 v1.14.2 [b964fa9f] LaTeXStrings v1.4.0 [0e77f7df] LazilyInitializedFields v1.3.0 [2ab3a3ac] LogExpFunctions v0.3.29 [e6f89c97] LoggingExtras v1.1.0 [1914dd2f] MacroTools v0.5.15 [d0879d2d] MarkdownAST v0.1.2 [739be429] MbedTLS v1.1.9 [e1d29d7a] Missings v1.2.0 [78c3b35d] Mocking v0.8.1 [4d8831e6] OpenSSL v1.4.3 [bac558e1] OrderedCollections v1.8.0 [69de0a69] Parsers v2.8.1 [2dfb63ee] PooledArrays v1.4.3 ⌅ [aea7be01] PrecompileTools v1.2.1 [21216c6a] Preferences v1.4.3 [08abe8d2] PrettyTables v2.4.0 [43287f4e] PtrArrays v1.3.0 [189a3867] Reexport v1.2.2 [2792f1a3] RegistryInstances v0.1.0 [6c6a2e73] Scratch v1.2.1 [91c51154] SentinelArrays v1.4.8 [1277b4bf] ShiftedArrays v2.0.0 [777ac1f9] SimpleBufferStream v1.2.0 [a2af1166] SortingAlgorithms v1.2.1 [10745b16] Statistics v1.11.1 [82ae8749] StatsAPI v1.7.0 [2913bbd2] StatsBase v0.34.4 [69024149] StringEncodings v0.3.7 [892a3eda] StringManipulation v0.4.1 [354b36f9] StringViews v1.3.4 [856f2bd8] StructTypes v1.11.0 [dc5dba14] TZJData v1.5.0+2025b [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.0 [86993f9b] TidierDB v0.8.2 [fe2206b3] TidierData v0.17.0 [20186a3f] TidierDates v0.4.1 [248e6834] TidierStrings v0.3.0 [f269a46b] TimeZones v1.21.3 [3bb67fe8] TranscodingStreams v0.11.3 [5c2747f8] URIs v1.5.2 [ea10d353] WeakRefStrings v1.4.2 [76eceee3] WorkerUtilities v1.6.1 [2cbbab25] DuckDB_jll v1.2.1+0 [2e619515] Expat_jll v2.6.5+0 [f8c6e375] Git_jll v2.49.0+0 [94ce4f54] Libiconv_jll v1.18.0+0 [5ced341a] Lz4_jll v1.10.1+0 [458c3c95] OpenSSL_jll v3.0.16+0 [3161d3a3] Zstd_jll v1.5.7+1 [0dad84c5] ArgTools v1.1.2 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [f43a241f] Downloads v1.6.0 [7b1f6079] FileWatching v1.11.0 [9fa8497b] Future v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [b27032c2] LibCURL v0.6.4 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.11.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [a63ad114] Mmap v1.11.0 [ca575930] NetworkOptions v1.2.0 [44cfe95a] Pkg v1.11.0 [de0858da] Printf v1.11.0 [3fa0cd96] REPL v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [6462fe0b] Sockets v1.11.0 [2f01184e] SparseArrays v1.11.0 [f489334b] StyledStrings v1.11.0 [fa267f1f] TOML v1.0.3 [a4e569a6] Tar v1.10.0 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.1.1+0 [deac9b47] LibCURL_jll v8.6.0+0 [e37daf67] LibGit2_jll v1.7.2+0 [29816b5a] LibSSH2_jll v1.11.0+1 [c8ffd9c3] MbedTLS_jll v2.28.6+0 [14a3606d] MozillaCACerts_jll v2023.12.12 [4536629a] OpenBLAS_jll v0.3.27+1 [efcefdf7] PCRE2_jll v10.42.0+1 [bea87d4a] SuiteSparse_jll v7.7.0+0 [83775a58] Zlib_jll v1.2.13+1 [8e850b90] libblastrampoline_jll v5.11.0+0 [8e850ede] nghttp2_jll v1.59.0+0 [3f19e933] p7zip_jll v17.4.0+2 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... ┌ Warning: Unable to determine HTML(edit_link = ...) from remote HEAD branch, defaulting to "master". │ Calling `git remote` failed with an exception. Set JULIA_DEBUG=Documenter to see the error. │ Unless this is due to a configuration error, the relevant variable should be set explicitly. └ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/utilities/utilities.jl:660 [ Info: SetupBuildDirectory: setting up build directory. [ Info: Doctest: running doctests. ┌ Error: doctest failure in ../src/sep_unite.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame( b = ["1", "2", "3"], c = ["1", "2", "3"], d = [missing, missing, "3"]); │ │ julia> @chain dt(db, df, "df") @unite(new_col, (b, c, d), "-") @collect │ 3×1 DataFrame │ Row │ new_col │ │ String │ ─────┼───────── │ 1 │ 1-1 │ 2 │ 2-2 │ 3 │ 3-3-3 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df") @unite(new_col, (b, c, d), "-") @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×1 DataFrame │ Row │ new_col │ │ String │ ─────┼───────── │ 1 │ 1-1 │ 2 │ 2-2 │ 3 │ 3-3-3 │ │ Expected output: │ │ 3×1 DataFrame │ Row │ new_col │ │ String │ ─────┼───────── │ 1 │ 1-1 │ 2 │ 2-2 │ 3 │ 3-3-3 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×1 DataFrame │ Row │ new_col │ new_col │ │ String │ String │ ─────┼───────── │ 1 │ 1-1 │ 2 │ 2-2 │ 3 │ 3-3-3 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/sep_unite.jl ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 ┌ Error: doctest failure in ../src/view_compute.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(a = ["1-1", "2-2", "3-3-3"]); │ │ julia> @chain dt(db, df, "df") @filter(a == "2-2") write_file("test.parquet") │ (Count = [1],) │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df") @filter(a == "2-2") write_file("test.parquet") │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ (Count = [1],) │ │ Expected output: │ │ (Count = [1],) │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ (Count = [1],) └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/view_compute.jl ┌ Error: doctest failure in ../src/windows.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @window_frame(3) │ @window_order(desc(percent)) │ @mutate(avg = mean(value)) │ #@show_query │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by groups │ @window_frame(3) │ @window_order(desc(percent)) │ @mutate(avg = mean(value)) │ #@show_query │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/windows.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(dfj), id == id2) │ @collect │ end │ 7×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 │ │ julia> query = @chain dfj begin │ @filter(score >= 74) # only show scores above 85 in joining table │ end; │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(query), id == id2) │ @collect │ end │ 6×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 │ ``` │ │ Subexpression: │ │ dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(dfj), id == id2) │ @collect │ end │ 7×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 │ │ julia> query = @chain dfj begin │ @filter(score >= 74) # only show scores above 85 in joining table │ end; │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(query), id == id2) │ @collect │ end │ 6×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @right_join(t(dfj), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 │ │ Expected output: │ │ 7×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String? Int64? Float64? String Int64 │ Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(dfj), id == id2) │ @collect │ end │ 7×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AK missing missing missing Y 68 │ 7 │ AM missing missing missing X 74 │ │ julia> query = @chain dfj begin │ @filter(score >= 74) # only show scores above 85 in joining table │ end; │ │ julia> @chain dt(db, df, "df_view") begin │ @right_join(t(query), id == id2) │ @collect │ end │ 6×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @right_join(t(query), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 │ │ Expected output: │ │ 6×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String? Int64? Float64? String Int64 │ Int64 │ ─────┼────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AM missing missing missing X 74 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ Expected output: │ │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String Int64 Float64 String? Int64? │ Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ missing │ 7 │ AD aa 4 0.4 missing missing │ missing │ 8 │ AF aa 1 0.6 missing missing │ missing │ 9 │ AH aa 3 0.8 missing missing │ missing │ 10 │ AJ aa 5 1.0 missing missing └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ Expected output: │ │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String Int64 Float64 String? Int64? │ Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ missing │ 5 │ AD aa 4 0.4 missing missing │ missing │ 6 │ AE bb 5 0.5 missing missing │ missing │ 7 │ AF aa 1 0.6 missing missing │ missing │ 8 │ AG bb 2 0.7 missing missing │ missing │ 9 │ AH aa 3 0.8 missing missing │ missing │ 10 │ AJ aa 5 1.0 missing missing └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ julia> dfm = dt(db, df, "df_mem"); dfj = dt(db, df2, "df_join"); │ │ julia> @chain dfm begin │ @left_join(t(dfj), id == id2 ) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> query = @chain dt(db, "df_join") begin │ @filter(score > 85) # only show scores above 85 in joining table │ end; │ │ julia> @chain dfm begin │ @left_join(t(query), id == id2) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String? Int64? │ ─────┼─────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AI bb 4 0.9 X 95 │ 4 │ AB aa 2 0.2 missing missing │ 5 │ AD aa 4 0.4 missing missing │ 6 │ AE bb 5 0.5 missing missing │ 7 │ AF aa 1 0.6 missing missing │ 8 │ AG bb 2 0.7 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ │ julia> @chain dfm begin │ @mutate(test = percent * 100) │ @left_join(t(dfj), test <= score, id = id2) │ @collect │ end; │ │ │ julia> @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dfm begin │ @mutate(test = percent * 200) │ @left_join(t(dfj), closest(test >= score)) # asof join │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/unnest.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> DuckDB.query(db, " │ CREATE TABLE df3 ( │ id INTEGER, │ pos ROW(lat DOUBLE, lon DOUBLE) │ ); │ INSERT INTO df3 VALUES │ (1, ROW(10.1, 30.3)), │ (2, ROW(10.2, 30.2)), │ (3, ROW(10.3, 30.1));"); │ │ julia> @chain dt(db, :df3) begin │ @unnest_wider(pos) │ @collect │ end │ 3×3 DataFrame │ Row │ id lat lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ julia> @chain dt(db, :df3) begin │ @unnest_wider(pos, names_sep = "_") │ @collect │ end │ 3×3 DataFrame │ Row │ id pos_lat pos_lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ ``` │ │ Subexpression: │ │ @chain dt(db, :df3) begin │ @unnest_wider(pos) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ id lat lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ │ Expected output: │ │ 3×3 DataFrame │ Row │ id lat lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ id lat lon │ lon │ │ Int32 Float64 Float64 │ Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/unnest.jl ┌ Error: doctest failure in ../src/unnest.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> DuckDB.query(db, " │ CREATE TABLE df3 ( │ id INTEGER, │ pos ROW(lat DOUBLE, lon DOUBLE) │ ); │ INSERT INTO df3 VALUES │ (1, ROW(10.1, 30.3)), │ (2, ROW(10.2, 30.2)), │ (3, ROW(10.3, 30.1));"); │ │ julia> @chain dt(db, :df3) begin │ @unnest_wider(pos) │ @collect │ end │ 3×3 DataFrame │ Row │ id lat lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ julia> @chain dt(db, :df3) begin │ @unnest_wider(pos, names_sep = "_") │ @collect │ end │ 3×3 DataFrame │ Row │ id pos_lat pos_lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ ``` │ │ Subexpression: │ │ @chain dt(db, :df3) begin │ @unnest_wider(pos, names_sep = "_") │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ id pos_lat pos_lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ │ Expected output: │ │ 3×3 DataFrame │ Row │ id pos_lat pos_lon │ │ Int32 Float64 Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ id pos_lat pos_lon │ pos_lon │ │ Int32 Float64 Float64 │ Float64 │ ─────┼───────────────────────── │ 1 │ 1 10.1 30.3 │ 2 │ 2 10.2 30.2 │ 3 │ 3 10.3 30.1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/unnest.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .5) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(mean = mean(percent)) │ @filter begin │ groups == "bb" || # logical operators can still be used like this │ mean > .5 │ end │ @arrange(groups) │ @collect │ end │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ julia> q = @chain dt(db, df, "df_view") @summarize(mean = mean(value)); │ │ julia> @eval @chain dt(db, df, "df_view") begin │ @filter(value < $q) │ @collect │ end │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @filter(percent > .5) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ Expected output: │ │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .5) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(mean = mean(percent)) │ @filter begin │ groups == "bb" || # logical operators can still be used like this │ mean > .5 │ end │ @arrange(groups) │ @collect │ end │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ julia> q = @chain dt(db, df, "df_view") @summarize(mean = mean(value)); │ │ julia> @eval @chain dt(db, df, "df_view") begin │ @filter(value < $q) │ @collect │ end │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(mean = mean(percent)) │ @filter begin │ groups == "bb" || # logical operators can still be used like this │ mean > .5 │ end │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ Expected output: │ │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ groups mean │ mean │ │ String Float64 │ Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .5) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(mean = mean(percent)) │ @filter begin │ groups == "bb" || # logical operators can still be used like this │ mean > .5 │ end │ @arrange(groups) │ @collect │ end │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ julia> q = @chain dt(db, df, "df_view") @summarize(mean = mean(value)); │ │ julia> @eval @chain dt(db, df, "df_view") begin │ @filter(value < $q) │ @collect │ end │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ ``` │ │ Subexpression: │ │ q = @chain dt(db, df, "df_view") @summarize(mean = mean(value)); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .5) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AG bb 2 0.7 │ 3 │ AH aa 3 0.8 │ 4 │ AI bb 4 0.9 │ 5 │ AJ aa 5 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(mean = mean(percent)) │ @filter begin │ groups == "bb" || # logical operators can still be used like this │ mean > .5 │ end │ @arrange(groups) │ @collect │ end │ 2×2 DataFrame │ Row │ groups mean │ │ String Float64 │ ─────┼───────────────── │ 1 │ aa 0.6 │ 2 │ bb 0.5 │ │ julia> q = @chain dt(db, df, "df_view") @summarize(mean = mean(value)); │ │ julia> @eval @chain dt(db, df, "df_view") begin │ @filter(value < $q) │ @collect │ end │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ ``` │ │ Subexpression: │ │ @eval @chain dt(db, df, "df_view") begin │ @filter(value < $q) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ │ Expected output: │ │ 4×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AF aa 1 0.6 │ 4 │ AG bb 2 0.7 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/parsing_duckdb.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value1 = [i - 4^1 for i in -4.5:4.5], │ value2 = [i + 2^i for i in 1:10], │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_agg") begin │ @summarise( │ r2 = regr_r2(value2, value1), │ across(contains("value"), median), │ _by = groups) │ @arrange(groups) │ @collect │ end │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ │ String Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = agg(regr_slope(value1, value2)), │ var = agg(var_samp(value2)), │ std = std(value2), # since this is in the list above, it does not get wrapped in `agg` │ _by = groups │ ) │ @mutate(var = round(var)) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ │ String String Float64 Int64 Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 │ │ julia> push!(TidierDB.window_agg_fxns, :regr_slope); │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = regr_slope(value1, value2), # no longer wrapped in `agg` following the above │ _by = groups │ ) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ │ String String Float64 Int64 Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_agg") begin │ @summarise( │ r2 = regr_r2(value2, value1), │ across(contains("value"), median), │ _by = groups) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ │ String Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 │ │ Expected output: │ │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ │ String Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ value2_median │ │ String Float64 Float64 Float64 │ Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/parsing_duckdb.jl ┌ Error: doctest failure in ../src/parsing_duckdb.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value1 = [i - 4^1 for i in -4.5:4.5], │ value2 = [i + 2^i for i in 1:10], │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_agg") begin │ @summarise( │ r2 = regr_r2(value2, value1), │ across(contains("value"), median), │ _by = groups) │ @arrange(groups) │ @collect │ end │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ │ String Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = agg(regr_slope(value1, value2)), │ var = agg(var_samp(value2)), │ std = std(value2), # since this is in the list above, it does not get wrapped in `agg` │ _by = groups │ ) │ @mutate(var = round(var)) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ │ String String Float64 Int64 Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 │ │ julia> push!(TidierDB.window_agg_fxns, :regr_slope); │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = regr_slope(value1, value2), # no longer wrapped in `agg` following the above │ _by = groups │ ) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ │ String String Float64 Int64 Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = agg(regr_slope(value1, value2)), │ var = agg(var_samp(value2)), │ std = std(value2), # since this is in the list above, it does not get wrapped in `agg` │ _by = groups │ ) │ @mutate(var = round(var)) │ @select !percent │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ │ String String Float64 Int64 Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 │ │ Expected output: │ │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ │ String String Float64 Int64 Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ std │ │ String String Float64 Int64 Float64 Float64 Float64 │ Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/parsing_duckdb.jl ┌ Error: doctest failure in ../src/parsing_duckdb.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value1 = [i - 4^1 for i in -4.5:4.5], │ value2 = [i + 2^i for i in 1:10], │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_agg") begin │ @summarise( │ r2 = regr_r2(value2, value1), │ across(contains("value"), median), │ _by = groups) │ @arrange(groups) │ @collect │ end │ 2×4 DataFrame │ Row │ groups r2 value1_median value2_median │ │ String Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────── │ 1 │ aa 0.700161 -3.5 70.0 │ 2 │ bb 0.703783 -4.5 37.0 │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = agg(regr_slope(value1, value2)), │ var = agg(var_samp(value2)), │ std = std(value2), # since this is in the list above, it does not get wrapped in `agg` │ _by = groups │ ) │ @mutate(var = round(var)) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×7 DataFrame │ Row │ id groups value1 value2 slope var std │ │ String String Float64 Int64 Float64 Float64 Float64 │ ─────┼──────────────────────────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 188885.0 434.609 │ 2 │ AD aa -5.5 20 0.00608835 188885.0 434.609 │ 3 │ AF aa -3.5 70 0.00608835 188885.0 434.609 │ 4 │ AH aa -1.5 264 0.00608835 188885.0 434.609 │ 5 │ AJ aa 0.5 1034 0.00608835 188885.0 434.609 │ 6 │ AA bb -8.5 3 0.0121342 47799.0 218.629 │ 7 │ AC bb -6.5 11 0.0121342 47799.0 218.629 │ 8 │ AE bb -4.5 37 0.0121342 47799.0 218.629 │ 9 │ AG bb -2.5 135 0.0121342 47799.0 218.629 │ 10 │ AI bb -0.5 521 0.0121342 47799.0 218.629 │ │ julia> push!(TidierDB.window_agg_fxns, :regr_slope); │ │ julia> @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = regr_slope(value1, value2), # no longer wrapped in `agg` following the above │ _by = groups │ ) │ @select !percent │ @arrange(groups) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ │ String String Float64 Int64 Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_agg") begin │ @mutate( │ slope = regr_slope(value1, value2), # no longer wrapped in `agg` following the above │ _by = groups │ ) │ @select !percent │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ │ String String Float64 Int64 Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 │ │ Expected output: │ │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ │ String String Float64 Int64 Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×5 DataFrame │ Row │ id groups value1 value2 slope │ slope │ │ String String Float64 Int64 Float64 │ Float64 │ ─────┼───────────────────────────────────────────── │ 1 │ AB aa -7.5 6 0.00608835 │ 2 │ AD aa -5.5 20 0.00608835 │ 3 │ AF aa -3.5 70 0.00608835 │ 4 │ AH aa -1.5 264 0.00608835 │ 5 │ AJ aa 0.5 1034 0.00608835 │ 6 │ AA bb -8.5 3 0.0121342 │ 7 │ AC bb -6.5 11 0.0121342 │ 8 │ AE bb -4.5 37 0.0121342 │ 9 │ AG bb -2.5 135 0.0121342 │ 10 │ AI bb -0.5 521 0.0121342 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/parsing_duckdb.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((value:percent), (mean, sum))) │ @arrange(groups) │ @collect │ end │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((value:percent), (mean, sum))) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ percent_sum │ │ String Float64 Float64 Int128 Float64 │ Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((value:percent), (mean, sum))) │ @arrange(groups) │ @collect │ end │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ Expected output: │ │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ n │ │ String Float64 Int64 │ Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> show_tables(db); │ ``` │ │ Subexpression: │ │ show_tables(db); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 1, 2, 2, 3, 4], │ name = ["Alice", "Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame(id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @setdiff(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ julia> @chain df1_table @setdiff(df2_table, all = true) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ ``` │ │ Subexpression: │ │ df1_table = dt(db, df1, "df1"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 1, 2, 2, 3, 4], │ name = ["Alice", "Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame(id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @setdiff(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ julia> @chain df1_table @setdiff(df2_table, all = true) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ ``` │ │ Subexpression: │ │ df2_table = dt(db, df2, "df2"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 1, 2, 2, 3, 4], │ name = ["Alice", "Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame(id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @setdiff(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ julia> @chain df1_table @setdiff(df2_table, all = true) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ ``` │ │ Subexpression: │ │ @chain df1_table @setdiff(df2_table) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ Expected output: │ │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ id name │ name │ │ Int64 String │ String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 1, 2, 2, 3, 4], │ name = ["Alice", "Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame(id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @setdiff(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 4 David │ │ julia> @chain df1_table @setdiff(df2_table, all = true) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ ``` │ │ Subexpression: │ │ @chain df1_table @setdiff(df2_table, all = true) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ │ Expected output: │ │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id name │ name │ │ Int64 String │ String │ ─────┼─────────────── │ 1 │ 1 Alice │ 2 │ 1 Alice │ 3 │ 4 David └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @anti_join(t(dfj), id == id2) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AB aa 2 0.2 │ 2 │ AD aa 4 0.4 │ 3 │ AF aa 1 0.6 │ 4 │ AH aa 3 0.8 │ 5 │ AJ aa 5 1.0 │ ``` │ │ Subexpression: │ │ dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @anti_join(t(dfj), id == id2) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AB aa 2 0.2 │ 2 │ AD aa 4 0.4 │ 3 │ AF aa 1 0.6 │ 4 │ AH aa 3 0.8 │ 5 │ AJ aa 5 1.0 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @anti_join(t(dfj), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AB aa 2 0.2 │ 2 │ AD aa 4 0.4 │ 3 │ AF aa 1 0.6 │ 4 │ AH aa 3 0.8 │ 5 │ AJ aa 5 1.0 │ │ Expected output: │ │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AB aa 2 0.2 │ 2 │ AD aa 4 0.4 │ 3 │ AF aa 1 0.6 │ 4 │ AH aa 3 0.8 │ 5 │ AJ aa 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AB aa 2 0.2 │ 2 │ AD aa 4 0.4 │ 3 │ AF aa 1 0.6 │ 4 │ AH aa 3 0.8 │ 5 │ AJ aa 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_sample(n = 2) │ @collect │ end; │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_sample() │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_sample(n = 2) │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_sample(n = 2) │ @collect │ end; │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_sample() │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @slice_sample() │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/relocate.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @relocate(groups, value, ends_with("d"), after = percent) │ @collect │ end │ 10×4 DataFrame │ Row │ percent groups value id │ │ Float64 String Int64 String │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb 1 AA │ 2 │ 0.2 aa 2 AB │ 3 │ 0.3 bb 3 AC │ 4 │ 0.4 aa 4 AD │ 5 │ 0.5 bb 5 AE │ 6 │ 0.6 aa 1 AF │ 7 │ 0.7 bb 2 AG │ 8 │ 0.8 aa 3 AH │ 9 │ 0.9 bb 4 AI │ 10 │ 1.0 aa 5 AJ │ │ julia> @chain dt(db, df, "df_view") begin │ @relocate([:percent, :groups], before = id) │ @collect │ end │ 10×4 DataFrame │ Row │ percent groups id value │ │ Float64 String String Int64 │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb AA 1 │ 2 │ 0.2 aa AB 2 │ 3 │ 0.3 bb AC 3 │ 4 │ 0.4 aa AD 4 │ 5 │ 0.5 bb AE 5 │ 6 │ 0.6 aa AF 1 │ 7 │ 0.7 bb AG 2 │ 8 │ 0.8 aa AH 3 │ 9 │ 0.9 bb AI 4 │ 10 │ 1.0 aa AJ 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @relocate(groups, value, ends_with("d"), after = percent) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ percent groups value id │ │ Float64 String Int64 String │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb 1 AA │ 2 │ 0.2 aa 2 AB │ 3 │ 0.3 bb 3 AC │ 4 │ 0.4 aa 4 AD │ 5 │ 0.5 bb 5 AE │ 6 │ 0.6 aa 1 AF │ 7 │ 0.7 bb 2 AG │ 8 │ 0.8 aa 3 AH │ 9 │ 0.9 bb 4 AI │ 10 │ 1.0 aa 5 AJ │ │ Expected output: │ │ 10×4 DataFrame │ Row │ percent groups value id │ │ Float64 String Int64 String │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb 1 AA │ 2 │ 0.2 aa 2 AB │ 3 │ 0.3 bb 3 AC │ 4 │ 0.4 aa 4 AD │ 5 │ 0.5 bb 5 AE │ 6 │ 0.6 aa 1 AF │ 7 │ 0.7 bb 2 AG │ 8 │ 0.8 aa 3 AH │ 9 │ 0.9 bb 4 AI │ 10 │ 1.0 aa 5 AJ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ percent groups value id │ id │ │ Float64 String Int64 String │ String │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb 1 AA │ 2 │ 0.2 aa 2 AB │ 3 │ 0.3 bb 3 AC │ 4 │ 0.4 aa 4 AD │ 5 │ 0.5 bb 5 AE │ 6 │ 0.6 aa 1 AF │ 7 │ 0.7 bb 2 AG │ 8 │ 0.8 aa 3 AH │ 9 │ 0.9 bb 4 AI │ 10 │ 1.0 aa 5 AJ └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/relocate.jl ┌ Error: doctest failure in ../src/relocate.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @relocate(groups, value, ends_with("d"), after = percent) │ @collect │ end │ 10×4 DataFrame │ Row │ percent groups value id │ │ Float64 String Int64 String │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb 1 AA │ 2 │ 0.2 aa 2 AB │ 3 │ 0.3 bb 3 AC │ 4 │ 0.4 aa 4 AD │ 5 │ 0.5 bb 5 AE │ 6 │ 0.6 aa 1 AF │ 7 │ 0.7 bb 2 AG │ 8 │ 0.8 aa 3 AH │ 9 │ 0.9 bb 4 AI │ 10 │ 1.0 aa 5 AJ │ │ julia> @chain dt(db, df, "df_view") begin │ @relocate([:percent, :groups], before = id) │ @collect │ end │ 10×4 DataFrame │ Row │ percent groups id value │ │ Float64 String String Int64 │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb AA 1 │ 2 │ 0.2 aa AB 2 │ 3 │ 0.3 bb AC 3 │ 4 │ 0.4 aa AD 4 │ 5 │ 0.5 bb AE 5 │ 6 │ 0.6 aa AF 1 │ 7 │ 0.7 bb AG 2 │ 8 │ 0.8 aa AH 3 │ 9 │ 0.9 bb AI 4 │ 10 │ 1.0 aa AJ 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @relocate([:percent, :groups], before = id) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ percent groups id value │ │ Float64 String String Int64 │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb AA 1 │ 2 │ 0.2 aa AB 2 │ 3 │ 0.3 bb AC 3 │ 4 │ 0.4 aa AD 4 │ 5 │ 0.5 bb AE 5 │ 6 │ 0.6 aa AF 1 │ 7 │ 0.7 bb AG 2 │ 8 │ 0.8 aa AH 3 │ 9 │ 0.9 bb AI 4 │ 10 │ 1.0 aa AJ 5 │ │ Expected output: │ │ 10×4 DataFrame │ Row │ percent groups id value │ │ Float64 String String Int64 │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb AA 1 │ 2 │ 0.2 aa AB 2 │ 3 │ 0.3 bb AC 3 │ 4 │ 0.4 aa AD 4 │ 5 │ 0.5 bb AE 5 │ 6 │ 0.6 aa AF 1 │ 7 │ 0.7 bb AG 2 │ 8 │ 0.8 aa AH 3 │ 9 │ 0.9 bb AI 4 │ 10 │ 1.0 aa AJ 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ percent groups id value │ value │ │ Float64 String String Int64 │ Int64 │ ─────┼──────────────────────────────── │ 1 │ 0.1 bb AA 1 │ 2 │ 0.2 aa AB 2 │ 3 │ 0.3 bb AC 3 │ 4 │ 0.4 aa AD 4 │ 5 │ 0.5 bb AE 5 │ 6 │ 0.6 aa AF 1 │ 7 │ 0.7 bb AG 2 │ 8 │ 0.8 aa AH 3 │ 9 │ 0.9 bb AI 4 │ 10 │ 1.0 aa AJ 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/relocate.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_view") begin │ @count(groups) │ @arrange(groups) │ @collect │ end │ 2×2 DataFrame │ Row │ groups count │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ bb 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @count(groups) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ groups count │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ bb 5 │ │ Expected output: │ │ 2×2 DataFrame │ Row │ groups count │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ bb 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ groups count │ count │ │ String Int64 │ Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ bb 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB.jl │ │ ```jldoctest │ │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> dt(db, df, "df_mem"); │ │ julia> db_table(db, "main.df_mem"); │ │ julia> dt(db, "df_mem" , alias = "my_table"); │ ``` │ │ Subexpression: │ │ dt(db, df, "df_mem"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB.jl ┌ Error: doctest failure in ../src/TidierDB.jl │ │ ```jldoctest │ │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> dt(db, df, "df_mem"); │ │ julia> db_table(db, "main.df_mem"); │ │ julia> dt(db, "df_mem" , alias = "my_table"); │ ``` │ │ Subexpression: │ │ db_table(db, "main.df_mem"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB.jl ┌ Error: doctest failure in ../src/TidierDB.jl │ │ ```jldoctest │ │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> dt(db, df, "df_mem"); │ │ julia> db_table(db, "main.df_mem"); │ │ julia> dt(db, "df_mem" , alias = "my_table"); │ ``` │ │ Subexpression: │ │ dt(db, "df_mem" , alias = "my_table"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> @chain df1_table @union_all(df1_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ ``` │ │ Subexpression: │ │ df1_table = dt(db, df1, "df1"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> @chain df1_table @union_all(df1_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ ``` │ │ Subexpression: │ │ @chain df1_table @union_all(df1_table) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ Expected output: │ │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ value │ │ Int64 Int64 │ Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @full_join((@chain dt(db, "df_join") @filter(score > 70)), id == id) │ @collect │ end │ 11×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String? Int64? │ ─────┼──────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ 11 │ AM missing missing missing X 74 │ ``` │ │ Subexpression: │ │ dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @full_join((@chain dt(db, "df_join") @filter(score > 70)), id == id) │ @collect │ end │ 11×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String? Int64? │ ─────┼──────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ 11 │ AM missing missing missing X 74 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @full_join((@chain dt(db, "df_join") @filter(score > 70)), id == id) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 11×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String? Int64? │ ─────┼──────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ 11 │ AM missing missing missing X 74 │ │ Expected output: │ │ 11×6 DataFrame │ Row │ id groups value percent category score │ │ String String? Int64? Float64? String? Int64? │ ─────┼──────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ 7 │ AD aa 4 0.4 missing missing │ 8 │ AF aa 1 0.6 missing missing │ 9 │ AH aa 3 0.8 missing missing │ 10 │ AJ aa 5 1.0 missing missing │ 11 │ AM missing missing missing X 74 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 11×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String? Int64? Float64? String? Int64? │ Int64? │ ─────┼──────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ 6 │ AB aa 2 0.2 missing missing │ missing │ 7 │ AD aa 4 0.4 missing missing │ missing │ 8 │ AF aa 1 0.6 missing missing │ missing │ 9 │ AH aa 3 0.8 missing missing │ missing │ 10 │ AJ aa 5 1.0 missing missing │ missing │ 11 │ AM missing missing missing X 74 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @arrange(groups) │ @collect │ end │ 2×1 DataFrame │ Row │ groups │ │ String │ ─────┼──────── │ 1 │ aa │ 2 │ bb │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×1 DataFrame │ Row │ groups │ │ String │ ─────┼──────── │ 1 │ aa │ 2 │ bb │ │ Expected output: │ │ 2×1 DataFrame │ Row │ groups │ │ String │ ─────┼──────── │ 1 │ aa │ 2 │ bb │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×1 DataFrame │ Row │ groups │ groups │ │ String │ String │ ─────┼──────── │ 1 │ aa │ 2 │ bb └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @inner_join(t(dfj), id == id2) │ @collect │ end │ 5×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String Int64 │ ─────┼───────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ ``` │ │ Subexpression: │ │ dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @inner_join(t(dfj), id == id2) │ @collect │ end │ 5×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String Int64 │ ─────┼───────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @inner_join(t(dfj), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String Int64 │ ─────┼───────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ │ Expected output: │ │ 5×6 DataFrame │ Row │ id groups value percent category score │ │ String String Int64 Float64 String Int64 │ ─────┼───────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×6 DataFrame │ Row │ id groups value percent category score │ score │ │ String String Int64 Float64 String Int64 │ Int64 │ ─────┼───────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 X 88 │ 2 │ AC bb 3 0.3 Y 92 │ 3 │ AE bb 5 0.5 X 77 │ 4 │ AG bb 2 0.7 Y 83 │ 5 │ AI bb 4 0.9 X 95 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 2, 3, 4], │ name = ["Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame( id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @intersect(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ julia> @chain df1_table @intersect(df2_table, all = true) @arrange(desc(id)) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ ``` │ │ Subexpression: │ │ df1_table = dt(db, df1, "df1"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 2, 3, 4], │ name = ["Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame( id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @intersect(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ julia> @chain df1_table @intersect(df2_table, all = true) @arrange(desc(id)) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ ``` │ │ Subexpression: │ │ df2_table = dt(db, df2, "df2"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 2, 3, 4], │ name = ["Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame( id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @intersect(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ julia> @chain df1_table @intersect(df2_table, all = true) @arrange(desc(id)) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ ``` │ │ Subexpression: │ │ @chain df1_table @intersect(df2_table) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ Expected output: │ │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×2 DataFrame │ Row │ id name │ name │ │ Int64 String │ String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 2, 3, 4], │ name = ["Alice", "Bob", "Bob", "Charlie", "David"]); │ │ julia> df2 = DataFrame( id = [2, 2, 3, 5], │ name = ["Bob", "Bob", "Charlie", "Eve"]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @intersect(df2_table) @collect │ 2×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 2 Bob │ 2 │ 3 Charlie │ │ julia> @chain df1_table @intersect(df2_table, all = true) @arrange(desc(id)) @collect │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ ``` │ │ Subexpression: │ │ @chain df1_table @intersect(df2_table, all = true) @arrange(desc(id)) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ │ Expected output: │ │ 3×2 DataFrame │ Row │ id name │ │ Int64 String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id name │ name │ │ Int64 String │ String │ ─────┼──────────────── │ 1 │ 3 Charlie │ 2 │ 2 Bob │ 3 │ 2 Bob └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/unnest.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> DuckDB.query(db, " │ CREATE TABLE nt ( │ id INTEGER, │ data ROW(a INTEGER[], b INTEGER[]) │ ); │ INSERT INTO nt VALUES │ (1, (ARRAY[1,2], ARRAY[3,4])), │ (2, (ARRAY[5,6], ARRAY[7,8,9])), │ (3, (ARRAY[10,11], ARRAY[12,13]));"); │ │ julia> @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a b │ @collect │ end │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ julia> @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a:b │ @collect │ end │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ ``` │ │ Subexpression: │ │ @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a b │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ Expected output: │ │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×3 DataFrame │ Row │ id a b │ b │ │ Int32 Int32? Int32 │ Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/unnest.jl ┌ Error: doctest failure in ../src/unnest.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> DuckDB.query(db, " │ CREATE TABLE nt ( │ id INTEGER, │ data ROW(a INTEGER[], b INTEGER[]) │ ); │ INSERT INTO nt VALUES │ (1, (ARRAY[1,2], ARRAY[3,4])), │ (2, (ARRAY[5,6], ARRAY[7,8,9])), │ (3, (ARRAY[10,11], ARRAY[12,13]));"); │ │ julia> @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a b │ @collect │ end │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ julia> @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a:b │ @collect │ end │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ ``` │ │ Subexpression: │ │ @chain dt(db, :nt) begin │ @unnest_wider data │ @unnest_longer a:b │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ Expected output: │ │ 7×3 DataFrame │ Row │ id a b │ │ Int32 Int32? Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 7×3 DataFrame │ Row │ id a b │ b │ │ Int32 Int32? Int32 │ Int32 │ ─────┼─────────────────────── │ 1 │ 1 1 3 │ 2 │ 1 2 4 │ 3 │ 2 5 7 │ 4 │ 2 6 8 │ 5 │ 2 missing 9 │ 6 │ 3 10 12 │ 7 │ 3 11 13 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/unnest.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ df1_table = dt(db, df1, "df1"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ df2_table = dt(db, df2, "df2"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ @chain df1_table @union(df2_table) @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ Expected output: │ │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ value │ │ Int64 Int64 │ Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ Expected output: │ │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id value │ value │ │ Int64 Int64 │ Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ Expected output: │ │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 6×2 DataFrame │ Row │ id value │ value │ │ Int64 Int64 │ Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/union_intersect_setdiff.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df1 = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> df2 = DataFrame(id = [4, 5, 6], value = [40, 50, 60]); │ │ julia> df1_table = dt(db, df1, "df1"); │ │ julia> df2_table = dt(db, df2, "df2"); │ │ julia> @chain df1_table @union(df2_table) @collect │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 4 40 │ 5 │ 5 50 │ 6 │ 6 60 │ │ julia> @chain df1_table begin │ @union("df1", all = false) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ │ julia> @chain df1_table begin │ @union("df1", all = true) │ @collect │ end │ 6×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 1 10 │ 2 │ 2 20 │ 3 │ 3 30 │ 4 │ 1 10 │ 5 │ 2 20 │ 6 │ 3 30 │ │ julia> query = @chain df2_table @filter(value == 50); │ │ julia> @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ ``` │ │ Subexpression: │ │ @chain df1_table begin │ @mutate(id = id + 5) │ @filter(id > 6) │ @union(t(query)) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ │ Expected output: │ │ 3×2 DataFrame │ Row │ id value │ │ Int64 Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ id value │ value │ │ Int64 Int64 │ Int64 │ ─────┼────────────── │ 1 │ 7 20 │ 2 │ 8 30 │ 3 │ 5 50 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/union_intersect_setdiff.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ Expected output: │ │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×5 DataFrame │ Row │ id groups value percent new_col │ new_col │ │ String String Int64 Float64 Float64 │ Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ Expected output: │ │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent max sum │ sum │ │ String String Int64 Float64 Float64 Float64 │ Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ Expected output: │ │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ value2 │ │ String String Int64 Float64 Int128 Int128? │ Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ Expected output: │ │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×5 DataFrame │ Row │ id groups value percent new_col │ │ String String Int64 Float64 Float64 │ ─────┼───────────────────────────────────────── │ 1 │ AA bb 4 0.1 0.01 │ 2 │ AB aa 8 0.2 0.04 │ 3 │ AC bb 12 0.3 0.09 │ 4 │ AD aa 16 0.4 0.16 │ 5 │ AE bb 20 0.5 0.25 │ 6 │ AF aa 4 0.6 0.36 │ 7 │ AG bb 8 0.7 0.49 │ 8 │ AH aa 12 0.8 0.64 │ 9 │ AI bb 16 0.9 0.81 │ 10 │ AJ aa 20 1.0 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(max = maximum(percent), sum = sum(percent), _by = groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent max sum │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1.0 3.0 │ 2 │ AD aa 4 0.4 1.0 3.0 │ 3 │ AF aa 1 0.6 1.0 3.0 │ 4 │ AH aa 3 0.8 1.0 3.0 │ 5 │ AJ aa 5 1.0 1.0 3.0 │ 6 │ AA bb 1 0.1 0.9 2.5 │ 7 │ AC bb 3 0.3 0.9 2.5 │ 8 │ AE bb 5 0.5 0.9 2.5 │ 9 │ AG bb 2 0.7 0.9 2.5 │ 10 │ AI bb 4 0.9 0.9 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value1 = sum(value), │ _order = percent, │ _frame = (-1, 1), │ _by = groups) │ @mutate(value2 = sum(value), │ _order = desc(percent), │ _frame = 2) │ @arrange(groups) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value1 value2 │ │ String String Int64 Float64 Int128 Int128? │ ─────┼───────────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 8 21 │ 2 │ AH aa 3 0.8 9 16 │ 3 │ AF aa 1 0.6 8 10 │ 4 │ AD aa 4 0.4 7 3 │ 5 │ AB aa 2 0.2 6 missing │ 6 │ AI bb 4 0.9 6 18 │ 7 │ AG bb 2 0.7 11 15 │ 8 │ AE bb 5 0.5 10 6 │ 9 │ AC bb 3 0.3 9 1 │ 10 │ AA bb 1 0.1 4 missing │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(across([:value, :percent], agg(kurtosis))) │ @collect │ end │ 10×6 DataFrame │ Row │ id groups value percent value_kurtosis percent_kurtosis │ │ String String Int64 Float64 Float64 Float64 │ ─────┼────────────────────────────────────────────────────────────────── │ 1 │ AA bb 1 0.1 -1.33393 -1.2 │ 2 │ AB aa 2 0.2 -1.33393 -1.2 │ 3 │ AC bb 3 0.3 -1.33393 -1.2 │ 4 │ AD aa 4 0.4 -1.33393 -1.2 │ 5 │ AE bb 5 0.5 -1.33393 -1.2 │ 6 │ AF aa 1 0.6 -1.33393 -1.2 │ 7 │ AG bb 2 0.7 -1.33393 -1.2 │ 8 │ AH aa 3 0.8 -1.33393 -1.2 │ 9 │ AI bb 4 0.9 -1.33393 -1.2 │ 10 │ AJ aa 5 1.0 -1.33393 -1.2 │ │ julia> @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @mutate(value2 = sum(value), │ _order = desc([:value, :percent]), │ _frame = 2); │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ Expected output: │ │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ Expected output: │ │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_max(value, n = 2) │ @arrange(groups) │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AD aa 4 0.4 2 │ 3 │ AE bb 5 0.5 1 │ 4 │ AI bb 4 0.9 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_max(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AE bb 5 0.5 1 │ 2 │ AJ aa 5 1.0 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent < .9) │ @slice_max(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AH aa 3 0.8 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_max(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AJ aa 5 1.0 1 │ 2 │ AI bb 4 0.9 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_max(percent_mean) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ │ Expected output: │ │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ rank_col │ │ String Float64 Int64 │ Int64 │ ─────┼──────────────────────────────── │ 1 │ aa 0.6 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/sep_unite.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(a = ["1-1", "2-2", "3-3-3"]); │ │ julia> @chain dt(db, df, "df") @separate(a, [b, c, d], "-") @collect │ 3×3 DataFrame │ Row │ b c d │ │ String String String? │ ─────┼───────────────────────── │ 1 │ 1 1 missing │ 2 │ 2 2 missing │ 3 │ 3 3 3 │ │ julia> @chain dt(db, df, "df") @separate( a, [c, d], "-") @collect │ 3×2 DataFrame │ Row │ c d │ │ String String │ ─────┼──────────────── │ 1 │ 1 1 │ 2 │ 2 2 │ 3 │ 3 3-3 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df") @separate(a, [b, c, d], "-") @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ b c d │ │ String String String? │ ─────┼───────────────────────── │ 1 │ 1 1 missing │ 2 │ 2 2 missing │ 3 │ 3 3 3 │ │ Expected output: │ │ 3×3 DataFrame │ Row │ b c d │ │ String String String? │ ─────┼───────────────────────── │ 1 │ 1 1 missing │ 2 │ 2 2 missing │ 3 │ 3 3 3 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×3 DataFrame │ Row │ b c d │ d │ │ String String String? │ String? │ ─────┼───────────────────────── │ 1 │ 1 1 missing │ missing │ 2 │ 2 2 missing │ missing │ 3 │ 3 3 3 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/sep_unite.jl ┌ Error: doctest failure in ../src/sep_unite.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(a = ["1-1", "2-2", "3-3-3"]); │ │ julia> @chain dt(db, df, "df") @separate(a, [b, c, d], "-") @collect │ 3×3 DataFrame │ Row │ b c d │ │ String String String? │ ─────┼───────────────────────── │ 1 │ 1 1 missing │ 2 │ 2 2 missing │ 3 │ 3 3 3 │ │ julia> @chain dt(db, df, "df") @separate( a, [c, d], "-") @collect │ 3×2 DataFrame │ Row │ c d │ │ String String │ ─────┼──────────────── │ 1 │ 1 1 │ 2 │ 2 2 │ 3 │ 3 3-3 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df") @separate( a, [c, d], "-") @collect │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ c d │ │ String String │ ─────┼──────────────── │ 1 │ 1 1 │ 2 │ 2 2 │ 3 │ 3 3-3 │ │ Expected output: │ │ 3×2 DataFrame │ Row │ c d │ │ String String │ ─────┼──────────────── │ 1 │ 1 1 │ 2 │ 2 2 │ 3 │ 3 3-3 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 3×2 DataFrame │ Row │ c d │ d │ │ String String │ String │ ─────┼──────────────── │ 1 │ 1 1 │ 2 │ 2 2 │ 3 │ 3 3-3 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/sep_unite.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_view") begin │ @transmute(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×2 DataFrame │ Row │ value new_col │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 4 0.01 │ 2 │ 8 0.04 │ 3 │ 12 0.09 │ 4 │ 16 0.16 │ 5 │ 20 0.25 │ 6 │ 4 0.36 │ 7 │ 8 0.49 │ 8 │ 12 0.64 │ 9 │ 16 0.81 │ 10 │ 20 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @transmute(max = maximum(value), _by = groups) │ @collect │ end │ 10×2 DataFrame │ Row │ groups max │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ aa 5 │ 3 │ aa 5 │ 4 │ aa 5 │ 5 │ aa 5 │ 6 │ bb 5 │ 7 │ bb 5 │ 8 │ bb 5 │ 9 │ bb 5 │ 10 │ bb 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @transmute(value = value * 4, new_col = percent^2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ value new_col │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 4 0.01 │ 2 │ 8 0.04 │ 3 │ 12 0.09 │ 4 │ 16 0.16 │ 5 │ 20 0.25 │ 6 │ 4 0.36 │ 7 │ 8 0.49 │ 8 │ 12 0.64 │ 9 │ 16 0.81 │ 10 │ 20 1.0 │ │ Expected output: │ │ 10×2 DataFrame │ Row │ value new_col │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 4 0.01 │ 2 │ 8 0.04 │ 3 │ 12 0.09 │ 4 │ 16 0.16 │ 5 │ 20 0.25 │ 6 │ 4 0.36 │ 7 │ 8 0.49 │ 8 │ 12 0.64 │ 9 │ 16 0.81 │ 10 │ 20 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ value new_col │ new_col │ │ Int64 Float64 │ Float64 │ ─────┼──────────────── │ 1 │ 4 0.01 │ 2 │ 8 0.04 │ 3 │ 12 0.09 │ 4 │ 16 0.16 │ 5 │ 20 0.25 │ 6 │ 4 0.36 │ 7 │ 8 0.49 │ 8 │ 12 0.64 │ 9 │ 16 0.81 │ 10 │ 20 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_view") begin │ @transmute(value = value * 4, new_col = percent^2) │ @collect │ end │ 10×2 DataFrame │ Row │ value new_col │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 4 0.01 │ 2 │ 8 0.04 │ 3 │ 12 0.09 │ 4 │ 16 0.16 │ 5 │ 20 0.25 │ 6 │ 4 0.36 │ 7 │ 8 0.49 │ 8 │ 12 0.64 │ 9 │ 16 0.81 │ 10 │ 20 1.0 │ │ julia> @chain dt(db, df, "df_view") begin │ @transmute(max = maximum(value), _by = groups) │ @collect │ end │ 10×2 DataFrame │ Row │ groups max │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ aa 5 │ 3 │ aa 5 │ 4 │ aa 5 │ 5 │ aa 5 │ 6 │ bb 5 │ 7 │ bb 5 │ 8 │ bb 5 │ 9 │ bb 5 │ 10 │ bb 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @transmute(max = maximum(value), _by = groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ groups max │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ aa 5 │ 3 │ aa 5 │ 4 │ aa 5 │ 5 │ aa 5 │ 6 │ bb 5 │ 7 │ bb 5 │ 8 │ bb 5 │ 9 │ bb 5 │ 10 │ bb 5 │ │ Expected output: │ │ 10×2 DataFrame │ Row │ groups max │ │ String Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ aa 5 │ 3 │ aa 5 │ 4 │ aa 5 │ 5 │ aa 5 │ 6 │ bb 5 │ 7 │ bb 5 │ 8 │ bb 5 │ 9 │ bb 5 │ 10 │ bb 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ groups max │ max │ │ String Int64 │ Int64 │ ─────┼─────────────── │ 1 │ aa 5 │ 2 │ aa 5 │ 3 │ aa 5 │ 4 │ aa 5 │ 5 │ aa 5 │ 6 │ bb 5 │ 7 │ bb 5 │ 8 │ bb 5 │ 9 │ bb 5 │ 10 │ bb 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ Expected output: │ │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ Expected output: │ │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ rank_col │ │ String String Int64 Float64 Int64 │ Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/slices_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @slice_min(value, n = 2) │ @arrange(groups, percent) # arranged due to duckdb multi threading │ @collect │ end │ 4×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 2 │ 2 │ AF aa 1 0.6 1 │ 3 │ AA bb 1 0.1 1 │ 4 │ AG bb 2 0.7 2 │ │ julia> @chain dt(db, df, "df_view") begin │ @slice_min(value) │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AA bb 1 0.1 1 │ 2 │ AF aa 1 0.6 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @filter(percent > .1) │ @slice_min(percent) │ @collect │ end │ 1×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by groups │ @slice_min(percent) │ @arrange groups │ @collect │ end │ 2×5 DataFrame │ Row │ id groups value percent rank_col │ │ String String Int64 Float64 Int64 │ ─────┼────────────────────────────────────────── │ 1 │ AB aa 2 0.2 1 │ 2 │ AA bb 1 0.1 1 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @summarize(percent_mean = mean(percent), _by = groups) │ @slice_min(percent_mean) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ │ Expected output: │ │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ │ String Float64 Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×3 DataFrame │ Row │ groups percent_mean rank_col │ rank_col │ │ String Float64 Int64 │ Int64 │ ─────┼──────────────────────────────── │ 1 │ bb 0.5 1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/slices_sq.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @select(groups:percent) │ @collect │ end │ 10×3 DataFrame │ Row │ groups value percent │ │ String Int64 Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 │ │ julia> @chain df_mem begin │ @select(contains("e")) │ @collect │ end │ 10×2 DataFrame │ Row │ value percent │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 │ ``` │ │ Subexpression: │ │ df_mem = dt(db, df, "df_view"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @select(groups:percent) │ @collect │ end │ 10×3 DataFrame │ Row │ groups value percent │ │ String Int64 Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 │ │ julia> @chain df_mem begin │ @select(contains("e")) │ @collect │ end │ 10×2 DataFrame │ Row │ value percent │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 │ ``` │ │ Subexpression: │ │ @chain df_mem begin │ @select(groups:percent) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×3 DataFrame │ Row │ groups value percent │ │ String Int64 Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 │ │ Expected output: │ │ 10×3 DataFrame │ Row │ groups value percent │ │ String Int64 Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×3 DataFrame │ Row │ groups value percent │ percent │ │ String Int64 Float64 │ Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @select(groups:percent) │ @collect │ end │ 10×3 DataFrame │ Row │ groups value percent │ │ String Int64 Float64 │ ─────┼──────────────────────── │ 1 │ bb 1 0.1 │ 2 │ aa 2 0.2 │ 3 │ bb 3 0.3 │ 4 │ aa 4 0.4 │ 5 │ bb 5 0.5 │ 6 │ aa 1 0.6 │ 7 │ bb 2 0.7 │ 8 │ aa 3 0.8 │ 9 │ bb 4 0.9 │ 10 │ aa 5 1.0 │ │ julia> @chain df_mem begin │ @select(contains("e")) │ @collect │ end │ 10×2 DataFrame │ Row │ value percent │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 │ ``` │ │ Subexpression: │ │ @chain df_mem begin │ @select(contains("e")) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ value percent │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 │ │ Expected output: │ │ 10×2 DataFrame │ Row │ value percent │ │ Int64 Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×2 DataFrame │ Row │ value percent │ percent │ │ Int64 Float64 │ Float64 │ ─────┼──────────────── │ 1 │ 1 0.1 │ 2 │ 2 0.2 │ 3 │ 3 0.3 │ 4 │ 4 0.4 │ 5 │ 5 0.5 │ 6 │ 1 0.6 │ 7 │ 2 0.7 │ 8 │ 3 0.8 │ 9 │ 4 0.9 │ 10 │ 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @rename(new_name = percent) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value new_name │ │ String String Int64 Float64 │ ─────┼───────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @rename(new_name = percent) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value new_name │ │ String String Int64 Float64 │ ─────┼───────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ │ Expected output: │ │ 10×4 DataFrame │ Row │ id groups value new_name │ │ String String Int64 Float64 │ ─────┼───────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value new_name │ new_name │ │ String String Int64 Float64 │ Float64 │ ─────┼───────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/view_compute.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer); # will not overwrite existing view │ │ julia> dt(db, "viewer"); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer, true); # will overwrite exisiting view │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df1") @create_view(viewer); # will not overwrite existing view │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/view_compute.jl ┌ Error: doctest failure in ../src/view_compute.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer); # will not overwrite existing view │ │ julia> dt(db, "viewer"); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer, true); # will overwrite exisiting view │ ``` │ │ Subexpression: │ │ dt(db, "viewer"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/view_compute.jl ┌ Error: doctest failure in ../src/view_compute.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer); # will not overwrite existing view │ │ julia> dt(db, "viewer"); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer, true); # will overwrite exisiting view │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df1") @create_view(viewer, true); # will overwrite exisiting view │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/view_compute.jl ┌ Error: doctest failure in ../src/windows.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(-3, 3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(to = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(from = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ ``` │ │ Subexpression: │ │ df_mem = dt(db, df, "df_view"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/windows.jl ┌ Error: doctest failure in ../src/windows.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(-3, 3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(to = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(from = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain df_mem begin │ @group_by groups │ @window_frame(to = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/windows.jl ┌ Error: doctest failure in ../src/windows.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> df_mem = dt(db, df, "df_view"); │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(-3, 3) │ @mutate(avg = mean(percent)) │ #@show_query │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(to = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ │ julia> @chain df_mem begin │ @group_by groups │ @window_frame(from = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ ``` │ │ Subexpression: │ │ @chain df_mem begin │ @group_by groups │ @window_frame(from = -3) │ @mutate(avg = mean(percent)) │ #@show_query │ @collect │ end; │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/windows.jl ┌ Error: doctest failure in ../src/view_compute.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(id = [1, 2, 3], value = [10, 20, 30]); │ │ julia> @chain dt(db, df, "df1") @create_view(viewer); │ │ julia> drop_view(db, "viewer"); │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df1") @create_view(viewer); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/view_compute.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @distinct(value) │ @arrange(value) │ @collect │ end │ 5×1 DataFrame │ Row │ value │ │ Int64 │ ─────┼─────── │ 1 │ 1 │ 2 │ 2 │ 3 │ 3 │ 4 │ 4 │ 5 │ 5 │ │ julia> @chain dt(db, df, "df_view") begin │ @distinct │ @arrange(id) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @distinct(value) │ @arrange(value) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×1 DataFrame │ Row │ value │ │ Int64 │ ─────┼─────── │ 1 │ 1 │ 2 │ 2 │ 3 │ 3 │ 4 │ 4 │ 5 │ 5 │ │ Expected output: │ │ 5×1 DataFrame │ Row │ value │ │ Int64 │ ─────┼─────── │ 1 │ 1 │ 2 │ 2 │ 3 │ 3 │ 4 │ 4 │ 5 │ 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×1 DataFrame │ Row │ value │ value │ │ Int64 │ Int64 │ ─────┼─────── │ 1 │ 1 │ 2 │ 2 │ 3 │ 3 │ 4 │ 4 │ 5 │ 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @distinct(value) │ @arrange(value) │ @collect │ end │ 5×1 DataFrame │ Row │ value │ │ Int64 │ ─────┼─────── │ 1 │ 1 │ 2 │ 2 │ 3 │ 3 │ 4 │ 4 │ 5 │ 5 │ │ julia> @chain dt(db, df, "df_view") begin │ @distinct │ @arrange(id) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @distinct │ @arrange(id) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ │ Expected output: │ │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AB aa 2 0.2 │ 3 │ AC bb 3 0.3 │ 4 │ AD aa 4 0.4 │ 5 │ AE bb 5 0.5 │ 6 │ AF aa 1 0.6 │ 7 │ AG bb 2 0.7 │ 8 │ AH aa 3 0.8 │ 9 │ AI bb 4 0.9 │ 10 │ AJ aa 5 1.0 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_view") begin │ @arrange(value, desc(percent)) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AA bb 1 0.1 │ 3 │ AG bb 2 0.7 │ 4 │ AB aa 2 0.2 │ 5 │ AH aa 3 0.8 │ 6 │ AC bb 3 0.3 │ 7 │ AI bb 4 0.9 │ 8 │ AD aa 4 0.4 │ 9 │ AJ aa 5 1.0 │ 10 │ AE bb 5 0.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @arrange(desc(df_view.value)) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AE bb 5 0.5 │ 2 │ AJ aa 5 1.0 │ 3 │ AD aa 4 0.4 │ 4 │ AI bb 4 0.9 │ 5 │ AC bb 3 0.3 │ 6 │ AH aa 3 0.8 │ 7 │ AB aa 2 0.2 │ 8 │ AG bb 2 0.7 │ 9 │ AA bb 1 0.1 │ 10 │ AF aa 1 0.6 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @arrange(value, desc(percent)) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AA bb 1 0.1 │ 3 │ AG bb 2 0.7 │ 4 │ AB aa 2 0.2 │ 5 │ AH aa 3 0.8 │ 6 │ AC bb 3 0.3 │ 7 │ AI bb 4 0.9 │ 8 │ AD aa 4 0.4 │ 9 │ AJ aa 5 1.0 │ 10 │ AE bb 5 0.5 │ │ Expected output: │ │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AA bb 1 0.1 │ 3 │ AG bb 2 0.7 │ 4 │ AB aa 2 0.2 │ 5 │ AH aa 3 0.8 │ 6 │ AC bb 3 0.3 │ 7 │ AI bb 4 0.9 │ 8 │ AD aa 4 0.4 │ 9 │ AJ aa 5 1.0 │ 10 │ AE bb 5 0.5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AA bb 1 0.1 │ 3 │ AG bb 2 0.7 │ 4 │ AB aa 2 0.2 │ 5 │ AH aa 3 0.8 │ 6 │ AC bb 3 0.3 │ 7 │ AI bb 4 0.9 │ 8 │ AD aa 4 0.4 │ 9 │ AJ aa 5 1.0 │ 10 │ AE bb 5 0.5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ julia> @chain dt(db, df, "df_view") begin │ @arrange(value, desc(percent)) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AF aa 1 0.6 │ 2 │ AA bb 1 0.1 │ 3 │ AG bb 2 0.7 │ 4 │ AB aa 2 0.2 │ 5 │ AH aa 3 0.8 │ 6 │ AC bb 3 0.3 │ 7 │ AI bb 4 0.9 │ 8 │ AD aa 4 0.4 │ 9 │ AJ aa 5 1.0 │ 10 │ AE bb 5 0.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @arrange(desc(df_view.value)) │ @collect │ end │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AE bb 5 0.5 │ 2 │ AJ aa 5 1.0 │ 3 │ AD aa 4 0.4 │ 4 │ AI bb 4 0.9 │ 5 │ AC bb 3 0.3 │ 6 │ AH aa 3 0.8 │ 7 │ AB aa 2 0.2 │ 8 │ AG bb 2 0.7 │ 9 │ AA bb 1 0.1 │ 10 │ AF aa 1 0.6 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @arrange(desc(df_view.value)) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AE bb 5 0.5 │ 2 │ AJ aa 5 1.0 │ 3 │ AD aa 4 0.4 │ 4 │ AI bb 4 0.9 │ 5 │ AC bb 3 0.3 │ 6 │ AH aa 3 0.8 │ 7 │ AB aa 2 0.2 │ 8 │ AG bb 2 0.7 │ 9 │ AA bb 1 0.1 │ 10 │ AF aa 1 0.6 │ │ Expected output: │ │ 10×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AE bb 5 0.5 │ 2 │ AJ aa 5 1.0 │ 3 │ AD aa 4 0.4 │ 4 │ AI bb 4 0.9 │ 5 │ AC bb 3 0.3 │ 6 │ AH aa 3 0.8 │ 7 │ AB aa 2 0.2 │ 8 │ AG bb 2 0.7 │ 9 │ AA bb 1 0.1 │ 10 │ AF aa 1 0.6 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 10×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AE bb 5 0.5 │ 2 │ AJ aa 5 1.0 │ 3 │ AD aa 4 0.4 │ 4 │ AI bb 4 0.9 │ 5 │ AC bb 3 0.3 │ 6 │ AH aa 3 0.8 │ 7 │ AB aa 2 0.2 │ 8 │ AG bb 2 0.7 │ 9 │ AA bb 1 0.1 │ 10 │ AF aa 1 0.6 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/TidierDB_macros.jl │ │ ```jldoctest │ julia> db = connect(duckdb()); │ │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @head(1) ## supports expressions ie `3-2` would return the same df below │ @collect │ end │ 1×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @head(1) ## supports expressions ie `3-2` would return the same df below │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ │ Expected output: │ │ 1×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 1×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/TidierDB_macros.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((ends_with("e"), starts_with("p")), (mean, sum))) │ @arrange(groups) │ @collect │ end │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarise(test = sum(percent), n = n(), _by = groups) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((ends_with("e"), starts_with("p")), (mean, sum))) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ Expected output: │ │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ percent_sum │ │ String Float64 Float64 Int128 Float64 │ Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((ends_with("e"), starts_with("p")), (mean, sum))) │ @arrange(groups) │ @collect │ end │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarise(test = sum(percent), n = n(), _by = groups) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ Expected output: │ │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ n │ │ String Float64 Int64 │ Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/mutate_and_summ.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> db = connect(duckdb()); │ │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(across((ends_with("e"), starts_with("p")), (mean, sum))) │ @arrange(groups) │ @collect │ end │ 2×5 DataFrame │ Row │ groups value_mean percent_mean value_sum percent_sum │ │ String Float64 Float64 Int128 Float64 │ ─────┼────────────────────────────────────────────────────────── │ 1 │ aa 3.0 0.6 15 3.0 │ 2 │ bb 3.0 0.5 15 2.5 │ │ julia> @chain dt(db, df, "df_view") begin │ @group_by(groups) │ @summarise(test = sum(percent), n = n()) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ julia> @chain dt(db, df, "df_view") begin │ @summarise(test = sum(percent), n = n(), _by = groups) │ @arrange(groups) │ @collect │ end │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @summarise(test = sum(percent), n = n(), _by = groups) │ @arrange(groups) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ Expected output: │ │ 2×3 DataFrame │ Row │ groups test n │ │ String Float64 Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 2×3 DataFrame │ Row │ groups test n │ n │ │ String Float64 Int64 │ Int64 │ ─────┼──────────────────────── │ 1 │ aa 3.0 5 │ 2 │ bb 2.5 5 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/mutate_and_summ.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @semi_join(t(dfj), id == id2) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AC bb 3 0.3 │ 3 │ AE bb 5 0.5 │ 4 │ AG bb 2 0.7 │ 5 │ AI bb 4 0.9 │ ``` │ │ Subexpression: │ │ dfj = dt(db, df2, "df_join"); │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ │ Expected output: │ │ │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: doctest failure in ../src/joins_sq.jl │ │ ```jldoctest │ julia> df = DataFrame(id = [string('A' + i ÷ 26, 'A' + i % 26) for i in 0:9], │ groups = [i % 2 == 0 ? "aa" : "bb" for i in 1:10], │ value = repeat(1:5, 2), │ percent = 0.1:0.1:1.0); │ │ julia> df2 = DataFrame(id2 = ["AA", "AC", "AE", "AG", "AI", "AK", "AM"], │ category = ["X", "Y", "X", "Y", "X", "Y", "X"], │ score = [88, 92, 77, 83, 95, 68, 74]); │ │ julia> db = connect(duckdb()); │ │ │ julia> dfj = dt(db, df2, "df_join"); │ │ julia> @chain dt(db, df, "df_view") begin │ @semi_join(t(dfj), id == id2) │ @collect │ end │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AC bb 3 0.3 │ 3 │ AE bb 5 0.5 │ 4 │ AG bb 2 0.7 │ 5 │ AI bb 4 0.9 │ ``` │ │ Subexpression: │ │ @chain dt(db, df, "df_view") begin │ @semi_join(t(dfj), id == id2) │ @collect │ end │ │ Evaluated output: │ │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AC bb 3 0.3 │ 3 │ AE bb 5 0.5 │ 4 │ AG bb 2 0.7 │ 5 │ AI bb 4 0.9 │ │ Expected output: │ │ 5×4 DataFrame │ Row │ id groups value percent │ │ String String Int64 Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AC bb 3 0.3 │ 3 │ AE bb 5 0.5 │ 4 │ AG bb 2 0.7 │ 5 │ AI bb 4 0.9 │ │ diff = │ Warning: Diff output requires color. │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:822 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:822 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:832 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:832 │ ┌ Warning: **DEPRECATION NOTICE**: This method is scheduled for removal in a future release. │ │ caller = nextDataChunk(q::DuckDB.QueryResult) at result.jl:836 │ └ @ DuckDB ~/.julia/packages/DuckDB/vI6tj/src/result.jl:836 │ 5×4 DataFrame │ Row │ id groups value percent │ percent │ │ String String Int64 Float64 │ Float64 │ ─────┼──────────────────────────────── │ 1 │ AA bb 1 0.1 │ 2 │ AC bb 3 0.3 │ 3 │ AE bb 5 0.5 │ 4 │ AG bb 2 0.7 │ 5 │ AI bb 4 0.9 └ @ Documenter ~/.julia/packages/TidierDB/ieJnx/src/joins_sq.jl ┌ Error: Doctesting failed │ exception = │ `makedocs` encountered a doctest error. Terminating build │ Stacktrace: │ [1] error(s::String) │ @ Base ./error.jl:35 │ [2] runner(::Type{Documenter.Builder.Doctest}, doc::Documenter.Document) │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/builder_pipeline.jl:213 │ [3] dispatch(::Type{Documenter.Builder.DocumentPipeline}, x::Documenter.Document) │ @ Documenter.Selectors ~/.julia/packages/Documenter/tbj1p/src/utilities/Selectors.jl:170 │ [4] #90 │ @ ~/.julia/packages/Documenter/tbj1p/src/makedocs.jl:275 [inlined] │ [5] withenv(::Documenter.var"#90#92"{Documenter.Document}, ::Pair{String, Nothing}, ::Vararg{Pair{String, Nothing}}) │ @ Base ./env.jl:265 │ [6] #89 │ @ ~/.julia/packages/Documenter/tbj1p/src/makedocs.jl:274 [inlined] │ [7] cd(f::Documenter.var"#89#91"{Documenter.Document}, dir::String) │ @ Base.Filesystem ./file.jl:112 │ [8] makedocs(; debug::Bool, format::Documenter.HTMLWriter.HTML, kwargs::@Kwargs{root::String, source::String, sitename::String, doctest::Symbol, modules::Vector{Module}, doctestfilters::Vector{Regex}, remotes::Nothing, plugins::Vector{Documenter.Plugin}}) │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/makedocs.jl:273 │ [9] (::Documenter.var"#all_doctests#135"{Bool, Vector{Regex}, Vector{Documenter.Plugin}, Vector{Module}})() │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:85 │ [10] macro expansion │ @ ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 [inlined] │ [11] macro expansion │ @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] │ [12] macro expansion │ @ ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 [inlined] │ [13] macro expansion │ @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] │ [14] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin}) │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 │ [15] doctest │ @ ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:69 [inlined] │ [16] doctest(package::Module; manual::Bool, testset::Nothing, kwargs::@Kwargs{}) │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:37 │ [17] doctest(package::Module) │ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:20 │ [18] top-level scope │ @ ~/.julia/packages/TidierDB/ieJnx/test/runtests.jl:9 │ [19] include(fname::String) │ @ Main ./sysimg.jl:38 │ [20] top-level scope │ @ none:6 │ [21] eval │ @ ./boot.jl:430 [inlined] │ [22] exec_options(opts::Base.JLOptions) │ @ Base ./client.jl:296 │ [23] _start() │ @ Base ./client.jl:531 └ @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:99 Doctests: TidierDB: Test Failed at /home/pkgeval/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 Expression: all_doctests() Stacktrace: [1] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:679 [inlined] [2] macro expansion @ ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 [inlined] [3] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [4] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin}) @ Documenter ~/.julia/packages/Documenter/tbj1p/src/doctest.jl:110 Test Summary: | Fail Total Time Doctests: TidierDB | 1 1 2m55.2s ERROR: LoadError: Some tests did not pass: 0 passed, 1 failed, 0 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/TidierDB/ieJnx/test/runtests.jl:1 Testing failed after 203.05s ERROR: LoadError: Package TidierDB errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.11/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.11/Pkg/src/Operations.jl:2124 [3] test @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/Operations.jl:2007 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:481 [5] test(pkgs::Vector{Pkg.Types.PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:159 [6] test @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:147 [inlined] [7] #test#74 @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:146 [inlined] [8] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:219 in expression starting at /PkgEval.jl/scripts/evaluate.jl:210 PkgEval failed after 284.99s: package has test failures