fixes

Author: ssweber

pysimplesql/pysimplesql.py

@@ -168,9 +168,9 @@
 DELETE_RETURNED: int = 2  # A result was found
 DELETE_ABORTED: int = 4  # The search was aborted, likely during a callback
 DELETE_RECURSION_LIMIT_ERROR: int = 8  # We hit max nested levels
-DELETE_CASCADE_RECURSION_LIMIT: int = (
-    15  # Mysql sets this as 15 when using foreign key CASCADE DELETE
-)
+
+# Mysql sets this as 15 when using foreign key CASCADE DELETE
+DELETE_CASCADE_RECURSION_LIMIT: int = 15
 
 # -------
 # Sorting
@@ -987,7 +987,7 @@ def requery(
                 not len(self.frm[parent_table].rows.index)
                 or Relationship.parent_virtual(self.table, self.frm)
             ):
-                self.rows = pd.DataFrame([])  # purge rows
+                self.rows = pd.DataFrame(columns=self.rows.columns)  # purge rows
                 if update_elements:
                     self.frm.update_elements(self.key)
                 if requery_dependents:
@@ -1008,9 +1008,15 @@ def requery(
         rows = self.driver.execute(query)
         self.rows = rows
 
-        # now we can restore the sort order
-        self.load_sort_settings(sort_settings)
-        self.sort(self.table)
+        if len(self.rows.index):
+            #             if "sort_order" not in self.rows.attrs:
+            #                 # Store the sort order as a dictionary in the attrs of the DataFrame
+            #                 sort_order = self.rows[self.pk_column].to_list()
+            #                 self.rows.attrs["sort_order"] = {self.pk_column: sort_order}
+
+            # now we can restore the sort order
+            self.load_sort_settings(sort_settings)
+            self.sort(self.table)
 
         # Perform transform one row at a time
         if self.transform is not None:
@@ -1022,8 +1028,9 @@ def requery(
         # can have an equal comparison. Not the prettiest solution.  Will look into
         # this more on the PySimpleGUI end and make a follow-up ticket.
 
-        # Note on the below.  Without rows.loc[:,:], the .applymap would return an entirely new DataFrame, and not
-        # a ResultSet.  TODO: Move this into it's own ResultSet method?
+        # Note on the below.  Without rows.loc[:,:], the .applymap would return an
+        # entirely new DataFrame, and not a ResultSet.  TODO: Move this into it's own
+        # ResultSet method?
         self.rows.loc[:, :] = self.rows.applymap(
             lambda x: x.rstrip() if isinstance(x, str) else x
         )
@@ -1369,7 +1376,7 @@ def set_by_pk(
                 omit_elements = []
             # don't update self/dependents if we are going to below anyway
             self.prompt_save(update_elements=False)
-
+            
         self.current_index = self.rows.index[self.rows[self.pk_column] == pk].tolist()[
             0
         ]
@@ -1683,7 +1690,7 @@ def save_record(
             else:
                 result = self.driver.save_record(self, changed_row)
 
-            if result.exception is not None:
+            if not isinstance(result, pd.DataFrame) and result.exception is not None:
                 self.frm.popup.ok(
                     lang.dataset_save_fail_title,
                     lang.dataset_save_fail.format_map(
@@ -1708,7 +1715,7 @@ def save_record(
 
             # If child changes parent, move index back and requery/requery_dependents
             if (
-                cascade_fk_changed and not current_row.virtual
+                cascade_fk_changed and not self.row_is_virtual()
             ):  # Virtual rows already requery, and have no dependents.
                 self.frm[self.table].requery(select_first=False)  # keep spot in table
                 self.frm[self.table].requery_dependents()
@@ -1829,18 +1836,22 @@ def delete_record(
 
         # Delete child records first!
         result = self.driver.delete_record(self, True)
-        if result == DELETE_RECURSION_LIMIT_ERROR:
-            self.frm.popup.ok(
-                lang.delete_failed_title,
-                lang.delete_failed.format_map(
-                    LangFormat(exception=lang.delete_recursion_limit_error)
-                ),
-            )
-        elif result.exception is not None:
-            self.frm.popup.ok(
-                lang.delete_failed_title,
-                lang.delete_failed.format_map(LangFormat(exception=result.exception)),
-            )
+
+        if not isinstance(result, pd.DataFrame):
+            if result == DELETE_RECURSION_LIMIT_ERROR:
+                self.frm.popup.ok(
+                    lang.delete_failed_title,
+                    lang.delete_failed.format_map(
+                        LangFormat(exception=lang.delete_recursion_limit_error)
+                    ),
+                )
+            elif result.exception is not None:
+                self.frm.popup.ok(
+                    lang.delete_failed_title,
+                    lang.delete_failed.format_map(
+                        LangFormat(exception=result.exception)
+                    ),
+                )
 
         # callback
         if "after_delete" in self.callbacks:
@@ -1990,7 +2001,9 @@ def row_is_virtual(self, index: int = None) -> bool:
         """
         if index is None:
             index = self.current_index
-        return self.rows.attrs["virtual"][index]
+        if self.rows is not None and len(self.rows.index):
+            return self.rows.attrs["virtual"][index]
+        return False
 
     def table_values(
         self, columns: List[str] = None, mark_virtual: bool = False
@@ -2291,12 +2304,15 @@ def sort(self, table: str) -> None:
             self.sort_reset()
         else:
             print(
-                f"Sort column is not None.  Sorting by column {self.rows.attrs['sort_column']}"
+                f"Sort column is not None. "
+                f"Sorting by column {self.rows.attrs['sort_column']}"
             )
             self.sort_by_column(
                 self.rows.attrs["sort_column"], table, self.rows.attrs["sort_reverse"]
             )
-        self.set_by_pk(pk)
+        self.set_by_pk(
+            pk, update_elements=False, requery_dependents=False, skip_prompt_save=True
+        )
 
     def sort_cycle(self, column: str, table: str) -> int:
         """
@@ -2333,7 +2349,11 @@ def insert_row(self, row: dict, idx: int = None) -> None:
         :returns: None
         """
         row_series = pd.Series(row)
-        self.rows.append(row_series, ignore_index=True)
+        attrs = self.rows.attrs.copy()
+        self.rows = pd.concat([self.rows, row_series.to_frame().T], ignore_index=True)
+        self.rows.attrs = attrs.copy()
+        # not quite working, but closer
+        # just need to update attrs with new index
         return
         if idx is None:
             idx = len(self.rows.index)
@@ -3244,22 +3264,23 @@ def update_elements(
         for data_key in self.datasets:
             if target_data_key is not None and data_key != target_data_key:
                 continue
+
             # disable mapped elements for this table if
             # there are no records in this table or edit protect mode
-            disable = len(self[data_key].rows) == 0 or self._edit_protect
+            disable = len(self[data_key].rows.index) == 0 or self._edit_protect
             self.update_element_states(data_key, disable)
 
             for m in (m for m in self.event_map if m["table"] == self[data_key].table):
                 # Disable delete and mapped elements for this table if there are no
                 # records in this table or edit protect mode
                 if ":table_delete" in m["event"]:
-                    disable = len(self[data_key].rows) == 0 or self._edit_protect
+                    disable = len(self[data_key].rows.index) == 0 or self._edit_protect
                     win[m["event"]].update(disabled=disable)
 
                 # Disable duplicate if no rows, edit protect, or current row virtual
                 elif ":table_duplicate" in m["event"]:
                     disable = (
-                        len(self[data_key].rows) == 0
+                        len(self[data_key].rows.index) == 0
                         or self._edit_protect
                         or self[data_key]
                         .get_current_row()
@@ -3271,15 +3292,16 @@ def update_elements(
                 # Disable first/prev if only 1 row, or first row
                 elif ":table_first" in m["event"] or ":table_previous" in m["event"]:
                     disable = (
-                        len(self[data_key].rows) < 2
+                        len(self[data_key].rows.index) < 2
                         or self[data_key].current_index == 0
                     )
                     win[m["event"]].update(disabled=disable)
 
                 # Disable next/last if only 1 row, or last row
                 elif ":table_next" in m["event"] or ":table_last" in m["event"]:
-                    disable = len(self[data_key].rows) < 2 or (
-                        self[data_key].current_index == len(self[data_key].rows) - 1
+                    disable = len(self[data_key].rows.index) < 2 or (
+                        self[data_key].current_index
+                        == len(self[data_key].rows.index) - 1
                     )
                     win[m["event"]].update(disabled=disable)
 
@@ -3289,7 +3311,7 @@ def update_elements(
                     parent = Relationship.get_parent(data_key)
                     if parent is not None:
                         disable = (
-                            len(self[parent].rows) == 0
+                            len(self[parent].rows.index) == 0
                             or self._edit_protect
                             or Relationship.parent_virtual(data_key, self)
                         )
@@ -3299,7 +3321,7 @@ def update_elements(
 
                 # Disable db_save when needed
                 elif ":db_save" in m["event"] or ":save_table" in m["event"]:
-                    disable = len(self[data_key].rows) == 0 or self._edit_protect
+                    disable = len(self[data_key].rows.index) == 0 or self._edit_protect
                     win[m["event"]].update(disabled=disable)
 
                 # Enable/Disable quick edit buttons
@@ -3819,7 +3841,8 @@ def update_table_element(
     # update element
     element.update(values=values, select_rows=select_rows)
     # set vertical scroll bar to follow selected element
-    if vscroll_position:
+    # call even for 0.0, so that a 'reset sort' repositions vscroll to top.
+    if vscroll_position is not None:
         element.set_vscroll_position(vscroll_position)
     window.refresh()  # Event handled and bypassed
     # Enable handling for "<<TreeviewSelect>>" event
@@ -5268,14 +5291,18 @@ def __init__(
     def __call__(self, column):
         # store the pk:
         pk = self.frm[self.data_key].get_current_pk()
-        sort_order = self.frm[self.data_key].sort_cycle(column, self.data_key)
-        # We only need to update the selectors not all elements,
-        # so first set by the primary key, then update_selectors()
-        self.frm[self.data_key].set_by_pk(
-            pk, update_elements=False, requery_dependents=False, skip_prompt_save=True
-        )
-        self.frm.update_selectors(self.data_key)
-        self.table_heading.update_headings(self.element, column, sort_order)
+        if len(self.frm[data_key].rows.index):
+            sort_order = self.frm[self.data_key].sort_cycle(column, self.data_key)
+            # We only need to update the selectors not all elements,
+            # so first set by the primary key, then update_selectors()
+            self.frm[self.data_key].set_by_pk(
+                pk,
+                update_elements=False,
+                requery_dependents=False,
+                skip_prompt_save=True,
+            )
+            self.frm.update_selectors(self.data_key)
+            self.table_heading.update_headings(self.element, column, sort_order)
 
 
 # ======================================================================================
@@ -6041,9 +6068,11 @@ def set(
         df.attrs["lastrowid"] = lastrowid
         df.attrs["exception"] = exception
         df.attrs["column_info"] = column_info
+
+        # Store virtual flags for each row
         df.attrs["virtual"] = pd.Series(
-            [False] * len(df.index), index=df.index
-        )  # Store virtual flags for each row
+            [False] * len(df.index), index=df.index, dtype="int64"
+        )
         return df