feat: support for Values (#286)

* Values are now supported by creating separate plans and changing aliases

* Modified the method of determining the type of column in values to support automatic conversion of the maximum type. Added tests for values

* fmt

* temp_table_name added to represent the data source

* Improve the logic

* chore: codefmt

---------

Co-authored-by: Kould <kould2333@gmail.com>

Author: wszhdshys

src/binder/select.rs

@@ -1,7 +1,3 @@
-use std::borrow::Borrow;
-use std::collections::HashSet;
-use std::sync::Arc;
-
 use crate::{
     expression::ScalarExpression,
     planner::{
@@ -13,15 +9,21 @@ use crate::{
     },
     types::value::DataValue,
 };
+use std::borrow::Borrow;
+use std::collections::HashSet;
+use std::sync::Arc;
 
 use super::{
     lower_case_name, lower_ident, Binder, BinderContext, QueryBindStep, Source, SubQueryType,
 };
 
-use crate::catalog::{ColumnCatalog, ColumnRef, ColumnSummary, TableName};
+use crate::catalog::{ColumnCatalog, ColumnDesc, ColumnRef, ColumnSummary, TableName};
 use crate::errors::DatabaseError;
 use crate::execution::dql::join::joins_nullable;
 use crate::expression::agg::AggKind;
+use crate::expression::simplify::ConstantCalculator;
+use crate::expression::visitor_mut::VisitorMut;
+use crate::expression::ScalarExpression::Constant;
 use crate::expression::{AliasType, BinaryOperator};
 use crate::planner::operator::aggregate::AggregateOperator;
 use crate::planner::operator::except::ExceptOperator;
@@ -59,6 +61,7 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                 left,
                 right,
             } => self.bind_set_operation(op, set_quantifier, left, right),
+            SetExpr::Values(values) => self.bind_temp_values(&values.rows),
             expr => {
                 return Err(DatabaseError::UnsupportedStmt(format!(
                     "query body: {:?}",
@@ -156,6 +159,64 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
         Ok(plan)
     }
 
+    fn bind_temp_values(
+        &mut self,
+        expr_rows: &Vec<Vec<Expr>>,
+    ) -> Result<LogicalPlan, DatabaseError> {
+        let values_len = expr_rows[0].len();
+
+        let mut inferred_types: Vec<Option<LogicalType>> = vec![None; values_len];
+        let mut rows = Vec::with_capacity(expr_rows.len());
+
+        for expr_row in expr_rows.iter() {
+            if expr_row.len() != values_len {
+                return Err(DatabaseError::ValuesLenMismatch(expr_row.len(), values_len));
+            }
+
+            let mut row = Vec::with_capacity(values_len);
+
+            for (col_index, expr) in expr_row.iter().enumerate() {
+                let mut expression = self.bind_expr(expr)?;
+                ConstantCalculator.visit(&mut expression)?;
+
+                if let Constant(value) = expression {
+                    let value_type = value.logical_type();
+
+                    inferred_types[col_index] = match &inferred_types[col_index] {
+                        Some(existing) => {
+                            Some(LogicalType::max_logical_type(existing, &value_type)?)
+                        }
+                        None => Some(value_type),
+                    };
+
+                    row.push(value);
+                } else {
+                    return Err(DatabaseError::ColumnsEmpty);
+                }
+            }
+
+            rows.push(row);
+        }
+
+        let value_name = self.context.temp_table();
+        let column_refs: Vec<ColumnRef> = inferred_types
+            .into_iter()
+            .enumerate()
+            .map(|(col_index, typ)| {
+                let typ = typ.ok_or(DatabaseError::InvalidType)?;
+                let mut column_ref = ColumnCatalog::new(
+                    col_index.to_string(),
+                    false,
+                    ColumnDesc::new(typ, None, false, None)?,
+                );
+                column_ref.set_ref_table(value_name.clone(), ColumnId::default(), true);
+                Ok(ColumnRef(Arc::new(column_ref)))
+            })
+            .collect::<Result<_, DatabaseError>>()?;
+
+        Ok(self.bind_values(rows, Arc::new(column_refs)))
+    }
+
     fn bind_set_cast(
         &self,
         mut left_plan: LogicalPlan,
@@ -356,9 +417,9 @@ impl<'a: 'b, 'b, T: Transaction, A: AsRef<[(&'static str, DataValue)]>> Binder<'
                         ));
                     }
                     let table_alias = Arc::new(name.value.to_lowercase());
+                    let table = tables.pop().unwrap_or_else(|| self.context.temp_table());
 
-                    plan =
-                        self.bind_alias(plan, alias_column, table_alias, tables.pop().unwrap())?;
+                    plan = self.bind_alias(plan, alias_column, table_alias, table)?;
                 }
                 plan
             }

src/types/mod.rs

