chore: error display

Author: KKould

src/binder/insert.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::binder::{lower_case_name, Binder};
+use crate::binder::{attach_span_if_absent, lower_case_name, Binder};
 use crate::errors::DatabaseError;
 use crate::expression::simplify::ConstantCalculator;
 use crate::expression::visitor_mut::VisitorMut;
@@ -96,13 +96,25 @@ impl<T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'_, '_, T, A>
                         }
                         // Check if the value length is too long
                         value.check_len(ty)?;
+                        if value.is_null() && !schema_ref[i].nullable() {
+                            return Err(attach_span_if_absent(
+                                DatabaseError::not_null_column(schema_ref[i].name().to_string()),
+                                expr,
+                            ));
+                        }
 
                         row.push(value);
                     }
                     ScalarExpression::Empty => {
                         let default_value = schema_ref[i]
                             .default_value()?
                             .ok_or(DatabaseError::DefaultNotExist)?;
+                        if default_value.is_null() && !schema_ref[i].nullable() {
+                            return Err(attach_span_if_absent(
+                                DatabaseError::not_null_column(schema_ref[i].name().to_string()),
+                                expr,
+                            ));
+                        }
                         row.push(default_value);
                     }
                     _ => return Err(DatabaseError::UnsupportedStmt(expr.to_string())),

src/binder/mod.rs

@@ -105,7 +105,7 @@ pub(crate) fn sqlparser_span_to_sql_error_span(span: Span) -> Option<SqlErrorSpa
         start,
         end,
         line: span.start.line as usize,
-        near: None,
+        highlight: None,
     })
 }
 

src/db.rs

@@ -739,7 +739,10 @@ pub(crate) mod test {
                 assert_eq!(span.line, 1);
                 assert!(span.start >= 12);
                 assert!(span.end > span.start);
-                assert_eq!(span.near.as_deref(), Some("missing_col"));
+                assert!(span
+                    .highlight
+                    .as_deref()
+                    .is_some_and(|h| h.contains("missing_col")));
             }
             other => panic!("unexpected error type: {other:?}"),
         }
@@ -768,7 +771,10 @@ pub(crate) mod test {
                 assert_eq!(span.line, 1);
                 assert!(span.start >= 8);
                 assert!(span.end > span.start);
-                assert_eq!(span.near.as_deref(), Some("missing_fn(id)"));
+                assert!(span
+                    .highlight
+                    .as_deref()
+                    .is_some_and(|h| h.contains("missing_fn(id)")));
             }
             other => panic!("unexpected error type: {other:?}"),
         }

src/errors.rs

