code: def _generate_query_analysis(self, parsed_query, db_name, collection_name):
          
  
          analyzed_fields = []
          field_count = 0
          supported = True
          sort_fields = []
          query_mask = None
  
          if 'command' in parsed_query and parsed_query['command'] not in SUPPORTED_COMMANDS:
              supported = False
          else:
              #if 'orderby' in parsed_query:
              sort_component = parsed_query['orderby'] if 'orderby' in parsed_query else []
              sort_seq = 0
              for key in sort_component:
                  sort_field = {'fieldName': key,
                                'fieldType': SORT_TYPE,
                                'seq': sort_seq}
                  sort_fields.append(key)
                  analyzed_fields.append(sort_field)
                  field_count += 1
                  sort_seq += 1
  
              query_component = parsed_query['query'] if 'query' in parsed_query else {}
              for key in query_component:
                  if key not in sort_fields:
                      field_type = UNSUPPORTED_TYPE
                      if ((key not in UNSUPPORTED_QUERY_OPERATORS) and
                              (key not in COMPOSITE_QUERY_OPERATORS)):
                          try:
                              if query_component[key] == {}:
                                  raise
                              nested_field_list = query_component[key].keys()
                          except:
                              field_type = EQUIV_TYPE
                          else:
                              for nested_field in nested_field_list:
                                  if ((nested_field in RANGE_QUERY_OPERATORS) and
                                      (nested_field not in UNSUPPORTED_QUERY_OPERATORS)):
                                      field_type = RANGE_TYPE
                                  else:
                                      supported = False
                                      field_type = UNSUPPORTED_TYPE
                                      break
  
                      if field_type is UNSUPPORTED_TYPE:
                          supported = False
  
                      analyzed_field = {'fieldName': key,
                                        'fieldType': field_type}
                      analyzed_fields.append(analyzed_field)
                      field_count += 1
  
          query_mask = parsed_query['queryMask']
  
          # QUERY ANALYSIS
          return OrderedDict({
              'analyzedFields': analyzed_fields,
              'fieldCount': field_count,
              'supported': supported,
              'queryMask': query_mask
          })
docs: Translates a raw query object into a Dex query analysis