Various fixes

Author: cgivre

exec/java-exec/src/main/java/org/apache/drill/exec/server/rest/DashboardResources.java

@@ -23,6 +23,7 @@
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.apache.drill.common.exceptions.DrillRuntimeException;
+import org.apache.drill.exec.ExecConstants;
 import org.apache.drill.exec.exception.StoreException;
 import org.apache.drill.exec.server.rest.auth.DrillUserPrincipal;
 import org.apache.drill.exec.store.sys.PersistentStore;
@@ -1099,14 +1100,26 @@ private File getUploadDir() {
     if (cachedUploadDir == null) {
       synchronized (DashboardResources.class) {
         if (cachedUploadDir == null) {
+          // 1. Prefer DRILL_LOG_DIR (set by Drill startup scripts)
           String basePath = System.getenv("DRILL_LOG_DIR");
+          // 2. Fall back to Drill's persistent store path (same dir as system tables)
           if (basePath == null) {
-            basePath = System.getProperty("java.io.tmpdir");
+            try {
+              basePath = workManager.getContext().getConfig()
+                  .getString(ExecConstants.SYS_STORE_PROVIDER_LOCAL_PATH);
+            } catch (Exception e) {
+              logger.debug("Could not read sys.store.provider.local.path", e);
+            }
+          }
+          // 3. Last resort: user home directory
+          if (basePath == null) {
+            basePath = System.getProperty("user.home");
           }
           File dir = new File(basePath, UPLOAD_DIR_NAME);
           if (!dir.exists() && !dir.mkdirs()) {
             throw new DrillRuntimeException("Failed to create upload directory: " + dir);
           }
+          logger.info("Dashboard image upload directory: {}", dir.getAbsolutePath());
           cachedUploadDir = dir;
         }
       }

exec/java-exec/src/main/java/org/apache/drill/exec/server/rest/StatusResources.java

@@ -21,8 +21,10 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 import jakarta.annotation.security.PermitAll;
 import jakarta.annotation.security.RolesAllowed;
@@ -58,6 +60,13 @@
 import org.apache.http.client.methods.HttpGet;
 import org.glassfish.jersey.server.mvc.Viewable;
 
+import com.codahale.metrics.Counter;
+import com.codahale.metrics.Gauge;
+import com.codahale.metrics.Histogram;
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.Snapshot;
+import com.codahale.metrics.Timer;
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
@@ -104,6 +113,102 @@ public Viewable getStatus() {
     return ViewableWithPermissions.create(authEnabled.get(), "/rest/status.ftl", sc, getStatusJSON());
   }
 
+  /**
+   * Returns the local Drillbit's metrics as JSON.
+   * Replaces the old Codahale MetricsServlet that was removed during
+   * the javax.servlet to jakarta.servlet migration.
+   */
+  @GET
+  @Path(StatusResources.PATH_METRICS)
+  @Produces(MediaType.APPLICATION_JSON)
+  @Operation(externalDocs = @ExternalDocumentation(description = "Apache Drill REST API documentation:", url = "https://drill.apache.org/docs/rest-api-introduction/"))
+  public Map<String, Object> getLocalMetrics() {
+    MetricRegistry metrics = work.getContext().getMetrics();
+    Map<String, Object> result = new LinkedHashMap<>();
+
+    // Gauges
+    Map<String, Object> gauges = new LinkedHashMap<>();
+    for (Map.Entry<String, Gauge> entry : metrics.getGauges().entrySet()) {
+      Map<String, Object> g = new LinkedHashMap<>();
+      g.put("value", entry.getValue().getValue());
+      gauges.put(entry.getKey(), g);
+    }
+    result.put("gauges", gauges);
+
+    // Counters
+    Map<String, Object> counters = new LinkedHashMap<>();
+    for (Map.Entry<String, Counter> entry : metrics.getCounters().entrySet()) {
+      Map<String, Object> c = new LinkedHashMap<>();
+      c.put("count", entry.getValue().getCount());
+      counters.put(entry.getKey(), c);
+    }
+    result.put("counters", counters);
+
+    // Histograms
+    Map<String, Object> histograms = new LinkedHashMap<>();
+    for (Map.Entry<String, Histogram> entry : metrics.getHistograms().entrySet()) {
+      Snapshot snap = entry.getValue().getSnapshot();
+      Map<String, Object> h = new LinkedHashMap<>();
+      h.put("count", entry.getValue().getCount());
+      h.put("max", snap.getMax());
+      h.put("mean", snap.getMean());
+      h.put("min", snap.getMin());
+      h.put("p50", snap.getMedian());
+      h.put("p75", snap.get75thPercentile());
+      h.put("p95", snap.get95thPercentile());
+      h.put("p98", snap.get98thPercentile());
+      h.put("p99", snap.get99thPercentile());
+      h.put("p999", snap.get999thPercentile());
+      h.put("stddev", snap.getStdDev());
+      histograms.put(entry.getKey(), h);
+    }
+    result.put("histograms", histograms);
+
+    // Meters
+    Map<String, Object> meters = new LinkedHashMap<>();
+    for (Map.Entry<String, Meter> entry : metrics.getMeters().entrySet()) {
+      Meter m = entry.getValue();
+      Map<String, Object> mData = new LinkedHashMap<>();
+      mData.put("count", m.getCount());
+      mData.put("m1_rate", m.getOneMinuteRate());
+      mData.put("m5_rate", m.getFiveMinuteRate());
+      mData.put("m15_rate", m.getFifteenMinuteRate());
+      mData.put("mean_rate", m.getMeanRate());
+      mData.put("units", "events/second");
+      meters.put(entry.getKey(), mData);
+    }
+    result.put("meters", meters);
+
+    // Timers
+    Map<String, Object> timers = new LinkedHashMap<>();
+    for (Map.Entry<String, Timer> entry : metrics.getTimers().entrySet()) {
+      Timer t = entry.getValue();
+      Snapshot snap = t.getSnapshot();
+      Map<String, Object> tData = new LinkedHashMap<>();
+      tData.put("count", t.getCount());
+      tData.put("max", snap.getMax());
+      tData.put("mean", snap.getMean());
+      tData.put("min", snap.getMin());
+      tData.put("p50", snap.getMedian());
+      tData.put("p75", snap.get75thPercentile());
+      tData.put("p95", snap.get95thPercentile());
+      tData.put("p98", snap.get98thPercentile());
+      tData.put("p99", snap.get99thPercentile());
+      tData.put("p999", snap.get999thPercentile());
+      tData.put("stddev", snap.getStdDev());
+      tData.put("m1_rate", t.getOneMinuteRate());
+      tData.put("m5_rate", t.getFiveMinuteRate());
+      tData.put("m15_rate", t.getFifteenMinuteRate());
+      tData.put("mean_rate", t.getMeanRate());
+      tData.put("duration_units", "seconds");
+      tData.put("rate_units", "calls/second");
+      timers.put(entry.getKey(), tData);
+    }
+    result.put("timers", timers);
+
+    return result;
+  }
+
   @GET
   @Path(StatusResources.PATH_METRICS + "/{hostname}")
   @Produces(MediaType.APPLICATION_JSON)

exec/java-exec/src/main/resources/webapp/package-lock.json

@@ -28,6 +28,7 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-grid-layout": "^1.4.4",
+    "react-icons": "^5.5.0",
     "react-markdown": "^10.1.0",
     "react-redux": "^9.0.4",
     "react-router-dom": "^6.21.0",

exec/java-exec/src/main/resources/webapp/package.json

@@ -16,7 +16,8 @@
  * limitations under the License.
  */
 import apiClient from './client';
-import type { SchemaInfo, TableInfo, ColumnInfo, PluginInfo } from '../types';
+import type { SchemaInfo, TableInfo, ColumnInfo, PluginInfo, NestedFieldInfo } from '../types';
+import { executeQuery } from './queries';
 
 const METADATA_BASE = '/api/v1/metadata';
 
@@ -155,3 +156,68 @@ export async function getFileColumns(schema: string, filePath: string): Promise<
   );
   return response.data.columns;
 }
