[][]Model, doubts about sorted returned array, using dataloader

[frederikhors]

Question for newbies like me. Eventually, if that's okay with you, I can open a wiki page to collect all these FAQs for newbies.

I'm experimenting with gqlgen and dataloader pattern using dataloaden.

These are the models:

type School struct {
  ID   int
  Desc string
}

type Author struct {
  ID       int
  Name     string
  SchoolID int
}

type Book struct {
  ID       int
  Pages    int
  AuthorID int
}

This is the schema.graphql:

type School {
  id: ID
  desc: String
  authors: [Author]
}

type Author {
  id: ID
  name: String
  books: [Book]
}

type Book {
  id: ID
  pages: Int
  author: Author
}

I'm also using go-pg ORM (sqlboiler is planned) like this:

loaders.booksByAuthor = &BooksSliceLoader{
  wait:     1 * time.Millisecond,
  maxBatch: 100,
  fetch: func(keys []int) ([][]Book, []error) {
    var dbItems []Book
    keysIn := pg.In(keys)
    if err := DB.Model(&dbItems).Where("author_id in (?)", keysIn).OrderExpr("array_position(ARRAY[?]::int[], author_id::int)", keysIn).Select(); err != nil {
      return nil, []error{err}
    }
    items := make([][]Book, len(keys))
    for i, key := range keys {
      for _, dbItem := range dbItems {
        if dbItem.AuthorID == key {
          items[i] = append(items[i], dbItem)
        }
      }
    }
    return items, nil
  },
}

QUESTION

I was wondering if the below is an optimized way to re-order the [][]Book array coming from DB every time.

I'm asking about this code:

items := make([][]Book, len(keys))
for i, key := range keys {
  for _, dbItem := range dbItems {
    if dbItem.AuthorID == key {
      items[i] = append(items[i], dbItem)
    }
  }
}

Am I totally wrong?

Is this ok with the Golang Garbage Collector?

[Daavidaviid]

Hey,

I too am using gqlgen in a project with go-pg.
Personally, I do something like that :

ldrs.EmployeesByStore = &EmployeeSliceLoader{
			wait:     wait,
			maxBatch: 100,
			fetch: func(storeIDs []string) ([][]employee.Employee, []error) {
				var employees []employee.Employee

				employeesByStoreID := make([][]employee.Employee, len(storeIDs))
				errors := make([]error, len(storeIDs))

				err := database.DB.Model(&employee.Employee{}).
					Where("store_id in (?)", pg.In(storeIDs)).
					Select(&employees)

				for index, storeID := range storeIDs {
					for _, employee := range employees {
						if employee.StoreID == storeID {
							employeesByStoreID[index] = append(employeesByStoreID[index], employee)
						}
					}
				}

				if err != nil {
					errors := []error{err}
					return [][]employee.Employee{}, errors
				}

				return employeesByStoreID, errors
			},
		}

[vektah]

#758 makes this a bit clearer