diff --git a/core/function.rs b/core/function.rs index 2b8be15c7..7f7545f3d 100644 --- a/core/function.rs +++ b/core/function.rs @@ -26,7 +26,7 @@ impl AggFunc { } #[derive(Debug, Clone, PartialEq)] -pub enum SingleRowFunc { +pub enum ScalarFunc { Coalesce, Like, Abs, @@ -41,21 +41,21 @@ pub enum SingleRowFunc { Date, } -impl ToString for SingleRowFunc { +impl ToString for ScalarFunc { fn to_string(&self) -> String { match self { - SingleRowFunc::Coalesce => "coalesce".to_string(), - SingleRowFunc::Like => "like(2)".to_string(), - SingleRowFunc::Abs => "abs".to_string(), - SingleRowFunc::Upper => "upper".to_string(), - SingleRowFunc::Lower => "lower".to_string(), - SingleRowFunc::Random => "random".to_string(), - SingleRowFunc::Trim => "trim".to_string(), - SingleRowFunc::Round => "round".to_string(), - SingleRowFunc::Length => "length".to_string(), - SingleRowFunc::Min => "min".to_string(), - SingleRowFunc::Max => "max".to_string(), - SingleRowFunc::Date => "date".to_string(), + ScalarFunc::Coalesce => "coalesce".to_string(), + ScalarFunc::Like => "like(2)".to_string(), + ScalarFunc::Abs => "abs".to_string(), + ScalarFunc::Upper => "upper".to_string(), + ScalarFunc::Lower => "lower".to_string(), + ScalarFunc::Random => "random".to_string(), + ScalarFunc::Trim => "trim".to_string(), + ScalarFunc::Round => "round".to_string(), + ScalarFunc::Length => "length".to_string(), + ScalarFunc::Min => "min".to_string(), + ScalarFunc::Max => "max".to_string(), + ScalarFunc::Date => "date".to_string(), } } } @@ -63,7 +63,7 @@ impl ToString for SingleRowFunc { #[derive(Debug)] pub enum Func { Agg(AggFunc), - SingleRow(SingleRowFunc), + Scalar(ScalarFunc), } impl Func { @@ -73,22 +73,22 @@ impl Func { "count" => Ok(Func::Agg(AggFunc::Count)), "group_concat" => Ok(Func::Agg(AggFunc::GroupConcat)), "max" if arg_count == 0 || arg_count == 1 => Ok(Func::Agg(AggFunc::Max)), - "max" if arg_count > 1 => Ok(Func::SingleRow(SingleRowFunc::Max)), + "max" if arg_count > 1 => Ok(Func::Scalar(ScalarFunc::Max)), "min" if arg_count == 0 || arg_count == 1 => Ok(Func::Agg(AggFunc::Min)), - "min" if arg_count > 1 => Ok(Func::SingleRow(SingleRowFunc::Min)), + "min" if arg_count > 1 => Ok(Func::Scalar(ScalarFunc::Min)), "string_agg" => Ok(Func::Agg(AggFunc::StringAgg)), "sum" => Ok(Func::Agg(AggFunc::Sum)), "total" => Ok(Func::Agg(AggFunc::Total)), - "coalesce" => Ok(Func::SingleRow(SingleRowFunc::Coalesce)), - "like" => Ok(Func::SingleRow(SingleRowFunc::Like)), - "abs" => Ok(Func::SingleRow(SingleRowFunc::Abs)), - "upper" => Ok(Func::SingleRow(SingleRowFunc::Upper)), - "lower" => Ok(Func::SingleRow(SingleRowFunc::Lower)), - "random" => Ok(Func::SingleRow(SingleRowFunc::Random)), - "trim" => Ok(Func::SingleRow(SingleRowFunc::Trim)), - "round" => Ok(Func::SingleRow(SingleRowFunc::Round)), - "length" => Ok(Func::SingleRow(SingleRowFunc::Length)), - "date" => Ok(Func::SingleRow(SingleRowFunc::Date)), + "coalesce" => Ok(Func::Scalar(ScalarFunc::Coalesce)), + "like" => Ok(Func::Scalar(ScalarFunc::Like)), + "abs" => Ok(Func::Scalar(ScalarFunc::Abs)), + "upper" => Ok(Func::Scalar(ScalarFunc::Upper)), + "lower" => Ok(Func::Scalar(ScalarFunc::Lower)), + "random" => Ok(Func::Scalar(ScalarFunc::Random)), + "trim" => Ok(Func::Scalar(ScalarFunc::Trim)), + "round" => Ok(Func::Scalar(ScalarFunc::Round)), + "length" => Ok(Func::Scalar(ScalarFunc::Length)), + "date" => Ok(Func::Scalar(ScalarFunc::Date)), _ => Err(()), } } diff --git a/core/translate/expr.rs b/core/translate/expr.rs index 393f93d9f..5bde1f144 100644 --- a/core/translate/expr.rs +++ b/core/translate/expr.rs @@ -2,7 +2,7 @@ use anyhow::Result; use sqlite3_parser::ast::{self, Expr, UnaryOperator}; use crate::{ - function::{Func, SingleRowFunc}, + function::{Func, ScalarFunc}, schema::{Schema, Table, Type}, translate::select::{ColumnInfo, Select, SrcTable}, util::normalize_ident, @@ -237,9 +237,9 @@ pub fn translate_expr( Some(Func::Agg(_)) => { anyhow::bail!("Parse error: aggregation function in non-aggregation context") } - Some(Func::SingleRow(srf)) => { + Some(Func::Scalar(srf)) => { match srf { - SingleRowFunc::Coalesce => { + ScalarFunc::Coalesce => { let args = if let Some(args) = args { if args.len() < 2 { anyhow::bail!( @@ -280,7 +280,7 @@ pub fn translate_expr( Ok(target_register) } - SingleRowFunc::Like => { + ScalarFunc::Like => { let args = if let Some(args) = args { if args.len() < 2 { anyhow::bail!( @@ -310,10 +310,10 @@ pub fn translate_expr( }); Ok(target_register) } - SingleRowFunc::Abs - | SingleRowFunc::Lower - | SingleRowFunc::Upper - | SingleRowFunc::Length => { + ScalarFunc::Abs + | ScalarFunc::Lower + | ScalarFunc::Upper + | ScalarFunc::Length => { let args = if let Some(args) = args { if args.len() != 1 { anyhow::bail!( @@ -338,7 +338,7 @@ pub fn translate_expr( }); Ok(target_register) } - SingleRowFunc::Random => { + ScalarFunc::Random => { if args.is_some() { anyhow::bail!( "Parse error: {} function with arguments", @@ -353,7 +353,7 @@ pub fn translate_expr( }); Ok(target_register) } - SingleRowFunc::Date => { + ScalarFunc::Date => { let mut start_reg = 0; if let Some(args) = args { if args.len() > 1 { @@ -373,11 +373,11 @@ pub fn translate_expr( program.emit_insn(Insn::Function { start_reg: start_reg, dest: target_register, - func: SingleRowFunc::Date, + func: ScalarFunc::Date, }); Ok(target_register) } - SingleRowFunc::Trim | SingleRowFunc::Round => { + ScalarFunc::Trim | ScalarFunc::Round => { let args = if let Some(args) = args { if args.len() > 2 { anyhow::bail!( @@ -407,7 +407,7 @@ pub fn translate_expr( }); Ok(target_register) } - SingleRowFunc::Min => { + ScalarFunc::Min => { let args = if let Some(args) = args { if args.len() < 1 { anyhow::bail!( @@ -430,11 +430,11 @@ pub fn translate_expr( program.emit_insn(Insn::Function { start_reg: target_register + 1, dest: target_register, - func: SingleRowFunc::Min, + func: ScalarFunc::Min, }); Ok(target_register) } - SingleRowFunc::Max => { + ScalarFunc::Max => { let args = if let Some(args) = args { if args.len() < 1 { anyhow::bail!( @@ -457,7 +457,7 @@ pub fn translate_expr( program.emit_insn(Insn::Function { start_reg: target_register + 1, dest: target_register, - func: SingleRowFunc::Max, + func: ScalarFunc::Max, }); Ok(target_register) } diff --git a/core/translate/mod.rs b/core/translate/mod.rs index 70ea5600d..0482fed79 100644 --- a/core/translate/mod.rs +++ b/core/translate/mod.rs @@ -551,7 +551,7 @@ fn translate_aggregation( let empty_args = &Vec::::new(); let args = info.args.as_ref().unwrap_or(empty_args); let dest = match func { - Func::SingleRow(_) => anyhow::bail!("Parse error: single row function in aggregation"), + Func::Scalar(_) => anyhow::bail!("Parse error: single row function in aggregation"), Func::Agg(agg_func) => match agg_func { AggFunc::Avg => { if args.len() != 1 { diff --git a/core/translate/where_clause.rs b/core/translate/where_clause.rs index 7e912f515..6895d3331 100644 --- a/core/translate/where_clause.rs +++ b/core/translate/where_clause.rs @@ -2,7 +2,7 @@ use anyhow::Result; use sqlite3_parser::ast::{self}; use crate::{ - function::SingleRowFunc, + function::ScalarFunc, translate::expr::{resolve_ident_qualified, resolve_ident_table, translate_expr}, translate::select::Select, vdbe::{builder::ProgramBuilder, BranchOffset, Insn}, @@ -408,7 +408,7 @@ fn translate_condition_expr( program.mark_last_insn_constant(); let _ = translate_expr(program, select, lhs, column_reg, cursor_hint)?; program.emit_insn(Insn::Function { - func: SingleRowFunc::Like, + func: ScalarFunc::Like, start_reg: pattern_reg, dest: cur_reg, }); diff --git a/core/vdbe/mod.rs b/core/vdbe/mod.rs index d512c6e72..8657ea34d 100644 --- a/core/vdbe/mod.rs +++ b/core/vdbe/mod.rs @@ -4,7 +4,7 @@ pub mod sorter; use crate::btree::BTreeCursor; use crate::datetime::get_date_from_time_value; -use crate::function::{AggFunc, SingleRowFunc}; +use crate::function::{AggFunc, ScalarFunc}; use crate::pager::Pager; use crate::pseudo::PseudoCursor; use crate::schema::Table; @@ -255,9 +255,9 @@ pub enum Insn { // Function Function { // constant_mask: i32, // P1, not used for now - start_reg: usize, // P2, start of argument registers - dest: usize, // P3 - func: SingleRowFunc, // P4 + start_reg: usize, // P2, start of argument registers + dest: usize, // P3 + func: ScalarFunc, // P4 }, } @@ -1025,8 +1025,8 @@ impl Program { start_reg, dest, } => match func { - SingleRowFunc::Coalesce => {} - SingleRowFunc::Like => { + ScalarFunc::Coalesce => {} + ScalarFunc::Like => { let start_reg = *start_reg; assert!( start_reg + 2 <= state.registers.len(), @@ -1047,7 +1047,7 @@ impl Program { state.registers[*dest] = result; state.pc += 1; } - SingleRowFunc::Abs => { + ScalarFunc::Abs => { let reg_value = state.registers[*start_reg].borrow_mut(); if let Some(value) = exec_abs(reg_value) { state.registers[*dest] = value; @@ -1056,7 +1056,7 @@ impl Program { } state.pc += 1; } - SingleRowFunc::Upper => { + ScalarFunc::Upper => { let reg_value = state.registers[*start_reg].borrow_mut(); if let Some(value) = exec_upper(reg_value) { state.registers[*dest] = value; @@ -1065,7 +1065,7 @@ impl Program { } state.pc += 1; } - SingleRowFunc::Lower => { + ScalarFunc::Lower => { let reg_value = state.registers[*start_reg].borrow_mut(); if let Some(value) = exec_lower(reg_value) { state.registers[*dest] = value; @@ -1074,16 +1074,16 @@ impl Program { } state.pc += 1; } - SingleRowFunc::Length => { + ScalarFunc::Length => { let reg_value = state.registers[*start_reg].borrow_mut(); state.registers[*dest] = exec_length(reg_value); state.pc += 1; } - SingleRowFunc::Random => { + ScalarFunc::Random => { state.registers[*dest] = exec_random(); state.pc += 1; } - SingleRowFunc::Trim => { + ScalarFunc::Trim => { let start_reg = *start_reg; let reg_value = state.registers[start_reg].clone(); let pattern_value = state.registers.get(start_reg + 1).cloned(); @@ -1093,7 +1093,7 @@ impl Program { state.registers[*dest] = result; state.pc += 1; } - SingleRowFunc::Round => { + ScalarFunc::Round => { let start_reg = *start_reg; let reg_value = state.registers[start_reg].clone(); let precision_value = state.registers.get(start_reg + 1).cloned(); @@ -1101,7 +1101,7 @@ impl Program { state.registers[*dest] = result; state.pc += 1; } - SingleRowFunc::Min => { + ScalarFunc::Min => { let start_reg = *start_reg; let reg_values = state.registers[start_reg..state.registers.len()] .iter() @@ -1114,7 +1114,7 @@ impl Program { } state.pc += 1; } - SingleRowFunc::Max => { + ScalarFunc::Max => { let start_reg = *start_reg; let reg_values = state.registers[start_reg..state.registers.len()] .iter() @@ -1127,7 +1127,7 @@ impl Program { } state.pc += 1; } - SingleRowFunc::Date => { + ScalarFunc::Date => { if *start_reg == 0 { let date_str = get_date_from_time_value(&OwnedValue::Text(Rc::new( "now".to_string(),