sql: allow aliasing column names

This will enable some transformations that will in turn enable record
types. It also unlocks a slew of CockroachDB sqllogictests, some of
which are enabled here.

Fix #3112.

Author: benesch

ci/test/slt-fast.sh

@@ -126,7 +126,7 @@ tests=(
     # test/sqllogictest/cockroach/select_index_span_ranges.slt
     # test/sqllogictest/cockroach/select_index.slt
     test/sqllogictest/cockroach/select_search_path.slt
-    # test/sqllogictest/cockroach/select_table_alias.slt
+    test/sqllogictest/cockroach/select_table_alias.slt
     # test/sqllogictest/cockroach/select.slt
     test/sqllogictest/cockroach/shift.slt
     # test/sqllogictest/cockroach/sqlsmith.slt
@@ -148,7 +148,7 @@ tests=(
     test/sqllogictest/cockroach/update.slt
     test/sqllogictest/cockroach/upsert.slt
     test/sqllogictest/cockroach/uuid.slt
-    # test/sqllogictest/cockroach/values.slt
+    test/sqllogictest/cockroach/values.slt
     # test/sqllogictest/cockroach/views.slt
     # test/sqllogictest/cockroach/where.slt
     test/sqllogictest/cockroach/window.slt

src/sql/src/plan/func.rs

@@ -18,7 +18,7 @@ use failure::bail;
 use lazy_static::lazy_static;
 
 use ore::collections::CollectionExt;
-use repr::{ColumnType, Datum, ScalarType};
+use repr::{ColumnName, ColumnType, Datum, ScalarType};
 use sql_parser::ast::{BinaryOperator, Expr, UnaryOperator};
 
 use super::cast::{self, rescale_decimal, CastTo};
@@ -1297,7 +1297,7 @@ pub fn plan_unary_op<'a>(
 pub struct TableFuncPlan {
     pub func: TableFunc,
     pub exprs: Vec<ScalarExpr>,
-    pub column_names: Vec<String>,
+    pub column_names: Vec<Option<ColumnName>>,
 }
 
 lazy_static! {
@@ -1317,7 +1317,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::CsvExtract(ncols),
                         exprs: vec![input],
-                        column_names: (1..=ncols).map(|i| format!("column{}", i)).collect(),
+                        column_names: (1..=ncols).map(|i| Some(format!("column{}", i).into())).collect(),
                     })
                 })
             },
@@ -1330,7 +1330,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::JsonbArrayElements { stringify: false },
                         exprs: vec![jsonb],
-                        column_names: vec!["value".into()],
+                        column_names: vec![Some("value".into())],
                     })
                 })
             },
@@ -1339,7 +1339,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::JsonbArrayElements { stringify: true },
                         exprs: vec![jsonb],
-                        column_names: vec!["value".into()],
+                        column_names: vec![Some("value".into())],
                     })
                 })
             },
@@ -1348,7 +1348,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::JsonbEach { stringify: false },
                         exprs: vec![jsonb],
-                        column_names: vec!["key".into(), "value".into()],
+                        column_names: vec![Some("key".into()), Some("value".into())],
                     })
                 })
             },
@@ -1357,7 +1357,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::JsonbEach { stringify: true },
                         exprs: vec![jsonb],
-                        column_names: vec!["key".into(), "value".into()],
+                        column_names: vec![Some("key".into()), Some("value".into())],
                     })
                 })
             },
@@ -1366,7 +1366,7 @@ lazy_static! {
                     Ok(TableFuncPlan {
                         func: TableFunc::JsonbObjectKeys,
                         exprs: vec![jsonb],
-                        column_names: vec!["jsonb_object_keys".into()],
+                        column_names: vec![Some("jsonb_object_keys".into())],
                     })
                 })
             },
@@ -1378,7 +1378,10 @@ lazy_static! {
                     };
                     let column_names = regex
                         .capture_groups_iter()
-                        .map(|cg| cg.name.clone().unwrap_or_else(|| format!("column{}", cg.index)))
+                        .map(|cg| {
+                            let name = cg.name.clone().unwrap_or_else(|| format!("column{}", cg.index));
+                            Some(name.into())
+                        })
                         .collect();
                     Ok(TableFuncPlan {
                         func: TableFunc::RegexpExtract(regex),
@@ -1396,7 +1399,7 @@ fn plan_generate_series(ty: ScalarType) -> Operation<TableFuncPlan> {
         Ok(TableFuncPlan {
             func: TableFunc::GenerateSeries(ty.clone()),
             exprs,
-            column_names: vec!["generate_series".into()],
+            column_names: vec![Some("generate_series".into())],
         })
     })
 }

src/sql/src/plan/query.rs

@@ -708,18 +708,6 @@ fn plan_table_factor<'a>(
             if !with_hints.is_empty() {
                 unsupported!("WITH hints");
             }
