@@ -41,6 +41,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Smaller updates: about 6 MB from any of the last five releases and 21 MB from older ones, down from 34 MB.
 - Several statements run together on PostgreSQL from iPhone and iPad commit one at a time, and a failure keeps the ones before it. (#3399)
 - MySQL dumps write TIMESTAMP values in UTC and turn off foreign key checks while they load, as mysqldump does.
+- Set Value > Empty and Set EMPTY offered only on columns that can hold an empty value, not on dates, numbers or booleans.
+- Clearing a date, number or boolean cell in a NOT NULL column keeps the stored value instead of saving an empty string.
+- Clearing a Redis key's TTL in the grid removes its expiry.
 
 ### Removed
 
@@ -120,6 +123,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - GitHub Copilot language server pinned to a reviewed version and checksum instead of the latest npm release.
 - One unreadable setting, or one unknown AI provider, resetting its whole settings group to defaults.
+- Clearing a date, number or boolean cell saving an empty string, stored as `0000-00-00 00:00:00` on MySQL, instead of NULL.
+- Pasting a copied NULL into a date, number or boolean cell writing the text NULL, stored as a zero date or 0 on MySQL.
+- Empty line in pasted cells moving the values below it up a row, or cutting off the columns after it.
 
 ### Security
 
 
@@ -2,8 +2,8 @@
 //  ColumnType.swift
 //  TablePro
 //
-//  Column type metadata for type-aware formatting and display.
-//  Driver-specific type mapping lives in each plugin; this enum is display-only.
+//  Column type metadata for type-aware formatting, display and editing.
+//  Driver-specific type mapping lives in each plugin.
 //
 
 import Foundation
@@ -163,6 +163,42 @@ enum ColumnType: Equatable, Sendable {
         }
     }
 
