Use @alias for explicit aliasing

Author: gustafsson

src/DataFrames.jl

@@ -52,6 +52,7 @@ export AbstractDataFrame,
        GroupedDataFrame,
        SubDataFrame,
        Tables,
+       @alias,
        allcombinations,
        allowmissing!,
        antijoin,
@@ -132,6 +133,7 @@ const METADATA_FIXED =
 
 include("other/utils.jl")
 include("other/index.jl")
+include("other/alias.jl")
 
 include("abstractdataframe/abstractdataframe.jl")
 include("dataframe/dataframe.jl")

src/abstractdataframe/abstractdataframe.jl

@@ -3223,7 +3223,7 @@ function insertcols!(df::AbstractDataFrame, col::ColumnIndex, name_cols::Pair{Sy
         firstindex(item_new) != 1 && _onebased_check_error()
 
         if ncol(dfp) == 0
-            dfp[!, name] = item_new
+            @alias dfp[!, name] = item_new
         else
             if hasproperty(dfp, name)
                 @assert makeunique

src/abstractdataframe/selection.jl

@@ -682,13 +682,13 @@ function _add_col_check_copy(newdf::DataFrame, df::AbstractDataFrame,
     @assert parent_cols isa Union{Int, AbstractVector{Int}}
     if copycols
         if !(fun isa ByRow) && (v isa SubArray || any(i -> vpar === parent(cdf[i]), parent_cols))
-            newdf[!, newname] = copy(v)
-        else
             newdf[!, newname] = v
+        else
+            @alias newdf[!, newname] = v
         end
     else
         if fun isa ByRow
-            newdf[!, newname] = v
+            @alias newdf[!, newname] = v
         else
             must_copy = false
             for i in parent_cols
@@ -702,7 +702,11 @@ function _add_col_check_copy(newdf::DataFrame, df::AbstractDataFrame,
                     end
                 end
             end
-            newdf[!, newname] = must_copy ? copy(v) : v
+            if must_copy
+                newdf[!, newname] = v
+            else
+                @alias newdf[!, newname] = v
+            end
         end
     end
 end
@@ -807,7 +811,7 @@ function select_transform!((nc,)::Ref{Any}, df::AbstractDataFrame, newdf::DataFr
             end
             newres = DataFrame()
             for n in kp1
-                newres[!, prepend ? Symbol("x", n) : Symbol(n)] = [x[n] for x in res]
+                @alias newres[!, prepend ? Symbol("x", n) : Symbol(n)] = [x[n] for x in res]
             end
             res = newres
         elseif !(res isa Union{AbstractDataFrame, NamedTuple, DataFrameRow, AbstractMatrix})
@@ -872,7 +876,7 @@ function select_transform!((nc,)::Ref{Any}, df::AbstractDataFrame, newdf::DataFr
             # allow squashing a scalar to 0 rows
             rows = nrow(newdf)
         end
-        newdf[!, newname] = fill!(Tables.allocatecolumn(typeof(res_unwrap), rows),
+        @alias newdf[!, newname] = fill!(Tables.allocatecolumn(typeof(res_unwrap), rows),
                                   res_unwrap)
         if (col_idx isa Int || (col_idx isa AbstractVector{Int} && length(col_idx) == 1)) &&
            (fun === identity || fun === copy || _names(df)[only(col_idx)] == newname)
@@ -1756,7 +1760,7 @@ function _manipulate(df::AbstractDataFrame, normalized_cs::Vector{Any}, copycols
                         end
                     end
                     # here even if keeprows is true all is OK
-                    newdf[!, newname] = column_to_copy[i] ? df[:, i] : df[!, i]
+                    @alias newdf[!, newname] = column_to_copy[i] ? df[:, i] : df[!, i]
                     column_to_copy[i] = true
                     allow_resizing_newdf[] = false
                     _copy_col_note_metadata!(newdf, newname, df, i)

src/dataframe/dataframe.jl

@@ -632,7 +632,7 @@ Base.getindex(df::DataFrame, row_ind::typeof(!), col_inds::MultiColumnIndex) =
 ##############################################################################
 
 # Will automatically add a new column if needed
-function insert_single_column!(df::DataFrame, v::Any, col_ind::ColumnIndex; copycols = false)
+function insert_single_column!(df::DataFrame, v::Any, col_ind::ColumnIndex; copycols = true)
     dv = _preprocess_column(v, nrow(df), copycols)
     if ncol(df) != 0 && nrow(df) != length(dv)
         throw(ArgumentError("New columns must have the same length as old columns"))
@@ -664,6 +664,12 @@ function insert_single_entry!(df::DataFrame, v::Any, row_ind::Integer, col_ind::
     end
 end
 
+# df[!, SingleColumnIndex] = AbstractVector
+function Base.setindex!(df::DataFrame, v::AbstractVector, ::typeof(!), col_ind::ColumnIndex; copycols = true)
+    insert_single_column!(df, v, col_ind; copycols)
+    return df
+end
+
 # df[!, SingleColumnIndex] = value
 function Base.setindex!(df::DataFrame, v::Any, ::typeof(!), col_ind::ColumnIndex)
     insert_single_column!(df, v, col_ind)
@@ -672,10 +678,10 @@ end
 
 # df.col = value
 # separate methods are needed due to dispatch ambiguity
-Base.setproperty!(df::DataFrame, col_ind::Symbol, v::AbstractVector) =
-    (df[!, col_ind] = v)
-Base.setproperty!(df::DataFrame, col_ind::AbstractString, v::AbstractVector) =
-    (df[!, col_ind] = v)
+Base.setproperty!(df::DataFrame, col_ind::Symbol, v::AbstractVector; copycols = true) =
+    setindex!(df, v, !, col_ind; copycols)
+Base.setproperty!(df::DataFrame, col_ind::AbstractString, v::AbstractVector; copycols = true) =
+    setindex!(df, v, !, col_ind; copycols)
 Base.setproperty!(df::DataFrame, col_ind::Symbol, v::Any) =
     (df[!, col_ind] = v)
 Base.setproperty!(df::DataFrame, col_ind::AbstractString, v::Any) =
@@ -716,7 +722,7 @@ for T in (:AbstractVector, :Not, :Colon)
                                   row_inds::$T,
                                   col_ind::ColumnIndex)
         if row_inds isa Colon && !haskey(index(df), col_ind)
-            df[!, col_ind] = copy(v)
+            df[!, col_ind] = v
             return df
         end
         x = df[!, col_ind]
@@ -1211,7 +1217,11 @@ function hcat!(df1::DataFrame, df2::AbstractDataFrame;
     _drop_all_nonnote_metadata!(df1)
     _keep_matching_table_note_metadata!(df1, df2)
     for i in 1:length(u)
-        df1[!, u[i]] = copycols ? df2[:, i] : df2[!, i]
+        if copycols
+            df1[!, u[i]] = df2[!, i]
+        else
+            @alias df1[!, u[i]] = df2[!, i]
+        end
         _copy_col_note_metadata!(df1, u[i], df2, i)
     end
 

src/other/alias.jl

@@ -0,0 +1,31 @@
+"""
+@alias df.col = v
+@alias df[!, :col] = v
+
+df::DataFrame
+v::AbstractVector
+
+Assigns v to the column `col` without copying. Such that `df.col === v === df]!, :col]```.
+Any AbstractVector is permissable, this may limit what operations are possible to do on `df` afterwards.
+For instance after `@alias df.col = 1:3` it won't be possible to change the number of rows because UnitRange does not support resizing.
+"""
+macro alias(ex)
+    if !Meta.isexpr(ex, :(=))
+        throw(ArgumentError("Invalid use of @alias macro: argument must be a column assignment `df.col = v` or `df[!, col] = v`"))
+    end
+
+    lhs, rhs = ex.args
+
+    if Meta.isexpr(lhs, :ref)
+        ex = :(setindex!($(lhs.args[1]), $rhs, $(lhs.args[2:end]...); copycols = false); $rhs)
+
+    elseif Meta.isexpr(lhs, :.)
+        ex = :(setproperty!($(lhs.args...), $rhs; copycols = false); $rhs)
+
+    else
+        throw(ArgumentError("Invalid use of @alias macro: argument must be a column assignment `df.col = v` or `df[!, col] = v`"))
+
+    end
+
+    esc(ex)
+end

test/alias.jl

@@ -0,0 +1,67 @@
+module TestAliasAssignment
+
+using Test, DataFrames
+const ≅ = isequal
+
+@testset "Aliasing asignment" begin
+    @testset "$init" for init in [[], Matrix([4 5 6]'), [4 5;6 7;8 9]]
+        dfr = DataFrame(init, :auto)
+        @testset "$v" for v in [
+                [1,2,3],
+                ]
+            @testset "df.x2 = v" begin
+                df = copy(dfr)
+                a = @alias df.x2 = v
+                @test a === v
+                @test df.x2 === df[!, :x2] === v
+                df.x2 = v
+                @test df.x2 !== v
+                @test df.x2 ≅ v
+                a = @alias df.x2 = v
+                @test a === v
+                @test df.x2 === df[!, :x2] === v
+            end
+
+            @testset "df[!, :x2] = v" begin
+                df = copy(dfr)
+                a = @alias df[!, :x2] = v
+                @test a === v
+                @test df.x2 === df[!, :x2] === v
+                df[!, :x2] = v
+                @test df[!, :x2] !== v
+                @test df[!, :x2] ≅ v
+                a = @alias df[!, :x2] = v
+                @test a === v
+                @test df.x2 === df[!, :x2] === v
+            end
+        end
+
+        @testset "Invalid use of alias macro" begin
+            ex = try
+                eval(:(@alias 1))
+            catch ex
+                ex
+            end
+            @test ex.error isa ArgumentError
+
+            df = copy(dfr)
+            ex = try
+                eval(:(@alias df.x .= 1))
+            catch ex
+                ex
+            end
+            @test ex.error isa ArgumentError
+
+            struct S; x; end
+            s = S(1)
+            @test_throws MethodError @alias s.x = 1
+            @test_throws MethodError @alias s.x2 = 1
+
+            @test_throws MethodError @alias df.x2 = 1
+            @test_throws MethodError @alias df[!, :x2] = 1
+            @test_throws MethodError @alias df[:, :x2] = 1
+        end
+    end
+end
+
+end # module

test/broadcasting.jl

@@ -1159,7 +1159,7 @@ end
         df1 = DataFrame(rand(100, 100), :auto)
         df2 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
         end
         df3 = copy(df2)
         df1 .= df2
@@ -1171,7 +1171,7 @@ end
         df1 = DataFrame(rand(100, 100), :auto)
         df2 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
         end
         df3 = copy(df2)
         df1 .= view(df2, :, :)
@@ -1183,7 +1183,7 @@ end
         df1 = DataFrame(rand(100, 100), :auto)
         df2 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
         end
         df3 = copy(df2)
         view(df1, :, :) .= df2
@@ -1196,8 +1196,8 @@ end
         df2 = copy(df1)
         df3 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
-            df3[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
+            @alias df3[!, rand(1:100)] = df1[!, i]
         end
         df6 = copy(df2)
         df7 = copy(df3)
@@ -1214,8 +1214,8 @@ end
         df2 = copy(df1)
         df3 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
-            df3[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
+            @alias df3[!, rand(1:100)] = df1[!, i]
         end
         df6 = copy(df2)
         df7 = copy(df3)
@@ -1232,8 +1232,8 @@ end
         df2 = copy(df1)
         df3 = copy(df1)
         for i in 1:100
-            df2[!, rand(1:100)] = df1[!, i]
-            df3[!, rand(1:100)] = df1[!, i]
+            @alias df2[!, rand(1:100)] = df1[!, i]
+            @alias df3[!, rand(1:100)] = df1[!, i]
         end
         df6 = copy(df2)
         df7 = copy(df3)
@@ -1937,21 +1937,33 @@ end
     @test df.z == fill("abc", 3)
     @test_throws ArgumentError df[:, 6] .= z
     @test_throws MethodError df[:, 1] .= z
+    dz = df.z
+    df[:, "z"] .= z
+    @test dz === df.z
+    @test dz == df[:, "z"]
 
     df = DataFrame(ones(3, 4), :auto)
     z = fill("abc", 1, 1, 2)
     @test_throws DimensionMismatch df[:, :z] .= z
 
     df = DataFrame(ones(3, 4), :auto)
     z = ["a", "b", "c"]
-    df[:, "z"] .= z
+    df[:, "z"] = z
     @test df.z == z
     @test df.z !== z
+    dz = df.z
+    df[:, "z"] .= z
+    @test dz === df.z
+    @test dz == df[:, "z"]
 
     df = DataFrame(ones(3, 4), :auto)
     z = "abc"
     df[:, "z"] .= z
     @test df.z == fill("abc", 3)
+    dz = df.z
+    df[:, "z"] .= z
+    @test dz === df.z
+    @test dz == df[:, "z"]
 
     df = DataFrame(ones(3, 4), :auto)
     z = fill("abc", 1, 1, 2)