Improves query execution/cancelation

Author: michael-s-molina

superset-frontend/packages/superset-core/src/api/sqlLab.ts

@@ -565,31 +565,91 @@ export declare function setActiveTab(tabId: string): Promise<void>;
  */
 
 /**
- * Executes the SQL query in the current tab.
+ * Options for executing a SQL query.
+ */
+export interface QueryOptions {
+  /**
+   * SQL to execute without modifying editor content.
+   * If not provided, uses the current editor content.
+   */
+  sql?: string;
+
+  /**
+   * Run only the selected text in the editor.
+   * Ignored if `sql` option is provided.
+   */
+  selectedOnly?: boolean;
+
+  /**
+   * Override the query row limit.
+   * If not provided, uses the tab's configured limit.
+   */
+  limit?: number;
+
+  /**
+   * Template parameters for Jinja templating.
+   * Merged with existing template parameters from the editor.
+   */
+  templateParams?: Record<string, unknown>;
+
+  /**
+   * Create Table/View As Select options.
+   * When provided, query results are stored in a new table instead of returned directly.
+   */
+  ctas?: {
+    /**
+     * Whether to create a TABLE or VIEW.
+     */
+    method: 'TABLE' | 'VIEW';
+
+    /**
+     * Name of the table or view to create.
+     */
+    tableName: string;
+  };
+}
+
+/**
+ * Executes a SQL query in the current tab.
  *
- * @returns Promise that resolves with the query client ID
+ * @param options Optional query execution options
+ * @returns Promise that resolves with the query ID
  *
  * @example
  * ```typescript
- * const queryId = await runQuery();
+ * // Execute the current editor content
+ * const queryId = await executeQuery();
+ *
+ * // Execute custom SQL without modifying the editor
+ * const queryId = await executeQuery({
+ *   sql: "SELECT * FROM users LIMIT 10"
+ * });
+ *
+ * // Execute only selected text
+ * const queryId = await executeQuery({ selectedOnly: true });
+ *
+ * // Create a table from query results
+ * const queryId = await executeQuery({
+ *   ctas: { method: 'TABLE', tableName: 'my_results' }
+ * });
  * ```
  */
-export declare function runQuery(): Promise<string>;
+export declare function executeQuery(options?: QueryOptions): Promise<string>;
 
 /**
- * Stops a running query.
+ * Cancels a running query.
  *
- * @param queryId The client ID of the query to stop
- * @returns Promise that resolves when the stop request is sent
+ * @param queryId The client ID of the query to cancel
+ * @returns Promise that resolves when the cancellation request is sent
  *
  * @example
  * ```typescript
- * const queryId = await runQuery();
+ * const queryId = await executeQuery();
  * // Later, if needed:
- * await stopQuery(queryId);
+ * await cancelQuery(queryId);
  * ```
  */
-export declare function stopQuery(queryId: string): Promise<void>;
+export declare function cancelQuery(queryId: string): Promise<void>;
 
 /**
  * Tab Context APIs

superset-frontend/src/core/sqlLab/index.ts

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { sqlLab as sqlLabApi } from '@apache-superset/core';
+import { nanoid } from 'nanoid';
 import {
   ADD_QUERY_EDITOR,
   QUERY_FAILED,
@@ -38,8 +39,9 @@ import {
   queryEditorSetDb,
   queryEditorSetCatalog,
   queryEditorSetSchema,
-  runQueryFromSqlEditor,
+  runQuery as runQueryAction,
   postStopQuery,
+  Query,
 } from 'src/SqlLab/actions/sqlLab';
 import { RootState, store } from 'src/views/store';
 import { AnyListenerPredicate } from '@reduxjs/toolkit';
@@ -156,16 +158,16 @@ const makeTab = (
   id: string,
   name: string,
   dbId: number,
-  catalog?: string | null,
-  schema?: string | null,
+  catalog: string | null = null,
+  schema: string | null = null,
 ): Tab => {
   const panels: Panel[] = []; // TODO: Populate panels
   return new Tab(
     id,
     name,
     dbId,
-    catalog ?? null,
-    schema ?? null,
+    catalog,
+    schema,
     () => getEditorAsync(id),
     panels,
   );
@@ -591,7 +593,7 @@ const setActiveTab: typeof sqlLabApi.setActiveTab = async (tabId: string) => {
   }
 };
 
-const runQuery: typeof sqlLabApi.runQuery = async () => {
+const executeQuery: typeof sqlLabApi.executeQuery = async options => {
   const state = store.getState() as SqlLabRootState;
   const editorId = activeEditorId();
   const queryEditor = findQueryEditor(editorId);
@@ -609,12 +611,58 @@ const runQuery: typeof sqlLabApi.runQuery = async () => {
   const database = qe.dbId ? databases[qe.dbId] : null;
   const defaultLimit = state.common?.conf?.DEFAULT_SQLLAB_LIMIT ?? 1000;
 
-  store.dispatch(runQueryFromSqlEditor(database, qe, defaultLimit) as any);
+  // Determine SQL to execute
+  let sql: string;
+  let updateTabState = true;
+
+  if (options?.sql !== undefined) {
+    // Custom SQL provided - don't update tab state
+    ({ sql } = options);
+    updateTabState = false;
+  } else if (options?.selectedOnly && qe.selectedText) {
+    // Run selected text only
+    sql = qe.selectedText;
+    updateTabState = false;
+  } else {
+    // Default: use editor content (selected text takes precedence)
+    sql = qe.selectedText || qe.sql;
+    updateTabState = !qe.selectedText;
+  }
+
+  // Merge template params
+  const templateParams = options?.templateParams
+    ? JSON.stringify({
+        ...JSON.parse(qe.templateParams || '{}'),
+        ...options.templateParams,
+      })
+    : qe.templateParams;
+
+  const queryId = nanoid(11);
+
+  const query: Query = {
+    id: queryId,
+    dbId: qe.dbId,
+    sql,
+    sqlEditorId: qe.tabViewId ?? qe.id,
+    sqlEditorImmutableId: qe.immutableId,
+    tab: qe.name,
+    catalog: qe.catalog,
+    schema: qe.schema,
+    tempTable: options?.ctas?.tableName,
+    templateParams,
+    queryLimit: options?.limit ?? qe.queryLimit ?? defaultLimit,
+    runAsync: database ? database.allow_run_async : false,
+    ctas: !!options?.ctas,
+    ctas_method: options?.ctas?.method,
+    updateTabState,
+  };
+
+  store.dispatch(runQueryAction(query));
 
-  return qe.id;
+  return queryId;
 };
 
-const stopQuery: typeof sqlLabApi.stopQuery = async (queryId: string) => {
+const cancelQuery: typeof sqlLabApi.cancelQuery = async (queryId: string) => {
   const state = store.getState() as SqlLabRootState;
   const query = state.sqlLab.queries[queryId];
 
@@ -664,8 +712,8 @@ export const sqlLab: typeof sqlLabApi = {
   createTab,
   closeTab,
   setActiveTab,
-  runQuery,
-  stopQuery,
+  executeQuery,
+  cancelQuery,
   setDatabase,
   setCatalog,
   setSchema,