Add not to indexing

Project.toml

@@ -5,6 +5,7 @@ version = "0.18.3"
 [deps]
 CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
+InvertedIndices = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
 IteratorInterfaceExtensions = "82899510-4779-5014-852e-03e436cf321d"
 Missings = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
 PooledArrays = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
@@ -31,11 +32,12 @@ test = ["DataStructures", "DataValues", "Dates", "LaTeXStrings", "Random", "Test
 
 [compat]
 julia = "1"
-Missings = ">= 0.2.3"
 CategoricalArrays = ">= 0.5.4"
-StatsBase = ">= 0.11.0"
 Compat = "2.0.0"
-Tables = ">= 0.2.3"
+InvertedIndices = "1"
 IteratorInterfaceExtensions = "0.1.1, 1"
-TableTraits = "0.4, 1"
+Missings = ">= 0.2.3"
 PooledArrays = ">= 0.5.0"
+StatsBase = ">= 0.11.0"
+Tables = ">= 0.2.3"
+TableTraits = "0.4, 1"

docs/src/lib/functions.md

@@ -35,8 +35,6 @@ completecases
 copy
 DataFrame
 DataFrame!
-deletecols!
-deletecols
 deleterows!
 describe
 disallowmissing!

src/DataFrames.jl

@@ -8,7 +8,7 @@ module DataFrames
 
 using Statistics, Printf, REPL
 using Reexport, StatsBase, SortingAlgorithms, Compat, Unicode, PooledArrays
-@reexport using CategoricalArrays, Missings
+@reexport using CategoricalArrays, Missings, InvertedIndices
 using Base.Sort, Base.Order, Base.Iterators
 
 ##############################################################################

src/abstractdataframe/abstractdataframe.jl

@@ -522,8 +522,8 @@ end
 
 
 """
-    completecases(df::AbstractDataFrame)
-    completecases(df::AbstractDataFrame, cols::Union{AbstractVector, Regex})
+    completecases(df::AbstractDataFrame, cols::Colon=:)
+    completecases(df::AbstractDataFrame, cols::Union{AbstractVector, Regex, Not})
     completecases(df::AbstractDataFrame, cols::Union{Integer, Symbol})
 
 Return a Boolean vector with `true` entries indicating rows without missing values
@@ -575,27 +575,32 @@ julia> completecases(df, [:x, :y])
 ```
 
 """
-function completecases(df::AbstractDataFrame)
+function completecases(df::AbstractDataFrame, col::Colon=:)
+    if ncol(df) == 0
+        throw(ArgumentError("Unable to compute complete cases of a data frame with no columns"))
+    end
     res = trues(size(df, 1))
     for i in 1:size(df, 2)
         _nonmissing!(res, df[i])
     end
     res
 end
 
-function completecases(df::AbstractDataFrame, col::Union{Integer, Symbol})
+function completecases(df::AbstractDataFrame, col::ColumnIndex)
     res = trues(size(df, 1))
     _nonmissing!(res, df[col])
     res
 end
 
-completecases(df::AbstractDataFrame, cols::Union{AbstractVector, Regex}) =
-    completecases(df[cols])
+completecases(df::AbstractDataFrame, cols::Union{AbstractVector, Regex, Not}) =
+    completecases(select(df, cols, copycols=false))
 
 """
-    dropmissing(df::AbstractDataFrame; disallowmissing::Bool=true)
-    dropmissing(df::AbstractDataFrame, cols::Union{AbstractVector, Regex}; disallowmissing::Bool=true)
-    dropmissing(df::AbstractDataFrame, cols::Union{Integer, Symbol}; disallowmissing::Bool=true)
+    dropmissing(df::AbstractDataFrame, cols::Colon=:; disallowmissing::Bool=true)
+    dropmissing(df::AbstractDataFrame, cols::Union{AbstractVector, Regex, Not};
+                disallowmissing::Bool=true)
+    dropmissing(df::AbstractDataFrame, cols::Union{Integer, Symbol};
+                disallowmissing::Bool=true)
 
 Return a copy of data frame `df` excluding rows with missing values.
 If `cols` is provided, only missing values in the corresponding columns are considered.
@@ -657,17 +662,19 @@ julia> dropmissing(df, [:x, :y])
 
 """
 function dropmissing(df::AbstractDataFrame,
-                     cols::Union{Integer, Symbol, AbstractVector, Regex}=1:size(df, 2);
+                     cols::Union{ColumnIndex, AbstractVector, Regex, Not, Colon}=:;
                      disallowmissing::Bool=true)
     newdf = df[completecases(df, cols), :]
     disallowmissing && disallowmissing!(newdf, cols)
     newdf
 end
 
 """
-    dropmissing!(df::AbstractDataFrame; disallowmissing::Bool=true)
-    dropmissing!(df::AbstractDataFrame, cols::Union{AbstractVector, Regex}; disallowmissing::Bool=true)
-    dropmissing!(df::AbstractDataFrame, cols::Union{Integer, Symbol}; disallowmissing::Bool=true)
+    dropmissing!(df::AbstractDataFrame, cols::Colon=:; disallowmissing::Bool=true)
+    dropmissing!(df::AbstractDataFrame, cols::Union{AbstractVector, Regex, Not};
+                 disallowmissing::Bool=true)
+    dropmissing!(df::AbstractDataFrame, cols::Union{Integer, Symbol};
+                 disallowmissing::Bool=true)
 
 Remove rows with missing values from data frame `df` and return it.
 If `cols` is provided, only missing values in the corresponding columns are considered.
@@ -727,7 +734,7 @@ julia> dropmissing!(df3, [:x, :y])
 
 """
 function dropmissing!(df::AbstractDataFrame,
-                      cols::Union{Integer, Symbol, AbstractVector, Regex}=1:size(df, 2);
+                      cols::Union{ColumnIndex, AbstractVector, Regex, Not, Colon}=:;
                       disallowmissing::Bool=true)
     deleterows!(df, (!).(completecases(df, cols)))
     disallowmissing && disallowmissing!(df, cols)
@@ -865,22 +872,17 @@ function nonunique(df::AbstractDataFrame)
     return res
 end
 
-nonunique(df::AbstractDataFrame, cols::Union{Integer, Symbol}) = nonunique(df[[cols]])
-nonunique(df::AbstractDataFrame, cols::Any) = nonunique(df[cols])
+nonunique(df::AbstractDataFrame, cols) = nonunique(select(df, cols, copycols=false))
 
 Base.unique!(df::AbstractDataFrame) = deleterows!(df, findall(nonunique(df)))
 Base.unique!(df::AbstractDataFrame, cols::AbstractVector) =
     deleterows!(df, findall(nonunique(df, cols)))
-Base.unique!(df::AbstractDataFrame, cols::Regex) =
-    deleterows!(df, findall(nonunique(df, cols)))
-Base.unique!(df::AbstractDataFrame, cols::Union{Integer, Symbol, Colon}) =
+Base.unique!(df::AbstractDataFrame, cols) =
     deleterows!(df, findall(nonunique(df, cols)))
 
 # Unique rows of an AbstractDataFrame.
 Base.unique(df::AbstractDataFrame) = df[(!).(nonunique(df)), :]
-Base.unique(df::AbstractDataFrame, cols::Union{AbstractVector,Regex}) =
-    df[(!).(nonunique(df, cols)), :]
-Base.unique(df::AbstractDataFrame, cols::Union{Integer, Symbol, Colon}) =
+Base.unique(df::AbstractDataFrame, cols) =
     df[(!).(nonunique(df, cols)), :]
 
 """

src/abstractdataframe/reshape.jl

@@ -122,7 +122,7 @@ end
 Stacks a DataFrame; convert from a wide to long format; see
 `stack`.
 """
-function melt(df::AbstractDataFrame, id_vars::Union{Int,Symbol};
+function melt(df::AbstractDataFrame, id_vars::ColumnIndex;
               variable_name::Symbol=:variable, value_name::Symbol=:value)
     melt(df, [id_vars]; variable_name=variable_name, value_name=value_name)
 end
@@ -150,12 +150,12 @@ melt(df::AbstractDataFrame; variable_name::Symbol=:variable, value_name::Symbol=
 Unstacks a DataFrame; convert from a long to wide format
 
 ```julia
-unstack(df::AbstractDataFrame, rowkeys::Union{Symbol, Integer},
-        colkey::Union{Symbol, Integer}, value::Union{Symbol, Integer})
-unstack(df::AbstractDataFrame, rowkeys::AbstractVector{<:Union{Symbol, Integer}},
-        colkey::Union{Symbol, Integer}, value::Union{Symbol, Integer})
-unstack(df::AbstractDataFrame, colkey::Union{Symbol, Integer},
-        value::Union{Symbol, Integer})
+unstack(df::AbstractDataFrame, rowkeys::Union{Integer, Symbol},
+        colkey::Union{Integer, Symbol}, value::Union{Integer, Symbol})
+unstack(df::AbstractDataFrame, rowkeys::AbstractVector{<:Union{Integer, Symbol}},
+        colkey::Union{Integer, Symbol}, value::Union{Integer, Symbol})
+unstack(df::AbstractDataFrame, colkey::Union{Integer, Symbol},
+        value::Union{Integer, Symbol})
 unstack(df::AbstractDataFrame)
 ```