<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.Int
8 import kotlin.String
9 import kotlin.Suppress
10 import kotlin.collections.List
11 import kotlin.collections.Set
12 import kotlin.reflect.KClass
13 import kotlin.text.StringBuilder
14
15 @Generated(value = ["androidx.room.RoomProcessor"])
16 @Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
17 public class MyDao_Impl(
18 __db: RoomDatabase,
19 ) : MyDao {
20 private val __db: RoomDatabase
21 init {
22 this.__db = __db
23 }
24
25 public override fun listOfString(arg: List<String>): MyEntity {
26 val _stringBuilder: StringBuilder = StringBuilder()
27 _stringBuilder.append("SELECT * FROM MyEntity WHERE string IN (")
28 val _inputSize: Int = arg.size
29 appendPlaceholders(_stringBuilder, _inputSize)
30 _stringBuilder.append(")")
31 val _sql: String = _stringBuilder.toString()
32 return performBlocking(__db, true, false) { _connection ->
33 val _stmt: SQLiteStatement = _connection.prepare(_sql)
34 try {
35 var _argIndex: Int = 1
36 for (_item: String in arg) {
37 _stmt.bindText(_argIndex, _item)
38 _argIndex++
39 }
40 val _columnIndexOfString: Int = getColumnIndexOrThrow(_stmt, "string")
41 val _result: MyEntity
42 if (_stmt.step()) {
43 val _tmpString: String
44 _tmpString = _stmt.getText(_columnIndexOfString)
45 _result = MyEntity(_tmpString)
46 } else {
47 error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
48 }
49 _result
50 } finally {
51 _stmt.close()
52 }
53 }
54 }
55
56 public override fun nullableListOfString(arg: List<String>?): MyEntity {
57 val _stringBuilder: StringBuilder = StringBuilder()
58 _stringBuilder.append("SELECT * FROM MyEntity WHERE string IN (")
59 val _inputSize: Int = if (arg == null) 1 else arg.size
60 appendPlaceholders(_stringBuilder, _inputSize)
61 _stringBuilder.append(")")
62 val _sql: String = _stringBuilder.toString()
63 return performBlocking(__db, true, false) { _connection ->
64 val _stmt: SQLiteStatement = _connection.prepare(_sql)
65 try {
66 var _argIndex: Int = 1
67 if (arg == null) {
68 _stmt.bindNull(_argIndex)
69 } else {
70 for (_item: String in arg) {
71 _stmt.bindText(_argIndex, _item)
72 _argIndex++
73 }
74 }
75 val _columnIndexOfString: Int = getColumnIndexOrThrow(_stmt, "string")
76 val _result: MyEntity
77 if (_stmt.step()) {
78 val _tmpString: String
79 _tmpString = _stmt.getText(_columnIndexOfString)
80 _result = MyEntity(_tmpString)
81 } else {
82 error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
83 }
84 _result
85 } finally {
86 _stmt.close()
87 }
88 }
89 }
90
91 public override fun listOfNullableString(arg: List<String?>): MyEntity {
92 val _stringBuilder: StringBuilder = StringBuilder()
93 _stringBuilder.append("SELECT * FROM MyEntity WHERE string IN (")
94 val _inputSize: Int = arg.size
95 appendPlaceholders(_stringBuilder, _inputSize)
96 _stringBuilder.append(")")
97 val _sql: String = _stringBuilder.toString()
98 return performBlocking(__db, true, false) { _connection ->
99 val _stmt: SQLiteStatement = _connection.prepare(_sql)
100 try {
101 var _argIndex: Int = 1
102 for (_item: String? in arg) {
103 if (_item == null) {
104 _stmt.bindNull(_argIndex)
105 } else {
106 _stmt.bindText(_argIndex, _item)
107 }
108 _argIndex++
109 }
110 val _columnIndexOfString: Int = getColumnIndexOrThrow(_stmt, "string")
111 val _result: MyEntity
112 if (_stmt.step()) {
113 val _tmpString: String
114 _tmpString = _stmt.getText(_columnIndexOfString)
115 _result = MyEntity(_tmpString)
116 } else {
117 error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
118 }
119 _result
120 } finally {
121 _stmt.close()
122 }
123 }
124 }
125
126 public override fun setOfString(arg: Set<String>): MyEntity {
127 val _stringBuilder: StringBuilder = StringBuilder()
128 _stringBuilder.append("SELECT * FROM MyEntity WHERE string IN (")
129 val _inputSize: Int = arg.size
130 appendPlaceholders(_stringBuilder, _inputSize)
131 _stringBuilder.append(")")
132 val _sql: String = _stringBuilder.toString()
133 return performBlocking(__db, true, false) { _connection ->
134 val _stmt: SQLiteStatement = _connection.prepare(_sql)
135 try {
136 var _argIndex: Int = 1
137 for (_item: String in arg) {
138 _stmt.bindText(_argIndex, _item)
139 _argIndex++
140 }
141 val _columnIndexOfString: Int = getColumnIndexOrThrow(_stmt, "string")
142 val _result: MyEntity
143 if (_stmt.step()) {
144 val _tmpString: String
145 _tmpString = _stmt.getText(_columnIndexOfString)
146 _result = MyEntity(_tmpString)
147 } else {
148 error("The query result was empty, but expected a single row to return a NON-NULL object of type <MyEntity>.")
149 }
150 _result
151 } finally {
152 _stmt.close()
153 }
154 }
155 }
156
157 public companion object {
158 public fun getRequiredConverters(): List<KClass<*>> = emptyList()
159 }
160 }
161