Ticket #451: compactchunks.patch

tests/api_compact.cc

@@ -259 +259 @@
 
     return true;
 }
+
+static void
+make_rebuildchunks_db(Xapian::WritableDatabase &db, const string & s)
+{
+    char * p = const_cast<char *>(s.c_str());
+    bool valuesonly = false;
+    if (*p == 'v') {
+        valuesonly = true;
+        ++p;
+    }
+    Xapian::docid first = strtoul(p, &p, 10);
+    if (*p != '-') {
+        FAIL_TEST("Bad rebuildchunks db param: (expected -): " << s);
+    }
+    ++p;
+    Xapian::docid last = strtoul(p, &p, 10);
+    if (*p != ':') {
+        FAIL_TEST("Bad rebuildchunks db param: (expected colon): " << s);
+    }
+    ++p;
+    Xapian::docid step = strtoul(p, &p, 10);
+
+    for (Xapian::docid i = first; i <= last; i += step) {
+        Xapian::Document doc;
+        if (!valuesonly) {
+            doc.add_term("a");
+            doc.add_term("Q" + str(i));
+        }
+        doc.add_value(0, "v" + str(i));
+        if (i % 3 == 0)
+            doc.add_value(1, "v" + str(i));
+        db.replace_document(i, doc);
+    }
+
+    db.commit();
+}
+
+// Test use of compact with the --rebuild-chunks option.
+DEFINE_TESTCASE(compactrebuildchunks1, chert) {
+    int status;
+    string cmd = XAPIAN_COMPACT" "SILENT" --no-renumber --rebuild-chunks ";
+    string indb1path = get_database_path("compactrebuildchunks1in1",
+                                         make_rebuildchunks_db, "1-10001:2");
+    string indb2path = get_database_path("compactrebuildchunks1in2",
+                                         make_rebuildchunks_db, "2-10000:2");
+    string outdbpath = get_named_writable_database_path("compactrebuildchunks1out");
+    rm_rf(outdbpath);
+
+    status = system(cmd + indb1path + " " + indb2path + " " + outdbpath);
+    TEST_EQUAL(WEXITSTATUS(status), 0);
+
+    Xapian::Database out(outdbpath);
+    dbcheck(out, 10001, 10001);
+    for (Xapian::docid i = 1; i <= 10001; ++i) {
+        Xapian::Document doc(out.get_document(i));
+        Xapian::Document correctdoc;
+        correctdoc.add_term("a");
+        correctdoc.add_term("Q" + str(i));
+        correctdoc.add_value(0, "v" + str(i));
+        if (i % 3 == 0)
+            correctdoc.add_value(1, "v" + str(i));
+        TEST_EQUAL(doc.serialise(), correctdoc.serialise());
+    }
+
+    return true;
+}
+
+// Test use of compact with the --rebuild-chunks option with no terms.
+DEFINE_TESTCASE(compactrebuildchunks2, chert) {
+    int status;
+    string cmd = XAPIAN_COMPACT" "SILENT" --no-renumber --rebuild-chunks ";
+    string indb1path = get_database_path("compactrebuildchunks2in1",
+                                         make_rebuildchunks_db, "v1-10001:2");
+    string indb2path = get_database_path("compactrebuildchunks2in2",
+                                         make_rebuildchunks_db, "v2-10000:2");
+    string outdbpath = get_named_writable_database_path("compactrebuildchunks2out");
+    rm_rf(outdbpath);
+
+    status = system(cmd + indb1path + " " + indb2path + " " + outdbpath);
+    TEST_EQUAL(WEXITSTATUS(status), 0);
+
+    Xapian::Database out(outdbpath);
+    dbcheck(out, 10001, 10001);
+    for (Xapian::docid i = 1; i <= 10001; ++i) {
+        Xapian::Document doc(out.get_document(i));
+        Xapian::Document correctdoc;
+        correctdoc.add_value(0, "v" + str(i));
+        if (i % 3 == 0)
+            correctdoc.add_value(1, "v" + str(i));
+        TEST_EQUAL(doc.serialise(), correctdoc.serialise());
+    }
+
+    return true;
+}

bin/xapian-compact.cc