+    /// Whether `''` is a value of this type, so an emptied cell can be written as one.
+    ///
+    /// A date, number, boolean, JSON document, geometry or array has no empty value. Sent `''`,
+    /// MySQL without strict mode stores its zero value (`0000-00-00 00:00:00`, `0`), SQL Server
+    /// stores `1900-01-01` or `0`, SQLite keeps the text, and a strict MySQL or PostgreSQL refuses
+    /// the save. An empty SET is the empty set, and an enum has an empty value only when one of
+    /// its labels is the empty string.
+    var hasEmptyValue: Bool {
+        switch self {
+        case .text(let rawType):
+            return !Self.nonCharacterTextTypes.contains(Self.baseTypeName(rawType))
+        case .set, .blob:
+            return true
+        case .enumType(_, let values):
+            return values?.contains("") ?? false
+        case .date, .timestamp, .datetime, .integer, .decimal, .boolean, .json, .spatial, .array:
+            return false
+        }
+    }
+
+    /// Types the classifier files under `.text`, either by name or because nothing else matched,
+    /// that hold no empty string either.
+    private static let nonCharacterTextTypes: Set<String> = [
+        "YEAR", "UUID", "TIMEUUID", "UNIQUEIDENTIFIER",
+        "INET", "CIDR", "MACADDR", "MACADDR8", "IPV4", "IPV6", "INTERVAL"
+    ]
+
+    /// `Nullable(UUID)`, `year(4)` and `INTERVAL DAY TO SECOND` all name their type in the first word.
+    private static func baseTypeName(_ rawType: String?) -> String {
+        guard var name = rawType?.uppercased() else { return "" }
+        while let wrapper = ["NULLABLE(", "LOWCARDINALITY("].first(where: { name.hasPrefix($0) }) {
+            name.removeFirst(wrapper.count)
+        }
+        return String(name.prefix { $0.isLetter || $0.isNumber || $0 == "_" })
+    }
+
     /// The element type of an array column, if this is one
     var arrayElement: ColumnType? {
         switch self {
 
@@ -0,0 +1,20 @@
+//
+//  PluginCellValue+EnteredText.swift
+//  TablePro
+//
+
+import Foundation
+import TableProPluginKit
+
+internal extension PluginCellValue {
+    /// What text entered for a column means as a value.
+    ///
+    /// Emptying a cell whose type has no empty value asks for no value, which is NULL. Writing `''`
+    /// there turned a cleared `deleted_at` into `0000-00-00 00:00:00` on MySQL, so the row still
+    /// read as deleted. A text column keeps `''`, which is a real value there.
+    static func entered(_ text: String?, columnType: ColumnType?) -> PluginCellValue {
+        guard let text else { return .null }
+        guard text.isEmpty, let columnType, !columnType.hasEmptyValue else { return .text(text) }
+        return .null
+    }
+}
@@ -94,6 +94,30 @@ struct TableRows: Sendable {
         return !ColumnDefaultLiteral.isNull(defaultValue)
     }
 
+    /// The column's type with the labels its catalog declared, which a result set alone never carries.
+    func editingColumnType(at index: Int) -> ColumnType? {
+        guard columnTypes.indices.contains(index) else { return nil }
+        let columnType = columnTypes[index]
+        guard columns.indices.contains(index),
+              let labels = columnEnumValues[columns[index]], !labels.isEmpty else { return columnType }
+        return columnType.withAllowedValues(labels)
+    }
+
+    /// What text entered for a column stages, or nil when the column holds neither it nor NULL.
+    ///
+    /// An emptied date in a NOT NULL column has no value to write. MySQL turns NULL there into the
+    /// current time when `explicit_defaults_for_timestamp` is off, and `''` into the zero date, so
+    /// the edit is refused rather than staged.
+    func enteredValue(_ text: String?, forColumn index: Int) -> PluginCellValue? {
+        let value = PluginCellValue.entered(text, columnType: editingColumnType(at: index))
+        guard value.isNull, refusesNull(columnAt: index) else { return value }
+        return nil
+    }
+
+    func refusesNull(columnAt index: Int) -> Bool {
+        columns.indices.contains(index) && columnNullable[columns[index]] == false
+    }
+
     func value(at row: Int, column: Int) -> PluginCellValue {
         guard row >= 0, row < rows.count else { return .null }
         return rows[row][column]
 
@@ -44,6 +44,9 @@ struct FieldEditState: Identifiable {
     /// Save never writes.
     var isServerOwned: Bool = false
 
+    /// False for a NOT NULL column. Nil from the schema reads as nullable, as the grid's menus do.
+    var isNullable = true
+
     /// The value already differs from the loaded schema because the edit is recorded elsewhere.
     var hasCommittedEdit: Bool = false
 
@@ -130,6 +133,7 @@ final class MultiRowEditState: ObservableObject {
     @Published private(set) var absentCells: [Set<Int>] = []
     @Published private(set) var columns: [String] = []
     @Published private(set) var columnTypes: [ColumnType] = []
+    private var nonNullableColumns: Set<String> = []
 
     var hasEdits: Bool {
         fields.contains { $0.hasEdit }
@@ -146,6 +150,7 @@ final class MultiRowEditState: ObservableObject {
         primaryKeyColumns: Set<String> = [],
         foreignKeyColumns: Set<String> = [],
         serverOwnedColumns: Set<String> = [],
+        nonNullableColumns: Set<String> = [],
         displayFormats: [ValueDisplayFormat?] = [],
         binaryColumns: Set<Int> = []
     ) {
@@ -159,6 +164,7 @@ final class MultiRowEditState: ObservableObject {
         self.absentCells = absentCells
         self.columns = columns
         self.columnTypes = columnTypes
+        self.nonNullableColumns = nonNullableColumns
 
         var newFields: [FieldEditState] = []
 
@@ -228,6 +234,7 @@ final class MultiRowEditState: ObservableObject {
                 isPrimaryKey: primaryKeyColumns.contains(columnName),
                 isForeignKey: foreignKeyColumns.contains(columnName),
                 isServerOwned: serverOwnedColumns.contains(columnName),
+                isNullable: !nonNullableColumns.contains(columnName),
                 originalValue: originalValue,
                 hasMultipleValues: hasMultipleValues,
                 pendingValue: pendingValue,
@@ -337,13 +344,22 @@ final class MultiRowEditState: ObservableObject {
         guard index < fields.count else { return }
         let hadPendingEdit = fields[index].hasEdit
         let original = fields[index].originalValue
-        let pending = Self.resolvePendingValue(value, original: original, isJson: fields[index].isJson)
+        var pending = Self.resolvePendingValue(value, original: original, isJson: fields[index].isJson)
+        var staged = pending.map { PluginCellValue.entered($0, columnType: fields[index].columnTypeEnum) }
+        /// A NOT NULL column whose type has no empty value holds nothing an emptied field could
+        /// mean, so the field goes back to its stored value, as the grid's cell does.
+        if staged == .null, !fields[index].isNullable {
+            pending = nil
+            staged = nil
+        }
         fields[index].pendingValue = pending
         fields[index].isPendingNull = false
         fields[index].isPendingDefault = false
         fields[index].isPendingRemoval = false
-        if pending != nil {
-            onFieldChanged?(index, PluginCellValue.fromOptional(pending), .typing)
+        /// The field keeps its empty text while the change it stages is NULL: swapping the editor
+        /// for the pending NULL pill would take the field away in the middle of typing a new value.
+        if let staged {
+            onFieldChanged?(index, staged, .typing)
         } else if hadPendingEdit {
             /// `originalValue` is nil for three different situations, and only one of them is a
             /// value: a stored NULL, a selection whose rows do not agree, and a field the rows do
@@ -391,7 +407,9 @@ final class MultiRowEditState: ObservableObject {
             updateField(at: columnIndex, value: value)
             return
         }
-        onDetachedFieldChanged?(columnIndex, PluginCellValue.fromOptional(value), rowIDs)
+        let staged = PluginCellValue.entered(value, columnType: columnTypes[safe: columnIndex])
+        if staged.isNull, columns[safe: columnIndex].map(nonNullableColumns.contains) == true { return }
+        onDetachedFieldChanged?(columnIndex, staged, rowIDs)
     }
 
     private static func resolvePendingValue(_ value: String?, original: String?, isJson: Bool) -> String? {
@@ -497,6 +515,7 @@ final class MultiRowEditState: ObservableObject {
         absentCells = []
         columns = []
         columnTypes = []
+        nonNullableColumns = []
     }
 
     /// Get all edited fields with their new values
 
@@ -40,6 +40,13 @@ extension MainContentCoordinator {
         guard !editedFields.isEmpty else { return [] }
 
         let tableRows = tabSessionRegistry.tableRows(for: tab.id)
+        /// Typed text is read for its column, as the grid reads a cell, and text a NOT NULL column can
+        /// hold neither as itself nor as NULL writes nothing. An explicit NULL stays NULL.
+        let writes: [(field: InspectorFieldEdit, value: PluginCellValue)] = editedFields.compactMap { field in
+            guard !field.removesField, let text = field.newValue else { return (field, .null) }
+            return tableRows.enteredValue(text, forColumn: field.columnIndex).map { (field, $0) }
+        }
+        guard !writes.isEmpty else { return [] }
         let displayIDs = activeGridDisplayIDs
         let changes: [RowChange] = selectionState.indices.sorted().compactMap { rowIndex -> RowChange? in
             guard let resolvedRow = DisplayRowMapping.row(
@@ -51,15 +58,15 @@ extension MainContentCoordinator {
             return RowChange(
                 rowID: resolvedRow.id,
                 type: .update,
-                cellChanges: editedFields.map { field in
+                cellChanges: writes.map { field, newValue in
                     let oldValue: PluginCellValue = field.columnIndex < originalRow.count
                         ? originalRow[field.columnIndex]
                         : .null
                     return CellChange(
                         columnIndex: field.columnIndex,
                         columnName: field.columnName,
                         oldValue: oldValue,
-                        newValue: field.removesField ? .null : PluginCellValue.fromOptional(field.newValue),
+                        newValue: newValue,
                         oldIsAbsent: resolvedRow.isAbsent(field.columnIndex),
                         newIsAbsent: field.removesField
                     )
 
@@ -180,12 +180,7 @@ extension MainContentView {
         }
         let allRows = selectedRows.map { Array($0.values) }
 
-        var columnTypes = tableRows.columnTypes
-        for (i, col) in tableRows.columns.enumerated() where i < columnTypes.count {
-            if let values = tableRows.columnEnumValues[col], !values.isEmpty {
-                columnTypes[i] = columnTypes[i].withAllowedValues(values)
-            }
-        }
+        let columnTypes = tableRows.columnTypes.indices.compactMap { tableRows.editingColumnType(at: $0) }
 
         if !changeManager.hasChanges {
             trailingPaneState.inspector.editState.clearEdits()
@@ -219,6 +214,7 @@ extension MainContentView {
             primaryKeyColumns: pkColumns,
             foreignKeyColumns: fkColumns,
             serverOwnedColumns: tableRows.generatedColumns.union(changeManager.unwritableColumns(among: tableRows.columns)),
+            nonNullableColumns: Set(tableRows.columnNullable.compactMap { $0.value ? nil : $0.key }),
             displayFormats: inspectorDisplayFormats(for: tab, columns: tableRows.columns, types: tableRows.columnTypes),
             binaryColumns: MultiRowEditState.binaryColumns(in: allRows)
         )
 
@@ -5,6 +5,7 @@
 
 import AppKit
 import Combine
+import TableProPluginKit
 
 @MainActor
 class DataGridRowView: NSTableRowView {
@@ -690,9 +691,12 @@ class DataGridRowView: NSTableRowView {
             && coordinator.isColumnWritable(tableRows.columns[dataColumnIndex])
         guard coordinator.isEditable, namesWritableColumn else { return }
 
-        let setValueItem = NSMenuItem(title: String(localized: "Set Value"), action: nil, keyEquivalent: "")
-        setValueItem.submenu = buildSetValueMenu(dataColumnIndex: dataColumnIndex, tableRows: tableRows)
-        menu.addItem(setValueItem)
+        let setValueMenu = buildSetValueMenu(dataColumnIndex: dataColumnIndex, tableRows: tableRows)
+        if !setValueMenu.items.isEmpty {
+            let setValueItem = NSMenuItem(title: String(localized: "Set Value"), action: nil, keyEquivalent: "")
+            setValueItem.submenu = setValueMenu
+            menu.addItem(setValueItem)
+        }
 
         guard coordinator.supportsFieldRemoval,
               coordinator.displayRow(at: rowIndex)?.isAbsent(dataColumnIndex) == false else { return }
@@ -703,14 +707,18 @@ class DataGridRowView: NSTableRowView {
         menu.addItem(removeFieldItem)
     }
 
-    private func buildSetValueMenu(dataColumnIndex: Int, tableRows: TableRows) -> NSMenu {
+    /// Empty is offered only where `''` is a value of the column's type, the way NULL is offered
+    /// only where the column takes it. On a date it wrote the server's zero date.
+    func buildSetValueMenu(dataColumnIndex: Int, tableRows: TableRows) -> NSMenu {
         let setValueMenu = NSMenu()
 
-        let emptyItem = NSMenuItem(
-            title: String(localized: "Empty"), action: #selector(setEmptyValue(_:)), keyEquivalent: "")
-        emptyItem.representedObject = dataColumnIndex
-        emptyItem.target = self
-        setValueMenu.addItem(emptyItem)
+        if tableRows.editingColumnType(at: dataColumnIndex)?.hasEmptyValue ?? true {
+            let emptyItem = NSMenuItem(
+                title: String(localized: "Empty"), action: #selector(setEmptyValue(_:)), keyEquivalent: "")
+            emptyItem.representedObject = dataColumnIndex
+            emptyItem.target = self
+            setValueMenu.addItem(emptyItem)
+        }
 
         let columnName = dataColumnIndex < tableRows.columns.count
             ? tableRows.columns[dataColumnIndex]
@@ -839,9 +847,10 @@ class DataGridRowView: NSTableRowView {
         coordinator?.removeField(row: rowIndex, columnIndex: columnIndex)
     }
 
+    /// Written as `''` itself rather than read as typed text, which would turn it into NULL.
     @objc private func setEmptyValue(_ sender: NSMenuItem) {
         guard let columnIndex = sender.representedObject as? Int else { return }
-        coordinator?.setCellValueAtColumn("", at: rowIndex, columnIndex: columnIndex)
+        coordinator?.commitTypedCellEdit(row: rowIndex, columnIndex: columnIndex, newValue: .text(""))
     }
 
     @objc private func setDefaultValue(_ sender: NSMenuItem) {
 
@@ -10,8 +10,21 @@ import TableProPluginKit
 private let cellCommitLogger = Logger(subsystem: "com.TablePro", category: "DataGrid")
 
 extension TableViewCoordinator {
+    /// Every caller hands over text a person entered, so it is read for the column it lands in:
+    /// an emptied date, number or boolean is NULL, an emptied text cell is `''`. A NOT NULL column
+    /// that can hold neither keeps its value, and the beep says the edit was refused.
     func commitCellEdit(row: Int, columnIndex: Int, newValue: String?) {
-        commitTypedCellEdit(row: row, columnIndex: columnIndex, newValue: PluginCellValue.fromOptional(newValue))
+        if !commitEnteredText(newValue, row: row, columnIndex: columnIndex) {
+            NSSound.beep()
+        }
+    }
+
+    /// False when the column holds neither the text nor NULL in its place, and nothing was staged.
+    @discardableResult
+    func commitEnteredText(_ text: String?, row: Int, columnIndex: Int) -> Bool {
+        guard let value = tableRowsProvider().enteredValue(text, forColumn: columnIndex) else { return false }
+        commitTypedCellEdit(row: row, columnIndex: columnIndex, newValue: value)
+        return true
     }
 
     func commitTypedCellEdit(row: Int, columnIndex: Int, newValue typedNewValue: PluginCellValue) {
@@ -42,7 +55,11 @@ extension TableViewCoordinator {
     /// A detached editor outlives a sort, a value filter and a display-format change, none of which
     /// close it, and a display row names a different record after any of them.
     func commitCellEdit(rowID: RowID, columnIndex: Int, newValue: String?) {
-        commitTypedCellEdit(rowID: rowID, columnIndex: columnIndex, newValue: PluginCellValue.fromOptional(newValue))
+        guard let value = tableRowsProvider().enteredValue(newValue, forColumn: columnIndex) else {
+            NSSound.beep()
+            return
+        }
+        commitTypedCellEdit(rowID: rowID, columnIndex: columnIndex, newValue: value)
     }
 
     func commitTypedCellEdit(rowID: RowID, columnIndex: Int, newValue typedNewValue: PluginCellValue) {