return delegate.createArray(length);
              }

              @Override
              public Iterable<E> order(List<E> insertionOrder) {
                List<E> list = new ArrayList<>();
                for (E e : delegate.order(insertionOrder)) {
                  list.add(e);
                }
                Collections.reverse(list);
                return list;
              }

		t.Fatalf("Build Order condition, but got %v", result.Statement.SQL.String())
	}

	result = dryDB.Order("age desc, name").Find(&User{})
	if !regexp.MustCompile("SELECT \\* FROM .*users.* ORDER BY age desc, name").MatchString(result.Statement.SQL.String()) {
		t.Fatalf("Build Order condition, but got %v", result.Statement.SQL.String())
	}

	result = dryDB.Order("age desc").Order("name").Find(&User{})

	}

	// Tests hashing order to be consistent.
	for i, testCase := range testCases {
		hashedOrder := hashOrder(testCase.objectName, 16)
		if !reflect.DeepEqual(testCase.hashedOrder, hashedOrder) {
			t.Errorf("Test case %d: Expected \"%v\" but failed \"%v\"", i+1, testCase.hashedOrder, hashedOrder)
		}
	}

	// Tests hashing order to fail for when order is '-1'.

   * Returns the platform preferred map implementation that preserves insertion order when used only
   * for insertions.
   */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> preservesInsertionOrderOnPutsMap() {
    return new LinkedHashMap<>();
  }

  /**
   * Returns the platform preferred map implementation that preserves insertion order when used only

  /**
   * Creates a {@code LinkedBlockingQueue} with a capacity of {@link Integer#MAX_VALUE}, containing
   * the elements of the specified iterable, in the order they are returned by the iterable's
   * iterator.
   *
   * @param elements the elements that the queue should contain, in order
   * @return a new {@code LinkedBlockingQueue} containing those elements
   */
  @J2ktIncompatible
  @GwtIncompatible // LinkedBlockingQueue

     * Callers of TestContainerGenerator.order need to be prepared for implementations to return a new
     * collection.
     */
    @SuppressWarnings("CanIgnoreReturnValueSuggester")
    @Override
    public List<String> order(List<String> insertionOrder) {
      sort(insertionOrder, Collections.reverseOrder());
      return insertionOrder;
    }

Now, if you check the docs, they will show all the additional metadata:

<img src="/img/tutorial/metadata/image02.png">

### Order of tags { #order-of-tags }

The order of each tag metadata dictionary also defines the order shown in the docs UI.

For example, even though `users` would go after `items` in alphabetical order, it is shown before them, because we added their metadata as the first dictionary in the list.

## OpenAPI URL { #openapi-url }

                return ((SortedMultiset<E>) super.create(entries)).descendingMultiset();
              }

              @Override
              public Iterable<E> order(List<E> insertionOrder) {
                return ImmutableList.copyOf(super.order(insertionOrder)).reverse();
              }
            })
        .named(parentBuilder.getName() + " descending")
        .withFeatures(features)

			}
		}

		tx.Statement.AddClause(clause.Select{Expression: expr})
	}

	if orderByClause, ok := db.Statement.Clauses["ORDER BY"]; ok {
		if _, ok := db.Statement.Clauses["GROUP BY"]; !ok {
			delete(tx.Statement.Clauses, "ORDER BY")
			defer func() {
				tx.Statement.Clauses["ORDER BY"] = orderByClause
			}()
		}
	}

	tx.Statement.Dest = count
	tx = tx.callbacks.Query().Execute(tx)

		customizable.
	</dd>
	<dt>Sort</dt>
	<dd>
		sort field sorts documents by a specified field name. The format is
		"sort:&lt;field&gt;.&lt;order&gt;", where &lt;order&gt; is asc or
		desc. If you want to find documents which has "Fess" and sort them in
		descending order, you can enter:
		<pre>Fess sort:content_length.desc</pre>
		The available sort field are "created", "content_length" and