+
+/**
+ * Parse a string-serialised map schema like "{field1=BIGINT, field2=VARCHAR}".
+ */
+function parseMapSchemaString(str: string): NestedFieldInfo[] {
+  const trimmed = str.replace(/^\{|\}$/g, '').trim();
+  if (!trimmed) {
+    return [];
+  }
+  return trimmed.split(',').map((pair) => {
+    const eqIdx = pair.indexOf('=');
+    if (eqIdx < 0) {
+      return { name: pair.trim(), type: 'ANY' };
+    }
+    return { name: pair.slice(0, eqIdx).trim(), type: pair.slice(eqIdx + 1).trim() || 'ANY' };
+  }).filter((f) => f.name.length > 0);
+}
+
+/**
+ * Fetch nested sub-fields for a MAP/STRUCT column using Drill's getMapSchema() function.
+ *
+ * @param schema      the schema name (e.g. "dfs.tmp")
+ * @param tableOrFile the table or file identifier (e.g. "data.json")
+ * @param columnPath  dot-separated path to the column (e.g. "record" or "record.nested_map")
+ */
+export async function getNestedColumns(
+  schema: string,
+  tableOrFile: string,
+  columnPath: string,
+): Promise<NestedFieldInfo[]> {
+  // Build the column expression with backtick-quoting on each path segment
+  const pathParts = columnPath.split('.');
+  const columnExpr = pathParts.map((p) => `\`${p}\``).join('.');
+
+  const query =
+    `SELECT getMapSchema(${columnExpr}) AS \`schema\`` +
+    ` FROM \`${schema}\`.\`${tableOrFile}\` LIMIT 1`;
+
+  const result = await executeQuery({
+    query,
+    queryType: 'SQL',
+    autoLimitRowCount: 1,
+  });
+
+  if (result.rows.length === 0) {
+    return [];
+  }
+
+  const schemaVal = result.rows[0]['schema'];
+
+  // MAP types are serialised as JSON objects by Drill's /query.json endpoint
+  if (typeof schemaVal === 'object' && schemaVal !== null) {
+    return Object.entries(schemaVal as Record<string, unknown>).map(([name, type]) => ({
+      name,
+      type: String(type),
+    }));
+  }
+
+  // Fallback: string representation like "{field1=BIGINT, field2=VARCHAR}"
+  if (typeof schemaVal === 'string') {
+    return parseMapSchemaString(schemaVal);
+  }
+
+  return [];
+}