@@ -56 +56 @@
 #define OPT_HELP 1
 #define OPT_VERSION 2
 #define OPT_NO_RENUMBER 3
+#define OPT_REBUILD_CHUNKS 4
 
 static void show_usage() {
     cout << "Usage: "PROG_NAME" [OPTIONS] SOURCE_DATABASE... DESTINATION_DATABASE\n\n"
@@ -72 +73 @@
 "                    external references to them, or have set them to match\n"
 "                    unique ids from an external source).  Currently this\n"
 "                    option is only supported when merging databases if they\n"
-"                    have disjoint ranges of used document ids\n"
+"                    have disjoint ranges of used document ids, or if\n"
+"                    --rebuild-chunks is also specified.\n"
+"  --rebuild-chunks  Rebuild the chunks in chunked tables.  Slower, but may\n"
+"                    produce a more compact database, and allows overlapping\n"
+"                    document IDs with the --no-renumber option.\n"
 "  --help            display this help and exit\n"
 "  --version         output version information and exit" << endl;
 }
@@ -179 +184 @@
         {"multipass",   no_argument, 0, 'm'},
         {"blocksize",   required_argument, 0, 'b'},
         {"no-renumber", no_argument, 0, OPT_NO_RENUMBER},
+        {"rebuild-chunks", no_argument, 0, OPT_REBUILD_CHUNKS},
         {"help",        no_argument, 0, OPT_HELP},
         {"version",     no_argument, 0, OPT_VERSION},
         {NULL,          0, 0, 0}
@@ -188 +194 @@
     size_t block_size = 8192;
     bool multipass = false;
     bool renumber = true;
+    bool rebuild_chunks = false;
 
     int c;
     while ((c = gnu_getopt_long(argc, argv, opts, long_opts, 0)) != -1) {
@@ -220 +227 @@
             case OPT_NO_RENUMBER:
                 renumber = false;
                 break;
+            case OPT_REBUILD_CHUNKS:
+                rebuild_chunks = true;
+                break;
             case OPT_HELP:
                 cout << PROG_NAME" - "PROG_DESC"\n\n";
                 show_usage();
@@ -397 +407 @@
                 if (p.first == 0 && p.second == 0)
                     continue;
                 // Check for overlap with the previous database's range.
-                if (p.first <= last_end) {
+                if (!rebuild_chunks && p.first <= last_end) {
                     cout << argv[0]
-                        << ": when merging databases, --no-renumber is only currently supported if the databases have disjoint ranges of used document ids.\n";
+                        << ": when merging databases which have disjoint ranges of used document ids, --no-renumber is only supported together with --rebuild-chunks.\n";
                     cout << sources[order[j - 1]] << " has range "
                          << last_start << "-" << last_end << '\n';
                     cout << sources[n] << " has range "
@@ -435 +445 @@
 
         if (backend == FLINT) {
             compact_flint(destdir, sources, offset, block_size, compaction,
-                          multipass, last_docid);
+                          multipass, last_docid, rebuild_chunks);
         } else if (backend == BRASS) {
             compact_brass(destdir, sources, offset, block_size, compaction,
-                          multipass, last_docid);
+                          multipass, last_docid, rebuild_chunks);
         } else {
             compact_chert(destdir, sources, offset, block_size, compaction,
-                          multipass, last_docid);
+                          multipass, last_docid, rebuild_chunks);
         }
 
         // Create the version file ("iamchert", etc).

bin/xapian-compact.h

@@ -33 +33 @@
 compact_brass(const char * destdir, const std::vector<std::string> & sources,
               const std::vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off);
+              Xapian::docid tot_off, bool rebuild_chunks);
 
 void
 compact_chert(const char * destdir, const std::vector<std::string> & sources,
               const std::vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off);
+              Xapian::docid tot_off, bool rebuild_chunks);
 
 void
 compact_flint(const char * destdir, const std::vector<std::string> & sources,
               const std::vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off);
+              Xapian::docid tot_off, bool rebuild_chunks);
 
 #endif

bin/xapian-compact-chert.cc

