diff --git a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluate.tsx b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluate.tsx
index c9aed0c979a..69022c3b5db 100644
--- a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluate.tsx
+++ b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluate.tsx
@@ -1,13 +1,25 @@
 import { MuiButton } from "@fiftyone/components";
 import { Add } from "@mui/icons-material";
+import { Box } from "@mui/material";
 import React from "react";
 
 export default function Evaluate(props: EvaluateProps) {
-  const { onEvaluate } = props;
+  const { onEvaluate, permissions } = props;
+  const canEvaluate = permissions.can_evaluate;
   return (
-    <MuiButton onClick={onEvaluate} startIcon={<Add />} variant="contained">
-      Evaluate Model
-    </MuiButton>
+    <Box
+      title={canEvaluate ? "" : "You do not have permission to evaluate model"}
+      sx={{ cursor: canEvaluate ? "pointer" : "not-allowed" }}
+    >
+      <MuiButton
+        onClick={onEvaluate}
+        startIcon={<Add />}
+        variant="contained"
+        disabled={!canEvaluate}
+      >
+        Evaluate Model
+      </MuiButton>
+    </Box>
   );
 }
 
diff --git a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluation.tsx b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluation.tsx
index eb5b401efce..db050651261 100644
--- a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluation.tsx
+++ b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Evaluation.tsx
@@ -51,6 +51,7 @@ import { formatValue, getNumericDifference, useTriggerEvent } from "./utils";
 const KEY_COLOR = "#ff6d04";
 const COMPARE_KEY_COLOR = "#03a9f4";
 const DEFAULT_BAR_CONFIG = { sortBy: "default" };
