anchor.diff:  Two million record tree would be expected to take up around 285MB based on the estimated data usage figures quoted above
   for 35k names.
   
  -doing a select on 4 819 443 tree_elements and ordering by name_path on my local machine took 3m 12s
  -
  - select * from tree_element order by name_path;
  - 2000 rows retrieved starting from 1 in 3m 12s 448ms (execution: 3m 11s 788ms, fetching: 660ms)
  +doing a select on 4 819 443 tree_version_elements and ordering by name_path on my local machine took 250ms
  +
  + sql> select te.simple_name, te.name_link, tve.element_link tree_link, tve.name_path
  +      from tree_element te
  +                  join tree_version_element tve on te.id = tve.tree_element_id
  + [2018-11-28 13:46:28] 2000 rows retrieved starting from 1 in 249 ms (execution: 144 ms, fetching: 105 ms)
   
   after optimising postgresql this came down to 1m 40s.
   
  -With a trigram index on name_path a search for everything under Eucalyptus on 4.8M tree_elements (159213 results 2000 fetched)
  -takes ~5 seconds.
  -
  - sql> select * from tree_element where name_path like '%/Eucalyptus/%' order by name_path
  - [2017-06-26 17:02:47] 2000 rows retrieved starting from 1 in 4s 910ms (execution: 4s 579ms, fetching: 331ms)
  -
  -On about 2M elements it takes 2.2s indicating the time taken for these queries is linear with number of records.
  -
  -  sql> select * from tree_element where tree_version_id > 80 and name_path like '%/Eucalyptus/%' order by name_path
  -  [2017-06-26 17:07:46] 2000 rows retrieved starting from 1 in 2s 271ms (execution: 2s 35ms, fetching: 236ms)
  -
  -This also indicates more machine grunt may improve performance. (After optimising postgresql this came down to 1.48s)
  +With an index on name_path a search for everything under Eucalyptus on 4.8M tree_elements (159213 results 2000 fetched)
  +takes ~200ms.
  +
  + sql> select te.simple_name, te.name_link, t.host_name|| tve.element_link tree_link, tve.name_path
  +      from tree_element te
  +                  join tree_version_element tve on te.id = tve.tree_element_id
  +                  join tree t on tve.tree_version_id = t.current_tree_version_id and t.accepted_tree
  +      where name_path like '%/Eucalyptus/%' order by name_path
  + [2018-11-28 13:42:41] 1168 rows retrieved starting from 1 in 203 ms (execution: 137 ms, fetching: 66 ms)
  +
  +More machine grunt may improve performance. (After optimising postgresql this came down a lot)
   
   ****
   My local machine is an i7-4820K 3.70GHz CPU x 4, 32GB machine with a 500GB Samsung SSD. Postgresql had not been optimised
  
positive.code: |===
  
  Take these changes adding excluded names to Correa pulchella J.B.Mackay ex Sweet which is this node
  https://biodiversity.org.au/nsl/services/node/apni/5424450 at 2015-12-23 08:49:16.608000 +11:00 but was a different
  node 3 minutes earlier. The reality is that these changes were meant to be done as a batch and should only have been
  published once.
  
  
negative.code: [source]
  .DDL.sql
  ----
      create table tree (
          id int8 default nextval('nsl_global_seq') not null,
          lock_version int8 default 0 not null,
          accepted_tree boolean default false not null,
          config jsonb,
          current_tree_version_id int8,
          default_draft_tree_version_id int8,
          description_html Text default 'Edit me' not null,
          group_name Text not null,
          host_name Text not null,
          link_to_home_page Text,
          name Text not null,
          reference_id int8,
          primary key (id)
      );
  
      create table tree_element (
          id int8 default nextval('nsl_global_seq') not null,
          lock_version int8 default 0 not null,
          display_html Text not null,
          excluded boolean default false not null,
          instance_id int8 not null,
          instance_link Text not null,
          name_element varchar(255) not null,
          name_id int8 not null,
          name_link Text not null,
          previous_element_id int8,
          profile jsonb,
          rank varchar(50) not null,
          simple_name Text not null,
          source_element_link Text,
          source_shard Text not null,
          synonyms jsonb,
          synonyms_html Text not null,
          updated_at timestamp with time zone not null,
          updated_by varchar(255) not null,
          primary key (id)
      );
  
      create table tree_version (
          id int8 default nextval('nsl_global_seq') not null,
          lock_version int8 default 0 not null,
          created_at timestamp with time zone not null,
          created_by varchar(255) not null,
          draft_name Text not null,
          log_entry Text,
          previous_version_id int8,
          published boolean default false not null,
          published_at timestamp with time zone,
          published_by varchar(100),
          tree_id int8 not null,
          primary key (id)
      );
  
      create table tree_version_element (
          element_link Text not null,
          depth int4 not null,
          merge_conflict boolean default false not null,
          name_path Text not null,
          parent_id Text,
          taxon_id int8 not null,
          taxon_link Text not null,
          tree_element_id int8 not null,
          tree_path Text not null,
          tree_version_id int8 not null,
          updated_at timestamp with time zone not null,
          updated_by varchar(255) not null,
          primary key (element_link)
      );
  
  ----
  
  Refer to code at
  https://github.com/bio-org-au/nsl-domain-plugin/blob/8685491bc3916f5615d9716465fe622c32deebfe/web-app/sql/nsl-ddl.sql#L735[github]
  
  ---
  
  IMPORTANT: This has been implemented in production so the Impact and Amount of work information below is only useful for
  retrospective evaluation. Skip to <<Query Examples>>
  
  ---
  == User impact of change over
  
  Currently in production:
  