+const toExpr = (arg: any): any => {
+  if (!arg) return { type: "default", value: "unknown_column" };
+  switch (arg.type) {
+    case "field":
+      return {
+        type: "column_ref",
+        table: arg.value?.streamAlias || null,
+        column: arg.value?.field || "unknown_column",
+      };
+    case "number":
+      return { type: "number", value: arg.value ?? 0 };
+    case "string":
+    case "histogramInterval":
+      return { type: "string", value: String(arg.value ?? "") };
+    case "function":
+      return processField(arg.value)?.expr || { type: "default", value: "unknown_column" };
+    default:
+      return { type: "default", value: "unknown_column" };
+  }
+};
+
 const processFunctionArgs = (args: any[], isAggregation: boolean) => {
   if (isAggregation) {
-    // Aggregation functions need a single `expr` argument
     return {
       distinct: null,
-      expr: {
-        type: "column_ref",
-        table: null,
-        column: args[0]?.value?.field || args[0]?.value || "unknown_column",
-      },
+      expr: toExpr(args[0]),
       orderby: null,
       separator: null,
     };
   } else {
-    // Regular functions need an `expr_list`
     return {
       type: "expr_list",
-      value: args.map((arg) => ({
-        type: "column_ref",
-        table: null,
-        column: arg.value?.field || arg.value || "unknown_column",
-      })),
+      value: (args || []).map(toExpr),
     };
   }
 };

+let groupedFieldsRequestId = 0;
+
 const updateGroupedFields = async () => {
   const currentStream =
     dashboardPanelData.data.queries[
       dashboardPanelData.layout.currentQueryIndex
     ].fields.stream;
   if (!currentStream) return;
 
-  // Collect streams (main + joins)
+  const requestId = ++groupedFieldsRequestId;
+
   const joinsStreams = [
     { stream: currentStream },
     ...(dashboardPanelData.data.queries[
       dashboardPanelData.layout.currentQueryIndex
     ].joins?.filter((stream: any) => stream?.stream) ?? []),
   ];
 
-  // Fetch stream fields
   const groupedFields = await Promise.all(
     joinsStreams.map(async (stream: any) => {
       return {
         ...(await loadStreamFields(stream?.stream)),
         stream_alias: stream?.streamAlias,
       };
     }),
   );
 
-  dashboardPanelData.meta.streamFields.groupedFields = groupedFields;
+  if (requestId === groupedFieldsRequestId) {
+    dashboardPanelData.meta.streamFields.groupedFields = groupedFields;
+  }
 };

 const filterFieldFn = (rows: any, terms: any) => {
   if (!terms || terms.trim() === "") {
     return rows;
   }
-
   const searchTerm = terms.toLowerCase();
 
-  const filteredRows = rows.filter((row: any) => {
-    // Always include group headers
+  const result: any[] = [];
+  let currentGroup: any | null = null;
+  let groupHasMatch = false;
+
+  for (const row of rows) {
     if (row.isGroup) {
-      return true;
+      // If previous group had matches, push it (already pushed its children as we go)
+      if (currentGroup && groupHasMatch) {
+        // nothing to do, header already pushed
+      } else if (currentGroup && !groupHasMatch) {
+        // remove the previously pushed header as no children matched
+        result.pop();
+      }
+      // start new group
+      currentGroup = row;
+      groupHasMatch = false;
+      // only push header now; remove later if no children match
+      if (row.groupName?.toLowerCase().includes(searchTerm)) {
+        groupHasMatch = true;
+      }
+      result.push(row);
+      continue;
     }
 
-    // Filter fields based on name
-    return row.name.toLowerCase().includes(searchTerm);
-  });
+    // field row
+    const fieldMatches = row.name?.toLowerCase().includes(searchTerm);
+    if (fieldMatches) {
+      // ensure group header exists; if none, just push row
+      if (currentGroup && result[result.length - 1] !== currentGroup) {
+        result.push(currentGroup);
+      }
+      groupHasMatch = true;
+      result.push(row);
+    }
+  }
 
-  return filteredRows;
+  // finalize last group header if it had no matches and wasn't matching itself
+  if (currentGroup && !groupHasMatch && !currentGroup.groupName?.toLowerCase().includes(searchTerm)) {
+    // last pushed item is the header; remove it
+    if (result.length && result[result.length - 1] === currentGroup) {
+      result.pop();
+    }
+  }
+
+  return result;
 };

 const commonBtnLabel = (field: any) => {
-  if (
-    dashboardPanelData.data.queries[
-      dashboardPanelData.layout.currentQueryIndex
-    ].customQuery
-  ) {
-    return field?.alias;
+  if (!field) return "";
+  const query = dashboardPanelData.data.queries[
+    dashboardPanelData.layout.currentQueryIndex
+  ];
+  if (query?.customQuery) {
+    return field?.alias || "";
   }
   return buildSQLQueryFromInput(
     field,
-    dashboardPanelData.data.queries[
-      dashboardPanelData.layout.currentQueryIndex
-    ]?.joins?.length
-      ? dashboardPanelData.data.queries[
-          dashboardPanelData.layout.currentQueryIndex
-        ].fields?.stream
-      : "",
-  );
+    (query?.joins?.length ? query?.fields?.stream : "") || ""
+  ) || "";
 };

 const selectedFunction = functionValidation.find(
   (fn: any) => fn.functionName === (functionName ?? null),
 );
 
