docs: def update(self, table, data_list, matched_field=None, return_cols='id'):
          """
          Create a bulk insert statement which is much faster (~2x in tests with 10k & 100k rows and 4 cols)
          for inserting data then executemany()
  
          TODO: Is there a limit of length the query can be? If so handle it.
          """
          data_list = copy.deepcopy(data_list)  # Create deepcopy so the original list does not get modified
          if matched_field is None:
              # Assume the id field
              logger.info("Matched field not defined, assuming the `id` field")
              matched_field = 'id'
  
          # Make sure that `data_list` is a list
          if not isinstance(data_list, list):
              data_list = [data_list]
  
          if len(data_list) == 0:
              # No need to continue
              return []
  
          # Make sure return_cols is a list
          if return_cols is None or len(return_cols) == 0 or return_cols[0] is None:
              return_cols = ''
          elif not isinstance(return_cols, list):
              return_cols = [return_cols]
  
          if len(return_cols) > 0:
              return_cols = 'RETURNING ' + ','.join(return_cols)
  
          # Data in the list must be dicts (just check the first one)
          if not isinstance(data_list[0], dict):
              logger.critical("Data must be a list of dicts")
              # Do not return here, let the exception handle the error that will be thrown when the query runs
  
          try:
              with self.getcursor() as cur:
                  query_list = []
                  # TODO: change to return data from the database, not just what you passed in
                  return_list = []
                  for row in data_list:
                      if row.get(matched_field) is None:
                          logger.debug("Cannot update row. Missing field {field} in data {data}"
                                       .format(field=matched_field, data=row))
                          logger.error("Cannot update row. Missing field {field} in data".format(field=matched_field))
                          continue
  
                      # Pull matched_value from data to be updated and remove that key
                      matched_value = row.get(matched_field)
                      del row[matched_field]
  
                      query = "UPDATE {table} SET {data} WHERE {matched_field}=%s {return_cols}"\
                              .format(table=table,
                                      data=','.join("%s=%%s" % u for u in row.keys()),
                                      matched_field=matched_field,
                                      return_cols=return_cols
                                      )
                      values = list(row.values())
                      values.append(matched_value)
                      values = _check_values(values)
  
                      query = cur.mogrify(query, values)
                      query_list.append(query)
                      return_list.append(matched_value)
  
                  finial_query = b';'.join(query_list)
                  cur.execute(finial_query)
  
                  try:
                      return cur.fetchall()
                  except Exception:
                      return None
  
          except Exception as e:
              logger.exception("Error updating data")
              logger.debug("Error updating data: {data}".format(data=data_list))
              raise e.with_traceback(sys.exc_info()[2])