data explorer: duckdb sql backend for convert to code (#9138)

Since we store the active where and sort clauses, we can probably just
reuse them to show to users. Since these are what is filtering/sorting
the data explorer, I assume they won't be stale. I haven't dug around
too much to see if there are any other drawbacks to reusing these, but
it does make this feature quite simple!


### Release Notes

<!--
Optionally, replace `N/A` with text to be included in the next release
notes.
The `N/A` bullets are ignored. If you refer to one or more Positron
issues,
these issues are used to collect information about the feature or
bugfix, such
as the relevant language pack as determined by Github labels of type
`lang: `.
  The note will automatically be tagged with the language.

These notes are typically filled by the Positron team. If you are an
external
  contributor, you may ignore this section.
-->

#### New Features

- #8986 Add Convert to Code that generates SQL for headless Data
Explorer sessions.

#### Bug Fixes

- N/A


### QA Notes

- Open up "flights.parquet" file in `positron-qa-examples`
- Do some filters, sorts, etc. DuckDB displays the number of rows only
if it's less than 9999, so if you want to do a quick sanity check that
it's equivalent to number of rows in the data explorer, make sure you
narrow it down accordingly!
- Convert to Code button -> copy to clipboard
- In Python, `pip install duckdb`
- Run ⏬ 
```python
import duckdb

conn = duckdb.connect()
conn.execute("CREATE TABLE flights AS SELECT * FROM 'data-files/flights/flights.parquet'")

conn.execute(""" 
ADD COPIED SQL HERE
""").df()

Author: isabelizimm

extensions/positron-duckdb/src/extension.ts

@@ -6,6 +6,7 @@
 import * as vscode from 'vscode';
 import {
 	BackendState,
+	CodeSyntaxName,
 	ColumnDisplayType,
 	ColumnFilter,
 	ColumnFilterType,
@@ -21,6 +22,8 @@ import {
 	ColumnSortKey,
 	ColumnSummaryStats,
 	ColumnValue,
+	ConvertedCode,
+	ConvertToCodeParams,
 	DataExplorerBackendRequest,
 	DataExplorerFrontendEvent,
 	DataExplorerResponse,
@@ -1326,7 +1329,8 @@ END`;
 					]
 				},
 				convert_to_code: {
-					support_status: SupportStatus.Unsupported,
+					support_status: SupportStatus.Supported,
+					code_syntaxes: [{ code_syntax_name: 'SQL' }]
 				}
 			}
 		};
