<lambda>null1 import androidx.room.RoomDatabase
2 import androidx.room.util.appendPlaceholders
3 import androidx.room.util.getColumnIndexOrThrow
4 import androidx.room.util.performBlocking
5 import androidx.sqlite.SQLiteStatement
6 import javax.`annotation`.processing.Generated
7 import kotlin.Array
8 import kotlin.Int
9 import kotlin.IntArray
10 import kotlin.String
11 import kotlin.Suppress
12 import kotlin.collections.List
13 import kotlin.reflect.KClass
14 import kotlin.text.StringBuilder
15 
16 @Generated(value = ["androidx.room.RoomProcessor"])
17 @Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
18 public class MyDao_Impl(
19   __db: RoomDatabase,
20 ) : MyDao {
21   private val __db: RoomDatabase
22   init {
23     this.__db = __db
24   }
25 
26   public override fun arrayOfString(arg: Array<String>): MyEntity {
27     val _stringBuilder: StringBuilder = StringBuilder()
28     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
29     val _inputSize: Int = arg.size
30     appendPlaceholders(_stringBuilder, _inputSize)
31     _stringBuilder.append(")")
32     val _sql: String = _stringBuilder.toString()
33     return performBlocking(__db, true, false) { _connection ->
34       val _stmt: SQLiteStatement = _connection.prepare(_sql)
35       try {
36         var _argIndex: Int = 1
37         for (_item: String in arg) {
38           _stmt.bindText(_argIndex, _item)
39           _argIndex++
40         }
41         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
42         val _result: MyEntity
43         if (_stmt.step()) {
44           val _tmpId: String
45           _tmpId = _stmt.getText(_columnIndexOfId)
46           _result = MyEntity(_tmpId)
47         } else {
48           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
49         }
50         _result
51       } finally {
52         _stmt.close()
53       }
54     }
55   }
56 
57   public override fun nullableArrayOfString(arg: Array<String>?): MyEntity {
58     val _stringBuilder: StringBuilder = StringBuilder()
59     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
60     val _inputSize: Int = if (arg == null) 1 else arg.size
61     appendPlaceholders(_stringBuilder, _inputSize)
62     _stringBuilder.append(")")
63     val _sql: String = _stringBuilder.toString()
64     return performBlocking(__db, true, false) { _connection ->
65       val _stmt: SQLiteStatement = _connection.prepare(_sql)
66       try {
67         var _argIndex: Int = 1
68         if (arg == null) {
69           _stmt.bindNull(_argIndex)
70         } else {
71           for (_item: String in arg) {
72             _stmt.bindText(_argIndex, _item)
73             _argIndex++
74           }
75         }
76         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
77         val _result: MyEntity
78         if (_stmt.step()) {
79           val _tmpId: String
80           _tmpId = _stmt.getText(_columnIndexOfId)
81           _result = MyEntity(_tmpId)
82         } else {
83           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
84         }
85         _result
86       } finally {
87         _stmt.close()
88       }
89     }
90   }
91 
92   public override fun arrayOfNullableString(arg: Array<String?>): MyEntity {
93     val _stringBuilder: StringBuilder = StringBuilder()
94     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
95     val _inputSize: Int = arg.size
96     appendPlaceholders(_stringBuilder, _inputSize)
97     _stringBuilder.append(")")
98     val _sql: String = _stringBuilder.toString()
99     return performBlocking(__db, true, false) { _connection ->
100       val _stmt: SQLiteStatement = _connection.prepare(_sql)
101       try {
102         var _argIndex: Int = 1
103         for (_item: String? in arg) {
104           if (_item == null) {
105             _stmt.bindNull(_argIndex)
106           } else {
107             _stmt.bindText(_argIndex, _item)
108           }
109           _argIndex++
110         }
111         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
112         val _result: MyEntity
113         if (_stmt.step()) {
114           val _tmpId: String
115           _tmpId = _stmt.getText(_columnIndexOfId)
116           _result = MyEntity(_tmpId)
117         } else {
118           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
119         }
120         _result
121       } finally {
122         _stmt.close()
123       }
124     }
125   }
126 
127   public override fun varargOfString(vararg arg: String): MyEntity {
128     val _stringBuilder: StringBuilder = StringBuilder()
129     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
130     val _inputSize: Int = arg.size
131     appendPlaceholders(_stringBuilder, _inputSize)
132     _stringBuilder.append(")")
133     val _sql: String = _stringBuilder.toString()
134     return performBlocking(__db, true, false) { _connection ->
135       val _stmt: SQLiteStatement = _connection.prepare(_sql)
136       try {
137         var _argIndex: Int = 1
138         for (_item: String in arg) {
139           _stmt.bindText(_argIndex, _item)
140           _argIndex++
141         }
142         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
143         val _result: MyEntity
144         if (_stmt.step()) {
145           val _tmpId: String
146           _tmpId = _stmt.getText(_columnIndexOfId)
147           _result = MyEntity(_tmpId)
148         } else {
149           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
150         }
151         _result
152       } finally {
153         _stmt.close()
154       }
155     }
156   }
157 
158   public override fun varargOfNullableString(vararg arg: String?): MyEntity {
159     val _stringBuilder: StringBuilder = StringBuilder()
160     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
161     val _inputSize: Int = arg.size
162     appendPlaceholders(_stringBuilder, _inputSize)
163     _stringBuilder.append(")")
164     val _sql: String = _stringBuilder.toString()
165     return performBlocking(__db, true, false) { _connection ->
166       val _stmt: SQLiteStatement = _connection.prepare(_sql)
167       try {
168         var _argIndex: Int = 1
169         for (_item: String? in arg) {
170           if (_item == null) {
171             _stmt.bindNull(_argIndex)
172           } else {
173             _stmt.bindText(_argIndex, _item)
174           }
175           _argIndex++
176         }
177         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
178         val _result: MyEntity
179         if (_stmt.step()) {
180           val _tmpId: String
181           _tmpId = _stmt.getText(_columnIndexOfId)
182           _result = MyEntity(_tmpId)
183         } else {
184           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
185         }
186         _result
187       } finally {
188         _stmt.close()
189       }
190     }
191   }
192 
193   public override fun primitiveIntArray(arg: IntArray): MyEntity {
194     val _stringBuilder: StringBuilder = StringBuilder()
195     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
196     val _inputSize: Int = arg.size
197     appendPlaceholders(_stringBuilder, _inputSize)
198     _stringBuilder.append(")")
199     val _sql: String = _stringBuilder.toString()
200     return performBlocking(__db, true, false) { _connection ->
201       val _stmt: SQLiteStatement = _connection.prepare(_sql)
202       try {
203         var _argIndex: Int = 1
204         for (_item: Int in arg) {
205           _stmt.bindLong(_argIndex, _item.toLong())
206           _argIndex++
207         }
208         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
209         val _result: MyEntity
210         if (_stmt.step()) {
211           val _tmpId: String
212           _tmpId = _stmt.getText(_columnIndexOfId)
213           _result = MyEntity(_tmpId)
214         } else {
215           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
216         }
217         _result
218       } finally {
219         _stmt.close()
220       }
221     }
222   }
223 
224   public override fun nullablePrimitiveIntArray(arg: IntArray?): MyEntity {
225     val _stringBuilder: StringBuilder = StringBuilder()
226     _stringBuilder.append("SELECT * FROM MyEntity WHERE id IN (")
227     val _inputSize: Int = if (arg == null) 1 else arg.size
228     appendPlaceholders(_stringBuilder, _inputSize)
229     _stringBuilder.append(")")
230     val _sql: String = _stringBuilder.toString()
231     return performBlocking(__db, true, false) { _connection ->
232       val _stmt: SQLiteStatement = _connection.prepare(_sql)
233       try {
234         var _argIndex: Int = 1
235         if (arg == null) {
236           _stmt.bindNull(_argIndex)
237         } else {
238           for (_item: Int in arg) {
239             _stmt.bindLong(_argIndex, _item.toLong())
240             _argIndex++
241           }
242         }
243         val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
244         val _result: MyEntity
245         if (_stmt.step()) {
246           val _tmpId: String
247           _tmpId = _stmt.getText(_columnIndexOfId)
248           _result = MyEntity(_tmpId)
249         } else {
250           error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
251         }
252         _result
253       } finally {
254         _stmt.close()
255       }
256     }
257   }
258 
259   public companion object {
260     public fun getRequiredConverters(): List<KClass<*>> = emptyList()
261   }
262 }
263