Create Index directly from Index(es) where applicable

Author: garborg

src/DataFrames.jl

@@ -99,10 +99,10 @@ export @~,
 ##
 ##############################################################################
 
-include(joinpath("other", "index.jl"))
-include(joinpath("abstractdataframe", "abstractdataframe.jl"))
 include(joinpath("other", "utils.jl"))
+include(joinpath("other", "index.jl"))
 
+include(joinpath("abstractdataframe", "abstractdataframe.jl"))
 include(joinpath("dataframe", "dataframe.jl"))
 include(joinpath("subdataframe", "subdataframe.jl"))
 include(joinpath("groupeddataframe", "grouping.jl"))

src/abstractdataframe/abstractdataframe.jl

@@ -74,7 +74,7 @@ Base.ndims(::AbstractDataFrame) = 2
 ##############################################################################
 
 Base.similar(df::AbstractDataFrame, dims::Int) =
-    DataFrame([similar(x, dims) for x in columns(df)], _names(df))
+    DataFrame([similar(x, dims) for x in columns(df)], copy(index(df)))
 
 nas{T}(dv::AbstractArray{T}, dims::Union(Int, (Int...))) =   # TODO move to datavector.jl?
     DataArray(Array(T, dims), trues(dims))
@@ -83,7 +83,7 @@ nas{T,R}(dv::PooledDataArray{T,R}, dims::Union(Int, (Int...))) =
     PooledDataArray(DataArrays.RefArray(zeros(R, dims)), dv.pool)
 
 nas(df::AbstractDataFrame, dims::Int) =
-    DataFrame(Any[nas(x, dims) for x in columns(df)], _names(df))
+    DataFrame(Any[nas(x, dims) for x in columns(df)], copy(index(df)))
 
 ##############################################################################
 ##

src/abstractdataframe/join.jl

@@ -182,6 +182,6 @@ function crossjoin(df1::AbstractDataFrame, df2::AbstractDataFrame)
     r1, r2 = size(df1, 1), size(df2, 1)
     cols = [[rep(c, 1, r2) for c in columns(df1)],
             [rep(c, r1, 1) for c in columns(df2)]]
-    colindex = Index([_names(df1), _names(df2)])
+    colindex = merge(index(df1), index(df2))
     DataFrame(cols, colindex)
 end

src/dataframe/dataframe.jl

@@ -211,7 +211,7 @@ end
 function Base.getindex{T <: ColumnIndex}(df::DataFrame, col_inds::AbstractVector{T})
     selected_columns = index(df)[col_inds]
     new_columns = df.columns[selected_columns]
-    return DataFrame(new_columns, Index(index(df).names[selected_columns]))
+    return DataFrame(new_columns, Index(_names(df)[selected_columns]))
 end
 
 # df[SingleRowIndex, SingleColumnIndex] => Scalar
@@ -224,7 +224,7 @@ end
 function Base.getindex{T <: ColumnIndex}(df::DataFrame, row_ind::Real, col_inds::AbstractVector{T})
     selected_columns = index(df)[col_inds]
     new_columns = Any[dv[[row_ind]] for dv in df.columns[selected_columns]]
-    return DataFrame(new_columns, Index(index(df).names[selected_columns]))
+    return DataFrame(new_columns, Index(_names(df)[selected_columns]))
 end
 
 # df[MultiRowIndex, SingleColumnIndex] => (Sub)?AbstractDataVector
@@ -237,7 +237,7 @@ end
 function Base.getindex{R <: Real, T <: ColumnIndex}(df::DataFrame, row_inds::AbstractVector{R}, col_inds::AbstractVector{T})
     selected_columns = index(df)[col_inds]
     new_columns = Any[dv[row_inds] for dv in df.columns[selected_columns]]
-    return DataFrame(new_columns, Index(index(df).names[selected_columns]))
+    return DataFrame(new_columns, Index(_names(df)[selected_columns]))
 end
 
 ##############################################################################
@@ -646,7 +646,7 @@ end
 ##############################################################################
 
 function hcat!(df1::DataFrame, df2::AbstractDataFrame)
-    u = unique_adds(df1, _names(df2))
+    u = add_names(index(df1), index(df2))
     for i in 1:length(u)
         df1[u[i]] = df2[i]
     end

src/other/index.jl

@@ -23,6 +23,7 @@ Base.deepcopy(x::Index) = Index(deepcopy(x.lookup), deepcopy(x.names))
 Base.isequal(x::Index, y::Index) = isequal(x.lookup, y.lookup) && isequal(x.names, y.names)
 Base.(:(==))(x::Index, y::Index) = isequal(x, y)
 
+# TODO: consider. 'unsafe', as in few other place allow duplicate names to corrupt index
 function names!(x::Index, nm::Vector{Symbol})
     if length(nm) != length(x)
         error("Lengths don't match.")
@@ -63,19 +64,25 @@ Base.haskey(x::Index, key::Real) = 1 <= key <= length(x.names)
 Base.keys(x::Index) = names(x)
 
 # TODO: If this should stay 'unsafe', perhaps make unexported
-#       If changing, make sure union stays fast
 function Base.push!(x::Index, nm::Symbol)
     x.lookup[nm] = length(x) + 1
     push!(x.names, nm)
     return x
 end
 
-function Base.union(x::Index, nm::Index)
-    x.lookup[nm] = length(x) + 1
-    push!(x.names, nm)
+function Base.merge!(x::Index, y::Index)
+    adds = add_names(x, y)
+    i = length(x)
+    for add in adds
+        i += 1
+        x.lookup[add] = i
+    end
+    append!(x.names, adds)
     return x
 end
 
+Base.merge(x::Index, y::Index) = merge!(copy(x), y)
+
 function Base.delete!(x::Index, idx::Integer)
     # reset the lookup's beyond the deleted item
     for i in (idx + 1):length(x.names)
@@ -126,3 +133,32 @@ SimpleIndex() = SimpleIndex(0)
 Base.length(x::SimpleIndex) = x.length
 Base.names(x::SimpleIndex) = nothing
 _names(x::SimpleIndex) = nothing
+
+# Helpers
+
+function add_names(ind::Index, add_ind::Index)
+    u = names(add_ind)
+
+    seen = Set(_names(ind))
+    dups = Int[]
+
+    for i in 1:length(u)
+        name = u[i]
+        in(name, seen) ? push!(dups, i) : push!(seen, name)
+    end
+    for i in dups
+        nm = u[i]
+        k = 1
+        while true
+            newnm = symbol("$(nm)_$k")
+            if !in(newnm, seen)
+                u[i] = newnm
+                push!(seen, newnm)
+                break
+            end
+            k += 1
+        end
+    end
+
+    return u
+end

src/other/utils.jl

@@ -74,32 +74,6 @@ function make_unique(names::Vector{Symbol})
     return names
 end
 
-function unique_adds(df::AbstractDataFrame, adds::Vector{Symbol})
-    seen = Set(_names(df))
-    dups = Int[]
-    u = copy(adds)
-
-    for i in 1:length(u)
-        name = u[i]
-        in(name, seen) ? push!(dups, i) : push!(seen, name)
-    end
-    for i in dups
-        nm = u[i]
-        k = 1
-        while true
-            newnm = symbol("$(nm)_$k")
-            if !in(newnm, seen)
-                u[i] = newnm
-                push!(seen, newnm)
-                break
-            end
-            k += 1
-        end
-    end
-
-    return u
-end
-
 #' @description
 #'
 #' Generate standardized names for columns of a DataFrame. The