-            let alias = if let Some(TableAlias { name, columns }) = alias {
-                if !columns.is_empty() {
-                    unsupported!(3112, "aliasing columns");
-                }
-                PartialName {
-                    database: None,
-                    schema: None,
-                    item: normalize::ident(name.clone()),
-                }
-            } else {
-                normalize::object_name(name.clone())?
-            };
             if let Some(args) = args {
                 let ecx = &ExprContext {
                     qcx,
@@ -729,19 +717,16 @@ fn plan_table_factor<'a>(
                     allow_aggregates: false,
                     allow_subqueries: true,
                 };
-                plan_table_function(ecx, left, &name, Some(alias), args)
+                plan_table_function(ecx, left, &name, alias.as_ref(), args)
             } else {
                 let name = qcx.scx.resolve_item(name.clone())?;
                 let item = qcx.scx.catalog.get_item(&name);
                 let expr = RelationExpr::Get {
                     id: Id::Global(item.id()),
                     typ: item.desc()?.typ().clone(),
                 };
-                let scope = Scope::from_source(
-                    Some(alias),
-                    item.desc()?.iter_names(),
-                    Some(qcx.outer_scope.clone()),
-                );
+                let column_names = item.desc()?.iter_names().map(|n| n.cloned()).collect();
+                let scope = plan_table_alias(qcx, alias.as_ref(), Some(name.into()), column_names)?;
                 plan_join_operator(qcx, &join_operator, left, left_scope, expr, scope)
             }
         }
@@ -754,20 +739,9 @@ fn plan_table_factor<'a>(
                 unsupported!(3111, "LATERAL derived tables");
             }
             let (expr, scope) = plan_subquery(&qcx, &subquery)?;
-            let alias = if let Some(TableAlias { name, columns }) = alias {
-                if !columns.is_empty() {
-                    unsupported!(3112, "aliasing columns");
-                }
-                Some(PartialName {
-                    database: None,
-                    schema: None,
-                    item: normalize::ident(name.clone()),
-                })
-            } else {
-                None
-            };
-            let scope =
-                Scope::from_source(alias, scope.column_names(), Some(qcx.outer_scope.clone()));
+            let table_name = None;
+            let column_names = scope.column_names().map(|n| n.cloned()).collect();
+            let scope = plan_table_alias(qcx, alias.as_ref(), table_name, column_names)?;
             plan_join_operator(qcx, &join_operator, left, left_scope, expr, scope)
         }
         TableFactor::NestedJoin(table_with_joins) => {
@@ -780,30 +754,71 @@ fn plan_table_function(
     ecx: &ExprContext,
     left: RelationExpr,
     name: &ObjectName,
-    alias: Option<PartialName>,
+    alias: Option<&TableAlias>,
     args: &FunctionArgs,
 ) -> Result<(RelationExpr, Scope), failure::Error> {
-    let ident = &*normalize::function_name(name.clone())?;
+    let ident = normalize::function_name(name.clone())?;
     let args = match args {
         FunctionArgs::Star => bail!("{} does not accept * as an argument", ident),
         FunctionArgs::Args(args) => args,
     };
-    let tf = func::select_table_func(ecx, ident, args)?;
+    let tf = func::select_table_func(ecx, &*ident, args)?;
     let call = RelationExpr::FlatMap {
         input: Box::new(left),
         func: tf.func,
         exprs: tf.exprs,
     };
-    let scope = Scope::from_source(
-        alias,
-        tf.column_names
-            .iter()
-            .map(|name| Some(ColumnName::from(&**name))),
-        Some(ecx.qcx.outer_scope.clone()),
-    );
+    let name = PartialName {
+        database: None,
+        schema: None,
+        item: ident,
+    };
+    let scope = plan_table_alias(ecx.qcx, alias, Some(name), tf.column_names)?;
     Ok((call, ecx.scope.clone().product(scope)))
 }
 
+fn plan_table_alias(
+    qcx: &QueryContext,
+    alias: Option<&TableAlias>,
+    inherent_table_name: Option<PartialName>,
+    inherent_column_names: Vec<Option<ColumnName>>,
+) -> Result<Scope, failure::Error> {
+    let table_name = match alias {
+        None => inherent_table_name,
+        Some(TableAlias { name, .. }) => Some(PartialName {
+            database: None,
+            schema: None,
+            item: normalize::ident(name.to_owned()),
+        }),
+    };
+    let column_names = match alias {
+        None => inherent_column_names,
+        Some(TableAlias { columns, .. }) if columns.is_empty() => inherent_column_names,
+        Some(TableAlias { columns, .. }) if columns.len() > inherent_column_names.len() => {
+            bail!(
+                "{} has {} columns available but {} columns specified",
+                table_name
+                    .map(|n| n.to_string())
+                    .as_deref()
+                    .unwrap_or("subquery"),
+                inherent_column_names.len(),
+                columns.len()
+            );
+        }
+        Some(TableAlias { columns, .. }) => columns
+            .iter()
+            .cloned()
+            .map(|n| Some(normalize::column_name(n)))
+            .chain(inherent_column_names.into_iter().skip(columns.len()))
+            .collect(),
+    };
+    Ok(Scope::from_source(
+        table_name,
+        column_names,
+        Some(qcx.outer_scope.clone()),
+    ))
+}
+
 fn plan_select_item<'a>(
     ecx: &ExprContext,
     s: &'a SelectItem,