exec/java-exec/src/main/resources/webapp/src/api/metadata.ts

@@ -15,7 +15,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { useRef, useCallback, useEffect } from 'react';
+import { useState, useRef, useCallback, useEffect } from 'react';
 import Editor, { OnMount, OnChange, Monaco } from '@monaco-editor/react';
 
 // Use Monaco's editor type from the package
@@ -164,8 +164,65 @@ export default function SqlEditor({
     };
   }, [insertText]);
 
+  // ---- Drag-and-drop support (Phase 3) ----
+  const [dragOver, setDragOver] = useState(false);
+
+  const handleDragOver = useCallback((e: React.DragEvent) => {
+    e.preventDefault();
+    e.dataTransfer.dropEffect = 'copy';
+    setDragOver(true);
+  }, []);
+
+  const handleDragLeave = useCallback(() => {
+    setDragOver(false);
+  }, []);
+
+  const handleDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault();
+    setDragOver(false);
+    const text = e.dataTransfer.getData('text/plain');
+    if (!text) {
+      return;
+    }
+    const editor = editorRef.current;
+    if (editor) {
+      // Try to place the text at the mouse drop position
+      const target = editor.getTargetAtClientPoint(e.clientX, e.clientY);
+      if (target?.position) {
+        const pos = target.position;
+        editor.executeEdits('drop', [
+          {
+            range: {
+              startLineNumber: pos.lineNumber,
+              startColumn: pos.column,
+              endLineNumber: pos.lineNumber,
+              endColumn: pos.column,
+            },
+            text,
+            forceMoveMarkers: true,
+          },
+        ]);
+      } else {
+        // Fallback: insert at current cursor position
+        insertText(text);
+      }
+      editor.focus();
+    }
+  }, [insertText]);
+
   return (
-    <div className="monaco-container" style={{ height }}>
+    <div
+      className="monaco-container"
+      style={{
+        height,
+        border: dragOver ? '2px solid #1890ff' : '2px solid transparent',
+        borderRadius: 4,
+        transition: 'border-color 0.2s',
+      }}
+      onDragOver={handleDragOver}
+      onDragLeave={handleDragLeave}
+      onDrop={handleDrop}
+    >
       <Editor
         height="100%"
         defaultLanguage="sql"