@@ -26,21 +26,31 @@ pub struct SqlErrorSpan {
     pub start: usize,
     pub end: usize,
     pub line: usize,
-    pub near: Option<String>,
+    pub highlight: Option<String>,
 }
 
 fn format_sql_error_loc(span: &Option<SqlErrorSpan>) -> String {
     span.as_ref()
         .map(|s| {
-            if let Some(near) = &s.near {
-                format!(" near '{near}' at line {}", s.line)
+            if let Some(highlight) = &s.highlight {
+                format!("\n{highlight}")
             } else {
                 format!(" at line {}, range {}..{}", s.line, s.start, s.end)
             }
         })
         .unwrap_or_default()
 }
 
+fn format_not_null_message(column: &Option<String>, span: &Option<SqlErrorSpan>) -> String {
+    match column {
+        Some(column) => format!(
+            "column: {column} cannot be null{}",
+            format_sql_error_loc(span)
+        ),
+        None => format!("cannot be null{}", format_sql_error_loc(span)),
+    }
+}
+
 #[derive(thiserror::Error, Debug)]
 pub enum DatabaseError {
     #[error("agg miss: {0}")]
@@ -160,8 +170,11 @@ pub enum DatabaseError {
     },
     #[error("no transaction begin")]
     NoTransactionBegin,
-    #[error("cannot be null")]
-    NotNull,
+    #[error("{msg}", msg = format_not_null_message(column, span))]
+    NotNull {
+        column: Option<String>,
+        span: Option<SqlErrorSpan>,
+    },
     #[error("over flow")]
     OverFlow,
     #[error("parser bool: {0}")]
@@ -291,6 +304,20 @@ impl DatabaseError {
         }
     }
 
+    pub fn not_null() -> Self {
+        Self::NotNull {
+            column: None,
+            span: None,
+        }
+    }
+
+    pub fn not_null_column(name: impl Into<String>) -> Self {
+        Self::NotNull {
+            column: Some(name.into()),
+            span: None,
+        }
+    }
+
     pub fn with_span(self, span: SqlErrorSpan) -> Self {
         match self {
             Self::CastFail { from, to, .. } => Self::CastFail {
@@ -318,15 +345,19 @@ impl DatabaseError {
                 name,
                 span: Some(span),
             },
+            Self::NotNull { column, .. } => Self::NotNull {
+                column,
+                span: Some(span),
+            },
             other => other,
         }
     }
 
     pub fn with_sql_context(self, sql: &str) -> Self {
         let annotate = |span: Option<SqlErrorSpan>| -> Option<SqlErrorSpan> {
             span.map(|mut span| {
-                if span.near.is_none() {
-                    span.near = extract_sql_near(sql, &span);
+                if span.highlight.is_none() {
+                    span.highlight = build_sql_highlight(sql, &span);
                 }
                 span
             })
@@ -358,6 +389,10 @@ impl DatabaseError {
                 name,
                 span: annotate(span),
             },
+            Self::NotNull { column, span } => Self::NotNull {
+                column,
+                span: annotate(span),
+            },
             other => other,
         }
     }
@@ -369,38 +404,48 @@ impl DatabaseError {
             | DatabaseError::ColumnNotFound { span, .. }
             | DatabaseError::InvalidTable { span, .. }
             | DatabaseError::FunctionNotFound { span, .. }
-            | DatabaseError::ParametersNotFound { span, .. } => span.as_ref(),
+            | DatabaseError::ParametersNotFound { span, .. }
+            | DatabaseError::NotNull { span, .. } => span.as_ref(),
             _ => None,
         }
     }
 }
 
-fn extract_sql_near(sql: &str, span: &SqlErrorSpan) -> Option<String> {
+fn build_sql_highlight(sql: &str, span: &SqlErrorSpan) -> Option<String> {
     if span.line == 0 || span.start == 0 {
         return None;
     }
 
-    let line = sql.lines().nth(span.line.saturating_sub(1))?;
-    let line = line.trim_end_matches('\r');
+    let lines = sql
+        .lines()
+        .map(|line| line.trim_end_matches('\r').to_string())
+        .collect::<Vec<_>>();
+    if lines.is_empty() || span.line > lines.len() {
+        return None;
+    }
 
-    let line_char_count = line.chars().count();
-    let start_idx = span.start.saturating_sub(1).min(line_char_count);
-    let end_idx = span.end.min(line_char_count).max(start_idx + 1);
+    let width = lines.len().to_string().len();
+    let mut out = String::new();
+    out.push_str(&format!("--> line {}\n", span.line));
 
-    let start_byte = char_to_byte_offset(line, start_idx)?;
-    let end_byte = char_to_byte_offset(line, end_idx)?;
-    let near = line.get(start_byte..end_byte)?.trim();
+    for (i, line) in lines.iter().enumerate() {
+        let line_no = i + 1;
+        out.push_str(&format!("{line_no:>width$} | {line}\n", width = width));
 
-    if near.is_empty() {
-        None
-    } else {
-        Some(near.to_string())
+        if line_no == span.line {
+            let char_len = line.chars().count();
+            let start = span.start.saturating_sub(1).min(char_len);
+            let end = span.end.min(char_len).max(start + 1);
+            let marker_len = end.saturating_sub(start).max(1);
+            out.push_str(&format!(
+                "{:>width$} | {}{}\n",
+                "",
+                " ".repeat(start),
+                "^".repeat(marker_len),
+                width = width
+            ));
+        }
     }
-}
 
-fn char_to_byte_offset(s: &str, char_index: usize) -> Option<usize> {
-    if char_index == s.chars().count() {
-        return Some(s.len());
-    }
-    s.char_indices().nth(char_index).map(|(idx, _)| idx)
+    Some(out.trim_end().to_string())
 }

src/execution/dml/insert.rs

@@ -96,7 +96,7 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                 .map(|(_, col)| col.key(is_mapping_by_name))
                 .collect_vec();
             if primary_keys.is_empty() {
-                throw!(co, Err(DatabaseError::NotNull))
+                throw!(co, Err(DatabaseError::not_null()))
             }
 
             if let Some(table_catalog) = throw!(
@@ -152,7 +152,8 @@ impl<'a, T: Transaction + 'a> WriteExecutor<'a, T> for Insert {
                             value.unwrap_or(DataValue::Null)
                         };
                         if value.is_null() && !col.nullable() {
-                            co.yield_(Err(DatabaseError::NotNull)).await;
+                            co.yield_(Err(DatabaseError::not_null_column(col.name().to_string())))
+                                .await;
                             return;
                         }
                         values.push(value)

src/function/numbers.rs

@@ -71,7 +71,9 @@ impl TableFunctionImpl for Numbers {
         if value.logical_type() != LogicalType::Integer {
             value = value.cast(&LogicalType::Integer)?;
         }
-        let num = value.i32().ok_or(DatabaseError::NotNull)?;
+        let num = value
+            .i32()
+            .ok_or_else(|| DatabaseError::not_null_column("numbers() arg"))?;
 
         Ok(
             Box::new((0..num).map(|i| Ok(Tuple::new(None, vec![DataValue::Int32(i)]))))

src/storage/table_codec.rs

@@ -75,7 +75,7 @@ impl TableCodec {
             return Err(DatabaseError::PrimaryKeyTooManyLayers);
         }
         if value.is_null() {
-            return Err(DatabaseError::NotNull);
+            return Err(DatabaseError::not_null_column("primary key"));
         }
 
         if let DataValue::Tuple(values, _) = &value {