function configureQuery()

in dashboard/new-dashboard/src/configurators/MeasureConfigurator.ts [283:390]
92 lines of code
22 McCabe index (conditional complexity)

function configureQuery(measureNames: string[], query: DataQuery, configuration: DataQueryExecutorConfiguration, skipZeroValues: boolean): void {
  // stable order of series (UI) and fields in query (caching)
  measureNames.sort((a, b) => collator.compare(a, b))

  query.insertField(
    {
      n: "t",
      sql: "toUnixTimestamp(generated_time)*1000",
    },
    0
  )

  // we cannot request several measures in one SQL query - for each measure separate SQl query with filter by measure name
  const isIj = dbTypeStore().isIJStartup()
  const structureName = isIj ? "measure" : "measures"
  const valueName = isIj ? "duration" : "value"
  const field: DataQueryDimension = { n: "" }
  query.insertField(field, 1)

  if (query.db !== "ij" && query.db !== "ijDev" && !(query.db === "fleet" && query.table === "report")) {
    query.addField({ n: "measures", subName: "name" })
    query.addField({ n: "measures", subName: "type" })
  }

  const metricNameField: DataQueryDimension = { n: "" }
  if (dbTypeStore().isStartup()) {
    query.insertField(metricNameField, 2)
  }

  const prevFilters: DataQueryFilter[] = []

  const addFilter = (filter: DataQueryFilter): void => {
    prevFilters.push(filter)
    query.addFilter(filter)
  }

  configuration.queryProducers.push({
    size(): number {
      return measureNames.length
    },
    mutate(index: number): void {
      const measure = measureNames[index]

      delete field.sql
      delete field.subName

      if (prevFilters.length > 0) {
        query.removeFilters(prevFilters)
        prevFilters.length = 0
      }

      if (dbTypeStore().isStartup()) {
        delete metricNameField.sql
        delete metricNameField.subName
        if (measure.startsWith("metrics.")) {
          metricNameField.n = "metrics"
          metricNameField.subName = "name"
        } else {
          metricNameField.n = "metricName"
          metricNameField.sql = `'${measure}'`
        }
      }

      let valueFieldName: string
      if (query.table === "measure") {
        field.n = "value"
        field.resultKey = measure.replaceAll(".", "_")
        addFilter({ f: "name", v: measure })
        valueFieldName = "value"
      } else if (isIj && measure.includes("metrics.")) {
        field.n = "metrics"
        field.subName = "value"
        addFilter({ f: "metrics.name", v: measure.split("metrics.", 2)[1] })
        valueFieldName = "metrics.value"
      } else if (isIj && !measure.includes(" ") && measure != "elementTypeCount") {
        field.n = measure
        valueFieldName = measure
      } else {
        if (measure.endsWith(".end")) {
          field.n = structureName
          field.subName = "end"
          field.sql = `(${structureName}.start+${structureName}.${valueName})`
        } else {
          field.n = structureName
          field.subName = valueName
        }

        addFilter({ f: `${structureName}.name`, v: measure.endsWith(".end") ? measure.slice(0, measure.length - ".end".length) : measure })
        valueFieldName = `${structureName}.${valueName}`
      }

      if (skipZeroValues) {
        addFilter({ f: valueFieldName, o: "!=", v: 0 })
      }
    },
    getSeriesName(index: number): string {
      return measureNames.length > 1 ? measureNames[index] : ""
    },
    getMeasureName(index: number): string {
      return measureNames[index]
    },
  })

  if (query.order != null) {
    throw new Error("order must be configured only by MetricLoader")
  }
  query.order = "t"
}