overwrite existing column in outer join

polars/polars-core/src/frame/explode.rs

@@ -77,9 +77,9 @@ impl DataFrame {
         // below will panic
         let mut columns = self.select_series(columns)?;
         columns.sort_by(|sa, sb| {
-            self.name_to_idx(sa.name())
+            self.check_name_to_idx(sa.name())
                 .expect("checked above")
-                .partial_cmp(&self.name_to_idx(sb.name()).expect("checked above"))
+                .partial_cmp(&self.check_name_to_idx(sb.name()).expect("checked above"))
                 .expect("cmp usize -> Ordering")
         });
 
@@ -93,7 +93,7 @@ impl DataFrame {
             // Safety:
             // offsets are not take longer than the Series.
             if let Ok((exploded, offsets)) = get_exploded(s) {
-                let col_idx = self.name_to_idx(s.name())?;
+                let col_idx = self.check_name_to_idx(s.name())?;
 
                 // expand all the other columns based the exploded first column
                 if i == 0 {

polars/polars-core/src/frame/hash_join/mod.rs

@@ -1215,7 +1215,7 @@ impl DataFrame {
                 for (s_left, s_right) in selected_left.iter().zip(&selected_right) {
                     let mut s = s_left.zip_outer_join_column(s_right, &opt_join_tuples);
                     s.rename(s_left.name());
-                    df_left.hstack_mut(&[s])?;
+                    df_left.with_column(s)?;
                 }
                 self.finish_join(df_left, df_right, suffix)
             }

polars/polars-core/src/frame/mod.rs

@@ -135,22 +135,12 @@ fn duplicate_err(name: &str) -> Result<()> {
 
 impl DataFrame {
     /// Get the index of the column.
-    fn name_to_idx(&self, name: &str) -> Result<usize> {
-        let mut idx = 0;
-        for column in &self.columns {
-            if column.name() == name {
-                break;
-            }
-            idx += 1;
-        }
-        if idx == self.columns.len() {
-            Err(PolarsError::NotFound(name.into()))
-        } else {
-            Ok(idx)
-        }
+    fn check_name_to_idx(&self, name: &str) -> Result<usize> {
+        self.find_idx_by_name(name)
+            .ok_or_else(|| PolarsError::NotFound(name.into()))
     }
 
-    fn has_column(&self, name: &str) -> Result<()> {
+    fn check_already_present(&self, name: &str) -> Result<()> {
         if self.columns.iter().any(|s| s.name() == name) {
             Err(PolarsError::Duplicate(
                 format!("column with name: '{}' already present in DataFrame", name).into(),
@@ -847,10 +837,8 @@ impl DataFrame {
     /// # Ok::<(), PolarsError>(())
     /// ```
     pub fn drop_in_place(&mut self, name: &str) -> Result<Series> {
-        let idx = self.name_to_idx(name)?;
-        let result = Ok(self.columns.remove(idx));
-        self.rechunk();
-        result
+        let idx = self.check_name_to_idx(name)?;
+        Ok(self.columns.remove(idx))
     }
 
     /// Return a new `DataFrame` where all null values are dropped.
@@ -923,7 +911,7 @@ impl DataFrame {
     /// # Ok::<(), PolarsError>(())
     /// ```
     pub fn drop(&self, name: &str) -> Result<Self> {
-        let idx = self.name_to_idx(name)?;
+        let idx = self.check_name_to_idx(name)?;
         let mut new_cols = Vec::with_capacity(self.columns.len() - 1);
 
         self.columns.iter().enumerate().for_each(|(i, s)| {
@@ -955,17 +943,16 @@ impl DataFrame {
     /// Insert a new column at a given index.
     pub fn insert_at_idx<S: IntoSeries>(&mut self, index: usize, column: S) -> Result<&mut Self> {
         let series = column.into_series();
-        self.has_column(series.name())?;
+        self.check_already_present(series.name())?;
         self.insert_at_idx_no_name_check(index, series)
     }
 
     /// Add a new column to this `DataFrame` or replace an existing one.
     pub fn with_column<S: IntoSeries>(&mut self, column: S) -> Result<&mut Self> {
         let series = column.into_series();
         if series.len() == self.height() || self.is_empty() {
-            if self.has_column(series.name()).is_err() {
-                let name = series.name().to_string();
-                self.apply(&name, |_| series)?;
+            if let Some(idx) = self.find_idx_by_name(series.name()) {
+                self.replace_at_idx(idx, series)?;
             } else {
                 self.columns.push(series);
                 self.rechunk();
@@ -1638,14 +1625,12 @@ impl DataFrame {
     /// | "egg"  | 3     |
     /// +--------+-------+
     /// ```
-    pub fn apply<F, S>(&mut self, column: &str, f: F) -> Result<&mut Self>
+    pub fn apply<F, S>(&mut self, name: &str, f: F) -> Result<&mut Self>
     where
         F: FnOnce(&Series) -> S,
         S: IntoSeries,
     {
-        let idx = self
-            .find_idx_by_name(column)
-            .ok_or_else(|| PolarsError::NotFound(column.to_string()))?;
+        let idx = self.check_name_to_idx(name)?;
         self.apply_at_idx(idx, f)
     }
 

polars/polars-core/src/frame/upstream_traits.rs

@@ -44,7 +44,7 @@ impl Index<&str> for DataFrame {
     type Output = Series;
 
     fn index(&self, index: &str) -> &Self::Output {
-        let idx = self.name_to_idx(index).unwrap();
+        let idx = self.check_name_to_idx(index).unwrap();
         &self.columns[idx]
     }
 }