perf: remove table headers from rows in query engine

joshua-spacetime · joshua-spacetime · commit 6ee852452b91 · 2023-09-12T15:45:45.000-07:00
Fixes #270
diff --git a/crates/core/src/db/datastore/locking_tx_datastore/mod.rs b/crates/core/src/db/datastore/locking_tx_datastore/mod.rs
@@ -99,8 +99,8 @@ impl traits::Data for Data {
 /// which may or may not have an associated `DataKey`.
 #[derive(Clone)]
 pub struct DataRef {
-    id: DataKey,
-    data: ProductValue,
+    pub id: DataKey,
+    pub data: ProductValue,
 }
 
 impl DataRef {
@@ -111,10 +111,6 @@ impl DataRef {
     pub fn view(&self) -> &ProductValue {
         &self.data
     }
-
-    pub fn id(&self) -> &DataKey {
-        &self.id
-    }
 }
 
 pub struct MutTxId {
diff --git a/crates/core/src/sql/execute.rs b/crates/core/src/sql/execute.rs
@@ -446,7 +446,7 @@ pub(crate) mod tests {
         let mut result = result.first().unwrap().clone();
 
         let row = product!(scalar(2u64), scalar("test"));
-        input.data.push(RelValue::new(&input.head, &row, None));
+        input.data.push(RelValue::new(row, None));
         input.data.sort();
         result.data.sort();
 
@@ -528,7 +528,7 @@ pub(crate) mod tests {
 
         let mut change = input;
         change.data.clear();
-        change.data.push(RelValue::new(&change.head, &row, None));
+        change.data.push(RelValue::new(row, None));
 
         assert_eq!(
             change.as_without_table_name(),
diff --git a/crates/core/src/subscription/query.rs b/crates/core/src/subscription/query.rs
@@ -55,7 +55,7 @@ pub fn to_mem_table(of: QueryExpr, data: &DatabaseTableUpdate) -> QueryExpr {
             let mut new = row.row.clone();
             new.elements[pos] = row.op_type.into();
             let mut bytes: &[u8] = row.row_pk.as_ref();
-            RelValue::new(&t.head, &new, Some(DataKey::decode(&mut bytes).unwrap()))
+            RelValue::new(new, Some(DataKey::decode(&mut bytes).unwrap()))
         }));
     } else {
         t.head.fields.push(Column::new(
@@ -67,7 +67,7 @@ pub fn to_mem_table(of: QueryExpr, data: &DatabaseTableUpdate) -> QueryExpr {
             new.elements.push(row.op_type.into());
             let mut bytes: &[u8] = row.row_pk.as_ref();
             t.data
-                .push(RelValue::new(&t.head, &new, Some(DataKey::decode(&mut bytes).unwrap())));
+                .push(RelValue::new(new, Some(DataKey::decode(&mut bytes).unwrap())));
         }
     }
 
diff --git a/crates/core/src/vm.rs b/crates/core/src/vm.rs
@@ -49,14 +49,16 @@ pub fn build_query<'a>(
     for q in query.query {
         result = match q {
             Query::Select(cmp) => {
-                let iter = result.select(move |row| cmp.compare(row));
+                let header = result.head().clone();
+                let iter = result.select(move |row| cmp.compare(row, &header));
                 Box::new(iter)
             }
             Query::Project(cols) => {
                 if cols.is_empty() {
                     result
                 } else {
-                    let iter = result.project(&cols.clone(), move |row| Ok(row.project(&cols)?))?;
+                    let header = result.head().clone();
+                    let iter = result.project(&cols.clone(), move |row| Ok(row.project(&cols, &header)?))?;
                     Box::new(iter)
                 }
             }
@@ -76,21 +78,25 @@ pub fn build_query<'a>(
                     }
                 };
                 let lhs = result;
+                let key_lhs_header = lhs.head().clone();
+                let key_rhs_header = rhs.head().clone();
+                let col_lhs_header = lhs.head().clone();
+                let col_rhs_header = rhs.head().clone();
 
                 let iter = lhs.join_inner(
                     rhs,
                     move |row| {
-                        let f = row.get(&key_lhs);
+                        let f = row.get(&key_lhs, &key_lhs_header);
                         Ok(f.into())
                     },
                     move |row| {
-                        let f = row.get(&key_rhs);
+                        let f = row.get(&key_rhs, &key_rhs_header);
                         Ok(f.into())
                     },
-                    move |lhs, rhs| {
-                        let lhs = lhs.get(&col_lhs);
-                        let rhs = rhs.get(&col_rhs);
-                        Ok(lhs == rhs)
+                    move |l, r| {
+                        let l = l.get(&col_lhs, &col_lhs_header);
+                        let r = r.get(&col_rhs, &col_rhs_header);
+                        Ok(l == r)
                     },
                 )?;
                 Box::new(iter)
@@ -343,7 +349,7 @@ impl RelOps for TableCursor<'_> {
     #[tracing::instrument(skip_all)]
     fn next(&mut self) -> Result<Option<RelValue>, ErrorVm> {
         if let Some(row) = self.iter.next() {
-            return Ok(Some(RelValue::new(self.head(), row.view(), Some(*row.id()))));
+            return Ok(Some(RelValue::new(row.data, Some(row.id))));
         };
         Ok(None)
     }
@@ -370,7 +376,7 @@ where
     #[tracing::instrument(skip_all)]
     fn next(&mut self) -> Result<Option<RelValue>, ErrorVm> {
         if let Some(row) = self.iter.next() {
-            return Ok(Some(RelValue::new(self.head(), &row, None)));
+            return Ok(Some(RelValue::new(row, None)));
         };
         Ok(None)
     }
diff --git a/crates/lib/src/relation.rs b/crates/lib/src/relation.rs
@@ -414,47 +414,44 @@ impl<T> RelIter<T> {
     }
 }
 
+/// A borrowed version of [RelValue].
 #[derive(Debug, Clone, Copy)]
 pub struct RelValueRef<'a> {
-    pub head: &'a Header,
     pub data: &'a ProductValue,
 }
 
 impl<'a> RelValueRef<'a> {
-    pub fn new(head: &'a Header, data: &'a ProductValue) -> Self {
-        Self { head, data }
+    pub fn new(data: &'a ProductValue) -> Self {
+        Self { data }
     }
 
-    pub fn get(&self, col: &'a FieldExpr) -> &'a AlgebraicValue {
+    pub fn get(&self, col: &'a FieldExpr, header: &'a Header) -> &'a AlgebraicValue {
         match col {
             FieldExpr::Name(col) => {
-                if let Some(pos) = self.head.column_pos(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:{}",
-                        self.head.table_name, self.head
-                    )
+                    unreachable!("Field `{col}` not found on `{}`. Fields:{}", header.table_name, header)
                 }
             }
             FieldExpr::Value(x) => x,
         }
     }
 
-    pub fn project(&self, cols: &[FieldExpr]) -> Result<ProductValue, RelationError> {
+    pub fn project(&self, cols: &[FieldExpr], header: &'a Header) -> Result<ProductValue, RelationError> {
         let mut elements = Vec::with_capacity(cols.len());
 
         for col in cols {
             match col {
                 FieldExpr::Name(col) => {
-                    if let Some(pos) = self.head.column_pos(col) {
+                    if let Some(pos) = header.column_pos(col) {
                         elements.push(self.data.elements[pos].clone());
                     } else {
-                        return Err(RelationError::FieldNotFound(self.head.clone(), col.clone()));
+                        return Err(RelationError::FieldNotFound(header.clone(), col.clone()));
                     }
                 }
                 FieldExpr::Value(col) => {
@@ -467,41 +464,29 @@ impl<'a> RelValueRef<'a> {
     }
 }
 
-impl Relation for RelValueRef<'_> {
-    fn head(&self) -> Header {
-        self.head.clone()
-    }
-
-    fn row_count(&self) -> RowCount {
-        RowCount::exact(1)
-    }
-}
-
-/// The row/tuple generated by a [Relation] operator
+/// RelValue represents a materialized row during query execution.
+/// In particular it is the type generated/consumed by a [Relation] operator.
+/// This is in contrast to a `DataRef` which represents a row belonging to a table.
+/// The difference being that a RelValue's [DataKey] is optional since relational
+/// operators can modify their input rows.
 #[derive(Debug, Clone, Eq)]
 pub struct RelValue {
     pub id: Option<DataKey>,
-    pub head: Header,
     pub data: ProductValue,
 }
 
 impl RelValue {
-    pub fn new(head: &Header, data: &ProductValue, id: Option<DataKey>) -> Self {
-        Self {
-            id,
-            head: head.clone(),
-            data: data.clone(),
-        }
+    pub fn new(data: ProductValue, id: Option<DataKey>) -> Self {
+        Self { id, data }
     }
 
     pub fn as_val_ref(&self) -> RelValueRef {
-        RelValueRef::new(&self.head, &self.data)
+        RelValueRef::new(&self.data)
     }
 
-    pub fn extend(self, head: &Header, with: RelValue) -> RelValue {
+    pub fn extend(self, with: RelValue) -> RelValue {
         let mut x = self;
         x.id = None;
-        x.head = head.clone();
         x.data.elements.extend(with.data.elements);
         x
     }
@@ -558,14 +543,14 @@ impl MemTable {
 
     pub fn from_value(of: AlgebraicValue) -> Self {
         let head = Header::for_mem_table(of.type_of().into());
-        let row = RelValue::new(&head, &of.into(), None);
+        let row = RelValue::new(of.into(), None);
         Self::new(&head, StAccess::Public, &[row])
     }
 
     pub fn from_iter(head: &Header, data: impl Iterator<Item = ProductValue>) -> Self {
         Self {
             head: head.clone(),
-            data: data.map(|row| RelValue::new(head, &row, None)).collect(),
+            data: data.map(|row| RelValue::new(row, None)).collect(),
             table_access: StAccess::Public,
         }
     }
diff --git a/crates/vm/src/eval.rs b/crates/vm/src/eval.rs
@@ -407,14 +407,16 @@ pub fn build_query(mut result: Box<IterRows>, query: Vec<Query>) -> Result<Box<I
     for q in query {
         result = match q {
             Query::Select(cmp) => {
-                let iter = result.select(move |row| cmp.compare(row));
+                let header = result.head().clone();
+                let iter = result.select(move |row| cmp.compare(row, &header));
                 Box::new(iter)
             }
             Query::Project(cols) => {
                 if cols.is_empty() {
                     result
                 } else {
-                    let iter = result.project(&cols.clone(), move |row| Ok(row.project(&cols)?))?;
+                    let header = result.head().clone();
+                    let iter = result.project(&cols.clone(), move |row| Ok(row.project(&cols, &header)?))?;
                     Box::new(iter)
                 }
             }
@@ -440,21 +442,25 @@ pub fn build_query(mut result: Box<IterRows>, query: Vec<Query>) -> Result<Box<I
                 };
 
                 let lhs = result;
+                let key_lhs_header = lhs.head().clone();
+                let key_rhs_header = rhs.head().clone();
+                let col_lhs_header = lhs.head().clone();
+                let col_rhs_header = rhs.head().clone();
 
                 let iter = lhs.join_inner(
                     rhs,
                     move |row| {
-                        let f = row.get(&key_lhs);
+                        let f = row.get(&key_lhs, &key_lhs_header);
                         Ok(f.into())
                     },
                     move |row| {
-                        let f = row.get(&key_rhs);
+                        let f = row.get(&key_rhs, &key_rhs_header);
                         Ok(f.into())
                     },
-                    move |lhs, rhs| {
-                        let lhs = lhs.get(&col_lhs);
-                        let rhs = rhs.get(&col_rhs);
-                        Ok(lhs == rhs)
+                    move |l, r| {
+                        let l = l.get(&col_lhs, &col_lhs_header);
+                        let r = r.get(&col_rhs, &col_rhs_header);
+                        Ok(l == r)
                     },
                 )?;
                 Box::new(iter)
@@ -720,7 +726,7 @@ mod tests {
         let head = q.source.head();
 
         let result = run_ast(p, q.into());
-        let row = RelValue::new(&head, &scalar(1).into(), None);
+        let row = RelValue::new(scalar(1).into(), None);
         assert_eq!(
             result,
             Code::Table(MemTable::new(&head, StAccess::Public, &[row])),
@@ -740,7 +746,7 @@ mod tests {
         let head = q.source.head();
 
         let result = run_ast(p, q.into());
-        let row = RelValue::new(&head, &input.into(), None);
+        let row = RelValue::new(input.into(), None);
         assert_eq!(
             result,
             Code::Table(MemTable::new(&head, StAccess::Public, &[row])),
diff --git a/crates/vm/src/expr.rs b/crates/vm/src/expr.rs
@@ -87,32 +87,39 @@ impl ColumnOp {
         }
     }
 
-    fn reduce(&self, row: RelValueRef, value: &ColumnOp) -> Result<AlgebraicValue, ErrorLang> {
+    fn reduce(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<AlgebraicValue, ErrorLang> {
         match value {
-            ColumnOp::Field(field) => Ok(row.get(field).clone()),
-            ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs)?.into()),
+            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) -> Result<bool, ErrorLang> {
+    fn reduce_bool(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<bool, ErrorLang> {
         match value {
             ColumnOp::Field(field) => {
-                let field = row.get(field);
+                let field = row.get(field, header);
 
                 match field.as_bool() {
                     Some(b) => Ok(*b),
                     None => Err(ErrorType::FieldBool(field.clone()).into()),
                 }
             }
-            ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs)?),
+            ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs, header)?),
         }
     }
 
-    fn compare_bin_op(&self, row: RelValueRef, op: OpQuery, lhs: &ColumnOp, rhs: &ColumnOp) -> Result<bool, ErrorVm> {
+    fn compare_bin_op(
+        &self,
+        row: RelValueRef,
+        op: OpQuery,
+        lhs: &ColumnOp,
+        rhs: &ColumnOp,
+        header: &Header,
+    ) -> Result<bool, ErrorVm> {
         match op {
             OpQuery::Cmp(op) => {
-                let lhs = self.reduce(row, lhs)?;
-                let rhs = self.reduce(row, rhs)?;
+                let lhs = self.reduce(row, lhs, header)?;
+                let rhs = self.reduce(row, rhs, header)?;
 
                 Ok(match op {
                     OpCmp::Eq => lhs == rhs,
@@ -124,8 +131,8 @@ impl ColumnOp {
                 })
             }
             OpQuery::Logic(op) => {
-                let lhs = self.reduce_bool(row, lhs)?;
-                let rhs = self.reduce_bool(row, rhs)?;
+                let lhs = self.reduce_bool(row, lhs, header)?;
+                let rhs = self.reduce_bool(row, rhs, header)?;
 
                 Ok(match op {
                     OpLogic::And => lhs && rhs,
@@ -135,13 +142,13 @@ impl ColumnOp {
         }
     }
 
-    pub fn compare(&self, row: RelValueRef) -> Result<bool, ErrorVm> {
+    pub fn compare(&self, row: RelValueRef, header: &Header) -> Result<bool, ErrorVm> {
         match self {
             ColumnOp::Field(field) => {
-                let lhs = row.get(field);
+                let lhs = row.get(field, header);
                 Ok(*lhs.as_bool().unwrap())
             }
-            ColumnOp::Cmp { op, lhs, rhs } => self.compare_bin_op(row, *op, lhs, rhs),
+            ColumnOp::Cmp { op, lhs, rhs } => self.compare_bin_op(row, *op, lhs, rhs, header),
         }
     }
 }
diff --git a/crates/vm/src/iterators.rs b/crates/vm/src/iterators.rs
diff --git a/crates/vm/src/rel_ops.rs b/crates/vm/src/rel_ops.rs

Original file line number	Diff line number	Diff line change
`@@ -99,8 +99,8 @@ impl traits::Data for Data {`
`99`	`99`	/// which may or may not have an associated `DataKey`.
`100`	`100`	`#[derive(Clone)]`
`101`	`101`	`pub struct DataRef {`
`102`		`- id: DataKey,`
`103`		`- data: ProductValue,`
	`102`	`+ pub id: DataKey,`
	`103`	`+ pub data: ProductValue,`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`impl DataRef {`
`@@ -111,10 +111,6 @@ impl DataRef {`
`111`	`111`	`pub fn view(&self) -> &ProductValue {`
`112`	`112`	`&self.data`
`113`	`113`	`}`
`114`		`-`
`115`		`- pub fn id(&self) -> &DataKey {`
`116`		`- &self.id`
`117`		`- }`
`118`	`114`	`}`
`119`	`115`
`120`	`116`	`pub struct MutTxId {`
Original file line number	Diff line number	Diff line change
`@@ -414,47 +414,44 @@ impl<T> RelIter<T> {`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
	`417`	`+/// A borrowed version of [RelValue].`
`417`	`418`	`#[derive(Debug, Clone, Copy)]`
`418`	`419`	`pub struct RelValueRef<'a> {`
`419`		`- pub head: &'a Header,`
`420`	`420`	`pub data: &'a ProductValue,`
`421`	`421`	`}`
`422`	`422`
`423`	`423`	`impl<'a> RelValueRef<'a> {`
`424`		`- pub fn new(head: &'a Header, data: &'a ProductValue) -> Self {`
`425`		`- Self { head, data }`
	`424`	`+ pub fn new(data: &'a ProductValue) -> Self {`
	`425`	`+ Self { data }`
`426`	`426`	`}`
`427`	`427`
`428`		`- pub fn get(&self, col: &'a FieldExpr) -> &'a AlgebraicValue {`
	`428`	`+ pub fn get(&self, col: &'a FieldExpr, header: &'a Header) -> &'a AlgebraicValue {`
`429`	`429`	`match col {`
`430`	`430`	`FieldExpr::Name(col) => {`
`431`		`- if let Some(pos) = self.head.column_pos(col) {`
	`431`	`+ if let Some(pos) = header.column_pos(col) {`
`432`	`432`	`if let Some(v) = self.data.elements.get(pos) {`
`433`	`433`	`v`
`434`	`434`	`} else {`
`435`	`435`	unreachable!("Field `{col}` at pos {pos} not found on row: {:?}", self.data.elements)
`436`	`436`	`}`
`437`	`437`	`} else {`
`438`		`- unreachable!(`
`439`		- "Field `{col}` not found on `{}`. Fields:{}",
`440`		`- self.head.table_name, self.head`
`441`		`- )`
	`438`	+ unreachable!("Field `{col}` not found on `{}`. Fields:{}", header.table_name, header)
`442`	`439`	`}`
`443`	`440`	`}`
`444`	`441`	`FieldExpr::Value(x) => x,`
`445`	`442`	`}`
`446`	`443`	`}`
`447`	`444`
`448`		`- pub fn project(&self, cols: &[FieldExpr]) -> Result<ProductValue, RelationError> {`
	`445`	`+ pub fn project(&self, cols: &[FieldExpr], header: &'a Header) -> Result<ProductValue, RelationError> {`
`449`	`446`	`let mut elements = Vec::with_capacity(cols.len());`
`450`	`447`
`451`	`448`	`for col in cols {`
`452`	`449`	`match col {`
`453`	`450`	`FieldExpr::Name(col) => {`
`454`		`- if let Some(pos) = self.head.column_pos(col) {`
	`451`	`+ if let Some(pos) = header.column_pos(col) {`
`455`	`452`	`elements.push(self.data.elements[pos].clone());`
`456`	`453`	`} else {`
`457`		`- return Err(RelationError::FieldNotFound(self.head.clone(), col.clone()));`
	`454`	`+ return Err(RelationError::FieldNotFound(header.clone(), col.clone()));`
`458`	`455`	`}`
`459`	`456`	`}`
`460`	`457`	`FieldExpr::Value(col) => {`
`@@ -467,41 +464,29 @@ impl<'a> RelValueRef<'a> {`
`467`	`464`	`}`
`468`	`465`	`}`
`469`	`466`
`470`		`-impl Relation for RelValueRef<'_> {`
`471`		`- fn head(&self) -> Header {`
`472`		`- self.head.clone()`
`473`		`- }`
`474`		`-`
`475`		`- fn row_count(&self) -> RowCount {`
`476`		`- RowCount::exact(1)`
`477`		`- }`
`478`		`-}`
`479`		`-`
`480`		`-/// The row/tuple generated by a [Relation] operator`
	`467`	`+/// RelValue represents a materialized row during query execution.`
	`468`	`+/// In particular it is the type generated/consumed by a [Relation] operator.`
	`469`	+/// This is in contrast to a `DataRef` which represents a row belonging to a table.
	`470`	`+/// The difference being that a RelValue's [DataKey] is optional since relational`
	`471`	`+/// operators can modify their input rows.`
`481`	`472`	`#[derive(Debug, Clone, Eq)]`
`482`	`473`	`pub struct RelValue {`
`483`	`474`	`pub id: Option<DataKey>,`
`484`		`- pub head: Header,`
`485`	`475`	`pub data: ProductValue,`
`486`	`476`	`}`
`487`	`477`
`488`	`478`	`impl RelValue {`
`489`		`- pub fn new(head: &Header, data: &ProductValue, id: Option<DataKey>) -> Self {`
`490`		`- Self {`
`491`		`- id,`
`492`		`- head: head.clone(),`
`493`		`- data: data.clone(),`
`494`		`- }`
	`479`	`+ pub fn new(data: ProductValue, id: Option<DataKey>) -> Self {`
	`480`	`+ Self { id, data }`
`495`	`481`	`}`
`496`	`482`
`497`	`483`	`pub fn as_val_ref(&self) -> RelValueRef {`
`498`		`- RelValueRef::new(&self.head, &self.data)`
	`484`	`+ RelValueRef::new(&self.data)`
`499`	`485`	`}`
`500`	`486`
`501`		`- pub fn extend(self, head: &Header, with: RelValue) -> RelValue {`
	`487`	`+ pub fn extend(self, with: RelValue) -> RelValue {`
`502`	`488`	`let mut x = self;`
`503`	`489`	`x.id = None;`
`504`		`- x.head = head.clone();`
`505`	`490`	`x.data.elements.extend(with.data.elements);`
`506`	`491`	`x`
`507`	`492`	`}`
`@@ -558,14 +543,14 @@ impl MemTable {`
`558`	`543`
`559`	`544`	`pub fn from_value(of: AlgebraicValue) -> Self {`
`560`	`545`	`let head = Header::for_mem_table(of.type_of().into());`
`561`		`- let row = RelValue::new(&head, &of.into(), None);`
	`546`	`+ let row = RelValue::new(of.into(), None);`
`562`	`547`	`Self::new(&head, StAccess::Public, &[row])`
`563`	`548`	`}`
`564`	`549`
`565`	`550`	`pub fn from_iter(head: &Header, data: impl Iterator<Item = ProductValue>) -> Self {`
`566`	`551`	`Self {`
`567`	`552`	`head: head.clone(),`
`568`		`- data: data.map(\|row\| RelValue::new(head, &row, None)).collect(),`
	`553`	`+ data: data.map(\|row\| RelValue::new(row, None)).collect(),`
`569`	`554`	`table_access: StAccess::Public,`
`570`	`555`	`}`
`571`	`556`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,32 +87,39 @@ impl ColumnOp {`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`		`- fn reduce(&self, row: RelValueRef, value: &ColumnOp) -> Result<AlgebraicValue, ErrorLang> {`
	`90`	`+ fn reduce(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<AlgebraicValue, ErrorLang> {`
`91`	`91`	`match value {`
`92`		`- ColumnOp::Field(field) => Ok(row.get(field).clone()),`
`93`		`- ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs)?.into()),`
	`92`	`+ ColumnOp::Field(field) => Ok(row.get(field, header).clone()),`
	`93`	`+ ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs, header)?.into()),`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`		`- fn reduce_bool(&self, row: RelValueRef, value: &ColumnOp) -> Result<bool, ErrorLang> {`
	`97`	`+ fn reduce_bool(&self, row: RelValueRef, value: &ColumnOp, header: &Header) -> Result<bool, ErrorLang> {`
`98`	`98`	`match value {`
`99`	`99`	`ColumnOp::Field(field) => {`
`100`		`- let field = row.get(field);`
	`100`	`+ let field = row.get(field, header);`
`101`	`101`
`102`	`102`	`match field.as_bool() {`
`103`	`103`	`Some(b) => Ok(*b),`
`104`	`104`	`None => Err(ErrorType::FieldBool(field.clone()).into()),`
`105`	`105`	`}`
`106`	`106`	`}`
`107`		`- ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs)?),`
	`107`	`+ ColumnOp::Cmp { op, lhs, rhs } => Ok(self.compare_bin_op(row, *op, lhs, rhs, header)?),`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- fn compare_bin_op(&self, row: RelValueRef, op: OpQuery, lhs: &ColumnOp, rhs: &ColumnOp) -> Result<bool, ErrorVm> {`
	`111`	`+ fn compare_bin_op(`
	`112`	`+ &self,`
	`113`	`+ row: RelValueRef,`
	`114`	`+ op: OpQuery,`
	`115`	`+ lhs: &ColumnOp,`
	`116`	`+ rhs: &ColumnOp,`
	`117`	`+ header: &Header,`
	`118`	`+ ) -> Result<bool, ErrorVm> {`
`112`	`119`	`match op {`
`113`	`120`	`OpQuery::Cmp(op) => {`
`114`		`- let lhs = self.reduce(row, lhs)?;`
`115`		`- let rhs = self.reduce(row, rhs)?;`
	`121`	`+ let lhs = self.reduce(row, lhs, header)?;`
	`122`	`+ let rhs = self.reduce(row, rhs, header)?;`
`116`	`123`
`117`	`124`	`Ok(match op {`
`118`	`125`	`OpCmp::Eq => lhs == rhs,`
`@@ -124,8 +131,8 @@ impl ColumnOp {`
`124`	`131`	`})`
`125`	`132`	`}`
`126`	`133`	`OpQuery::Logic(op) => {`
`127`		`- let lhs = self.reduce_bool(row, lhs)?;`
`128`		`- let rhs = self.reduce_bool(row, rhs)?;`
	`134`	`+ let lhs = self.reduce_bool(row, lhs, header)?;`
	`135`	`+ let rhs = self.reduce_bool(row, rhs, header)?;`
`129`	`136`
`130`	`137`	`Ok(match op {`
`131`	`138`	`OpLogic::And => lhs && rhs,`
`@@ -135,13 +142,13 @@ impl ColumnOp {`
`135`	`142`	`}`
`136`	`143`	`}`
`137`	`144`
`138`		`- pub fn compare(&self, row: RelValueRef) -> Result<bool, ErrorVm> {`
	`145`	`+ pub fn compare(&self, row: RelValueRef, header: &Header) -> Result<bool, ErrorVm> {`
`139`	`146`	`match self {`
`140`	`147`	`ColumnOp::Field(field) => {`
`141`		`- let lhs = row.get(field);`
	`148`	`+ let lhs = row.get(field, header);`
`142`	`149`	`Ok(*lhs.as_bool().unwrap())`
`143`	`150`	`}`
`144`		`- ColumnOp::Cmp { op, lhs, rhs } => self.compare_bin_op(row, *op, lhs, rhs),`
	`151`	`+ ColumnOp::Cmp { op, lhs, rhs } => self.compare_bin_op(row, *op, lhs, rhs, header),`
`145`	`152`	`}`
`146`	`153`	`}`
`147`	`154`	`}`