docs: def write(self, symbol, item, metadata=None, chunker=DateChunker(), audit=None, **kwargs):
          """
          Writes data from item to symbol in the database
  
          Parameters
          ----------
          symbol: str
              the symbol that will be used to reference the written data
          item: Dataframe or Series
              the data to write the database
          metadata: ?
              optional per symbol metadata
          chunker: Object of type Chunker
              A chunker that chunks the data in item
          audit: dict
              audit information
          kwargs:
              optional keyword args that are passed to the chunker. Includes:
              chunk_size:
                  used by chunker to break data into discrete chunks.
                  see specific chunkers for more information about this param.
              func: function
                  function to apply to each chunk before writing. Function
                  can not modify the date column.
          """
          if not isinstance(item, (DataFrame, Series)):
              raise Exception("Can only chunk DataFrames and Series")
  
          self._arctic_lib.check_quota()
  
          previous_shas = []
          doc = {}
          meta = {}
  
          doc[SYMBOL] = symbol
          doc[LEN] = len(item)
          doc[SERIALIZER] = self.serializer.TYPE
          doc[CHUNKER] = chunker.TYPE
          doc[USERMETA] = metadata
  
          sym = self._get_symbol_info(symbol)
          if sym:
              previous_shas = set([Binary(x[SHA]) for x in self._collection.find({SYMBOL: symbol},
                                                                                 projection={SHA: True, '_id': False},
                                                                                 )])
          ops = []
          meta_ops = []
          chunk_count = 0
  
          for start, end, chunk_size, record in chunker.to_chunks(item, **kwargs):
              chunk_count += 1
              data = self.serializer.serialize(record)
              doc[CHUNK_SIZE] = chunk_size
              doc[METADATA] = {'columns': data[METADATA][COLUMNS] if COLUMNS in data[METADATA] else ''}
              meta = data[METADATA]
  
              for i in xrange(int(len(data[DATA]) / MAX_CHUNK_SIZE + 1)):
                  chunk = {DATA: Binary(data[DATA][i * MAX_CHUNK_SIZE: (i + 1) * MAX_CHUNK_SIZE])}
                  chunk[SEGMENT] = i
                  chunk[START] = meta[START] = start
                  chunk[END] = meta[END] = end
                  chunk[SYMBOL] = meta[SYMBOL] = symbol
                  dates = [chunker.chunk_to_str(start), chunker.chunk_to_str(end), str(chunk[SEGMENT]).encode('ascii')]
                  chunk[SHA] = self._checksum(dates, chunk[DATA])
  
                  meta_ops.append(pymongo.ReplaceOne({SYMBOL: symbol,
                                                      START: start,
                                                      END: end},
                                                     meta, upsert=True))
  
                  if chunk[SHA] not in previous_shas:
                      ops.append(pymongo.UpdateOne({SYMBOL: symbol,
                                                    START: start,
                                                    END: end,
                                                    SEGMENT: chunk[SEGMENT]},
                                                   {'$set': chunk}, upsert=True))
                  else:
                      # already exists, dont need to update in mongo
                      previous_shas.remove(chunk[SHA])
  
          if ops:
              self._collection.bulk_write(ops, ordered=False)
          if meta_ops:
              self._mdata.bulk_write(meta_ops, ordered=False)
  
          doc[CHUNK_COUNT] = chunk_count
          doc[APPEND_COUNT] = 0
  
          if previous_shas:
              mongo_retry(self._collection.delete_many)({SYMBOL: symbol, SHA: {'$in': list(previous_shas)}})
  
          mongo_retry(self._symbols.update_one)({SYMBOL: symbol},
                                                {'$set': doc},
                                                upsert=True)
          if audit is not None:
              audit['symbol'] = symbol
              audit['action'] = 'write'
              audit['chunks'] = chunk_count
              self._audit.insert_one(audit)