1 import androidx.room.RoomDatabase
2 import androidx.room.rxjava3.createFlowable
3 import androidx.room.rxjava3.createMaybe
4 import androidx.room.rxjava3.createObservable
5 import androidx.room.rxjava3.createSingle
6 import androidx.room.util.appendPlaceholders
7 import androidx.room.util.getColumnIndexOrThrow
8 import androidx.sqlite.SQLiteStatement
9 import io.reactivex.rxjava3.core.Flowable
10 import io.reactivex.rxjava3.core.Maybe
11 import io.reactivex.rxjava3.core.Observable
12 import io.reactivex.rxjava3.core.Single
13 import javax.`annotation`.processing.Generated
14 import kotlin.Int
15 import kotlin.String
16 import kotlin.Suppress
17 import kotlin.collections.List
18 import kotlin.reflect.KClass
19 import kotlin.text.StringBuilder
20 
21 @Generated(value = ["androidx.room.RoomProcessor"])
22 @Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
23 public class MyDao_Impl(
24   __db: RoomDatabase,
25 ) : MyDao {
26   private val __db: RoomDatabase
<lambda>null27   init {
28     this.__db = __db
29   }
30 
getFlowablenull31   public override fun getFlowable(vararg arg: String?): Flowable<MyEntity> {
32     val _stringBuilder: StringBuilder = StringBuilder()
33     _stringBuilder.append("SELECT * FROM MyEntity WHERE pk IN (")
34     val _inputSize: Int = arg.size
35     appendPlaceholders(_stringBuilder, _inputSize)
36     _stringBuilder.append(")")
37     val _sql: String = _stringBuilder.toString()
38     return createFlowable(__db, false, arrayOf("MyEntity")) { _connection ->
39       val _stmt: SQLiteStatement = _connection.prepare(_sql)
40       try {
41         var _argIndex: Int = 1
42         for (_item: String? in arg) {
43           if (_item == null) {
44             _stmt.bindNull(_argIndex)
45           } else {
46             _stmt.bindText(_argIndex, _item)
47           }
48           _argIndex++
49         }
50         val _columnIndexOfPk: Int = getColumnIndexOrThrow(_stmt, "pk")
51         val _columnIndexOfOther: Int = getColumnIndexOrThrow(_stmt, "other")
52         val _result: MyEntity?
53         if (_stmt.step()) {
54           val _tmpPk: Int
55           _tmpPk = _stmt.getLong(_columnIndexOfPk).toInt()
56           val _tmpOther: String
57           _tmpOther = _stmt.getText(_columnIndexOfOther)
58           _result = MyEntity(_tmpPk,_tmpOther)
59         } else {
60           _result = null
61         }
62         _result
63       } finally {
64         _stmt.close()
65       }
66     }
67   }
68 
getObservablenull69   public override fun getObservable(vararg arg: String?): Observable<MyEntity> {
70     val _stringBuilder: StringBuilder = StringBuilder()
71     _stringBuilder.append("SELECT * FROM MyEntity WHERE pk IN (")
72     val _inputSize: Int = arg.size
73     appendPlaceholders(_stringBuilder, _inputSize)
74     _stringBuilder.append(")")
75     val _sql: String = _stringBuilder.toString()
76     return createObservable(__db, false, arrayOf("MyEntity")) { _connection ->
77       val _stmt: SQLiteStatement = _connection.prepare(_sql)
78       try {
79         var _argIndex: Int = 1
80         for (_item: String? in arg) {
81           if (_item == null) {
82             _stmt.bindNull(_argIndex)
83           } else {
84             _stmt.bindText(_argIndex, _item)
85           }
86           _argIndex++
87         }
88         val _columnIndexOfPk: Int = getColumnIndexOrThrow(_stmt, "pk")
89         val _columnIndexOfOther: Int = getColumnIndexOrThrow(_stmt, "other")
90         val _result: MyEntity?
91         if (_stmt.step()) {
92           val _tmpPk: Int
93           _tmpPk = _stmt.getLong(_columnIndexOfPk).toInt()
94           val _tmpOther: String
95           _tmpOther = _stmt.getText(_columnIndexOfOther)
96           _result = MyEntity(_tmpPk,_tmpOther)
97         } else {
98           _result = null
99         }
100         _result
101       } finally {
102         _stmt.close()
103       }
104     }
105   }
106 
getSinglenull107   public override fun getSingle(vararg arg: String?): Single<MyEntity> {
108     val _stringBuilder: StringBuilder = StringBuilder()
109     _stringBuilder.append("SELECT * FROM MyEntity WHERE pk IN (")
110     val _inputSize: Int = arg.size
111     appendPlaceholders(_stringBuilder, _inputSize)
112     _stringBuilder.append(")")
113     val _sql: String = _stringBuilder.toString()
114     return createSingle(__db, true, false) { _connection ->
115       val _stmt: SQLiteStatement = _connection.prepare(_sql)
116       try {
117         var _argIndex: Int = 1
118         for (_item: String? in arg) {
119           if (_item == null) {
120             _stmt.bindNull(_argIndex)
121           } else {
122             _stmt.bindText(_argIndex, _item)
123           }
124           _argIndex++
125         }
126         val _columnIndexOfPk: Int = getColumnIndexOrThrow(_stmt, "pk")
127         val _columnIndexOfOther: Int = getColumnIndexOrThrow(_stmt, "other")
128         val _result: MyEntity?
129         if (_stmt.step()) {
130           val _tmpPk: Int
131           _tmpPk = _stmt.getLong(_columnIndexOfPk).toInt()
132           val _tmpOther: String
133           _tmpOther = _stmt.getText(_columnIndexOfOther)
134           _result = MyEntity(_tmpPk,_tmpOther)
135         } else {
136           _result = null
137         }
138         _result
139       } finally {
140         _stmt.close()
141       }
142     }
143   }
144 
getMaybenull145   public override fun getMaybe(vararg arg: String?): Maybe<MyEntity> {
146     val _stringBuilder: StringBuilder = StringBuilder()
147     _stringBuilder.append("SELECT * FROM MyEntity WHERE pk IN (")
148     val _inputSize: Int = arg.size
149     appendPlaceholders(_stringBuilder, _inputSize)
150     _stringBuilder.append(")")
151     val _sql: String = _stringBuilder.toString()
152     return createMaybe(__db, true, false) { _connection ->
153       val _stmt: SQLiteStatement = _connection.prepare(_sql)
154       try {
155         var _argIndex: Int = 1
156         for (_item: String? in arg) {
157           if (_item == null) {
158             _stmt.bindNull(_argIndex)
159           } else {
160             _stmt.bindText(_argIndex, _item)
161           }
162           _argIndex++
163         }
164         val _columnIndexOfPk: Int = getColumnIndexOrThrow(_stmt, "pk")
165         val _columnIndexOfOther: Int = getColumnIndexOrThrow(_stmt, "other")
166         val _result: MyEntity?
167         if (_stmt.step()) {
168           val _tmpPk: Int
169           _tmpPk = _stmt.getLong(_columnIndexOfPk).toInt()
170           val _tmpOther: String
171           _tmpOther = _stmt.getText(_columnIndexOfOther)
172           _result = MyEntity(_tmpPk,_tmpOther)
173         } else {
174           _result = null
175         }
176         _result
177       } finally {
178         _stmt.close()
179       }
180     }
181   }
182 
183   public companion object {
getRequiredConvertersnull184     public fun getRequiredConverters(): List<KClass<*>> = emptyList()
185   }
186 }
187