@@ -407,8 +407,9 @@ impl TryFrom<sqlparser::ast::DataType> for LogicalType {
             sqlparser::ast::DataType::String | sqlparser::ast::DataType::Text => {
                 Ok(LogicalType::Varchar(None, CharLengthUnits::Characters))
             }
-            sqlparser::ast::DataType::Float(_) => Ok(LogicalType::Float),
-            sqlparser::ast::DataType::Real => Ok(LogicalType::Float),
+            sqlparser::ast::DataType::Float(_) | sqlparser::ast::DataType::Real => {
+                Ok(LogicalType::Float)
+            }
             sqlparser::ast::DataType::Double | sqlparser::ast::DataType::DoublePrecision => {
                 Ok(LogicalType::Double)
             }
@@ -438,7 +439,7 @@ impl TryFrom<sqlparser::ast::DataType> for LogicalType {
                     Some(0..5) | None => (),
                     _ => {
                         return Err(DatabaseError::UnsupportedStmt(
-                            "time's precision must less than 5".to_string(),
+                            "time's precision must be less than 5".to_string(),
                         ))
                     }
                 }
@@ -455,7 +456,7 @@ impl TryFrom<sqlparser::ast::DataType> for LogicalType {
                     Some(3 | 6 | 9) | None => (),
                     _ => {
                         return Err(DatabaseError::UnsupportedStmt(
-                            "timestamp's precision must 3,6,9".to_string(),
+                            "timestamp's precision must be 3,6,9".to_string(),
                         ))
                     }
                 }
@@ -464,15 +465,15 @@ impl TryFrom<sqlparser::ast::DataType> for LogicalType {
                 }
                 Ok(LogicalType::TimeStamp(precision, zone))
             }
-            sqlparser::ast::DataType::Decimal(info) | sqlparser::ast::DataType::Dec(info) => {
-                match info {
-                    ExactNumberInfo::None => Ok(Self::Decimal(None, None)),
-                    ExactNumberInfo::Precision(p) => Ok(Self::Decimal(Some(p as u8), None)),
-                    ExactNumberInfo::PrecisionAndScale(p, s) => {
-                        Ok(Self::Decimal(Some(p as u8), Some(s as u8)))
-                    }
+            sqlparser::ast::DataType::Decimal(info)
+            | sqlparser::ast::DataType::Dec(info)
+            | sqlparser::ast::DataType::Numeric(info) => match info {
+                ExactNumberInfo::None => Ok(Self::Decimal(None, None)),
+                ExactNumberInfo::Precision(p) => Ok(Self::Decimal(Some(p as u8), None)),
+                ExactNumberInfo::PrecisionAndScale(p, s) => {
+                    Ok(Self::Decimal(Some(p as u8), Some(s as u8)))
                 }
-            }
+            },
             other => Err(DatabaseError::UnsupportedStmt(format!(
                 "unsupported data type: {other}"
             ))),

tests/slt/crdb/join.slt

@@ -174,9 +174,10 @@ null 43
 # query
 # SELECT * FROM onecolumn AS a NATURAL FULL OUTER JOIN othercolumn AS b ORDER BY x
 
-# TODO: Join Values
-# query
-# SELECT * FROM (SELECT x FROM onecolumn ORDER BY x DESC) NATURAL JOIN (VALUES (42)) AS v(x) LIMIT 1
+query II
+SELECT * FROM (SELECT x FROM onecolumn ORDER BY x DESC) NATURAL JOIN (VALUES (42)) AS v(x) LIMIT 1
+----
+null 42
 
 statement ok
 drop table if exists empty

tests/slt/values.slt

@@ -0,0 +1,69 @@
+query I
+SELECT * FROM (VALUES (1), (2), (3));
+----
+1
+2
+3
+
+query IT
+SELECT * FROM (VALUES (1, 'a'), (2, 'b'), (3, 'c'));
+----
+1 a
+2 b
+3 c
+
+query II
+SELECT * FROM (VALUES (1, 2)) AS t(x, y);
+----
+1 2
+
+query I rowsort
+SELECT * FROM (VALUES (4), (5), (6)) LIMIT 2;
+----
+4
+5
+
+query I
+SELECT * FROM (VALUES (1), (NULL), (3));
+----
+1
+null
+3
+
+statement ok
+CREATE TABLE t (x INT PRIMARY KEY);
+
+statement ok
+INSERT INTO t VALUES (1), (2), (3);
+
+query I rowsort
+SELECT * FROM t JOIN (VALUES (2), (3)) AS v(x) ON t.x = v.x;
+----
+2
+3
+
+query I
+SELECT * FROM (VALUES (1), (2.5));
+----
+1.0
+2.5
+
+query I rowsort
+SELECT * FROM (VALUES (1), (2)) UNION SELECT * FROM (VALUES (2), (3));
+----
+1
+2
+3
+
+query I
+SELECT * FROM (VALUES (3), (1), (2)) AS v(x) ORDER BY v.x ASC;
+----
+1
+2
+3
+
+query I
+SELECT t.y FROM (VALUES (10, 20), (30, 40)) AS t(x, y);
+----
+20
+40