lib: Don't panic in RelValueRef::get (#450)

There is no guarantee that a named field is in the supplied table
header, nor that it is in the row. Panicking at this location can be
disastrous, while all call sites are inside Result already. So, return
Result.

crates/core/src/vm.rs

@@ -112,16 +112,16 @@ fn join_inner<'a>(
         rhs,
         header,
         move |row| {
-            let f = row.get(&key_lhs, &key_lhs_header);
+            let f = row.get(&key_lhs, &key_lhs_header)?;
             Ok(f.into())
         },
         move |row| {
-            let f = row.get(&key_rhs, &key_rhs_header);
+            let f = row.get(&key_rhs, &key_rhs_header)?;
             Ok(f.into())
         },
         move |l, r| {
-            let l = l.get(&col_lhs, &col_lhs_header);
-            let r = r.get(&col_rhs, &col_rhs_header);
+            let l = l.get(&col_lhs, &col_lhs_header)?;
+            let r = r.get(&col_rhs, &col_rhs_header)?;
             Ok(l == r)
         },
         move |l, r| {

crates/lib/src/error.rs

@@ -120,6 +120,8 @@ pub enum AuthError {
 pub enum RelationError {
     #[error("Field `{1}` not found. Must be one of {0}")]
     FieldNotFound(Header, FieldName),
+    #[error("Field `{1}` not found at position {0}")]
+    FieldNotFoundAtPos(usize, FieldName),
     #[error("Field `{0}` fail to infer the type: {1}")]
     TypeInference(FieldName, TypeError),
     #[error("Field declaration only support `table.field` or `field`. It gets instead `{0}`")]

crates/lib/src/relation.rs

@@ -416,21 +416,21 @@ impl<'a> RelValueRef<'a> {
         Self { data }
     }
 
-    pub fn get(&self, col: &'a FieldExpr, header: &'a Header) -> &'a AlgebraicValue {
-        match col {
+    pub fn get(&self, col: &'a FieldExpr, header: &'a Header) -> Result<&'a AlgebraicValue, RelationError> {
+        let val = match col {
             FieldExpr::Name(col) => {
-                if let Some(pos) = header.column_pos(col) {
-                    if let Some(v) = self.data.elements.get(pos) {
-                        v
-                    } else {
-                        unreachable!("Field `{col}` at pos {pos} not found on row: {:?}", self.data.elements)
-                    }
-                } else {
-                    unreachable!("Field `{col}` not found on `{}`. Fields:{}", header.table_name, header)
-                }
+                let pos = header
+                    .column_pos(col)
+                    .ok_or_else(|| RelationError::FieldNotFound(header.clone(), col.clone()))?;
+                self.data
+                    .elements
+                    .get(pos)
+                    .ok_or_else(|| RelationError::FieldNotFoundAtPos(pos, col.clone()))?
             }
             FieldExpr::Value(x) => x,
-        }
+        };
+
+        Ok(val)
     }
 
     pub fn project(&self, cols: &[FieldExpr], header: &'a Header) -> Result<ProductValue, RelationError> {

crates/vm/src/eval.rs

@@ -458,16 +458,16 @@ pub fn build_query(mut result: Box<IterRows>, query: Vec<Query>) -> Result<Box<I
                     rhs,
                     col_lhs_header.extend(&col_rhs_header),
                     move |row| {
-                        let f = row.get(&key_lhs, &key_lhs_header);
+                        let f = row.get(&key_lhs, &key_lhs_header)?;
                         Ok(f.into())
                     },
                     move |row| {
-                        let f = row.get(&key_rhs, &key_rhs_header);
+                        let f = row.get(&key_rhs, &key_rhs_header)?;
                         Ok(f.into())
                     },
                     move |l, r| {
-                        let l = l.get(&col_lhs, &col_lhs_header);
-                        let r = r.get(&col_rhs, &col_rhs_header);
+                        let l = l.get(&col_lhs, &col_lhs_header)?;
+                        let r = r.get(&col_rhs, &col_rhs_header)?;
                         Ok(l == r)
                     },
                     move |l, r| l.extend(r),

crates/vm/src/expr.rs

@@ -100,15 +100,15 @@ impl ColumnOp {
 
     fn reduce(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<AlgebraicValue, ErrorLang> {
         match value {
-            ColumnOp::Field(field) => Ok(row.get(field, header).clone()),
+            ColumnOp::Field(field) => Ok(row.get(field, header)?.clone()),
             ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs, header)?.into()),
         }
     }
 
     fn reduce_bool(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<bool, ErrorLang> {
         match value {
             ColumnOp::Field(field) => {
-                let field = row.get(field, header);
+                let field = row.get(field, header)?;
 
                 match field.as_bool() {
                     Some(b) => Ok(*b),
@@ -156,7 +156,7 @@ impl ColumnOp {
     pub fn compare(&self, row: RelValueRef, header: &Header) -> Result<bool, ErrorVm> {
         match self {
             ColumnOp::Field(field) => {
-                let lhs = row.get(field, header);
+                let lhs = row.get(field, header)?;
                 Ok(*lhs.as_bool().unwrap())
             }
             ColumnOp::Cmp { op, lhs, rhs } => self.compare_bin_op(row, *op, lhs, rhs, header),