View Javadoc

    1   package sharin.util;
    2
    3   import java.math.BigDecimal;
    4   import java.sql.Connection;
    5   import java.sql.Date;
    6   import java.sql.PreparedStatement;
    7   import java.sql.ResultSet;
    8   import java.sql.ResultSetMetaData;
    9   import java.sql.SQLException;
    10  import java.sql.Statement;
    11  import java.sql.Time;
    12  import java.sql.Timestamp;
    13
    14  import javax.sql.DataSource;
    15
    16  public class SqlUtils {
    17
    18      public static Connection getConnection(DataSource ds) {
    19
    20          try {
    21              return ds.getConnection();
    22
    23          } catch (SQLException e) {
    24              throw new RuntimeException(e);
    25          }
    26      }
    27
    28      public static PreparedStatement prepareStatement(Connection conn, String sql) {
    29
    30          try {
    31              return conn.prepareStatement(sql);
    32
    33          } catch (SQLException e) {
    34              throw new RuntimeException(e);
    35          }
    36      }
    37
    38      public static void close(Connection conn) {
    39
    40          try {
    41              conn.close();
    42
    43          } catch (SQLException e) {
    44              throw new RuntimeException(e);
    45          }
    46      }
    47
    48      public static void setObject(PreparedStatement pstmt, int parameterIndex,
    49              Object x) {
    50
    51          try {
    52              pstmt.setObject(parameterIndex, x);
    53
    54          } catch (SQLException e) {
    55              throw new RuntimeException(e);
    56          }
    57      }
    58
    59      public static ResultSet executeQuery(PreparedStatement pstmt) {
    60
    61          try {
    62              return pstmt.executeQuery();
    63
    64          } catch (SQLException e) {
    65              throw new RuntimeException(e);
    66          }
    67      }
    68
    69      public static void close(Statement stmt) {
    70
    71          try {
    72              stmt.close();
    73
    74          } catch (SQLException e) {
    75              throw new RuntimeException(e);
    76          }
    77      }
    78
    79      public static boolean next(ResultSet rs) {
    80
    81          try {
    82              return rs.next();
    83
    84          } catch (SQLException e) {
    85              throw new RuntimeException(e);
    86          }
    87      }
    88
    89      public static void close(ResultSet rs) {
    90
    91          try {
    92              rs.close();
    93
    94          } catch (SQLException e) {
    95              throw new RuntimeException(e);
    96          }
    97      }
    98
    99      public static int executeUpdate(PreparedStatement pstmt) {
    100
    101         try {
    102             return pstmt.executeUpdate();
    103
    104         } catch (SQLException e) {
    105             throw new RuntimeException(e);
    106         }
    107     }
    108
    109     public static ResultSet getGeneratedKeys(Statement stmt) {
    110
    111         try {
    112             return stmt.getGeneratedKeys();
    113
    114         } catch (SQLException e) {
    115             throw new RuntimeException(e);
    116         }
    117     }
    118
    119     public static ResultSetMetaData getMetaData(ResultSet rs) {
    120
    121         try {
    122             return rs.getMetaData();
    123
    124         } catch (SQLException e) {
    125             throw new RuntimeException(e);
    126         }
    127     }
    128
    129     public static int getColumnCount(ResultSetMetaData metaData) {
    130
    131         try {
    132             return metaData.getColumnCount();
    133
    134         } catch (SQLException e) {
    135             throw new RuntimeException(e);
    136         }
    137     }
    138
    139     public static String getColumnLabel(ResultSetMetaData metaData, int column) {
    140
    141         try {
    142             return metaData.getColumnLabel(column);
    143
    144         } catch (SQLException e) {
    145             throw new RuntimeException(e);
    146         }
    147     }
    148
    149     public static Object getObject(ResultSet rs, int columnIndex) {
    150
    151         try {
    152             return rs.getObject(columnIndex);
    153
    154         } catch (SQLException e) {
    155             throw new RuntimeException(e);
    156         }
    157     }
    158
    159     public static BigDecimal getBigDecimal(ResultSet rs, int columnIndex) {
    160
    161         try {
    162             return rs.getBigDecimal(columnIndex);
    163
    164         } catch (SQLException e) {
    165             throw new RuntimeException(e);
    166         }
    167     }
    168
    169     public static String getString(ResultSet rs, int columnIndex) {
    170
    171         try {
    172             return rs.getString(columnIndex);
    173
    174         } catch (SQLException e) {
    175             throw new RuntimeException(e);
    176         }
    177     }
    178
    179     public static boolean getBoolean(ResultSet rs, int columnIndex) {
    180
    181         try {
    182             return rs.getBoolean(columnIndex);
    183
    184         } catch (SQLException e) {
    185             throw new RuntimeException(e);
    186         }
    187     }
    188
    189     public static byte getByte(ResultSet rs, int columnIndex) {
    190
    191         try {
    192             return rs.getByte(columnIndex);
    193
    194         } catch (SQLException e) {
    195             throw new RuntimeException(e);
    196         }
    197     }
    198
    199     public static byte[] getBytes(ResultSet rs, int columnIndex) {
    200
    201         try {
    202             return rs.getBytes(columnIndex);
    203
    204         } catch (SQLException e) {
    205             throw new RuntimeException(e);
    206         }
    207     }
    208
    209     public static Date getDate(ResultSet rs, int columnIndex) {
    210
    211         try {
    212             return rs.getDate(columnIndex);
    213
    214         } catch (SQLException e) {
    215             throw new RuntimeException(e);
    216         }
    217     }
    218
    219     public static double getDouble(ResultSet rs, int columnIndex) {
    220
    221         try {
    222             return rs.getDouble(columnIndex);
    223
    224         } catch (SQLException e) {
    225             throw new RuntimeException(e);
    226         }
    227     }
    228
    229     public static float getFloat(ResultSet rs, int columnIndex) {
    230
    231         try {
    232             return rs.getFloat(columnIndex);
    233
    234         } catch (SQLException e) {
    235             throw new RuntimeException(e);
    236         }
    237     }
    238
    239     public static int getInt(ResultSet rs, int columnIndex) {
    240
    241         try {
    242             return rs.getInt(columnIndex);
    243
    244         } catch (SQLException e) {
    245             throw new RuntimeException(e);
    246         }
    247     }
    248
    249     public static long getLong(ResultSet rs, int columnIndex) {
    250
    251         try {
    252             return rs.getLong(columnIndex);
    253
    254         } catch (SQLException e) {
    255             throw new RuntimeException(e);
    256         }
    257     }
    258
    259     public static short getShort(ResultSet rs, int columnIndex) {
    260
    261         try {
    262             return rs.getShort(columnIndex);
    263
    264         } catch (SQLException e) {
    265             throw new RuntimeException(e);
    266         }
    267     }
    268
    269     public static Time getTime(ResultSet rs, int columnIndex) {
    270
    271         try {
    272             return rs.getTime(columnIndex);
    273
    274         } catch (SQLException e) {
    275             throw new RuntimeException(e);
    276         }
    277     }
    278
    279     public static Timestamp getTimestamp(ResultSet rs, int columnIndex) {
    280
    281         try {
    282             return rs.getTimestamp(columnIndex);
    283
    284         } catch (SQLException e) {
    285             throw new RuntimeException(e);
    286         }
    287     }
    288
    289     public static boolean wasNull(ResultSet rs) {
    290
    291         try {
    292             return rs.wasNull();
    293
    294         } catch (SQLException e) {
    295             throw new RuntimeException(e);
    296         }
    297     }
    298 }