You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@couchdb.apache.org by da...@apache.org on 2017/08/16 19:56:25 UTC
[couchdb] branch compactor-rewrite updated (0f899b7 -> fb67c8b)
This is an automated email from the ASF dual-hosted git repository.
davisp pushed a change to branch compactor-rewrite
in repository https://gitbox.apache.org/repos/asf/couchdb.git.
omit 0f899b7 Copy the docid tree from the old db
omit c4969f3 Simplify compaction state management
new b267ccc Simplify compaction state management
new cebc5d2 Copy the docid tree from the old db
new fb67c8b Add a test suite for compactions
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (0f899b7)
\
N -- N -- N refs/heads/compactor-rewrite (fb67c8b)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omit" are not gone; other references still
refer to them. Any revisions marked "discard" are gone forever.
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
src/couch/src/couch_db_updater.erl | 12 ++++++------
.../test/couch_db_updater_tests.erl} | 22 ++++++++++------------
2 files changed, 16 insertions(+), 18 deletions(-)
copy src/{chttpd/src/chttpd_test_util.erl => couch/test/couch_db_updater_tests.erl} (69%)
--
To stop receiving notification emails like this one, please contact
['"commits@couchdb.apache.org" <co...@couchdb.apache.org>'].
[couchdb] 02/03: Copy the docid tree from the old db
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davisp pushed a commit to branch compactor-rewrite
in repository https://gitbox.apache.org/repos/asf/couchdb.git
commit cebc5d2080e9ce57ca0d59ac193dccdbda31ed8a
Author: Paul J. Davis <pa...@gmail.com>
AuthorDate: Wed Aug 16 13:47:38 2017 -0500
Copy the docid tree from the old db
This optimizes the first pass of compaction to avoid writing data to the
emsort structure stored in the .compact.meta file. Instead of writing
data there we instead just re-read the docid tree from the original
database.
---
src/couch/src/couch_db_updater.erl | 139 +++++++++++++++++++++++++++++++------
1 file changed, 118 insertions(+), 21 deletions(-)
diff --git a/src/couch/src/couch_db_updater.erl b/src/couch/src/couch_db_updater.erl
index a83e3b4..4b0e0c5 100644
--- a/src/couch/src/couch_db_updater.erl
+++ b/src/couch/src/couch_db_updater.erl
@@ -26,6 +26,7 @@
-record(comp_st, {
old_db,
new_db,
+ new_id_tree,
meta_fd,
retry
}).
@@ -1049,9 +1050,7 @@ start_copy_compact(#db{}=Db) ->
fun copy_purge_info/1,
fun copy_compact/1,
fun commit_compaction_data/1,
- fun sort_meta_data/1,
- fun commit_compaction_data/1,
- fun copy_meta_data/1,
+ fun copy_doc_ids/1,
fun compact_final_sync/1
],
@@ -1092,8 +1091,9 @@ open_compaction_files(OldDb) ->
#comp_st{
old_db = OldDb,
new_db = Db1,
+ new_id_tree = Db0#db.id_tree,
meta_fd = MetaFd,
- retry = Db0#db.id_tree
+ retry = (couch_btree:size(Db0#db.id_tree) > 0)
};
_ when DataHdrIsDbHdr ->
% We tried to swap out the compaction but there were
@@ -1105,8 +1105,9 @@ open_compaction_files(OldDb) ->
#comp_st{
old_db = OldDb,
new_db = Db1,
+ new_id_tree = Db0#db.id_tree,
meta_fd = MetaFd,
- retry = Db0#db.id_tree
+ retry = true
};
_ ->
% We're starting a compaction from scratch
@@ -1118,8 +1119,9 @@ open_compaction_files(OldDb) ->
#comp_st{
old_db = OldDb,
new_db = Db1,
+ new_id_tree = Db0#db.id_tree,
meta_fd = MetaFd,
- retry = nil
+ retry = false
}
end,
unlink(DataFd),
@@ -1194,7 +1196,7 @@ copy_compact(#comp_st{} = CompSt) ->
AccUncopiedSize2 = AccUncopiedSize + ?term_size(DocInfo),
if AccUncopiedSize2 >= BufferSize ->
NewDb2 = copy_docs(
- Db, AccNewDb, lists:reverse([DocInfo | AccUncopied]), Retry),
+ Db, AccNewDb, lists:reverse([DocInfo | AccUncopied]), CompSt),
AccCopiedSize2 = AccCopiedSize + AccUncopiedSize2,
if AccCopiedSize2 >= CheckpointAfter ->
CommNewDb2 = commit_compaction_data(NewDb2#db{update_seq=Seq}),
@@ -1216,7 +1218,7 @@ copy_compact(#comp_st{} = CompSt) ->
{changes_done, 0},
{total_changes, TotalChanges}
],
- case (Retry /= nil) and couch_task_status:is_task_added() of
+ case Retry and couch_task_status:is_task_added() of
true ->
couch_task_status:update([
{retry, true},
@@ -1234,7 +1236,7 @@ copy_compact(#comp_st{} = CompSt) ->
{NewDb, [], 0, 0},
[{start_key, NewDb#db.update_seq + 1}]),
- NewDb3 = copy_docs(Db, NewDb2, lists:reverse(Uncopied), Retry),
+ NewDb3 = copy_docs(Db, NewDb2, lists:reverse(Uncopied), CompSt),
% copy misc header values
if NewDb3#db.security /= Db#db.security ->
@@ -1253,7 +1255,7 @@ copy_compact(#comp_st{} = CompSt) ->
}.
-copy_docs(Db, #db{fd = DestFd} = NewDb, MixedInfos, Retry) ->
+copy_docs(Db, #db{fd = DestFd} = NewDb, MixedInfos, CompSt) ->
DocInfoIds = [Id || #doc_info{id=Id} <- MixedInfos],
LookupResults = couch_btree:lookup(Db#db.id_tree, DocInfoIds),
% COUCHDB-968, make sure we prune duplicates during compaction
@@ -1305,28 +1307,41 @@ copy_docs(Db, #db{fd = DestFd} = NewDb, MixedInfos, Retry) ->
NewInfos = stem_full_doc_infos(Db, NewInfos1),
RemoveSeqs =
- case Retry of
- nil ->
- [];
- OldDocIdTree ->
+ case CompSt#comp_st.retry of
+ true ->
+ NewDocIdTree = CompSt#comp_st.new_id_tree,
% Compaction is being rerun to catch up to writes during the
% first pass. This means we may have docs that already exist
% in the seq_tree in the .data file. Here we lookup any old
% update_seqs so that they can be removed.
Ids = [Id || #full_doc_info{id=Id} <- NewInfos],
- Existing = couch_btree:lookup(OldDocIdTree, Ids),
- [Seq || {ok, #full_doc_info{update_seq=Seq}} <- Existing]
+ Existing = couch_btree:lookup(NewDocIdTree, Ids),
+ [Seq || {ok, #full_doc_info{update_seq=Seq}} <- Existing];
+ false ->
+ []
end,
{ok, SeqTree} = couch_btree:add_remove(
NewDb#db.seq_tree, NewInfos, RemoveSeqs),
- FDIKVs = lists:map(fun(#full_doc_info{id=Id, update_seq=Seq}=FDI) ->
- {{Id, Seq}, FDI}
- end, NewInfos),
- {ok, IdEms} = couch_emsort:add(NewDb#db.id_tree, FDIKVs),
+ NewIdEms = case CompSt#comp_st.retry of
+ false ->
+ % If we're not in a retry compaction then there's
+ % no reason for us to copy doc infos to the emsort
+ % structure. We can just re-use the id_tree in the
+ % old db record.
+ NewDb#db.id_tree;
+ true ->
+ % We have to store doc infos because of the possible
+ % changes in the update sequences.
+ FDIKVs = lists:map(fun(#full_doc_info{id=Id, update_seq=Seq}=FDI) ->
+ {{Id, Seq}, FDI}
+ end, NewInfos),
+ {ok, IdEms} = couch_emsort:add(NewDb#db.id_tree, FDIKVs),
+ IdEms
+ end,
update_compact_task(length(NewInfos)),
- NewDb#db{id_tree=IdEms, seq_tree=SeqTree}.
+ NewDb#db{id_tree=NewIdEms, seq_tree=SeqTree}.
copy_doc_attachments(#db{fd = SrcFd} = SrcDb, SrcSp, DestFd) ->
@@ -1417,6 +1432,88 @@ bind_id_tree(Db, Fd, State) ->
Db#db{id_tree=IdBtree}.
+copy_doc_ids(#comp_st{retry = false} = CompSt) ->
+ copy_from_tree(CompSt);
+copy_doc_ids(#comp_st{retry = true} = CompSt) ->
+ Stages = [
+ fun sort_meta_data/1,
+ fun commit_compaction_data/1,
+ fun copy_meta_data/1
+ ],
+ lists:foreach(fun(Stage, St) -> Stage(St) end, CompSt, Stages).
+
+
+copy_from_tree(#comp_st{old_db = OldDb, new_db = NewDb} = CompSt) ->
+ #db{
+ fd = OldFd,
+ header = OldHdr
+ } = OldDb,
+
+ % We're reopening a custom view of the id_tree to
+ % avoid the work of creating complete `#full_doc_info{}`
+ % records.
+ OldIdTreeState = couch_db_header:id_tree_state(OldHdr),
+ Compression = couch_compress:get_compression_method(),
+ {ok, OldIdTree} = couch_btree:open(OldIdTreeState, OldFd, [
+ {split, fun ?MODULE:btree_by_id_split/1},
+ {join, fun compact_id_join/2},
+ {reduce, fun ?MODULE:btree_by_id_reduce/2},
+ {compression, Compression}
+ ]),
+
+ NewIdTree = CompSt#comp_st.new_id_tree,
+ NewSeqTree = NewDb#db.seq_tree,
+
+ BufferSize = list_to_integer(
+ config:get("database_compaction", "doc_buffer_size", "524288")),
+
+ EnumByIdFun = fun({DocId, UpdateSeq}, _, {DstIdTree, Batch, Count}) ->
+ case Count >= 1000 of
+ true ->
+ DstIdTree2 = flush_docid_batch(
+ Batch, NewSeqTree, DstIdTree, BufferSize),
+ {ok, {DstIdTree2, [{DocId, UpdateSeq}], 1}};
+ false ->
+ {ok, {DstIdTree, [{DocId, UpdateSeq} | Batch], Count + 1}}
+ end
+ end,
+
+ {ok, _, {NewIdTree2, LastBatch, _}} =
+ couch_btree:foldl(OldIdTree, EnumByIdFun, {NewIdTree, [], 0}, []),
+ NewIdTree3 = flush_docid_batch(
+ LastBatch, NewSeqTree, NewIdTree2, BufferSize),
+ CompSt#comp_st{
+ new_db = NewDb#db{id_tree = NewIdTree3}
+ }.
+
+
+flush_docid_batch(DocIds, SeqTree, IdTree, MaxBufSize) ->
+ flush_docid_batch(DocIds, SeqTree, IdTree, MaxBufSize, [], 0).
+
+
+flush_docid_batch([], _, IdTree, _, Batch, _) ->
+ {ok, NewIdTree} = couch_btree:add(IdTree, Batch),
+ NewIdTree;
+
+flush_docid_batch(DocIds, SeqTree, IdTree, MaxBufSize, Buf, BufSize)
+ when BufSize >= MaxBufSize ->
+ {ok, NewIdTree} = couch_btree:add(IdTree, Buf),
+ flush_docid_batch(DocIds, SeqTree, NewIdTree, MaxBufSize, [], 0);
+
+flush_docid_batch(DocIds, SeqTree, IdTree, MaxBufSize, Buf, BufSize) ->
+ [{_Id, Seq} | Rest] = DocIds,
+ [{ok, #full_doc_info{} = FDI}] = couch_btree:lookup(SeqTree, [Seq]),
+ NewBuf = [FDI | Buf],
+ NewBufSize = BufSize + ?term_size(FDI),
+ flush_docid_batch(Rest, SeqTree, IdTree, MaxBufSize, NewBuf, NewBufSize).
+
+
+compact_id_join(Id, {HighSeq, _, _}) ->
+ {Id, HighSeq};
+compact_id_join(Id, {HighSeq, _, _, _}) ->
+ {Id, HighSeq}.
+
+
sort_meta_data(#comp_st{new_db = Db0} = CompSt) ->
{ok, Ems} = couch_emsort:merge(Db0#db.id_tree),
CompSt#comp_st{
--
To stop receiving notification emails like this one, please contact
"commits@couchdb.apache.org" <co...@couchdb.apache.org>.
[couchdb] 01/03: Simplify compaction state management
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davisp pushed a commit to branch compactor-rewrite
in repository https://gitbox.apache.org/repos/asf/couchdb.git
commit b267ccceab85e6baf77178bbb1f234e76568dce1
Author: Paul J. Davis <pa...@gmail.com>
AuthorDate: Wed Aug 16 12:17:40 2017 -0500
Simplify compaction state management
This change adds a new `#comp_st{}` record that is used to pass
compaction state through the various compaction steps. There are zero
changes to the existing compaction logic. This merely sets the stage for
adding our docid copy optimization.
---
src/couch/src/couch_db_updater.erl | 169 +++++++++++++++++++++++++++----------
1 file changed, 124 insertions(+), 45 deletions(-)
diff --git a/src/couch/src/couch_db_updater.erl b/src/couch/src/couch_db_updater.erl
index f786048..a83e3b4 100644
--- a/src/couch/src/couch_db_updater.erl
+++ b/src/couch/src/couch_db_updater.erl
@@ -23,9 +23,16 @@
-define(IDLE_LIMIT_DEFAULT, 61000).
+-record(comp_st, {
+ old_db,
+ new_db,
+ meta_fd,
+ retry
+}).
+
-record(comp_header, {
db_header,
- meta_state
+ meta_st
}).
-record(merge_st, {
@@ -1034,56 +1041,90 @@ check_md5(_, _) -> throw(md5_mismatch).
start_copy_compact(#db{}=Db) ->
erlang:put(io_priority, {db_compact, Db#db.name}),
- #db{name=Name, filepath=Filepath, options=Options, header=Header} = Db,
- couch_log:debug("Compaction process spawned for db \"~s\"", [Name]),
+ couch_log:debug("Compaction process spawned for db \"~s\"", [Db#db.name]),
+
+ {ok, InitCompSt} = open_compaction_files(Db),
+
+ Stages = [
+ fun copy_purge_info/1,
+ fun copy_compact/1,
+ fun commit_compaction_data/1,
+ fun sort_meta_data/1,
+ fun commit_compaction_data/1,
+ fun copy_meta_data/1,
+ fun compact_final_sync/1
+ ],
- {ok, NewDb, DName, DFd, MFd, Retry} =
- open_compaction_files(Name, Header, Filepath, Options),
- erlang:monitor(process, MFd),
+ FinalCompSt = lists:foldl(fun(Stage, CompSt) ->
+ Stage(CompSt)
+ end, InitCompSt, Stages),
- % This is a bit worrisome. init_db/4 will monitor the data fd
- % but it doesn't know about the meta fd. For now I'll maintain
- % that the data fd is the old normal fd and meta fd is special
- % and hope everything works out for the best.
- unlink(DFd),
+ #comp_st{
+ new_db = FinalNewDb,
+ meta_fd = MetaFd
+ } = FinalCompSt,
- NewDb1 = copy_purge_info(Db, NewDb),
- NewDb2 = copy_compact(Db, NewDb1, Retry),
- NewDb3 = sort_meta_data(NewDb2),
- NewDb4 = commit_compaction_data(NewDb3),
- NewDb5 = copy_meta_data(NewDb4),
- NewDb6 = sync_header(NewDb5, db_to_header(NewDb5, NewDb5#db.header)),
- close_db(NewDb6),
+ close_db(FinalNewDb),
+ ok = couch_file:close(MetaFd),
- ok = couch_file:close(MFd),
- gen_server:cast(Db#db.main_pid, {compact_done, DName}).
+ gen_server:cast(Db#db.main_pid, {compact_done, FinalNewDb#db.filepath}).
-open_compaction_files(DbName, SrcHdr, DbFilePath, Options) ->
+open_compaction_files(OldDb) ->
+ #db{
+ name = DbName,
+ filepath = DbFilePath,
+ options = Options,
+ header = SrcHdr
+ } = OldDb,
DataFile = DbFilePath ++ ".compact.data",
MetaFile = DbFilePath ++ ".compact.meta",
{ok, DataFd, DataHdr} = open_compaction_file(DataFile),
{ok, MetaFd, MetaHdr} = open_compaction_file(MetaFile),
DataHdrIsDbHdr = couch_db_header:is_header(DataHdr),
- case {DataHdr, MetaHdr} of
+ CompSt = case {DataHdr, MetaHdr} of
{#comp_header{}=A, #comp_header{}=A} ->
+ % We're restarting a compaction that did not finish
+ % before trying to swap out with the original db
DbHeader = A#comp_header.db_header,
Db0 = init_db(DbName, DataFile, DataFd, DbHeader, Options),
- Db1 = bind_emsort(Db0, MetaFd, A#comp_header.meta_state),
- {ok, Db1, DataFile, DataFd, MetaFd, Db0#db.id_tree};
+ Db1 = bind_emsort(Db0, MetaFd, A#comp_header.meta_st),
+ #comp_st{
+ old_db = OldDb,
+ new_db = Db1,
+ meta_fd = MetaFd,
+ retry = Db0#db.id_tree
+ };
_ when DataHdrIsDbHdr ->
+ % We tried to swap out the compaction but there were
+ % writes to the database during compaction. Start
+ % a compaction retry.
ok = reset_compaction_file(MetaFd, couch_db_header:from(SrcHdr)),
Db0 = init_db(DbName, DataFile, DataFd, DataHdr, Options),
Db1 = bind_emsort(Db0, MetaFd, nil),
- {ok, Db1, DataFile, DataFd, MetaFd, Db0#db.id_tree};
+ #comp_st{
+ old_db = OldDb,
+ new_db = Db1,
+ meta_fd = MetaFd,
+ retry = Db0#db.id_tree
+ };
_ ->
+ % We're starting a compaction from scratch
Header = couch_db_header:from(SrcHdr),
ok = reset_compaction_file(DataFd, Header),
ok = reset_compaction_file(MetaFd, Header),
Db0 = init_db(DbName, DataFile, DataFd, Header, Options),
Db1 = bind_emsort(Db0, MetaFd, nil),
- {ok, Db1, DataFile, DataFd, MetaFd, nil}
- end.
+ #comp_st{
+ old_db = OldDb,
+ new_db = Db1,
+ meta_fd = MetaFd,
+ retry = nil
+ }
+ end,
+ unlink(DataFd),
+ erlang:monitor(process, MetaFd),
+ {ok, CompSt}.
open_compaction_file(FilePath) ->
@@ -1104,25 +1145,34 @@ reset_compaction_file(Fd, Header) ->
ok = couch_file:write_header(Fd, Header).
-copy_purge_info(OldDb, NewDb) ->
+copy_purge_info(#comp_st{old_db = OldDb, new_db = NewDb} = CompSt) ->
OldHdr = OldDb#db.header,
NewHdr = NewDb#db.header,
OldPurgeSeq = couch_db_header:purge_seq(OldHdr),
- if OldPurgeSeq > 0 ->
+ NewPurgeSeq = couch_db_header:purge_seq(NewHdr),
+ if OldPurgeSeq > NewPurgeSeq ->
{ok, PurgedIdsRevs} = couch_db:get_last_purged(OldDb),
Opts = [{compression, NewDb#db.compression}],
{ok, Ptr, _} = couch_file:append_term(NewDb#db.fd, PurgedIdsRevs, Opts),
- NewNewHdr = couch_db_header:set(NewHdr, [
- {purge_seq, OldPurgeSeq},
- {purged_docs, Ptr}
- ]),
- NewDb#db{header = NewNewHdr};
+ CompSt#comp_st{
+ new_db = NewDb#db{
+ header = couch_db_header:set(NewHdr, [
+ {purge_seq, OldPurgeSeq},
+ {purged_docs, Ptr}
+ ])
+ }
+ };
true ->
- NewDb
+ CompSt
end.
-copy_compact(Db, NewDb0, Retry) ->
+copy_compact(#comp_st{} = CompSt) ->
+ #comp_st{
+ old_db = Db,
+ new_db = NewDb0,
+ retry = Retry
+ } = CompSt,
Compression = couch_compress:get_compression_method(),
NewDb = NewDb0#db{compression=Compression},
TotalChanges = couch_db:count_changes_since(Db, NewDb#db.update_seq),
@@ -1160,12 +1210,13 @@ copy_compact(Db, NewDb0, Retry) ->
TaskProps0 = [
{type, database_compaction},
+ {retry, (Retry /= nil)},
{database, Db#db.name},
{progress, 0},
{changes_done, 0},
{total_changes, TotalChanges}
],
- case (Retry =/= nil) and couch_task_status:is_task_added() of
+ case (Retry /= nil) and couch_task_status:is_task_added() of
true ->
couch_task_status:update([
{retry, true},
@@ -1195,7 +1246,11 @@ copy_compact(Db, NewDb0, Retry) ->
NewDb4 = NewDb3
end,
- commit_compaction_data(NewDb4#db{update_seq=Db#db.update_seq}).
+ CompSt#comp_st{
+ new_db = NewDb4#db{
+ update_seq = Db#db.update_seq
+ }
+ }.
copy_docs(Db, #db{fd = DestFd} = NewDb, MixedInfos, Retry) ->
@@ -1310,12 +1365,15 @@ copy_doc_attachments(#db{fd = SrcFd} = SrcDb, SrcSp, DestFd) ->
{BodyData, NewBinInfos}.
-commit_compaction_data(#db{}=Db) ->
+commit_compaction_data(#comp_st{new_db = Db} = CompSt) ->
% Compaction needs to write headers to both the data file
% and the meta file so if we need to restart we can pick
% back up from where we left off.
commit_compaction_data(Db, couch_emsort:get_fd(Db#db.id_tree)),
- commit_compaction_data(Db, Db#db.fd).
+ NewDb = commit_compaction_data(Db, Db#db.fd),
+ CompSt#comp_st{
+ new_db = NewDb
+ }.
commit_compaction_data(#db{header=OldHeader}=Db0, Fd) ->
@@ -1330,7 +1388,7 @@ commit_compaction_data(#db{header=OldHeader}=Db0, Fd) ->
Header = db_to_header(Db1, OldHeader),
CompHeader = #comp_header{
db_header = Header,
- meta_state = MetaState
+ meta_st = MetaState
},
ok = couch_file:sync(Fd),
ok = couch_file:write_header(Fd, CompHeader),
@@ -1359,12 +1417,20 @@ bind_id_tree(Db, Fd, State) ->
Db#db{id_tree=IdBtree}.
-sort_meta_data(Db0) ->
+sort_meta_data(#comp_st{new_db = Db0} = CompSt) ->
{ok, Ems} = couch_emsort:merge(Db0#db.id_tree),
- Db0#db{id_tree=Ems}.
+ CompSt#comp_st{
+ new_db = Db0#db{
+ id_tree = Ems
+ }
+ }.
-copy_meta_data(#db{fd=Fd, header=Header}=Db) ->
+copy_meta_data(#comp_st{new_db = Db} = CompSt) ->
+ #db{
+ fd = Fd,
+ header = Header
+ } = Db,
Src = Db#db.id_tree,
DstState = couch_db_header:id_tree_state(Header),
{ok, IdTree0} = couch_btree:open(DstState, Fd, [
@@ -1384,7 +1450,20 @@ copy_meta_data(#db{fd=Fd, header=Header}=Db) ->
{ok, SeqTree} = couch_btree:add_remove(
Acc#merge_st.seq_tree, [], Acc#merge_st.rem_seqs
),
- Db#db{id_tree=IdTree, seq_tree=SeqTree}.
+ CompSt#comp_st{
+ new_db = Db#db{
+ id_tree = IdTree,
+ seq_tree = SeqTree
+ }
+ }.
+
+
+compact_final_sync(#comp_st{new_db = NewDb0} = CompSt) ->
+ NewHdr = db_to_header(NewDb0, NewDb0#db.header),
+ NewDb1 = sync_header(NewDb0, NewHdr),
+ CompSt#comp_st{
+ new_db = NewDb1
+ }.
merge_docids(Iter, #merge_st{infos=Infos}=Acc) when length(Infos) > 1000 ->
--
To stop receiving notification emails like this one, please contact
"commits@couchdb.apache.org" <co...@couchdb.apache.org>.
[couchdb] 03/03: Add a test suite for compactions
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davisp pushed a commit to branch compactor-rewrite
in repository https://gitbox.apache.org/repos/asf/couchdb.git
commit fb67c8b4ef23e3a2808d1d4d291c1fe1da9c3d25
Author: Paul J. Davis <pa...@gmail.com>
AuthorDate: Wed Aug 16 14:38:11 2017 -0500
Add a test suite for compactions
---
src/couch/test/couch_db_updater_tests.erl | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/src/couch/test/couch_db_updater_tests.erl b/src/couch/test/couch_db_updater_tests.erl
new file mode 100644
index 0000000..5dd5e54
--- /dev/null
+++ b/src/couch/test/couch_db_updater_tests.erl
@@ -0,0 +1,25 @@
+% Licensed under the Apache License, Version 2.0 (the "License"); you may not
+% use this file except in compliance with the License. You may obtain a copy of
+% the License at
+%
+% http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+% WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+% License for the specific language governing permissions and limitations under
+% the License.
+
+-module(couch_db_updater_tests).
+
+-include_lib("couch/include/couch_eunit.hrl").
+
+% Tests to test
+% 10k docs
+% kill during first pass
+% kill during docid copy
+% kill before docid copy starts
+% kill during docid copy
+% kill after docid copy
+% 5k docs, write docs during compaction
+%
\ No newline at end of file
--
To stop receiving notification emails like this one, please contact
"commits@couchdb.apache.org" <co...@couchdb.apache.org>.