1 package org.davidmoten.rx.jdbc; 2 3 import java.sql.ResultSet; 4 import java.util.Optional; 5 6 import javax.annotation.Nonnull; 7 8 import org.davidmoten.rx.jdbc.tuple.Tuple2; 9 import org.davidmoten.rx.jdbc.tuple.Tuple3; 10 import org.davidmoten.rx.jdbc.tuple.Tuple4; 11 import org.davidmoten.rx.jdbc.tuple.Tuple5; 12 import org.davidmoten.rx.jdbc.tuple.Tuple6; 13 import org.davidmoten.rx.jdbc.tuple.Tuple7; 14 import org.davidmoten.rx.jdbc.tuple.TupleN; 15 import org.davidmoten.rx.jdbc.tuple.Tuples; 16 17 import com.github.davidmoten.guavamini.Preconditions; 18 19 import io.reactivex.Flowable; 20 import io.reactivex.Single; 21 22 public interface GetterTx { 23 24 /** 25 * Transforms the results using the given function. 26 * 27 * @param mapper 28 * transforms ResultSet row to an object of type T 29 * @param <T> 30 * the type being mapped to 31 * @return the results of the query as an Observable 32 */ 33 <T> Flowable<Tx<T>> get(@Nonnull ResultSetMapper<? extends T> mapper); 34 35 default <T> Flowable<Tx<T>> getAs(@Nonnull Class<T> cls) { 36 Preconditions.checkNotNull(cls, "cls cannot be null"); 37 return get(rs -> Util.mapObject(rs, cls, 1)); 38 } 39 40 default <T> Flowable<Tx<Optional<T>>> getAsOptional(@Nonnull Class<T> cls) { 41 Preconditions.checkNotNull(cls, "cls cannot be null"); 42 return get(rs -> Optional.ofNullable(Util.mapObject(rs, cls, 1))); 43 } 44 45 /** 46 * <p> 47 * Transforms each row of the {@link ResultSet} into an instance of 48 * <code>T</code> using <i>automapping</i> of the ResultSet columns into 49 * corresponding constructor parameters that are assignable. Beyond normal 50 * assignable criteria (for example Integer 123 is assignable to a Double) other 51 * conversions exist to facilitate the automapping: 52 * </p> 53 * <p> 54 * They are: 55 * <ul> 56 * <li>java.sql.Blob --> byte[]</li> 57 * <li>java.sql.Blob --> java.io.InputStream</li> 58 * <li>java.sql.Clob --> String</li> 59 * <li>java.sql.Clob --> java.io.Reader</li> 60 * <li>java.sql.Date --> java.util.Date</li> 61 * <li>java.sql.Date --> Long</li> 62 * <li>java.sql.Timestamp --> java.util.Date</li> 63 * <li>java.sql.Timestamp --> Long</li> 64 * <li>java.sql.Time --> java.util.Date</li> 65 * <li>java.sql.Time --> Long</li> 66 * <li>java.math.BigInteger --> 67 * Short,Integer,Long,Float,Double,BigDecimal</li> 68 * <li>java.math.BigDecimal --> 69 * Short,Integer,Long,Float,Double,BigInteger</li> 70 * </ul> 71 * 72 * @param cls 73 * class to automap each row of the ResultSet to 74 * @param <T> 75 * generic type of returned stream emissions 76 * @return Flowable of T 77 * 78 */ 79 default <T> Flowable<Tx<T>> autoMap(@Nonnull Class<T> cls) { 80 Preconditions.checkNotNull(cls, "cls cannot be null"); 81 return get(Util.autoMap(cls)); 82 } 83 84 /** 85 * Automaps all the columns of the {@link ResultSet} into the target class 86 * <code>cls</code>. See {@link #autoMap(Class) autoMap()}. 87 * 88 * @param cls 89 * class of the TupleN elements 90 * @param <T> 91 * generic type of returned stream emissions 92 * @return stream of transaction items 93 */ 94 default <T> Flowable<Tx<TupleN<T>>> getTupleN(@Nonnull Class<T> cls) { 95 Preconditions.checkNotNull(cls, "cls cannot be null"); 96 return get(Tuples.tupleN(cls)); 97 } 98 99 /** 100 * Automaps all the columns of the {@link ResultSet} into {@link Object} . See 101 * {@link #autoMap(Class) autoMap()}. 102 * 103 * @return stream of transaction items 104 */ 105 default Flowable<Tx<TupleN<Object>>> getTupleN() { 106 return get(Tuples.tupleN(Object.class)); 107 } 108 109 /** 110 * Automaps the columns of the {@link ResultSet} into the specified classes. See 111 * {@link #autoMap(Class) autoMap()}. 112 * 113 * @param cls1 114 * first class 115 * @param cls2 116 * second class 117 * @param <T1> 118 * type of first class 119 * @param <T2> 120 * type of second class 121 * @return stream of transaction items 122 */ 123 default <T1, T2> Flowable<Tx<Tuple2<T1, T2>>> getAs(@Nonnull Class<T1> cls1, 124 @Nonnull Class<T2> cls2) { 125 return get(Tuples.tuple(cls1, cls2)); 126 } 127 128 /** 129 * Automaps the columns of the {@link ResultSet} into the specified classes. See 130 * {@link #autoMap(Class) autoMap()}. 131 * 132 * @param cls1 133 * first class 134 * @param cls2 135 * second class 136 * @param cls3 137 * third class 138 * @param <T1> 139 * type of first class 140 * @param <T2> 141 * type of second class 142 * @param <T3> 143 * type of third class 144 * @return stream of tuples 145 */ 146 default <T1, T2, T3> Flowable<Tx<Tuple3<T1, T2, T3>>> getAs(@Nonnull Class<T1> cls1, 147 @Nonnull Class<T2> cls2, @Nonnull Class<T3> cls3) { 148 return get(Tuples.tuple(cls1, cls2, cls3)); 149 } 150 151 /** 152 * Automaps the columns of the {@link ResultSet} into the specified classes. See 153 * {@link #autoMap(Class) autoMap()}. 154 * 155 * @param cls1 156 * first class 157 * @param cls2 158 * second class 159 * @param cls3 160 * third class 161 * @param cls4 162 * fourth class 163 * @param <T1> 164 * type of first class 165 * @param <T2> 166 * type of second class 167 * @param <T3> 168 * type of third class 169 * @param <T4> 170 * type of fourth class 171 * @return stream of tuples 172 */ 173 default <T1, T2, T3, T4> Flowable<Tx<Tuple4<T1, T2, T3, T4>>> getAs(@Nonnull Class<T1> cls1, 174 @Nonnull Class<T2> cls2, @Nonnull Class<T3> cls3, @Nonnull Class<T4> cls4) { 175 return get(Tuples.tuple(cls1, cls2, cls3, cls4)); 176 } 177 178 /** 179 * Automaps the columns of the {@link ResultSet} into the specified classes. See 180 * {@link #autoMap(Class) autoMap()}. 181 * 182 * @param cls1 183 * first class 184 * @param cls2 185 * second class 186 * @param cls3 187 * third class 188 * @param cls4 189 * fourth class 190 * @param cls5 191 * fifth class 192 * @param <T1> 193 * type of first class 194 * @param <T2> 195 * type of second class 196 * @param <T3> 197 * type of third class 198 * @param <T4> 199 * type of fourth class 200 * @param <T5> 201 * type of fifth class 202 * @return stream of transaction items 203 */ 204 default <T1, T2, T3, T4, T5> Flowable<Tx<Tuple5<T1, T2, T3, T4, T5>>> getAs( 205 @Nonnull Class<T1> cls1, @Nonnull Class<T2> cls2, @Nonnull Class<T3> cls3, 206 @Nonnull Class<T4> cls4, @Nonnull Class<T5> cls5) { 207 return get(Tuples.tuple(cls1, cls2, cls3, cls4, cls5)); 208 } 209 210 /** 211 * Automaps the columns of the {@link ResultSet} into the specified classes. See 212 * {@link #autoMap(Class) autoMap()}. 213 * 214 * @param cls1 215 * first class 216 * @param cls2 217 * second class 218 * @param cls3 219 * third class 220 * @param cls4 221 * fourth class 222 * @param cls5 223 * fifth class 224 * @param cls6 225 * sixth class 226 * @param <T1> 227 * type of first class 228 * @param <T2> 229 * type of second class 230 * @param <T3> 231 * type of third class 232 * @param <T4> 233 * type of fourth class 234 * @param <T5> 235 * type of fifth class 236 * @param <T6> 237 * type of sixth class 238 * @return stream of transaction items 239 */ 240 default <T1, T2, T3, T4, T5, T6> Flowable<Tx<Tuple6<T1, T2, T3, T4, T5, T6>>> getAs( 241 @Nonnull Class<T1> cls1, @Nonnull Class<T2> cls2, @Nonnull Class<T3> cls3, 242 @Nonnull Class<T4> cls4, @Nonnull Class<T5> cls5, @Nonnull Class<T6> cls6) { 243 return get(Tuples.tuple(cls1, cls2, cls3, cls4, cls5, cls6)); 244 } 245 246 /** 247 * Automaps the columns of the {@link ResultSet} into the specified classes. See 248 * {@link #autoMap(Class) autoMap()}. 249 * 250 * @param cls1 251 * first class 252 * @param cls2 253 * second class 254 * @param cls3 255 * third class 256 * @param cls4 257 * fourth class 258 * @param cls5 259 * fifth class 260 * @param cls6 261 * sixth class 262 * @param cls7 263 * seventh class 264 * @param <T1> 265 * type of first class 266 * @param <T2> 267 * type of second class 268 * @param <T3> 269 * type of third class 270 * @param <T4> 271 * type of fourth class 272 * @param <T5> 273 * type of fifth class 274 * @param <T6> 275 * type of sixth class 276 * @param <T7> 277 * type of seventh class 278 * @return stream of transaction items 279 */ 280 default <T1, T2, T3, T4, T5, T6, T7> Flowable<Tx<Tuple7<T1, T2, T3, T4, T5, T6, T7>>> getAs( 281 @Nonnull Class<T1> cls1, @Nonnull Class<T2> cls2, @Nonnull Class<T3> cls3, 282 @Nonnull Class<T4> cls4, @Nonnull Class<T5> cls5, @Nonnull Class<T6> cls6, 283 @Nonnull Class<T7> cls7) { 284 return get(Tuples.tuple(cls1, cls2, cls3, cls4, cls5, cls6, cls7)); 285 } 286 287 default Single<Long> count() { 288 return get(rs -> 1).count(); 289 } 290 }