docs: def QueryAllFeatures(self, url=None,
                           where="1=1",
                          out_fields="*",
                          timeFilter=None,
                          geometryFilter=None,
                          returnFeatureClass=False,
                          out_fc=None,
                          outSR=None,
                          chunksize=1000,
                          printIndent=""):
  
          """Performs an SQL query against a hosted feature service layer
          and returns all features regardless of service limit.
  
          Args:
              url (str): The URL of the feature service layer.
              where - the selection sql statement
              out_fields - the attribute fields to return
              timeFilter - a TimeFilter object where either the start time
                           or start and end time are defined to limit the
                           search results for a given time.  The values in
                           the timeFilter should be as UTC timestampes in
                           milliseconds.  No checking occurs to see if they
                           are in the right format.
              geometryFilter - a GeometryFilter object to parse down a given
                              query by another spatial dataset.
              returnFeatureClass - Default False. If true, query will be
                                   returned as feature class
              chunksize (int): The maximum amount of features to query at a time. Defaults to 1000.
              out_fc - only valid if returnFeatureClass is set to True.
                          Output location of query.
  
              Output:
                 A list of Feature Objects (default) or a path to the output featureclass if
                 returnFeatureClass is set to True.
  
          """
          if (url is None):
              return
          fl = None
          try:
              fl = FeatureLayer(url=url, securityHandler=self._securityHandler)
              qRes = fl.query(where=where,
                              returnIDsOnly=True,
                              timeFilter=timeFilter,
                              geometryFilter=geometryFilter)
  
              if 'error' in qRes:
                  print (printIndent + qRes)
                  return []
              elif 'objectIds' in qRes:
                  oids = qRes['objectIds']
                  total = len(oids)
                  if total == 0:
                      return fl.query(where=where,
                                      returnGeometry=True,
                                      out_fields=out_fields,
                                      timeFilter=timeFilter,
                                      geometryFilter=geometryFilter,
                                      outSR=outSR)
  
                  print (printIndent + "%s features to be downloaded" % total)
                  chunksize = min(chunksize, fl.maxRecordCount)
                  combinedResults = None
                  totalQueried = 0
                  for chunk in chunklist(l=oids, n=chunksize):
                      oidsQuery = ",".join(map(str, chunk))
                      if not oidsQuery:
                          continue
                      else:
                          results = fl.query(objectIds=oidsQuery,
                                             returnGeometry=True,
                                             out_fields=out_fields,
                                             timeFilter=timeFilter,
                                              geometryFilter=geometryFilter,
                                              outSR=outSR)
                          if isinstance(results,FeatureSet):
                              if combinedResults is None:
                                  combinedResults = results
                              else:
                                  for feature in results.features:
                                      combinedResults.features.append(feature)
  
                              totalQueried += len(results.features)
                              print(printIndent + "{:.0%} Completed: {}/{}".format(totalQueried / float(total), totalQueried, total))
  
                          else:
                              print (printIndent + results)
                  if returnFeatureClass == True:
                      return combinedResults.save(*os.path.split(out_fc))
                  else:
                      return combinedResults
              else:
                  print (printIndent + qRes)
          except:
              line, filename, synerror = trace()
              raise common.ArcRestHelperError({
                          "function": "QueryAllFeatures",
                          "line": line,
                          "filename":  filename,
                          "synerror": synerror,
                                          }
                                          )
          finally:
              fl = None
              del fl
              gc.collect()