@@ -1654,6 +1658,35 @@ END`;
 		const numRows = Number(result.toArray()[0].num_rows);
 		return [numRows, numColumns];
 	}
+
+	async suggestCodeSyntaxes(): RpcResponse<CodeSyntaxName> {
+		return {
+			code_syntax_name: 'SQL'
+		};
+	}
+
+	async convertToCode(params: ConvertToCodeParams, uri: string): RpcResponse<ConvertedCode> {
+		const parsedUri = vscode.Uri.parse(uri);
+		const filename = path.basename(parsedUri.path, path.extname(parsedUri.path));
+
+		// Escape any quotes in the filename to prevent SQL injection
+		const escapedFilename = filename.replace(/"/g, '""');
+		const result = ["SELECT * ", `FROM "${escapedFilename}"`];
+
+		if (this._whereClause) {
+			const whereClause = this._whereClause.replace(/\n/g, ' ').trim();
+			result.push(whereClause);
+		}
+
+		if (this._sortClause) {
+			const sortClause = this._sortClause.replace(/\n/g, ' ').trim();
+			result.push(sortClause);
+		}
+
+		return {
+			converted_code: result
+		};
+	}
 }
 
 /**
@@ -1823,6 +1856,10 @@ export class DataExplorerRpcHandler implements vscode.Disposable {
 				return table.setSortColumns(rpc.params as SetSortColumnsParams);
 			case DataExplorerBackendRequest.SearchSchema:
 				return table.searchSchema(rpc.params as SearchSchemaParams);
+			case DataExplorerBackendRequest.SuggestCodeSyntax:
+				return table.suggestCodeSyntaxes();
+			case DataExplorerBackendRequest.ConvertToCode:
+				return table.convertToCode(rpc.params as ConvertToCodeParams, rpc.uri!);
 			case DataExplorerBackendRequest.SetColumnFilters:
 				return `${rpc.method} not yet implemented`;
 			default:

extensions/positron-duckdb/src/test/extension.test.ts

@@ -260,7 +260,12 @@ suite('Positron DuckDB Extension Test Suite', () => {
 						ExportFormat.Html
 					]
 				},
-				convert_to_code: { support_status: SupportStatus.Unsupported }
+				convert_to_code: {
+					support_status: SupportStatus.Supported,
+					code_syntaxes: [{
+						code_syntax_name: "SQL"
+					}]
+				}
 			}
 		} satisfies BackendState);
 
@@ -2117,4 +2122,255 @@ suite('Positron DuckDB Extension Test Suite', () => {
 		assert.strictEqual(numberStats.median, '42', 'Median should be 42');
 		assert.strictEqual(numberStats.stdev, '0', 'Standard deviation should be 0 for single value');
 	});
+
+	test('convertToCode - with row filters', async () => {
+		const tableName = makeTempTableName();
+
+		// Create a test table with more diverse data for filtering
+		await createTempTable(tableName, [
+			{
+				name: 'id',
+				type: 'INTEGER',
+				values: ['1', '2', '3', '4', '5']
+			},
+			{
+				name: 'name',
+				type: 'VARCHAR',
+				values: ["'Alice'", "'Bob'", "'Charlie'", "'David'", "'Eve'"]
+			},
+			{
+				name: 'age',
+				type: 'INTEGER',
+				values: ['25', '30', '35', '40', '45']
+			}
+		]);
+
+		const uri = vscode.Uri.from({ scheme: 'duckdb', path: tableName });
+
+		// Get full schema to build row filter
+		const fullSchema = await getSchema(tableName);
+
+		// Create filter: age > 30
+		const rowFilter: RowFilter = {
+			filter_id: 'test-filter',
+			condition: RowFilterCondition.And,
+			column_schema: fullSchema.columns[2], // age column
+			filter_type: RowFilterType.Compare,
+			params: {
+				op: FilterComparisonOp.Gt,
+				value: '30'
+			}
+		};
+
+		// Apply the filter first so it's reflected in the SQL generation
+		await dxExec({
+			method: DataExplorerBackendRequest.SetRowFilters,
+			uri: uri.toString(),
+			params: {
+				filters: [rowFilter]
+			}
+		});
+
+		// Test convert to code with row filter applied
+		const result = await dxExec({
+			method: DataExplorerBackendRequest.ConvertToCode,
+			uri: uri.toString(),
+			params: {
+				column_filters: [],
+				row_filters: [rowFilter],
+				sort_keys: [],
+				code_syntax_name: { code_syntax_name: 'SQL' }
+			}
+		});
+
+		assert.ok(result, 'Convert to code result should be returned');
+		assert.ok(result.converted_code, 'Converted code should be present');
+		assert.strictEqual(result.converted_code.length, 3, 'Should have 3 lines of code');
+		assert.strictEqual(result.converted_code[0], 'SELECT * ', 'First line should be SELECT * ');
+		assert.strictEqual(result.converted_code[1], `FROM "${tableName}"`, `Second line should reference the table name`);
+		assert.strictEqual(result.converted_code[2], 'WHERE "age" > 30', 'Third line should have the WHERE clause');
+	});
+
+	test('convertToCode - with sort columns', async () => {
+		const tableName = makeTempTableName();
+
+		// Create a test table with more diverse data for sorting
+		await createTempTable(tableName, [
+			{
+				name: 'id',
+				type: 'INTEGER',
+				values: ['1', '2', '3', '4', '5']
+			},
+			{
+				name: 'name',
+				type: 'VARCHAR',
+				values: ["'Alice'", "'Bob'", "'Charlie'", "'David'", "'Eve'"]
+			},
+			{
+				name: 'age',
+				type: 'INTEGER',
+				values: ['25', '30', '35', '40', '45']
+			}
+		]);
+
+		const uri = vscode.Uri.from({ scheme: 'duckdb', path: tableName });
+
+		// Create sort key: sort by name descending
+		const sortKey: ColumnSortKey = {
+			column_index: 1, // name column
+			ascending: false
+		};
+
+		// Apply the sort key first so it's reflected in the SQL generation
+		await dxExec({
+			method: DataExplorerBackendRequest.SetSortColumns,
+			uri: uri.toString(),
+			params: {
+				sort_keys: [sortKey]
+			}
+		});
+
+		// Test convert to code with sort key applied
+		const result = await dxExec({
+			method: DataExplorerBackendRequest.ConvertToCode,
+			uri: uri.toString(),
+			params: {
+				column_filters: [],
+				row_filters: [],
+				sort_keys: [sortKey],
+				code_syntax_name: { code_syntax_name: 'SQL' }
+			}
+		});
+
+		assert.ok(result, 'Convert to code result should be returned');
+		assert.ok(result.converted_code, 'Converted code should be present');
+		assert.strictEqual(result.converted_code.length, 3, 'Should have 3 lines of code');
+		assert.strictEqual(result.converted_code[0], 'SELECT * ', 'First line should be SELECT * ');
+		assert.strictEqual(result.converted_code[1], `FROM "${tableName}"`, `Second line should reference the table name`);
+		assert.strictEqual(result.converted_code[2], 'ORDER BY "name" DESC', 'Third line should have the ORDER BY clause');
+	});
+
+	test('convertToCode - with both row filters and sort columns', async () => {
+		const tableName = makeTempTableName();
+
+		// Create a test table with data for filtering and sorting
+		await createTempTable(tableName, [
+			{
+				name: 'id',
+				type: 'INTEGER',
+				values: ['1', '2', '3', '4', '5']
+			},
+			{
+				name: 'name',
+				type: 'VARCHAR',
+				values: ["'Alice'", "'Bob'", "'Charlie'", "'David'", "'Eve'"]
+			},
+			{
+				name: 'age',
+				type: 'INTEGER',
+				values: ['25', '30', '35', '40', '45']
+			}
+		]);
+
+		const uri = vscode.Uri.from({ scheme: 'duckdb', path: tableName });
+
+		// Get full schema to build row filter
+		const fullSchema = await getSchema(tableName);
+
+		// Create filter: age > 30
+		const rowFilter: RowFilter = {
+			filter_id: 'test-filter',
+			condition: RowFilterCondition.And,
+			column_schema: fullSchema.columns[2], // age column
+			filter_type: RowFilterType.Compare,
+			params: {
+				op: FilterComparisonOp.Gt,
+				value: '30'
+			}
+		};
+
+		// Create sort key: sort by name ascending
+		const sortKey: ColumnSortKey = {
+			column_index: 1, // name column
+			ascending: true
+		};
+
+		// Apply the filter and sort key
+		await dxExec({
+			method: DataExplorerBackendRequest.SetRowFilters,
+			uri: uri.toString(),
+			params: {
+				filters: [rowFilter]
+			}
+		});
+
+		await dxExec({
+			method: DataExplorerBackendRequest.SetSortColumns,
+			uri: uri.toString(),
+			params: {
+				sort_keys: [sortKey]
+			}
+		});
+
+		// Test convert to code with both row filter and sort key applied
+		const result = await dxExec({
+			method: DataExplorerBackendRequest.ConvertToCode,
+			uri: uri.toString(),
+			params: {
+				column_filters: [],
+				row_filters: [rowFilter],
+				sort_keys: [sortKey],
+				code_syntax_name: { code_syntax_name: 'SQL' }
+			}
+		});
+
+		assert.ok(result, 'Convert to code result should be returned');
+		assert.ok(result.converted_code, 'Converted code should be present');
+		assert.strictEqual(result.converted_code.length, 4, 'Should have 4 lines of code');
+		assert.strictEqual(result.converted_code[0], 'SELECT * ', 'First line should be SELECT * ');
+		assert.strictEqual(result.converted_code[1], `FROM "${tableName}"`, `Second line should reference the table name`);
+		assert.strictEqual(result.converted_code[2], 'WHERE "age" > 30', 'Third line should have the WHERE clause');
+		assert.strictEqual(result.converted_code[3], 'ORDER BY "name"', 'Fourth line should have the ORDER BY clause');
+	});
+
+	test('convertToCode - with long/complex filename/URI', async () => {
+		// Use a long filename that needs to be quoted in SQL
+		const specialTableName = makeTempTableName() + '_complex_tablename_with_underscores';
+
+		// Create a simple test table
+		await createTempTable(specialTableName, [
+			{
+				name: 'id',
+				type: 'INTEGER',
+				values: ['1', '2', '3']
+			},
+			{
+				name: 'data',
+				type: 'VARCHAR',
+				values: ["'A'", "'B'", "'C'"]
+			}
+		]);
+
+		const uri = vscode.Uri.from({ scheme: 'duckdb', path: specialTableName });
+
+		// Test convert to code with a complex filename
+		const result = await dxExec({
+			method: DataExplorerBackendRequest.ConvertToCode,
+			uri: uri.toString(),
+			params: {
+				column_filters: [],
+				row_filters: [],
+				sort_keys: [],
+				code_syntax_name: { code_syntax_name: 'SQL' }
+			}
+		});
+
+		assert.ok(result, 'Convert to code result should be returned');
+		assert.ok(result.converted_code, 'Converted code should be present');
+		assert.strictEqual(result.converted_code.length, 2, 'Should have 2 lines of code');
+		assert.strictEqual(result.converted_code[0], 'SELECT * ', 'First line should be SELECT * ');
+
+		// Verify that the table name is properly quoted in SQL
+		assert.strictEqual(result.converted_code[1], `FROM "${specialTableName}"`, 'Second line should properly quote the table name');
+	});
 });