+const NONE_CLASS = "(none)";
 
 export default function Evaluation(props: EvaluationProps) {
   const {
@@ -611,20 +612,26 @@ export default function Evaluation(props: EvaluationProps) {
       <Card sx={{ p: 2 }}>
         <Stack direction="row" sx={{ justifyContent: "space-between" }}>
           <Typography color="secondary">Evaluation notes</Typography>
-          {can_edit_note && (
-            <Box>
-              <IconButton
-                size="small"
-                color="secondary"
-                sx={{ borderRadius: 16 }}
-                onClick={() => {
-                  setEditNoteState((note) => ({ ...note, open: true }));
-                }}
-              >
-                <EditNote />
-              </IconButton>
-            </Box>
-          )}
+          <Box
+            title={
+              can_edit_note
+                ? ""
+                : "You do not have permission to edit evaluation notes"
+            }
+            sx={{ cursor: can_edit_note ? "pointer" : "not-allowed" }}
+          >
+            <IconButton
+              size="small"
+              color="secondary"
+              sx={{ borderRadius: 16 }}
+              onClick={() => {
+                setEditNoteState((note) => ({ ...note, open: true }));
+              }}
+              disabled={!can_edit_note}
+            >
+              <EditNote />
+            </IconButton>
+          </Box>
         </Stack>
         <EvaluationNotes notes={evaluationNotes} variant="details" />
       </Card>
@@ -1656,12 +1663,23 @@ function getMatrix(matrices, config, maskTargets, compareMaskTargets?) {
   if (!matrices) return;
   const { sortBy = "az", limit } = config;
   const parsedLimit = typeof limit === "number" ? limit : undefined;
-  const classes = matrices[`${sortBy}_classes`].slice(0, parsedLimit);
-  const matrix = matrices[`${sortBy}_matrix`].slice(0, parsedLimit);
+  const originalClasses = matrices[`${sortBy}_classes`];
+  const originalMatrix = matrices[`${sortBy}_matrix`];
+  const classes = originalClasses.slice(0, parsedLimit);
+  const matrix = originalMatrix.slice(0, parsedLimit);
   const colorscale = matrices[`${sortBy}_colorscale`];
   const labels = classes.map((c) => {
     return compareMaskTargets?.[c] || maskTargets?.[c] || c;
   });
+  const noneIndex = originalClasses.indexOf(NONE_CLASS);
+  if (parsedLimit < originalClasses.length) {
+    labels.push(
+      compareMaskTargets?.[NONE_CLASS] ||
+        maskTargets?.[NONE_CLASS] ||
+        NONE_CLASS
+    );
+    matrix.push(originalMatrix[noneIndex]);
+  }
   return { labels, matrix, colorscale };
 }
 
@@ -1687,7 +1705,7 @@ function useActiveFilter(evaluation, compareEvaluation) {
     const { _cls, kwargs } = stage;
     if (_cls.endsWith("FilterLabels")) {
       const [_, filter] = kwargs;
-      const filterEq = filter[1].$eq;
+      const filterEq = filter[1].$eq || [];
       const [filterEqLeft, filterEqRight] = filterEq;
       if (filterEqLeft === "$$this.label") {
         return { type: "label", value: filterEqRight };
diff --git a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Overview.tsx b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Overview.tsx
index b0aa8f99d8c..643ec14b7d1 100644
--- a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Overview.tsx
+++ b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Overview.tsx
@@ -97,7 +97,7 @@ function EvaluationCard(props: EvaluationCardProps) {
               }
             />
           )}
-          {status && <Status status={status} />}
+          {status && <Status status={status} readOnly />}
         </Stack>
         {note && <EvaluationNotes notes={note} variant="overview" />}
       </Card>
diff --git a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Status.tsx b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Status.tsx
index 346cbb3245a..bc3eb526355 100644
--- a/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Status.tsx
+++ b/app/packages/core/src/plugins/SchemaIO/components/NativeModelEvaluationView/Status.tsx
@@ -4,10 +4,10 @@ import React from "react";
 import { useTriggerEvent } from "./utils";
 
 export default function Status(props: StatusProps) {
-  const { status, canEdit, setStatusEvent } = props;
+  const { status, canEdit, readOnly, setStatusEvent } = props;
   const triggerEvent = useTriggerEvent();
 
-  if (canEdit) {
+  if (!readOnly) {
     return (
       <Select
         sx={{
@@ -22,6 +22,12 @@ export default function Status(props: StatusProps) {
         onChange={(e) => {
           triggerEvent(setStatusEvent, { status: e.target.value });
         }}
+        title={
+          canEdit
+            ? ""
+            : "You do not have permission to update evaluation status"
+        }
+        disabled={!canEdit}
       >
         {STATUSES.map((status) => {
           const color = COLOR_BY_STATUS[status];
@@ -63,7 +69,8 @@ export default function Status(props: StatusProps) {
 type StatusProps = {
   status?: string;
   canEdit?: boolean;
-  setStatusEvent?: string;
+  readOnly?: boolean;
+  setStatusEvent: string;
 };
 
 const STATUS_LABELS = {
diff --git a/app/packages/operators/src/CustomPanel.tsx b/app/packages/operators/src/CustomPanel.tsx
index 14d3548ca09..36743740274 100644
--- a/app/packages/operators/src/CustomPanel.tsx
+++ b/app/packages/operators/src/CustomPanel.tsx
@@ -14,12 +14,14 @@ import { useActivePanelEventsCount } from "./hooks";
 import { Property } from "./types";
 import { CustomPanelProps, useCustomPanelHooks } from "./useCustomPanelHooks";
 import { useTrackEvent } from "@fiftyone/analytics";
+import usePanelEvent from "./usePanelEvent";
 
 export function CustomPanel(props: CustomPanelProps) {
   const { panelId, dimensions, panelName, panelLabel, isModalPanel } = props;
   const { height, width } = dimensions?.bounds || {};
   const { count } = useActivePanelEventsCount(panelId);
   const [_, setLoading] = usePanelLoading(panelId);
+  const triggerPanelEvent = usePanelEvent();
 
   const {
     handlePanelStateChange,
@@ -36,6 +38,7 @@ export function CustomPanel(props: CustomPanelProps) {
     setPanelCloseEffect(() => {
       clearUseKeyStores(panelId);
       trackEvent("close_panel", { panel: panelName });
+      triggerPanelEvent(panelId, { operator: props.onUnLoad });
     });
   }, []);
 
diff --git a/app/packages/operators/src/useCustomPanelHooks.ts b/app/packages/operators/src/useCustomPanelHooks.ts
index 7363234138a..60c685255e3 100644
--- a/app/packages/operators/src/useCustomPanelHooks.ts
+++ b/app/packages/operators/src/useCustomPanelHooks.ts
@@ -165,14 +165,6 @@ export function useCustomPanelHooks(props: CustomPanelProps): CustomPanelHooks {
     triggerPanelEvent,
   ]);
 
-  useEffect(() => {
-    return () => {
-      if (props.onUnLoad) {
-        triggerPanelEvent(panelId, { operator: props.onUnLoad });
-      }
-    };
-  }, []); // eslint-disable-line react-hooks/exhaustive-deps
-
   const handlePanelStateChangeOpDebounced = useMemo(() => {
     return debounce(
       (state, onChange, panelId) => {
diff --git a/docs/source/release-notes.rst b/docs/source/release-notes.rst
index 6344e829c04..d500859ba6a 100644
--- a/docs/source/release-notes.rst
+++ b/docs/source/release-notes.rst
@@ -3,6 +3,101 @@ FiftyOne Release Notes
 
 .. default-role:: code
 
+FiftyOne Teams 2.3.0
+--------------------
+*Released December 20, 2024*
+
+Includes all updates from :ref:`FiftyOne 1.2.0 <release-notes-v1.2.0>`, plus:
+
+- Added an example :ref:`Databricks connector <data-lens-databricks>` showing
+  how to connect FiftyOne Teams to your lakehouse via
+  :ref:`Data Lens <data-lens>`
+- Added a :ref:`Data Lens connector <data-lens-snippet-remap-fields>`
+  that demonstrates how to allow users to dynamically configure the field(s)
+  that are imported
+- :ref:`Data Lens <data-lens>` now supports previewing 3D data imports
+- Guest users can now open :ref:`Data Lens <data-lens>`
+- When scanning for issues with the :ref:`Data Quality Panel <data-quality>`,
+  any fields created are now added to a `DATA QUALITY` sidebar group
+- Prevented unnecessary scrollbars from appearing when using the
+  :ref:`Data Quality Panel <data-quality>`
+- AWS session tokens are now supported when configuring
+  :ref:`cloud credentials <teams-cloud-credentials>`
+- Fixed a bug that could cause `StopIteration` errors when performing
+  long-running operations like computing embeddings when using
+  :ref:`API connections <teams-api-connection>`
+
+.. _release-notes-v1.2.0:
+
+FiftyOne 1.2.0
+--------------
+*Released December 30, 2024*
+
+App
+
+- Added support for :ref:`instance segmentations <instance-segmentation>` whose
+  masks are stored on-disk
+  `#5120 <https://github.com/voxel51/fiftyone/pull/5120>`_,
+  `#5256 <https://github.com/voxel51/fiftyone/pull/5256>`_
+- Optimized overlay rendering for dense label fields like segmentations and
+  heatmaps
+  `#5156 <https://github.com/voxel51/fiftyone/pull/5156>`_,
+  `#5169 <https://github.com/voxel51/fiftyone/pull/5169>`_,
+  `#5247 <https://github.com/voxel51/fiftyone/pull/5247>`_
+- Improved stability of frame rendering for videos
+  `#5199 <https://github.com/voxel51/fiftyone/pull/5199>`_,
+  `#5293 <https://github.com/voxel51/fiftyone/pull/5293>`_
+- Sidebar groups that contain only list fields are no longer collapsed by
+  default
+  `#5280 <https://github.com/voxel51/fiftyone/pull/5280>`_
+- The :ref:`Model Evaluation panel <app-model-evaluation-panel>` now filters
+  both ground truth and prediction fields when you perform interactive filters
+  via the TP/FP/FN icons, per-class histograms, and confusion matrices
+  `#5268 <https://github.com/voxel51/fiftyone/pull/5268>`_
+- When comparing two models in the
+  :ref:`Model Evaluation panel <app-model-evaluation-panel>`, interactive
+  filters now apply to both evaluation runs
+  `#5268 <https://github.com/voxel51/fiftyone/pull/5268>`_
+- The :ref:`Model Evaluation panel <app-model-evaluation-panel>` now supports
+  evaluations that were performed on subsets (views) of the full dataset
+  `#5267 <https://github.com/voxel51/fiftyone/pull/5267>`_
+- The :ref:`Model Evaluation panel <app-model-evaluation-panel>` now shows mask
+  targets for segmentation evaluations when they are available
+  `#5281 <https://github.com/voxel51/fiftyone/pull/5281>`_
+- The :ref:`Model Evaluation panel <app-model-evaluation-panel>` now hides
+  metrics that aren't applicable to a given evaluation type
+  `#5281 <https://github.com/voxel51/fiftyone/pull/5281>`_
+- Fixed an issue where backtick can't be typed when editing markdown notes in
+  the :ref:`Model Evaluation panel <app-model-evaluation-panel>`
+  `#5233 <https://github.com/voxel51/fiftyone/pull/5233>`_
+- Fixed a race condition that could cause errors when performing
+  :ref:`text similarity searches <brain-similarity-text>`
+  `#5273 <https://github.com/voxel51/fiftyone/pull/5273>`_
+- Fixed a caching bug that prevented label overlay font sizes from dynamically
+  resizing as expected in some cases
+  `#5287 <https://github.com/voxel51/fiftyone/pull/5287>`_
+- Fixed a bug that excluded selected samples from the counter above the Samples
+  panel
+  `#5286 <https://github.com/voxel51/fiftyone/pull/5286>`_
+
+SDK
+
+- Optimized :meth:`dataset.first() <fiftyone.core.dataset.Dataset.first>` calls
+  `#5305 <https://github.com/voxel51/fiftyone/pull/5305>`_
+
+Brain
+
+- Upgraded the :Ref:`MongoDB vector search integration <mongodb-integration>`
+  to use the `vectorSearch` type
+  `#218 <https://github.com/voxel51/fiftyone-brain/pull/218>`_
+
+Zoo
+
+- Fixed a bug with loading the
+  :ref:`rtdetr-l-coco-torch <model-zoo-rtdetr-l-coco-torch>` and
+  :ref:`rtdetr-x-coco-torch <model-zoo-rtdetr-x-coco-torch>` zoo models
+  `#5220 <https://github.com/voxel51/fiftyone/pull/5220>`_
+
 FiftyOne Teams 2.2.0
 --------------------
 *Released December 6, 2024*
@@ -21,7 +116,7 @@ Includes all updates from :ref:`FiftyOne 1.1.0 <release-notes-v1.1.0>`, plus:
 - Added support for creating embeddings visualizations natively from the
   :ref:`Embeddings panel <app-embeddings-panel>`
 - Added support for evaluating models natively from the
-  :ref:`Modal Evaluation panel <app-model-evaluation-panel>`
+  :ref:`Model Evaluation panel <app-model-evaluation-panel>`
 - Added support for :ref:`configuring an SMTP server <identity-providers>` for
   sending user invitiations via email when running in
   :ref:`Internal Mode <internal-mode>`
@@ -2639,8 +2734,8 @@ Core
 - Using new libraries for ndjson and archive extraction
   `#2864 <https://github.com/voxel51/fiftyone/pull/2864>`_
 - Fixed a bug that prevented
-  :ref:`text similarity searches <brain-similarity-text>` searches from
-  succeeding when GPU is available
+  :ref:`text similarity searches <brain-similarity-text>` from succeeding when
+  GPU is available
   `#2853 <https://github.com/voxel51/fiftyone/pull/2853>`_
 - Fixed a bug where
   :meth:`stats() <fiftyone.core.collections.SampleCollection.stats>` would
diff --git a/docs/source/teams/data_lens.rst b/docs/source/teams/data_lens.rst
index d8f3923eb22..048cc6811e7 100644
--- a/docs/source/teams/data_lens.rst
+++ b/docs/source/teams/data_lens.rst
@@ -12,8 +12,10 @@ which allows you to use FiftyOne to explore and import samples from external
 data sources.
 
 Whether your data resides in a database like PostgreSQL or a data lake like
-Google BigQuery, Data Lens provides a way to search your data sources,
-visualize sample data, and import into FiftyOne for further analysis.
+:ref:`Databricks <data-lens-databricks>` or
+:ref:`BigQuery <data-lens-bigquery>`, Data Lens provides a way to search your
+data sources, visualize sample data, and import into FiftyOne for further
+analysis.
 
 .. image:: /images/teams/data_lens_home.png
     :alt: data-lens-home-tab
@@ -355,7 +357,7 @@ Using these inputs, we are expected to return a generator which yields
 :class:`DataLensSearchResponse <fiftyone.operators.data_lens.models.DataLensSearchResponse>`
 objects. To start, we'll create some synthetic data to better understand the
 interaction between Data Lens and our operator. We'll look at a
-:ref:`more realistic example <data-lens-bigquery>` later on.
+:ref:`more realistic example <data-lens-databricks>` later on.
 
 .. note::
 
@@ -573,7 +575,7 @@ There are a couple things to note about the changes we made here.
     This example is meant to illustrate how users can interact with our
     operator. For a more realistic view into how inputs can tailor our search
     experience, see our example
-    :ref:`integration with BigQuery <data-lens-bigquery>`.
+    :ref:`integration with Databricks <data-lens-databricks>`.
 
 .. _data-lens-preview-vs-import:
 
@@ -594,12 +596,350 @@ ______________________________
 This section provides example Data Lens connectors for various popular data
 sources.
 
+.. _data-lens-databricks:
+
+Databricks
+----------
+
+Below is an example of a Data Lens connector for Databricks. This example uses
+a schema consistent with the Berkeley DeepDrive dataset format.
+
+.. code-block:: python
+    :linenos:
+
+    import json
+    import time
+    from typing import Generator
+
+    import fiftyone as fo
+    from databricks.sdk import WorkspaceClient
+    from databricks.sdk.service.sql import (
+        StatementResponse, StatementState, StatementParameterListItem
+    )
+    from fiftyone import operators as foo
+    from fiftyone.operators import types
+    from fiftyone.operators.data_lens import (
+        DataLensOperator, DataLensSearchRequest, DataLensSearchResponse
+    )
+
+    class DatabricksConnector(DataLensOperator):
+        """Data Lens operator which retrieves samples from Databricks."""
+
+        @property
+        def config(self) -> foo.OperatorConfig:
+            return foo.OperatorConfig(
+                name="databricks_connector",
+                label="Databricks Connector",
+                unlisted=True,
+                execute_as_generator=True,
+            )
+
+        def resolve_input(self, ctx: foo.ExecutionContext):
+            inputs = types.Object()
+
+            # Times of day
+            inputs.bool(
+                "daytime",
+                label="Day",
+                description="Show daytime samples",
+                default=True,
+            )
+            inputs.bool(
+                "night",
+                label="Night",
+                description="Show night samples",
+                default=True,
+            )
+            inputs.bool(
+                "dawn/dusk",
+                label="Dawn / Dusk",
+                description="Show dawn/dusk samples",
+                default=True,
+            )
+
+            # Weather
+            inputs.bool(
+                "clear",
+                label="Clear weather",
+                description="Show samples with clear weather",
+                default=True,
+            )
+            inputs.bool(
+                "rainy",
+                label="Rainy weather",
+                description="Show samples with rainy weather",
+                default=True,
+            )
+
+            # Detection label
+            inputs.str(
+                "detection_label",
+                label="Detection label",
+                description="Filter samples by detection label",
+            )
+
+            return types.Property(inputs)
+
+        def handle_lens_search_request(
+                self,
+                request: DataLensSearchRequest,
+                ctx: foo.ExecutionContext
+        ) -> Generator[DataLensSearchResponse, None, None]:
+            handler = DatabricksHandler()
+            for response in handler.handle_request(request, ctx):
+                yield response
+
+
+    class DatabricksHandler:
+        """Handler for interacting with Databricks tables."""
+
+        def __init__(self):
+            self.client = None
+            self.warehouse_id = None
+
+        def handle_request(
+                self,
+                request: DataLensSearchRequest,
+                ctx: foo.ExecutionContext
+        ) -> Generator[DataLensSearchResponse, None, None]:
+
+            # Initialize the client
+            self._init_client(ctx)
+
+            # Iterate over samples
+            sample_buffer = []
+            for sample in self._iter_data(request):
+                sample_buffer.append(self._transform_sample(sample))
+
+                # Yield batches of data as they are available
+                if len(sample_buffer) == request.batch_size:
+                    yield DataLensSearchResponse(
+                        result_count=len(sample_buffer),
+                        query_result=sample_buffer,
+                    )
+
+                    sample_buffer = []
+
+            # Yield final batch if it's non-empty
+            if len(sample_buffer) > 0:
+                yield DataLensSearchResponse(
+                    result_count=len(sample_buffer),
+                    query_result=sample_buffer,
+                )
+
+            # No more samples.
+
+        def _init_client(self, ctx: foo.ExecutionContext):
+            """Prepare the Databricks client for query execution."""
+
+            # Initialize the Databricks client using credentials provided via `ctx.secret`
+            self.client = WorkspaceClient(
+                host=ctx.secret("DATABRICKS_HOST"),
+                account_id=ctx.secret("DATABRICKS_ACCOUNT_ID"),
+                client_id=ctx.secret("DATABRICKS_CLIENT_ID"),
+                client_secret=ctx.secret("DATABRICKS_CLIENT_SECRET"),
+            )
+
+            # Start a SQL warehouse instance to execute our query
+            self.warehouse_id = self._start_warehouse()
+            if self.warehouse_id is None:
+                raise ValueError("No available warehouse")
+
+        def _start_warehouse(self) -> str:
+            """Start a SQL warehouse and return its ID."""
+
+            last_warehouse_id = None
+
+            # If any warehouses are already running, use the first available
+            for warehouse in self.client.warehouses.list():
+                last_warehouse_id = warehouse.id
+                if warehouse.health.status is not None:
+                    return warehouse.id
+
+            # Otherwise, manually start the last available warehouse
+            if last_warehouse_id is not None:
+                self.client.warehouses.start(last_warehouse_id)
+
+            return last_warehouse_id
+
+        def _iter_data(self, request: DataLensSearchRequest) -> Generator[dict, None, None]:
+            """Iterate over sample data retrieved from Databricks."""
+
+            # Filter samples based on selected times of day
+            enabled_times_of_day = tuple([
+                f'"{tod}"'
+                for tod in ["daytime", "night", "dawn/dusk"]
+                if request.search_params.get(tod, False)
+            ])
+
+            # Filter samples based on selected weather
+            enabled_weather = tuple([
+                f'"{weather}"'
+                for weather in ["clear", "rainy"]
+                if request.search_params.get(weather, False)
+            ])
+
+            # Build Databricks query
+            query = f"""
+                SELECT * FROM datasets.bdd.det_train samples
+                WHERE
+                    samples.attributes.timeofday IN ({", ".join(enabled_times_of_day)})
+                AND samples.attributes.weather IN ({", ".join(enabled_weather)})
+            """
+
+            query_parameters = []
+
+            # Filter samples based on detection label if provided
+            if request.search_params.get("detection_label") not in (None, ""):
+                query += f"""
+                AND samples.name IN (
+                    SELECT DISTINCT(labels.name)
+                    FROM datasets.bdd.det_train_labels labels
+                    WHERE labels.category = :detection_label
+                )
+                """
+
+                query_parameters.append(
+                    StatementParameterListItem(
+                        "detection_label",
+                        value=request.search_params.get("detection_label")
+                    )
+                )
+
+            # Execute query asynchronously;
+            #   we'll get a statement_id that we can use to poll for results
+            statement_response = self.client.statement_execution.execute_statement(
+                query,
+                self.warehouse_id,
+                catalog="datasets",
+                parameters=query_parameters,
+                row_limit=request.max_results,
+                wait_timeout="0s"
+            )
+
+            # Poll on our statement until it's no longer in an active state
+            while (
+                    statement_response.status.state in
+                    (StatementState.PENDING, StatementState.RUNNING)
+            ):
+                statement_response = self.client.statement_execution.get_statement(
+                    statement_response.statement_id
+                )
+
+                time.sleep(2.5)
+
+            # Process the first batch of data
+            json_result = self._response_to_dicts(statement_response)
+
+            for element in json_result:
+                yield element
+
+            # Databricks paginates samples using "chunks"; iterate over chunks until next is None
+            while statement_response.result.next_chunk_index is not None:
+                statement_response = self.client.statement_execution.get_statement_result_chunk_n(
+                    statement_response.statement_id,
+                    statement_response.result.next_chunk_index
+                )
+
+                # Process the next batch of data
+                json_result = self._response_to_dicts(statement_response)
+
+                for element in json_result:
+                    yield element
+
+        def _transform_sample(self, sample: dict) -> dict:
+            """Transform a dict of raw Databricks data into a FiftyOne Sample dict."""
+
+            return fo.Sample(
+                filepath=f"cloud://bucket/{sample.get('name')}",
+                detections=self._build_detections(sample),
+            ).to_dict()
+
+        def _build_detections(self, sample: dict) -> fo.Detections:
+            # Images are a known, static size
+            image_width = 1280
+            image_height = 720
+
+            # Extract detection labels and pre-process bounding boxes
+            labels_list = json.loads(sample["labels"])
+            for label_data in labels_list:
+                if "box2d" in label_data:
+                    label_data["box2d"] = {
+                        k: float(v)
+                        for k, v in label_data["box2d"].items()
+                    }
+
+            return fo.Detections(
+                detections=[
+                    fo.Detection(
+                        label=label_data["category"],
+                        # FiftyOne expects bounding boxes to be of the form
+                        #   [x, y, width, height]
+                        # where values are normalized to the image's dimensions.
+                        #
+                        # Our source data is of the form
+                        #   {x1, y1, x2, y2}
+                        # where values are in absolute pixels.
+                        bounding_box=[
+                            label_data["box2d"]["x1"] / image_width,
+                            label_data["box2d"]["y1"] / image_height,
+                            (label_data["box2d"]["x2"] - label_data["box2d"]["x1"]) / image_width,
+                            (label_data["box2d"]["y2"] - label_data["box2d"]["y1"]) / image_height
+                        ]
+                    )
+                    for label_data in labels_list
+                    if "box2d" in label_data
+                ]
+            )
+
+        def _response_to_dicts(self, response: StatementResponse) -> list[dict]:
+            # Check for response errors before processing
+            self._check_for_error(response)
+
+            # Extract column names from response
+            columns = response.manifest.schema.columns
+            column_names = [column.name for column in columns]
+
+            # Extract data from response
+            data = response.result.data_array or []
+
+            # Each element in data is a list of raw column values.
+            # Remap ([col1, col2, ..., colN], [val1, val2, ..., valN]) tuples
+            #   to {col1: val1, col2: val2, ..., colN: valN} dicts
+            return [
+                {
+                    key: value
+                    for key, value in zip(column_names, datum)
+                }
+                for datum in data
+            ]
+
+        def _check_for_error(self, response: StatementResponse):
+            if response is None:
+                raise ValueError("received null response from databricks")
+
+            if response.status is not None:
+                if response.status.error is not None:
+                    raise ValueError("databricks error: ({0}) {1}".format(
+                        response.status.error.error_code,
+                        response.status.error.message
+                    ))
+
+                if response.status.state in (
+                        StatementState.CLOSED,
+                        StatementState.FAILED,
+                        StatementState.CANCELED,
+                ):
+                    raise ValueError(
+                        f"databricks error: response state = {response.status.state}"
+                    )
+
 .. _data-lens-bigquery:
 
 Google BigQuery
 ---------------
 
-Here's a fully-functional Data Lens connector for BigQuery:
+Below is an example of a Data Lens connector for BigQuery:
 
 .. code-block:: python
     :linenos:
@@ -787,3 +1127,84 @@ as powerful as it needs to be. We can leverage internal libraries and services,
 hosted solutions, and tooling that meets the specific needs of our data. We
 can expose flexible but precise controls to users to allow them to find exactly
 the data that's needed.
+
+.. _data-lens-snippet-remap-fields:
+
+Snippet: Dynamic user inputs
+----------------------------
+
+As the volume and complexity of your data grows, you may want to expose many
+options to Data Lens users, but doing so all at once can be overwhelming for
+the user. In this example, we'll look at how we can use
+:ref:`dynamic operators <operator-inputs>` to conditionally expose
+configuration options to Data Lens users.
+
+.. code-block:: python
+    :linenos:
+
+    class MyOperator(DataLensOperator):
+        @property
+        def config(self) -> foo.OperatorConfig:
+            return OperatorConfig(
+                name="my_operator",
+                label="My operator",
+                dynamic=True,
+            )
+
+
+By setting `dynamic=True` in our operator config, our operator will be able to
+customize the options shown to a Data Lens user based on the current state.
+Let's use this to optionally show an "advanced options" section in our query
+parameters.
+
+.. code-block:: python
+    :linenos:
+
+    def resolve_input(self, ctx: foo.ExecutionContext):
+        inputs = types.Object()
+
+        inputs.str("some_param", label="Parameter value")
+        inputs.str("other_param", label="Other value")
+
+        inputs.bool("show_advanced", label="Show advanced options", default=False)
+
+        # Since this is a dynamic operator,
+        #   we can use `ctx.params` to conditionally show options
+        if ctx.params.get("show_advanced") is True:
+            # In this example, we'll optionally show configuration which allows a user
+            #   to remap selected sample fields to another name.
+            # This could be used to enable users to import samples into datasets with
+            #   varying schemas.
+            remappable_fields = ("field_a", "field_b")
+            for field_name in remappable_fields:
+                inputs.str(f"{field_name}_remap", label=f"Remap {field_name} to another name")
+
+        return types.Property(inputs)
+
+Our operator's `resolve_input` method will be called each time `ctx.params`
+changes, which allows us to create an experience that is tailored to the Data
+Lens user's behavior. In this example, we're optionally displaying advanced
+configuration that allows a user to remap sample fields. Applying this
+remapping might look something like this.
+
+.. code-block:: python
+    :linenos:
+
+    def _remap_sample_fields(self, sample: dict, request: DataLensSearchRequest):
+        remappable_fields = ("field_a", "field_b")
+        for field_name in remappable_fields:
+            remapped_field_name = request.search_params.get(f"{field_name}_remap")
+            if remapped_field_name not in (None, ""):
+                sample[remapped_field_name] = sample[field_name]
+                del sample[field_name]
+
+Of course, dynamic operators can be used for much more than this. Search
+experiences can be broadened or narrowed to allow for both breadth and depth
+within your connected data sources.
+
+As an example, suppose a user is searching for detections of "traffic light"
+in an autonomous driving dataset. A dynamic operator can be used to expose
+additional search options that are specific to traffic lights, such as being
+able to select samples with only red, yellow, or green lights. In this way,
+dynamic operators provide a simple mechanism for developing intuitive and
+context-sensitive search experiences for Data Lens users.
diff --git a/fiftyone/core/utils.py b/fiftyone/core/utils.py
index 045a8595bd0..1f0eb1d5969 100644
--- a/fiftyone/core/utils.py
+++ b/fiftyone/core/utils.py
@@ -973,19 +973,6 @@ def __init__(self, total=None, progress=None, quiet=None, **kwargs):
         self._progress = progress
         self._callback = callback
 
-    def __call__(self, iterable):
-        # Ensure that `len(iterable)` is not computed unnecessarily
-        no_len = self._quiet and self._total is None
-        if no_len:
-            self._total = -1
-
-        super().__call__(iterable)
-
-        if no_len:
-            self._total = None
-
-        return self
-
     def set_iteration(self, *args, **kwargs):
         super().set_iteration(*args, **kwargs)
 
diff --git a/fiftyone/operators/builtins/panels/model_evaluation/__init__.py b/fiftyone/operators/builtins/panels/model_evaluation/__init__.py
index c83e8972cf3..2878b65a9a9 100644
--- a/fiftyone/operators/builtins/panels/model_evaluation/__init__.py
+++ b/fiftyone/operators/builtins/panels/model_evaluation/__init__.py
@@ -247,7 +247,7 @@ def get_confusion_matrix_colorscale(self, matrix):
         return colorscale
 
     def get_confusion_matrices(self, results):
-        default_classes = results.classes
+        default_classes = results.classes.tolist()
         freq = Counter(results.ytrue)
         if results.missing in freq:
             freq.pop(results.missing)
@@ -255,11 +255,35 @@ def get_confusion_matrices(self, results):
         za_classes = sorted(default_classes, reverse=True)
         mc_classes = sorted(freq, key=freq.get, reverse=True)
         lc_classes = sorted(freq, key=freq.get)
-        default_matrix = results.confusion_matrix()
-        az_matrix = results.confusion_matrix(classes=az_classes)
-        za_matrix = results.confusion_matrix(classes=za_classes)
-        mc_matrix = results.confusion_matrix(classes=mc_classes)
-        lc_matrix = results.confusion_matrix(classes=lc_classes)
+        default_matrix, _default_classes, _ = results._confusion_matrix(
+            include_other=False,
+            include_missing=True,
+            tabulate_ids=False,
+        )
+        az_matrix, _az_classes, _ = results._confusion_matrix(
+            classes=az_classes,
+            include_other=False,
+            include_missing=True,
+            tabulate_ids=False,
+        )
+        za_matrix, _za_classes, _ = results._confusion_matrix(
+            classes=za_classes,
+            include_other=False,
+            include_missing=True,
+            tabulate_ids=False,
+        )
+        mc_matrix, _mc_classes, _ = results._confusion_matrix(
+            classes=mc_classes,
+            include_other=False,
+            include_missing=True,
+            tabulate_ids=False,
+        )
+        lc_matrix, _lc_classes, _ = results._confusion_matrix(
+            classes=lc_classes,
+            include_other=False,
+            include_missing=True,
+            tabulate_ids=False,
+        )
         default_colorscale = self.get_confusion_matrix_colorscale(
             default_matrix
         )
@@ -268,11 +292,11 @@ def get_confusion_matrices(self, results):
         mc_colorscale = self.get_confusion_matrix_colorscale(mc_matrix)
         lc_colorscale = self.get_confusion_matrix_colorscale(lc_matrix)
         return {
-            "default_classes": default_classes.tolist(),
-            "az_classes": az_classes,
-            "za_classes": za_classes,
-            "mc_classes": mc_classes,
-            "lc_classes": lc_classes,
+            "default_classes": _default_classes,
+            "az_classes": _az_classes,
+            "za_classes": _za_classes,
+            "mc_classes": _mc_classes,
+            "lc_classes": _lc_classes,
             "default_matrix": default_matrix.tolist(),
             "az_matrix": az_matrix.tolist(),
             "za_matrix": za_matrix.tolist(),
@@ -308,13 +332,13 @@ def load_evaluation(self, ctx):
         if evaluation_data is None:
             info = ctx.dataset.get_evaluation_info(computed_eval_key)
             evaluation_type = info.config.type
+            serialized_info = info.serialize()
             if evaluation_type not in SUPPORTED_EVALUATION_TYPES:
                 ctx.panel.set_data(
                     f"evaluation_{computed_eval_key}_error",
                     {"error": "unsupported", "info": serialized_info},
                 )
                 return
-            serialized_info = info.serialize()
             gt_field = info.config.gt_field
             mask_targets = (
                 self.get_mask_targets(ctx.dataset, gt_field)
diff --git a/setup.py b/setup.py
index 097ac20823a..cd25b6874d4 100644
--- a/setup.py
+++ b/setup.py
@@ -76,7 +76,7 @@ def get_version():
     # internal packages
     "fiftyone-brain>=0.18.2,<0.19",
     "fiftyone-db>=0.4,<2.0",
-    "voxel51-eta>=0.13.0,<0.14",
+    "voxel51-eta>=0.13.1,<0.14",
 ]