Targeted Column Extraction in SQL

Many real-world SQL queries require extracting only a subset of columns from a table. This challenge focuses on crafting SQL queries that precisely select the desired columns, ensuring efficient data retrieval and minimizing unnecessary data transfer. Mastering this skill is fundamental for optimizing database interactions and building performant applications.

Problem Description

You are tasked with writing SQL queries that select a specific set of columns from a given table. The input will be the table name and a list of column names to retrieve. Your query should return only the specified columns, and nothing more. The table structure is assumed to be known. The query should be robust and handle cases where the requested columns exist in the table. If a requested column doesn't exist, the query should still execute without error, but simply not return that column (effectively treating it as if it wasn't requested).

Key Requirements:

• Column Selection: The query must return only the columns specified in the input list.
• Table Specification: The query must operate on the table specified in the input.
• Error Handling (Graceful Degradation): The query should not fail if a requested column does not exist in the table. It should simply omit that column from the result set.
• Standard SQL: The query should adhere to standard SQL syntax and be compatible with most SQL database systems (e.g., PostgreSQL, MySQL, SQL Server, SQLite).

Expected Behavior:

Given a table named employees with columns employee_id, first_name, last_name, department, and salary, and a request to select first_name and salary, the query should return a result set containing only those two columns. If the request included a non-existent column like address, the query should still execute and return first_name and salary without error.

Examples

Example 1:

Input:
Table Name: employees
Columns to Select: [first_name, last_name]

Output:
SELECT first_name, last_name FROM employees;

Explanation:
This query selects the 'first_name' and 'last_name' columns from the 'employees' table.

Example 2:

Input:
Table Name: products
Columns to Select: [product_id, product_name, price, description, rating]

Output:
SELECT product_id, product_name, price, description, rating FROM products;

Explanation:
This query selects all specified columns from the 'products' table.

Example 3: (Edge Case - Non-existent column)

Input:
Table Name: customers
Columns to Select: [customer_id, name, email, phone, address, non_existent_column]

Output:
SELECT customer_id, name, email, phone, address FROM customers;

Explanation:
The query selects the existing columns from the 'customers' table, ignoring the 'non_existent_column' request.  No error is thrown.

Constraints

• Table Name Length: The table name will be a string with a maximum length of 64 characters.
• Column Name Length: Each column name will be a string with a maximum length of 32 characters.
• Number of Columns: The number of columns to select will be between 1 and 20, inclusive.
• Input Format: The input will be provided as a table name (string) and a list of column names (list of strings).
• SQL Dialect: The solution should be compatible with standard SQL. No database-specific functions or syntax should be used unless explicitly allowed.

Notes

• Consider how to dynamically construct the SELECT statement based on the input list of column names.
• The order of columns in the input list does not matter in the output query.
• Focus on generating a valid SQL query string. You do not need to execute the query or handle database connections.
• The challenge is about generating the correct SQL syntax, not about data validation or error handling beyond the graceful degradation of non-existent columns.
• Think about how to handle cases where the list of columns is empty. While not explicitly required, a robust solution might consider this. (Returning all columns is acceptable in this case).
• Assume the table exists and is accessible.