docs: public static ExtractFromRow extractUniqueKey( final int rowWidth,
                                                     TypeSystem types ) {
          final TypeFactory<NodeKey> keyType = types.getNodeKeyFactory();
          assert rowWidth > 0;
          if (rowWidth == 1) {
              return new ExtractFromRow() {
                  @Override
                  public TypeFactory<NodeKey> getType() {
                      return keyType;
                  }
  
                  @Override
                  public Object getValueInRow( RowAccessor row ) {
                      return NodeSequence.keyFor(row.getNode());
                  }
  
                  @Override
                  public String toString() {
                      return "(extract-key-for-order-1-tuples)";
                  }
              };
          }
          if (rowWidth == 2) {
              final TypeFactory<?> tupleType = Tuples.typeFactory(keyType, keyType);
              return new ExtractFromRow() {
                  @Override
                  public TypeFactory<?> getType() {
                      return tupleType;
                  }
  
                  @Override
                  public Object getValueInRow( RowAccessor row ) {
                      return Tuples.tuple(NodeSequence.keyFor(row.getNode(0)), NodeSequence.keyFor(row.getNode(1)));
                  }
  
                  @Override
                  public String toString() {
                      return "(extract-key-for-order-2-tuples)";
                  }
              };
          }
          if (rowWidth == 3) {
              final TypeFactory<?> tupleType = Tuples.typeFactory(keyType, keyType, keyType);
              return new ExtractFromRow() {
                  @Override
                  public TypeFactory<?> getType() {
                      return tupleType;
                  }
  
                  @Override
                  public Object getValueInRow( RowAccessor row ) {
                      return Tuples.tuple(NodeSequence.keyFor(row.getNode(0)), NodeSequence.keyFor(row.getNode(1)),
                                          NodeSequence.keyFor(row.getNode(2)));
                  }
  
                  @Override
                  public String toString() {
                      return "(extract-key-for-order-3-tuples)";
                  }
              };
          }
          if (rowWidth == 4) {
              final TypeFactory<?> tupleType = Tuples.typeFactory(keyType, keyType, keyType, keyType);
              return new ExtractFromRow() {
                  @Override
                  public TypeFactory<?> getType() {
                      return tupleType;
                  }
  
                  @Override
                  public Object getValueInRow( RowAccessor row ) {
                      return Tuples.tuple(NodeSequence.keyFor(row.getNode(0)), NodeSequence.keyFor(row.getNode(1)),
                                          NodeSequence.keyFor(row.getNode(2)), NodeSequence.keyFor(row.getNode(3)));
                  }
  
                  @Override
                  public String toString() {
                      return "(extract-key-for-order-4-tuples)";
                  }
              };
          }
          final TypeFactory<?> tupleType = Tuples.typeFactory(keyType, rowWidth);
          return new ExtractFromRow() {
              @Override
              public TypeFactory<?> getType() {
                  return tupleType;
              }
  
              @Override
              public Object getValueInRow( RowAccessor row ) {
                  Object[] keys = new Object[rowWidth];
                  for (int i = 0; i != rowWidth; ++i) {
                      keys[i] = NodeSequence.keyFor(row.getNode(i));
                  }
                  return Tuples.tuple(keys);
              }
  
              @Override
              public String toString() {
                  return "(extract-key-for-order-N-tuples)";
              }
          };
      }