DataArray: sorting by multiple keys

[ngirard]

Given that the query language already allows to express e.g. SORT k1, k2, I'd assume the same would be possible using the Dataview API, but I couldn't figure out how.

Here's the relevant line from the API:

sort<U>(key: ArrayFunc<T, U>, direction?: 'asc' | 'desc', comparator?: ArrayComparator<U>): DataArray<T>;

[blacksmithgu]

You can sort on an array - array.sort(p => [p.field1, p.field2, ....]), which sorts by each field (1st field, then 2nd field to tie break, and so on). You can't specify asc/dec for each, but you can get around that by negating numeric fields.

[ngirard]

@blacksmithgu, thank you for your feedback, and apologizes for the late reply.

Unfortunately, using this syntax didn't produce the expected ordering here (latest Dataview & Obsidian versions on Ubuntu 21.04).

Here's my query (in French)

let pages = dv.pages("[[Projet]]");
dv.table([
  "Tâche", "Priorité", "Projets", "Revue"
  ],
  pages
  .where( p => 
    (!p.Responsable || p.Responsable.path=="Moi")
	&& p.Statut == "#État/Projet/1_Actif"
	&& p["Date_de_revue"]
  )
  .map( p => [
  	p.file.link, p.Priorité, p.Projets, p.Date_de_revue
  ])
  .sort(p => [p.Date_de_revue, p.Priorité])
)

and here's the relevant part of the output:

Notice that the priority (2nd key) is the same, but the dates (1st key) are sorted anyhow.

[blacksmithgu]

Sort before you do the map; after the map, the data is a collection of arrays instead of the original page objects:

let pages = dv.pages("[[Projet]]");
dv.table([
  "Tâche", "Priorité", "Projets", "Revue"
  ],
  pages
  .where( p => 
    (!p.Responsable || p.Responsable.path=="Moi")
	&& p.Statut == "#État/Projet/1_Actif"
	&& p["Date_de_revue"]
  )
  .sort(p => [p.Date_de_revue, p.Priorité])
  .map( p => [
  	p.file.link, p.Priorité, p.Projets, p.Date_de_revue
  ])
)

[ngirard]

Indeed, it's working just fine. Thanks again !
Feel free to close the issue whenever you want.
You might want to mention the ordering of the calls to sort() and map() in the docs.
Also, since there are very few example code leveraging the Dataview API, adding an example based on my code would be useful IMHO.
Here's a trimmed-down, english version of the code for that purpose:

let pages = dv.pages("[[Project]]");
dv.table([
  "Task", "Priority", "Projects", "Review date"
  ],
  pages
  .where( p => 
    p.Status == "#Status/1_Active"
    && p["review-date"]
  )
  .sort(p => [p["review-date"], p.Priority])
  .map( p => [
  	p.file.link, p.Priority, p.Projects, p["review-date"]
  ])
)

[CovetingEpiphany2152]

The existing documentation already has an example of using .sort() and .map(), and another for .where(). Perhaps a short explanation on why the order matters would suffice.

That said, I don't think it is wise to clutter dataview's documentation with how JS programming works. One will need to learn some JS to use dataviewjs, and there are plenty of JS documentation explaining how function return and the dot operator works. They can also ask questions in the discussion section, Obsidian forum/discord, and stackoverflow too.

[Moonbase59]

I had a similar issue where a grouped list wouldn’t sort the entries at the 2nd level. But as @blacksmithgu said, you only have to know where to sort what 😉

Since the world can always use examples, here’s a small dataviewjs to sort "ingredients" notes by their category, and also have the ingredients file names sorted nicely beneath their category headings:

---
tags: [ingredient, toc]
---

# Ingredients by category TOC

```dataviewjs
for (let entry of dv.pages('"Recipes" and #ingredient and -#toc')
        .groupBy(p => p.category)) {
    dv.header(2, entry.key);
    dv.list(entry.rows.sort(p => p.file.name).map(p => [p.file.link]))
}
```

Ingredients are stored in the folder "Recipes/Ingredients" and have

---
category: other
tags: [ingredient, other]
---

[blacksmithgu]

Better UX for being able to specify per-key sort direction is probably still useful, though I'm not sure if I should make it a different method .multisort(), or add special behavior to .sort() if you pass in a unique value for the first argument. Something like

dv.pages().sort(dv.sortKeys([p => p.file.name, 'asc'], ...)

[blacksmithgu]

Alternatively, perhaps the sort direction could also be an array?

dv.pages().sort(p => [p.file.name, p.file.day], ['asc', 'desc'], ...)

That seems like a better approach.

[wenlzhang]

> dv.pages().sort(p => [p.file.name, p.file.day], ['asc', 'desc'], ...)

Is this already supported? @blacksmithgu

.sort(k => [k.file.mtime, k.file.ctime], ['desc', 'desc']) does not work for me. Specifically, it does not give any errors but the order is not as expected.

.sort(k => k.file.mtime, 'desc') works for me.

[blacksmithgu]

I haven't implemented this functionality yet, no.