<lambda>null1 import androidx.room.RoomDatabase
2 import androidx.room.util.getColumnIndexOrThrow
3 import androidx.room.util.performBlocking
4 import androidx.sqlite.SQLiteStatement
5 import javax.`annotation`.processing.Generated
6 import kotlin.Int
7 import kotlin.String
8 import kotlin.Suppress
9 import kotlin.collections.LinkedHashMap
10 import kotlin.collections.List
11 import kotlin.collections.Map
12 import kotlin.collections.MutableList
13 import kotlin.collections.MutableMap
14 import kotlin.collections.mutableListOf
15 import kotlin.reflect.KClass
16 
17 @Generated(value = ["androidx.room.RoomProcessor"])
18 @Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
19 public class MyDao_Impl(
20   __db: RoomDatabase,
21 ) : MyDao {
22   private val __db: RoomDatabase
23   init {
24     this.__db = __db
25   }
26 
27   public override fun singleNested(): Map<Artist, Map<Album, List<Song>>> {
28     val _sql: String = "SELECT * FROM Artist JOIN (Album JOIN Song ON Album.albumName = Song.album) ON Artist.artistName = Album.albumArtist"
29     return performBlocking(__db, true, false) { _connection ->
30       val _stmt: SQLiteStatement = _connection.prepare(_sql)
31       try {
32         val _columnIndexOfArtistId: Int = getColumnIndexOrThrow(_stmt, "artistId")
33         val _columnIndexOfArtistName: Int = getColumnIndexOrThrow(_stmt, "artistName")
34         val _columnIndexOfAlbumId: Int = getColumnIndexOrThrow(_stmt, "albumId")
35         val _columnIndexOfAlbumName: Int = getColumnIndexOrThrow(_stmt, "albumName")
36         val _columnIndexOfAlbumArtist: Int = getColumnIndexOrThrow(_stmt, "albumArtist")
37         val _columnIndexOfSongId: Int = getColumnIndexOrThrow(_stmt, "songId")
38         val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
39         val _columnIndexOfSongArtist: Int = getColumnIndexOrThrow(_stmt, "songArtist")
40         val _result: MutableMap<Artist, MutableMap<Album, MutableList<Song>>> = LinkedHashMap<Artist, MutableMap<Album, MutableList<Song>>>()
41         while (_stmt.step()) {
42           val _key: Artist
43           val _tmpArtistId: String
44           _tmpArtistId = _stmt.getText(_columnIndexOfArtistId)
45           val _tmpArtistName: String
46           _tmpArtistName = _stmt.getText(_columnIndexOfArtistName)
47           _key = Artist(_tmpArtistId,_tmpArtistName)
48           val _values: MutableMap<Album, MutableList<Song>>
49           if (_result.containsKey(_key)) {
50             _values = _result.getValue(_key)
51           } else {
52             _values = LinkedHashMap<Album, MutableList<Song>>()
53             _result.put(_key, _values)
54           }
55           if (_stmt.isNull(_columnIndexOfAlbumId) && _stmt.isNull(_columnIndexOfAlbumName) && _stmt.isNull(_columnIndexOfAlbumArtist)) {
56             continue
57           }
58           val _key_1: Album
59           val _tmpAlbumId: String
60           _tmpAlbumId = _stmt.getText(_columnIndexOfAlbumId)
61           val _tmpAlbumName: String
62           _tmpAlbumName = _stmt.getText(_columnIndexOfAlbumName)
63           val _tmpAlbumArtist: String
64           _tmpAlbumArtist = _stmt.getText(_columnIndexOfAlbumArtist)
65           _key_1 = Album(_tmpAlbumId,_tmpAlbumName,_tmpAlbumArtist)
66           val _values_1: MutableList<Song>
67           if (_values.containsKey(_key_1)) {
68             _values_1 = _values.getValue(_key_1)
69           } else {
70             _values_1 = mutableListOf()
71             _values.put(_key_1, _values_1)
72           }
73           if (_stmt.isNull(_columnIndexOfSongId) && _stmt.isNull(_columnIndexOfAlbum) && _stmt.isNull(_columnIndexOfSongArtist)) {
74             continue
75           }
76           val _value: Song
77           val _tmpSongId: String
78           _tmpSongId = _stmt.getText(_columnIndexOfSongId)
79           val _tmpAlbum: String
80           _tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
81           val _tmpSongArtist: String
82           _tmpSongArtist = _stmt.getText(_columnIndexOfSongArtist)
83           _value = Song(_tmpSongId,_tmpAlbum,_tmpSongArtist)
84           _values_1.add(_value)
85         }
86         _result
87       } finally {
88         _stmt.close()
89       }
90     }
91   }
92 
93   public override fun doubleNested(): Map<Playlist, Map<Artist, Map<Album, List<Song>>>> {
94     val _sql: String = "SELECT * FROM Playlist JOIN (Artist JOIN (Album JOIN Song ON Album.albumName = Song.album) ON Artist.artistName = Album.albumArtist)ON Playlist.playlistArtist = Artist.artistName"
95     return performBlocking(__db, true, false) { _connection ->
96       val _stmt: SQLiteStatement = _connection.prepare(_sql)
97       try {
98         val _columnIndexOfPlaylistId: Int = getColumnIndexOrThrow(_stmt, "playlistId")
99         val _columnIndexOfPlaylistArtist: Int = getColumnIndexOrThrow(_stmt, "playlistArtist")
100         val _columnIndexOfArtistId: Int = getColumnIndexOrThrow(_stmt, "artistId")
101         val _columnIndexOfArtistName: Int = getColumnIndexOrThrow(_stmt, "artistName")
102         val _columnIndexOfAlbumId: Int = getColumnIndexOrThrow(_stmt, "albumId")
103         val _columnIndexOfAlbumName: Int = getColumnIndexOrThrow(_stmt, "albumName")
104         val _columnIndexOfAlbumArtist: Int = getColumnIndexOrThrow(_stmt, "albumArtist")
105         val _columnIndexOfSongId: Int = getColumnIndexOrThrow(_stmt, "songId")
106         val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
107         val _columnIndexOfSongArtist: Int = getColumnIndexOrThrow(_stmt, "songArtist")
108         val _result: MutableMap<Playlist, MutableMap<Artist, MutableMap<Album, MutableList<Song>>>> = LinkedHashMap<Playlist, MutableMap<Artist, MutableMap<Album, MutableList<Song>>>>()
109         while (_stmt.step()) {
110           val _key: Playlist
111           val _tmpPlaylistId: String
112           _tmpPlaylistId = _stmt.getText(_columnIndexOfPlaylistId)
113           val _tmpPlaylistArtist: String
114           _tmpPlaylistArtist = _stmt.getText(_columnIndexOfPlaylistArtist)
115           _key = Playlist(_tmpPlaylistId,_tmpPlaylistArtist)
116           val _values: MutableMap<Artist, MutableMap<Album, MutableList<Song>>>
117           if (_result.containsKey(_key)) {
118             _values = _result.getValue(_key)
119           } else {
120             _values = LinkedHashMap<Artist, MutableMap<Album, MutableList<Song>>>()
121             _result.put(_key, _values)
122           }
123           if (_stmt.isNull(_columnIndexOfArtistId) && _stmt.isNull(_columnIndexOfArtistName)) {
124             continue
125           }
126           val _key_1: Artist
127           val _tmpArtistId: String
128           _tmpArtistId = _stmt.getText(_columnIndexOfArtistId)
129           val _tmpArtistName: String
130           _tmpArtistName = _stmt.getText(_columnIndexOfArtistName)
131           _key_1 = Artist(_tmpArtistId,_tmpArtistName)
132           val _values_1: MutableMap<Album, MutableList<Song>>
133           if (_values.containsKey(_key_1)) {
134             _values_1 = _values.getValue(_key_1)
135           } else {
136             _values_1 = LinkedHashMap<Album, MutableList<Song>>()
137             _values.put(_key_1, _values_1)
138           }
139           if (_stmt.isNull(_columnIndexOfAlbumId) && _stmt.isNull(_columnIndexOfAlbumName) && _stmt.isNull(_columnIndexOfAlbumArtist)) {
140             continue
141           }
142           val _key_2: Album
143           val _tmpAlbumId: String
144           _tmpAlbumId = _stmt.getText(_columnIndexOfAlbumId)
145           val _tmpAlbumName: String
146           _tmpAlbumName = _stmt.getText(_columnIndexOfAlbumName)
147           val _tmpAlbumArtist: String
148           _tmpAlbumArtist = _stmt.getText(_columnIndexOfAlbumArtist)
149           _key_2 = Album(_tmpAlbumId,_tmpAlbumName,_tmpAlbumArtist)
150           val _values_2: MutableList<Song>
151           if (_values_1.containsKey(_key_2)) {
152             _values_2 = _values_1.getValue(_key_2)
153           } else {
154             _values_2 = mutableListOf()
155             _values_1.put(_key_2, _values_2)
156           }
157           if (_stmt.isNull(_columnIndexOfSongId) && _stmt.isNull(_columnIndexOfAlbum) && _stmt.isNull(_columnIndexOfSongArtist)) {
158             continue
159           }
160           val _value: Song
161           val _tmpSongId: String
162           _tmpSongId = _stmt.getText(_columnIndexOfSongId)
163           val _tmpAlbum: String
164           _tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
165           val _tmpSongArtist: String
166           _tmpSongArtist = _stmt.getText(_columnIndexOfSongArtist)
167           _value = Song(_tmpSongId,_tmpAlbum,_tmpSongArtist)
168           _values_2.add(_value)
169         }
170         _result
171       } finally {
172         _stmt.close()
173       }
174     }
175   }
176 
177   public companion object {
178     public fun getRequiredConverters(): List<KClass<*>> = emptyList()
179   }
180 }
181