-// If the function is not found, return empty string instead of throwing
+// If the function is not found, return an explicit indicator
 if (!selectedFunction) {
-  return "";
+  return "__INVALID_FUNCTION__";
 }

 const addXAxisItem = (row: { name: string; streamAlias?: string }) => {
-  ...
+  if (
+    !dashboardPanelData.data.queries[
+      dashboardPanelData.layout.currentQueryIndex
+    ]?.fields?.x
+  ) {
+    return;
+  }
+
+  const isDerived = checkIsDerivedField(row.name) ?? false;
+
+  const alreadyExists = dashboardPanelData.data.queries[
+    dashboardPanelData.layout.currentQueryIndex
+  ].fields.x.some((it: any) => {
+    const fieldArg = Array.isArray(it.args) ? it.args.find((a: any) => a?.type === "field") : null;
+    return fieldArg?.value?.field === row.name && fieldArg?.value?.streamAlias === row.streamAlias;
+  });
+
+  if (alreadyExists) {
+    return;
+  }
+
   dashboardPanelData.data.queries[
     dashboardPanelData.layout.currentQueryIndex
   ].fields.x.push({
     label: !dashboardPanelData.data.queries[
       dashboardPanelData.layout.currentQueryIndex
     ].customQuery
       ? generateLabelFromName(row.name)
       : row.name,
     alias:
       !dashboardPanelData.data.queries[
         dashboardPanelData.layout.currentQueryIndex
       ].customQuery && !isDerived
         ? "x_axis_" +
           (dashboardPanelData.data.queries[
             dashboardPanelData.layout.currentQueryIndex
           ].fields.x.length +
             1)
         : row.name,
-    // column: row.name,
     color: null,
     type: "build",
     functionName:
       row.name == store.state.zoConfig.timestamp_column && !isDerived
         ? "histogram"
         : null,
     args:
       row.name == store.state.zoConfig.timestamp_column && !isDerived
         ? [
             {
               type: "field",
               value: {
                 field: row.name,
                 streamAlias: row.streamAlias,
               },
             },
             {
               type: "histogramInterval",
               value: null,
             },
           ]
         : [
             {
               type: "field",
               value: {
                 field: row.name,
                 streamAlias: row.streamAlias,
               },
             },
           ],
     sortBy:
       row.name == store.state.zoConfig.timestamp_column
         ? dashboardPanelData.data.type == "table"
           ? "DESC"
           : "ASC"
         : null,
     isDerived,
     havingConditions: [],
   });
-  ...
+
+  updateArrayAlias();
 };

 export function buildSQLJoinsFromInput(
   joins: any[],
   defaultStream: any,
 ): string {
-  ...
-  joinClauses.push(
-    `${joinType.toUpperCase()} JOIN "${stream}" AS ${streamAlias ?? defaultStream} ON ${joinConditionsSQL}`,
-  );
-  ...
+  if (!joins || joins.length === 0) {
+    return "";
+  }
+
+  const joinClauses: string[] = [];
+
+  for (const join of joins) {
+    const { stream, streamAlias, joinType, conditions } = join;
+    if (!stream || !joinType || !conditions || conditions.length === 0) {
+      continue;
+    }
+
+    const joinConditionStrings: string[] = [];
+    for (const condition of conditions) {
+      const { leftField, rightField, operation } = condition;
+      if (!leftField?.field || !rightField?.field || !operation) continue;
+
+      const leftFieldStr = leftField.streamAlias
+        ? `${leftField.streamAlias}.${leftField.field}`
+        : defaultStream
+          ? `${defaultStream}.${leftField.field}`
+          : leftField.field;
+
+      const rightFieldStr = rightField.streamAlias
+        ? `${rightField.streamAlias}.${rightField.field}`
+        : defaultStream
+          ? `${defaultStream}.${rightField.field}`
+          : rightField.field;
+
+      joinConditionStrings.push(`${leftFieldStr} ${operation} ${rightFieldStr}`);
+    }
+
+    if (joinConditionStrings.length === 0) continue;
+
+    const joinConditionsSQL = joinConditionStrings.join(" AND ");
+    const safeAlias = streamAlias || stream; // fallback to stream name
+    joinClauses.push(
+      `${joinType.toUpperCase()} JOIN "${stream}" AS ${safeAlias} ON ${joinConditionsSQL}`,
+    );
+  }
+
+  return joinClauses.join(" ");
 }

 watch(
   () =>
     dashboardPanelData.data.queries[
       dashboardPanelData.layout.currentQueryIndex
     ].joins,
   () => {
-    // generate alias for each join stream
-    // make sure that alias is unique
-    // if stream is duplicate then add _1, _2, _3 etc
-    dashboardPanelData.data.queries[
-      dashboardPanelData.layout.currentQueryIndex
-    ]?.joins?.forEach((join: any, index: number) => {
-      if (join?.stream) {
-        join.streamAlias = `stream_${index}`;
-      }
+    const query =
+      dashboardPanelData.data.queries[
+        dashboardPanelData.layout.currentQueryIndex
+      ];
+    const used: Record<string, number> = {};
+    query?.joins?.forEach((join: any) => {
+      if (!join?.stream) return;
+      const base = (join.streamAlias && join._lastStream === join.stream)
+        ? join.streamAlias.replace(/_\d+$/, "")
+        : `stream`;
+      // ensure stable alias per stream occurrence
+      used[base] = (used[base] || 0) + 1;
+      const alias = `${base}_${used[base]}`;
+      join.streamAlias = alias;
+      join._lastStream = join.stream;
     });
   },
-  {
-    deep: true,
-  },
+  { deep: true },
 );

 const buildCondition = (condition: any) => {
   const streamAlias =
-    condition.column.streamAlias ??
+    condition?.column?.streamAlias ??
     dashboardPanelData.data.queries[
       dashboardPanelData.layout.currentQueryIndex
     ].fields.stream;
 
-  if (condition.filterType === "group") {
-    const groupConditions = condition.conditions
-      .map(buildCondition)
-      .filter(Boolean);
-    const logicalOperators = condition.conditions
-      .map((c: any) => c.logicalOperator)
-      .filter(Boolean);
+  if (!condition) return "";
 
-    let groupQuery = "";
-    groupConditions.forEach((cond: any, index: any) => {
-      if (index > 0) {
-        groupQuery += ` ${logicalOperators[index]} `;
-      }
-      groupQuery += cond;
-    });
+  if (condition.filterType === "group" && Array.isArray(condition.conditions)) {
+    const built = condition.conditions.map(buildCondition).filter((c: any) => typeof c === "string" && c.length > 0);
+    if (!built.length) return "";
+    let groupQuery = built[0];
+    for (let i = 1; i < built.length; i++) {
+      const op = condition.conditions[i]?.logicalOperator || "AND";
+      groupQuery += ` ${op} ${built[i]}`;
+    }
+    return `(${groupQuery})`;
+  }
 
-    return groupConditions.length ? `(${groupQuery})` : "";
-  } else if (condition.type === "list" && condition.values?.length > 0) {
-    return `${streamAlias}.${condition.column.field} IN (${condition.values
+  if (!condition.column || !condition.column.field) return "";
+
+  if (condition.type === "list" && Array.isArray(condition.values) && condition.values.length > 0) {
+    const inVals = condition.values
       .map((value: any) => formatValue(value, condition.column))
-      .join(", ")})`;
-  } else if (condition.type === "condition" && condition.operator != null) {
+      .filter((v: any) => v !== null && v !== undefined)
+      .join(", ");
+    if (!inVals) return "";
+    return `${streamAlias}.${condition.column.field} IN (${inVals})`;
+  }
+
+  if (condition.type === "condition" && condition.operator != null) {
     let selectFilter = "";
+    const colExpr = `${streamAlias}.${condition.column.field}`;
+
     if (["Is Null", "Is Not Null"].includes(condition.operator)) {
-      selectFilter += `${streamAlias}.${condition.column.field} `;
-      switch (condition.operator) {
-        case "Is Null":
-          selectFilter += `IS NULL`;
-          break;
-        case "Is Not Null":
-          selectFilter += `IS NOT NULL`;
-          break;
-      }
-    } else if (condition.operator === "IN") {
-      selectFilter += `${streamAlias}.${condition.column.field} IN (${formatINValue(
-        condition.value,
-      )})`;
-    } else if (condition.operator === "NOT IN") {
-      selectFilter += `${streamAlias}.${condition.column.field} NOT IN (${formatINValue(
-        condition.value,
-      )})`;
-    } else if (condition.operator === "match_all") {
-      selectFilter += `match_all(${formatValue(condition.value, condition.column)})`;
-    } else if (condition.operator === "str_match") {
-      selectFilter += `str_match(${streamAlias}.${condition.column.field}, ${formatValue(
-        condition.value,
-        condition.column,
-      )})`;
-    } else if (condition.operator === "str_match_ignore_case") {
-      selectFilter += `str_match_ignore_case(${streamAlias}.${condition.column.field}, ${formatValue(condition.value, condition.column)})`;
-    } else if (condition.operator === "re_match") {
-      selectFilter += `re_match(${streamAlias}.${condition.column.field}, ${formatValue(
-        condition.value,
-        condition.column,
-      )})`;
-    } else if (condition.operator === "re_not_match") {
-      selectFilter += `re_not_match(${streamAlias}.${condition.column.field}, ${formatValue(
-        condition.value,
-        condition.column,
-      )})`;
-    } else if (condition.value != null && condition.value !== "") {
-      // streamAlias can be undefined or null, also, groupedfield will have one entry with streamAlias as null
-      // so we need to handle both cases
-      const streamFields = condition.column.streamAlias
-        ? dashboardPanelData?.meta?.streamFields?.groupedFields.find(
-            (it: any) => it.stream_alias === condition.column.streamAlias,
-          )
-        : dashboardPanelData?.meta?.streamFields?.groupedFields.find(
-            (it: any) =>
-              it.stream_alias === null || it.stream_alias === undefined,
-          );
+      selectFilter += `${colExpr} ${condition.operator === "Is Null" ? "IS NULL" : "IS NOT NULL"}`;
+      return selectFilter;
+    }
 
-      const columnType = streamFields?.schema?.find(
-        (it: any) => it.name == condition.column.field,
-      )?.type;
+    if (condition.operator === "IN" || condition.operator === "NOT IN") {
+      const v = formatINValue(condition.value);
+      if (!v) return "";
+      selectFilter += `${colExpr} ${condition.operator} (${v})`;
+      return selectFilter;
+    }
 
-      selectFilter += `${streamAlias}.${condition.column.field} `;
-      switch (condition.operator) {
-        case "=":
-        case "<>":
-        case "<":
-        case ">":
-        case "<=":
-        case ">=":
-          selectFilter += `${condition.operator} ${formatValue(
-            condition.value,
-            condition.column,
-          )}`;
-          break;
-        case "Contains":
-          selectFilter +=
-            columnType === "Utf8"
-              ? `LIKE '%${condition.value}%'`
-              : `LIKE %${condition.value}%`;
-          break;
-        case "Not Contains":
-          selectFilter +=
-            columnType === "Utf8"
-              ? `NOT LIKE '%${condition.value}%'`
-              : `NOT LIKE %${condition.value}%`;
-          break;
-        case "Starts With":
-          selectFilter +=
-            columnType === "Utf8"
-              ? `LIKE '${condition.value}%'`
-              : `LIKE ${condition.value}%`;
-          break;
-        case "Ends With":
-          selectFilter +=
-            columnType === "Utf8"
-              ? `LIKE '%${condition.value}'`
-              : `LIKE %${condition.value}`;
-          break;
-        default:
-          selectFilter += `${condition.operator} ${formatValue(
-            condition.value,
-            condition.column,
-          )}`;
-          break;
-      }
+    if (condition.operator === "match_all") {
+      const v = formatValue(condition.value, condition.column);
+      if (v === null || v === undefined) return "";
+      return `match_all(${v})`;
     }
-    return selectFilter;
+
+    if (condition.operator === "str_match") {
+      const v = formatValue(condition.value, condition.column);
+      if (v === null || v === undefined) return "";
+      return `str_match(${colExpr}, ${v})`;
+    }
+
+    if (condition.operator === "str_match_ignore_case") {
+      const v = formatValue(condition.value, condition.column);
+      if (v === null || v === undefined) return "";
+      return `str_match_ignore_case(${colExpr}, ${v})`;
+    }
+
+    if (condition.operator === "re_match") {
+      const v = formatValue(condition.value, condition.column);
+      if (v === null || v === undefined) return "";
+      return `re_match(${colExpr}, ${v})`;
+    }
+
+    if (condition.operator === "re_not_match") {
+      const v = formatValue(condition.value, condition.column);
+      if (v === null || v === undefined) return "";
+      return `re_not_match(${colExpr}, ${v})`;
+    }
+
+    if (condition.value == null || condition.value === "") return "";
+
+    const streamFields = condition.column.streamAlias
+      ? dashboardPanelData?.meta?.streamFields?.groupedFields.find(
+          (it: any) => it.stream_alias === condition.column.streamAlias,
+        )
+      : dashboardPanelData?.meta?.streamFields?.groupedFields.find(
+          (it: any) => it.stream_alias === null || it.stream_alias === undefined,
+        );
+
+    const columnType = streamFields?.schema?.find(
+      (it: any) => it.name == condition.column.field,
+    )?.type;
+
+    const safeOperator = ["=", "<>", "<", ">", "<=", ">=", "Contains", "Not Contains", "Starts With", "Ends With"].includes(condition.operator)
+      ? condition.operator
+      : "=";
+
+    switch (safeOperator) {
+      case "=":
+      case "<>":
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+        return `${colExpr} ${safeOperator} ${formatValue(condition.value, condition.column)}`;
+      case "Contains":
+        return `${colExpr} ${columnType === "Utf8" ? `LIKE '%${condition.value}%'` : `LIKE %${condition.value}%`}`;
+      case "Not Contains":
+        return `${colExpr} ${columnType === "Utf8" ? `NOT LIKE '%${condition.value}%'` : `NOT LIKE %${condition.value}%`}`;
+      case "Starts With":
+        return `${colExpr} ${columnType === "Utf8" ? `LIKE '${condition.value}%'` : `LIKE ${condition.value}%`}`;
+      case "Ends With":
+        return `${colExpr} ${columnType === "Utf8" ? `LIKE '%${condition.value}'` : `LIKE %${condition.value}`}`;
+      default:
+        return `${colExpr} = ${formatValue(condition.value, condition.column)}`;
+    }
   }
   return "";
 };