@@ -2 +2 @@
  * @brief Compact a chert database, or merge and compact several.
  */
 /* Copyright (C) 2004,2005,2006,2007,2008,2009,2010 Olly Betts
+ * Copyright (C) 2010 Richard Boulton
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -29 +30 @@
 
 #include <cstdio>
 
+#include "autoptr.h"
 #include "safeerrno.h"
 #include <sys/types.h>
 #include "safesysstat.h"
@@ -193 +195 @@
 }
 
 static void
+merge_postlist_chunks(ChertTable * out,
+                      priority_queue<PostlistCursor *,
+                                     vector<PostlistCursor *>,
+                                     PostlistCursorGt> & pq);
+static void
+rebuild_valuelist_chunks(ChertTable * out,
+                         priority_queue<PostlistCursor *,
+                                        vector<PostlistCursor *>,
+                                        PostlistCursorGt> & pq);
+static void
+rebuild_postlist_chunks(ChertTable * out,
+                        priority_queue<PostlistCursor *,
+                                       vector<PostlistCursor *>,
+                                       PostlistCursorGt> & pq);
+
+static void
 merge_postlists(ChertTable * out, vector<Xapian::docid>::const_iterator offset,
                 vector<string>::const_iterator b, vector<string>::const_iterator e,
-                Xapian::docid tot_off)
+                Xapian::docid tot_off, bool rebuild_chunks)
 {
     totlen_t tot_totlen = 0;
     Xapian::termcount doclen_lbound = static_cast<Xapian::termcount>(-1);
@@ -364 +382 @@
         }
     }
 
+    if (rebuild_chunks) {
+        rebuild_valuelist_chunks(out, pq);
+        rebuild_postlist_chunks(out, pq);
+    } else {
+        merge_postlist_chunks(out, pq);
+    }
+}
+
+/// Merge postlist chunks, without rebuilding them.
+static void
+merge_postlist_chunks(ChertTable * out,
+                      priority_queue<PostlistCursor *,
+                                     vector<PostlistCursor *>,
+                                     PostlistCursorGt> & pq)
+{
     // Merge valuestream chunks.
     while (!pq.empty()) {
         PostlistCursor * cur = pq.top();
@@ -381 +414 @@
 
     Xapian::termcount tf = 0, cf = 0; // Initialise to avoid warnings.
     vector<pair<Xapian::docid, string> > tags;
+    string last_key;
     while (true) {
         PostlistCursor * cur = NULL;
         if (!pq.empty()) {
@@ -391 +425 @@
         if (cur == NULL || cur->key != last_key) {
             if (!tags.empty()) {
                 string first_tag;
-                pack_uint(first_tag, tf);
+                pack_uint(first_tag, tf);
                 pack_uint(first_tag, cf);
                 pack_uint(first_tag, tags[0].first - 1);
                 string tag = tags[0].second;
@@ -431 +465 @@
     }
 }
 
+class ValueChunkReader {
+    string chunk;
+    const char * p;
+    const char * end;
+    Xapian::docid did;
+    Xapian::valueno slot;
+    string value;
+  public:
+    ValueChunkReader(const string & key, const string & chunk_)
+    {
+        Assert(key.size() > 2 && key[0] == '\0' && key[1] == '\xd8');
+        p = key.data() + 2;
+        end = key.data() + key.size();
+        if (!unpack_uint(&p, end, &slot))
+            throw Xapian::DatabaseCorruptError("Invalid value number");
+        if (!unpack_uint_preserving_sort(&p, end, &did))
+            throw Xapian::DatabaseCorruptError("Invalid docid in value key");
+        if (p != end)
+            throw Xapian::DatabaseCorruptError("Junk at end of value key");
+
+        chunk = chunk_;
+        p = chunk.data();
+        end = p + chunk.size();
+        if (!unpack_string(&p, end, value))
+            throw Xapian::DatabaseCorruptError("Invalid initial value");
+    }
+    bool at_end() const { return p == NULL; }
+    Xapian::docid get_docid() const { return did; }
+    string get_value() const { return value; }
+    Xapian::valueno get_slot() const { return slot; }
+    void next() {
+        if (p == end) {
+            p = NULL;
+            return;
+        }
+        Xapian::docid delta;
+        if (!unpack_uint(&p, end, &delta))
+            throw Xapian::DatabaseCorruptError("Invalid docid delta in valuechunk");
+        did += delta + 1;
+        if (!unpack_string(&p, end, value))
+            throw Xapian::DatabaseCorruptError("Invalid value in valuechunk");
+    }
+};
+
+class ValueChunkReaderGt {
+  public:
+    /** Return true if and only if a's id is strictly greater than b's id.
+     */
+    bool operator()(const ValueChunkReader *a, const ValueChunkReader *b) {
+        return (a->get_docid() > b->get_docid());
+    }
+};
+
+static const size_t VALUE_CHUNK_SIZE_THRESHOLD = 2000;
+
+inline std::string
+make_valuechunk_key(Xapian::valueno slot, Xapian::docid did)
+{
+    std::string key("\0\xd8", 2);
+    pack_uint(key, slot);
+    pack_uint_preserving_sort(key, did);
+    return key;
+}
+
+/// Build merged valuelist chunks
+static void
+rebuild_valuelist_chunks(ChertTable * out,
+                         priority_queue<PostlistCursor *,
+                                        vector<PostlistCursor *>,
+                                        PostlistCursorGt> & pq)
+{
+    priority_queue<ValueChunkReader *,
+                   vector<ValueChunkReader *>,
+                   ValueChunkReaderGt> chunks;
+    Xapian::valueno cur_slot = Xapian::valueno(-1);
+    while (true) {
+        PostlistCursor * cur = NULL;
+        if (!pq.empty()) {
+            cur = pq.top();
+            if (is_valuechunk_key(cur->key)) {
+                pq.pop();
+            } else {
+                cur = NULL;
+            }
+        }
+
+        Xapian::valueno new_slot = Xapian::valueno(-1);
+        AutoPtr<ValueChunkReader> r;
+        if (cur != NULL) {
+            r = AutoPtr<ValueChunkReader>(new ValueChunkReader(cur->key, cur->tag));
+            new_slot = r->get_slot();
+        }
+
+        if (cur == NULL || new_slot != cur_slot) {
+            if (!chunks.empty()) {
+                string key, tag;
+                Xapian::docid prev_docid(0);
+                while (!chunks.empty()) {
+                    AutoPtr<ValueChunkReader> reader(chunks.top());
+                    chunks.pop();
+                    if (tag.empty()) {
+                        key = make_valuechunk_key(reader->get_slot(),
+                                                  reader->get_docid());
+                    } else {
+                        pack_uint(tag, reader->get_docid() - prev_docid - 1);
+                    }
+                    prev_docid = reader->get_docid();
+                    pack_string(tag, reader->get_value());
+                    if (tag.size() >= VALUE_CHUNK_SIZE_THRESHOLD) {
+                        out->add(key, tag);
+                        tag.resize(0);
+                    }
+
+                    reader->next();
+                    if (!reader->at_end()) {
+                        chunks.push(reader.release());
+                    }
+                }
+                if (!tag.empty()) {
+                    out->add(key, tag);
+                    tag.resize(0);
+                }
+            }
+            Assert(chunks.empty());
+            if (cur == NULL) break;
+        }
+        cur_slot = new_slot;
+
+        chunks.push(r.release());
+        if (cur->next()) {
+            pq.push(cur);
+        } else {
+            delete cur;
+        }
+    }
+
+    while (!pq.empty()) {
+        PostlistCursor * cur = pq.top();
+        const string & key = cur->key;
+        if (!is_valuechunk_key(key)) break;
+        Assert(!is_user_metadata_key(key));
+        out->add(key, cur->tag);
+        pq.pop();
+        if (cur->next()) {
+            pq.push(cur);
+        } else {
+            delete cur;
+        }
+    }
+}
+
+class XAPIAN_VISIBILITY_DEFAULT PostlistChunkReader {
+    string chunk;
+    const char *p;
+    const char *end;
+    Xapian::docid did;
+    Xapian::termcount wdf;
+  public:
+    PostlistChunkReader(Xapian::docid firstdid, const string & chunk_)
+            : chunk(chunk_), p(chunk.data()), end(p + chunk.size()),
+              did(firstdid), wdf(0)
+    {
+        bool is_last_chunk;
+        if (!unpack_bool(&p, end, &is_last_chunk))
+            throw Xapian::DatabaseCorruptError(
+                "Bad postlist chunk - no is_last_chunk bool");
+        Xapian::docid increase_to_last;
+        if (!unpack_uint(&p, end, &increase_to_last))
+            throw Xapian::DatabaseCorruptError(
+                "Bad postlist chunk - no increase_to_last");
+
+        if (!unpack_uint(&p, end, &wdf))
+            throw Xapian::DatabaseCorruptError("Bad postlist chunk - no wdf");
+    }
+    bool at_end() const { return p == NULL; }
+    Xapian::docid get_docid() const { return did; }
+    Xapian::termcount get_wdf() const { return wdf; }
+    void next() {
+        if (p == end) {
+            p = NULL;
+            return;
+        }
+        Xapian::docid did_increase;
+        if (!unpack_uint(&p, end, &did_increase))
+            throw Xapian::DatabaseCorruptError(
+                "Bad postlist chunk - no docid increase");
+        did += did_increase + 1;
+
+        if (!unpack_uint(&p, end, &wdf))
+            throw Xapian::DatabaseCorruptError(
+                "Bad postlist chunk - no wdf");
+    }
+};
+
+class PostlistChunkReaderGt {
+  public:
+    /** Return true if and only if a's id is strictly greater than b's id.
+     */
+    bool operator()(const PostlistChunkReader *a, const PostlistChunkReader *b) {
+        return (a->get_docid() > b->get_docid());
+    }
+};
+
+static const size_t POSTLIST_CHUNK_SIZE_THRESHOLD = 2000;
+/// Build merged postlist chunks
+static void
+rebuild_postlist_chunks(ChertTable * out,
+                        priority_queue<PostlistCursor *,
+                                       vector<PostlistCursor *>,
+                                       PostlistCursorGt> & pq)
+{
+    Xapian::termcount tf = 0, cf = 0;
+    priority_queue<PostlistChunkReader *,
+                   vector<PostlistChunkReader *>,
+                   PostlistChunkReaderGt> tags;
+    string last_key;
+    while (true) {
+        PostlistCursor * cur = NULL;
+        if (!pq.empty()) {
+            cur = pq.top();
+            pq.pop();
+        }
+        Assert(cur == NULL || !is_user_metadata_key(cur->key));
+        if (cur == NULL || cur->key != last_key) {
+            if (!tags.empty()) {
+                string term;
+                if (!is_doclenchunk_key(last_key)) {
+                    const char * p = last_key.data();
+                    const char * end = p + last_key.size();
+                    if (!unpack_string_preserving_sort(&p, end, term) || p != end)
+                        throw Xapian::DatabaseCorruptError("Bad postlist chunk key");
+                }
+
+                string key, tag, tagstart;
+                Xapian::docid prevdocid = 0;
+                bool firstkey = true;
+                Xapian::docid firstdocid = 0;
+                while (!tags.empty()) {
+                    AutoPtr<PostlistChunkReader> reader(tags.top());
+                    tags.pop();
+                    if (reader->get_docid() == prevdocid)
+                        throw Xapian::InvalidOperationError("Docid " + str(prevdocid) + " occurs in multiple input databases");
+
+                    if (tag.size() >=
+                        POSTLIST_CHUNK_SIZE_THRESHOLD) {
+                        pack_bool(tagstart, false); // not last chunk
+                        pack_uint(tagstart, prevdocid - firstdocid);
+                        out->add(key, tagstart + tag);
+                        tag.resize(0);
+                        tagstart.resize(0);
+                    }
+
+                    if (tag.empty()) {
+                        firstdocid = reader->get_docid();
+                        if (firstkey) {
+                            key = pack_chert_postlist_key(term);
+                            pack_uint(tagstart, tf);
+                            pack_uint(tagstart, cf);
+                            pack_uint(tagstart, reader->get_docid() - 1);
+                            firstkey = false;
+                        } else {
+                            key = pack_chert_postlist_key(term, reader->get_docid());
+                        }
+                    } else {
+                        pack_uint(tag, reader->get_docid() - prevdocid - 1);
+                    }
+                    pack_uint(tag, reader->get_wdf());
+
+                    prevdocid = reader->get_docid();
+                    reader->next();
+                    if (!reader->at_end()) {
+                        tags.push(reader.release());
+                    }
+                }
+                if (!tag.empty()) {
+                    pack_bool(tagstart, true); // last chunk
+                    pack_uint(tagstart, prevdocid - firstdocid);
+                    out->add(key, tagstart + tag);
+                    tag.resize(0);
+                }
+            }
+            Assert(tags.empty());
+            if (cur == NULL) break;
+            tf = cf = 0;
+            last_key = cur->key;
+        }
+        tf += cur->tf;
+        cf += cur->cf;
+        tags.push(new PostlistChunkReader(cur->firstdid, cur->tag));
+        if (cur->next()) {
+            pq.push(cur);
+        } else {
+            delete cur;
+        }
+    }
+}
+
 struct MergeCursor : public ChertCursor {
     MergeCursor(ChertTable *in) : ChertCursor(in) {
         find_entry(string());
@@ -798 +1129 @@
 static void
 multimerge_postlists(ChertTable * out, const char * tmpdir,
                      Xapian::docid tot_off,
-                     vector<string> tmp, vector<Xapian::docid> off)
+                     vector<string> tmp, vector<Xapian::docid> off,
+                     bool rebuild_chunks)
 {
     unsigned int c = 0;
     while (tmp.size() > 3) {
@@ -821 +1153 @@
             // Use maximum blocksize for temporary tables.
             tmptab.create_and_open(65536);
 
-            merge_postlists(&tmptab, off.begin() + i, tmp.begin() + i, tmp.begin() + j, 0);
+            merge_postlists(&tmptab, off.begin() + i, tmp.begin() + i, tmp.begin() + j, 0,
+                            rebuild_chunks);
             if (c > 0) {
                 for (unsigned int k = i; k < j; ++k) {
                     unlink((tmp[k] + "DB").c_str());
@@ -837 +1170 @@
         swap(off, newoff);
         ++c;
     }
-    merge_postlists(out, off.begin(), tmp.begin(), tmp.end(), tot_off);
+    merge_postlists(out, off.begin(), tmp.begin(), tmp.end(), tot_off,
+                    rebuild_chunks);
     if (c > 0) {
         for (size_t k = 0; k < tmp.size(); ++k) {
             unlink((tmp[k] + "DB").c_str());
@@ -898 +1232 @@
 compact_chert(const char * destdir, const vector<string> & sources,
               const vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off) {
+              Xapian::docid tot_off, bool rebuild_chunks) {
     enum table_type {
         POSTLIST, RECORD, TERMLIST, POSITION, VALUE, SPELLING, SYNONYM
     };
@@ -999 +1333 @@
             case POSTLIST:
                 if (multipass && inputs.size() > 3) {
                     multimerge_postlists(&out, destdir, tot_off,
-                                         inputs, offset);
+                                         inputs, offset, rebuild_chunks);
                 } else {
                     merge_postlists(&out, offset.begin(),
                                     inputs.begin(), inputs.end(),
-                                    tot_off);
+                                    tot_off, rebuild_chunks);
                 }
                 break;
             case SPELLING:

bin/xapian-compact-brass.cc

@@ -898 +898 @@
 compact_brass(const char * destdir, const vector<string> & sources,
               const vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off) {
+              Xapian::docid tot_off, bool rebuild_chunks) {
+    if (rebuild_chunks) {
+        throw "--rebuild-chunks is not currently supported for brass databases";
+    }
     enum table_type {
         POSTLIST, RECORD, TERMLIST, POSITION, VALUE, SPELLING, SYNONYM
     };

bin/xapian-compact-flint.cc

@@ -720 +720 @@
 compact_flint(const char * destdir, const vector<string> & sources,
               const vector<Xapian::docid> & offset, size_t block_size,
               compaction_level compaction, bool multipass,
-              Xapian::docid tot_off) {
+              Xapian::docid tot_off, bool rebuild_chunks) {
+    if (rebuild_chunks) {
+        throw "--rebuild-chunks is not currently supported for flint databases";
+    }
     enum table_type {
         POSTLIST, RECORD, TERMLIST, POSITION, VALUE, SPELLING, SYNONYM
     };