title: Gorm Joins not mapping to models
body: <p>I'm trying to optimize my app by using sql joins instead of Preload().
  But i've ran into an issue where the joined table in the model is always empty.</p>
  
  <p>In desperation i've opened a new project and found some simple sample code, and again the same problem.
  If you run the code below you'll see that the joined table is always an empty array.</p>
  
  <p>Am i doing something wrong?</p>
  
  <pre><code>import (
  "fmt"
  "log"
  
  "github.com/jinzhu/gorm"
  _ "github.com/lib/pq"
  )
  
  type Language struct {
      ID   uint `gorm:"primary_key"`
      Name string
  }
  
  type Movie struct {
      ID         uint `gorm:"primary_key"`
      Title      string
      Language   Language
      LanguageID uint
  }
  
  type Artist struct {
      ID     uint `gorm:"primary_key"`
      Name   string
      Movies []Movie `gorm:"many2many:artist_movies"`
  }
  
  func createArtists() {
      langs := []Language{{Name: "english"},
          {Name: "tamil"},
          {Name: "french"}}
  
      for i, _ := range langs {
          if err := db.Create(&amp;langs[i]).Error; err != nil {
              log.Fatal(err)
          }
      }
  
      movies := []Movie{
          {Title: "Nayagan", Language: langs[1]},
          {Title: "Anbe sivam", Language: langs[1]},
          {Title: "3 idiots", Language: langs[2]},
          {Title: "Shamithab", Language: langs[2]},
          {Title: "Dark Knight", Language: langs[0]},
          {Title: "310 to Yuma", Language: langs[0]},
      }
      for i, _ := range movies {
          if err := db.Create(&amp;movies[i]).Error; err != nil {
              log.Fatal(err)
          }
      }
  
      artists := []Artist{
          {Name: "Madhavan", Movies: []Movie{movies[1],movies[2]}},
          {Name: "Kamal Hassan", Movies: []Movie{movies[0], movies[1]}},
          {Name: "Dhanush", Movies: []Movie{movies[3]}},
          {Name: "Aamir Khan", Movies: []Movie{movies[2]}},
          {Name: "Amitabh Bachchan", Movies: []Movie{movies[3]}},
          {Name: "Christian Bale", Movies: []Movie{movies[4], movies[5]}},
          {Name: "Russell Crowe", Movies: []Movie{movies[5]}},
      }
  
      for i, _ := range artists {
      if err := db.Create(&amp;artists[i]).Error; err != nil {
          log.Fatal(err)
          }
      }
  }
  
  var db *gorm.DB
  
  func main() {
      var err error
      db, err = gorm.Open("postgres", "user=admin password=1234 dbname=test sslmode=disable")
  if err != nil {
      log.Fatal(err)
  }
  db.AutoMigrate(new(Language), new(Movie), new(Artist))
  db.LogMode(true)
  
  createArtists()
  
  var artists []Artist
  
  if err = db.Joins("JOIN artist_movies on artist_movies.artist_id=artists.id").
      Joins("JOIN movies on movies.id=artist_movies.movie_id").
      Joins("JOIN languages on movies.language_id=languages.id").
      Where("languages.name=?", "tamil").
      Group("artists.id").Find(&amp;artists).Error; err != nil {
      log.Fatal(err)
  }
  for _, ar := range artists {
      fmt.Println(ar.Movies)
  }
  
  artists = []Artist{}
  if err = db.Joins("JOIN artist_movies on artist_movies.artist_id=artists.id").
      Joins("JOIN movies on artist_movies.movie_id=movies.id").Where("movies.title=?", "Nayagan").
      Group("artists.id").Find(&amp;artists).Error; err != nil {
      log.Fatal(err)
  }
  
  for _, ar := range artists {
      fmt.Println(ar.Movies)
  }
  
  artists = []Artist{}
  
  if err = db.Joins("JOIN artist_movies on artist_movies.artist_id=artists.id").
      Joins("JOIN movies on artist_movies.movie_id=movies.id").
      Where("movies.title in (?)", []string{"3 idiots", "Shamitabh", "310 to Yuma"}).
      Group("artists.id").Find(&amp;artists).Error; err != nil {
      log.Fatal(err)
  }
  for _, ar := range artists {
      fmt.Println(ar.Movies)
  }
  </code></pre>
  
  <p>}</p>