anchor.diff:      |> createInsertOperation insertMode
       |> table.Execute
   
  -let insertEntityObject connection tableName partitionKey rowKey entity insertMode = 
  -    insertEntity connection tableName insertMode { PartitionKey = partitionKey
  -                                                   RowKey = rowKey
  -                                                   Timestamp = DateTimeOffset.MinValue
  -                                                   Values = 
  -                                                       entity.GetType()
  -                                                             .GetProperties(Reflection.BindingFlags.Public 
  -                                                                            ||| Reflection.BindingFlags.Instance)
  -                                                       |> Seq.map(fun prop -> prop.Name, prop.GetValue(entity, null))
  -                                                       |> Map.ofSeq }
  -
   let insertEntityObjectBatch connection tableName insertMode entities = 
       let table = getTable connection tableName
       entities
  -    |> Seq.map(fun (partition, row, entity) -> 
  -           { PartitionKey = partition
  -             RowKey = row
  +    |> Seq.map(fun (partitionKey, rowKey, entity) -> 
  +           { PartitionKey = partitionKey
  +             RowKey = rowKey
                Timestamp = DateTimeOffset.MinValue
                Values = 
                    entity.GetType().GetProperties(Reflection.BindingFlags.Public ||| Reflection.BindingFlags.Instance)
  
positive.code:     |> Seq.map buildDynamicTableEntity
      |> executeBatchOperation (createInsertOperation insertMode) table
      |> Seq.toArray
  
  let composeAllFilters filters = 
      match filters with
  
negative.code:     | TableInsertMode.InsertOrReplace -> TableOperation.InsertOrReplace
      | _ -> failwith "unknown insertion mode"
  
  let private batch size source =
      let rec doBatch output currentBatch counter remainder =
          match remainder with
          | [] -> if currentBatch = [] then output else currentBatch::output |> List.rev
          | theList when counter = size -> doBatch ((currentBatch |> List.rev) ::output) [] 0 theList
          | head::tail -> doBatch output (head::currentBatch) (counter + 1) tail
      doBatch [] [] 0 (source |> Seq.toList)
  
  let private executeBatchOperation operation (table:CloudTable) entities =
      entities
      |> Seq.groupBy(fun (entity:DynamicTableEntity) -> entity.PartitionKey)
      |> Seq.collect(fun (partitionKey, entities) -> 
             entities
             |> batch 100
             |> Seq.map(fun entityBatch ->
                  let batchForPartition = TableBatchOperation()
                  for entity in entityBatch do
                      entity
                      |> operation
                      |> batchForPartition.Add
                  batchForPartition))
      |> Seq.collect table.ExecuteBatch
  
  let deleteEntities connection tableName entities =
  