The active config object within the current scope. See SQLConf.get for more information.

Expand the UnresolvedStar. The expected use case for this method is star expansion inside Project.

Star without a target:

-- Here the star will be expanded to [a, b, c].
SELECT * FROM VALUES (1, 2, 3) AS t(a, b, c);

Star with a multipart name target:

USE CATALOG catalog1;
USE DATABASE database1;

CREATE TABLE IF NOT EXISTS table1 (col1 INT, col2 INT);

-- Here the star will be expanded to [col1, col2].
SELECT catalog1.database1.table1.* FROM catalog1.database1.table1;

Star with a struct target:

-- Here the star will be expanded to [field1, field2].
SELECT d.* FROM VALUES (named_struct('field1', 1, 'field2', 2)) AS t(d);

Star as an argument to a function:

-- Here the star will be expanded to [col1, col2, col3] and those would be passed as
-- arguments to `concat_ws`.
SELECT concat_ws('', *) AS result FROM VALUES (1, 2, 3);

Also, see UnresolvedStarBase.expandStar for more details.

Find attributes in this NameScope that match a provided one-part name.

This method is simpler and more lightweight than resolveMultipartName, because here we just return all the attributes matched by the one-part name. This is only suitable for situations where name _resolution_ is not required (e.g. accessing struct fields from the lower operator's output).

For example, this method is used to look up attributes to match a specific View schema. See ExpressionResolver.resolveGetViewColumnByNameAndOrdinal for more info on view column lookup.

We are relying on a simple IdentifierMap to perform that work, since we just need to match one-part name from the lower operator's output here.

Check if output contains attributes with expressionId. This is used to disable missing attribute propagation for DataFrames, because we don't support it yet.

Resolve multipart name into a NameTarget. NameTarget's candidates may contain simple AttributeReferences if it's a column or alias, or ExtractValue expressions if it's a struct field, map value or array value. The aliasName will optionally be set to the proposed alias name for the value extracted from a struct, map or array.

Example that demonstrates those major use-cases:

CREATE TABLE IF NOT EXISTS t (
  col1 INT,
  col2 STRUCT<field: INT>,
  col3 STRUCT<struct: STRUCT<field: INT>>,
  col4 MAP<STRING: INT>,
  col5 STRING
);

-- For the SELECT below the top Project list will be resolved using this method like this:
-- AttributeReference(col1),
-- AttributeReference(a),
-- GetStructField(col2, field),
-- GetStructField(GetStructField(col3, struct), field),
-- GetMapValue(col4, key)
SELECT
  col1, a, col2.field, col3.struct.field, col4.key
FROM
  (SELECT *, col5 AS a FROM t);

Since there can be several expressions that matched the same multipart name, this method may return a NameTarget with the following candidates: - 0 values: No matched expressions - 1 value: Unique expression matched - 1+ values: Ambiguity, several expressions matched

Some examples of ambiguity:

CREATE TABLE IF NOT EXISTS t1 (c1 INT, c2 INT);
CREATE TABLE IF NOT EXISTS t2 (c2 INT, c3 INT);

-- Identically named columns from different tables.
-- This will fail with AMBIGUOUS_REFERENCE error.
SELECT c2 FROM t1, t2;

CREATE TABLE IF NOT EXISTS foo (c1 INT);
CREATE TABLE IF NOT EXISTS bar (foo STRUCT<c1: INT>);

-- Ambiguity between a column in a table and a field in a struct.
-- This will succeed, and column will win over the struct field.
SELECT foo.c1 FROM foo, bar;

The candidates are deduplicated by expression ID (not by attribute name!):

CREATE TABLE IF NOT EXISTS t1 (col1 STRING);

-- No ambiguity here, since we are selecting the same column (same expression ID).
SELECT col1 FROM (SELECT col1, col1 FROM t);

The case of the multipartName takes precedence over the original name case, so the candidates will have names that are case-identical to the multipartName:

CREATE TABLE IF NOT EXISTS t1 (col1 STRING);

-- The output schema of this query is [COL1], despite the fact that the column is in
-- lower-case.
SELECT COL1 FROM t;

We are relying on the AttributeSeq to perform that work, since it requires complex resolution logic involving nested field extraction and multipart name matching.

Also, see AttributeSeq.resolve for more details.

Sets all SQL configurations specified in pairs, calls f, and then restores all SQL configurations.