docs: def drill_filter(esfilter, data):
      """
      PARTIAL EVALUATE THE FILTER BASED ON DATA GIVEN
  
      TODO:  FIX THIS MONUMENALLY BAD IDEA
      """
      esfilter = unwrap(esfilter)
      primary_nested = []  # track if nested, changes if not
      primary_column = []  # only one path allowed
      primary_branch = (
          []
      )  # CONTAINS LISTS OF RECORDS TO ITERATE: constantly changing as we dfs the tree
  
      def parse_field(fieldname, data, depth):
          """
          RETURN (first, rest) OF fieldname
          """
          col = split_field(fieldname)
          d = data
          for i, c in enumerate(col):
              try:
                  d = d[c]
              except Exception as e:
                  Log.error("{{name}} does not exist", name=fieldname)
              if is_list(d) and len(col) > 1:
                  if len(primary_column) <= depth + i:
                      primary_nested.append(True)
                      primary_column.append(c)
                      primary_branch.append(d)
                  elif primary_nested[depth] and primary_column[depth + i] != c:
                      Log.error("only one branch of tree allowed")
                  else:
                      primary_nested[depth + i] = True
                      primary_column[depth + i] = c
                      primary_branch[depth + i] = d
  
                  return c, join_field(col[i + 1 :])
              else:
                  if len(primary_column) <= depth + i:
                      primary_nested.append(False)
                      primary_column.append(c)
                      primary_branch.append([d])
          return fieldname, None
  
      def pe_filter(filter, data, depth):
          """
          PARTIAL EVALUATE THE filter BASED ON data GIVEN
          """
          if filter is TRUE:
              return True
          if filter is FALSE:
              return False
  
          filter = wrap(filter)
  
          if filter["and"]:
              result = True
              output = FlatList()
              for a in filter["and"]:
                  f = pe_filter(a, data, depth)
                  if f is False:
                      result = False
                  elif f is not True:
                      output.append(f)
              if result and output:
                  return {"and": output}
              else:
                  return result
          elif filter["or"]:
              output = FlatList()
              for o in filter["or"]:
                  f = pe_filter(o, data, depth)
                  if f is True:
                      return True
                  elif f is not False:
                      output.append(f)
              if output:
                  return {"or": output}
              else:
                  return False
          elif filter["not"]:
              f = pe_filter(filter["not"], data, depth)
              if f is True:
                  return False
              elif f is False:
                  return True
              else:
                  return {"not": f}
          elif filter.term or filter.eq:
              eq = coalesce(filter.term, filter.eq)
              result = True
              output = {}
              for col, val in eq.items():
                  first, rest = parse_field(col, data, depth)
                  d = data[first]
                  if not rest:
                      if d != val:
                          result = False
                  else:
                      output[rest] = val
  
              if result and output:
                  return {"term": output}
              else:
                  return result
          elif filter.equal:
              a, b = filter["equal"]
              first_a, rest_a = parse_field(a, data, depth)
              first_b, rest_b = parse_field(b, data, depth)
              val_a = data[first_a]
              val_b = data[first_b]
              if not rest_a:
                  if not rest_b:
                      if val_a != val_b:
                          return False
                      else:
                          return True
                  else:
                      return {"term": {rest_b: val_a}}
              else:
                  if not rest_b:
                      return {"term": {rest_a: val_b}}
                  else:
                      return {"equal": [rest_a, rest_b]}
  
          elif filter.terms:
              result = True
              output = {}
              for col, vals in filter["terms"].items():
                  first, rest = parse_field(col, data, depth)
                  d = data[first]
                  if not rest:
                      if d not in vals:
                          result = False
                  else:
                      output[rest] = vals
              if result and output:
                  return {"terms": output}
              else:
                  return result
  
          elif filter.range:
              result = True
              output = {}
              for col, ranges in filter["range"].items():
                  first, rest = parse_field(col, data, depth)
                  d = data[first]
                  if not rest:
                      for sign, val in ranges.items():
                          if sign in ("gt", ">") and d <= val:
                              result = False
                          if sign == "gte" and d < val:
                              result = False
                          if sign == "lte" and d > val:
                              result = False
                          if sign == "lt" and d >= val:
                              result = False
                  else:
                      output[rest] = ranges
              if result and output:
                  return {"range": output}
              else:
                  return result
          elif filter.missing:
              if is_text(filter.missing):
                  field = filter["missing"]
              else:
                  field = filter["missing"]["field"]
  
              first, rest = parse_field(field, data, depth)
              d = data[first]
              if not rest:
                  if d == None:
                      return True
                  return False
              else:
                  return {"missing": rest}
          elif filter.prefix:
              result = True
              output = {}
              for col, val in filter["prefix"].items():
                  first, rest = parse_field(col, data, depth)
                  d = data[first]
                  if not rest:
                      if d == None or not d.startswith(val):
                          result = False
                  else:
                      output[rest] = val
              if result and output:
                  return {"prefix": output}
              else:
                  return result
  
          elif filter.exists:
              if is_text(filter["exists"]):
                  field = filter["exists"]
              else:
                  field = filter["exists"]["field"]
  
              first, rest = parse_field(field, data, depth)
              d = data[first]
              if not rest:
                  if d != None:
                      return True
                  return False
              else:
                  return {"exists": rest}
          else:
              Log.error("Can not interpret esfilter: {{esfilter}}", {"esfilter": filter})
  
      output = []  # A LIST OF OBJECTS MAKING THROUGH THE FILTER
  
      def main(sequence, esfilter, row, depth):
          """
          RETURN A SEQUENCE OF REFERENCES OF OBJECTS DOWN THE TREE
          SHORT SEQUENCES MEANS ALL NESTED OBJECTS ARE INCLUDED
          """
          new_filter = pe_filter(esfilter, row, depth)
          if new_filter is True:
              seq = list(sequence)
              seq.append(row)
              output.append(seq)
              return
          elif new_filter is False:
              return
  
          seq = list(sequence)
          seq.append(row)
          for d in primary_branch[depth]:
              main(seq, new_filter, d, depth + 1)
  
      # OUTPUT
      for i, d in enumerate(data):
          if is_data(d):
              main([], esfilter, wrap(d), 0)
          else:
              Log.error("filter is expecting a dict, not {{type}}", type=d.__class__)
  
      # AT THIS POINT THE primary_column[] IS DETERMINED
      # USE IT TO EXPAND output TO ALL NESTED OBJECTS
      max = 0  # EVEN THOUGH A ROW CAN HAVE MANY VALUES, WE ONLY NEED UP TO max
      for i, n in enumerate(primary_nested):
          if n:
              max = i + 1
  
      # OUTPUT IS A LIST OF ROWS,
      # WHERE EACH ROW IS A LIST OF VALUES SEEN DURING A WALK DOWN A PATH IN THE HIERARCHY
      uniform_output = FlatList()
  
      def recurse(row, depth):
          if depth == max:
              uniform_output.append(row)
          else:
              nested = row[-1][primary_column[depth]]
              if not nested:
                  # PASSED FILTER, BUT NO CHILDREN, SO ADD NULL CHILDREN
                  for i in range(depth, max):
                      row.append(None)
                  uniform_output.append(row)
              else:
                  for d in nested:
                      r = list(row)
                      r.append(d)
                      recurse(r, depth + 1)
  
      for o in output:
          recurse(o, 0)
  
      if not max:
          # SIMPLE LIST AS RESULT
          return wrap([unwrap(u[0]) for u in uniform_output])
  
      return PartFlatList(primary_column[0:max], uniform_output)