/**
* puts the value for the column aginst the column Name
*
* @param os
* @param rows
* @param oldResultSet
* @param index
* @param modifiedColumns
* @param columnName
* @throws SQLException
* @throws IOException
*/
public void writeUpdate(
Writer os,
ResultSet rows,
ResultSet oldResultSet,
int index,
HashMap modifiedColumns,
String columnName,
ArrayList encodedCols)
throws SQLException, IOException {
Object newObject = rows.getObject(index);
Object oldObject = oldResultSet.getObject(index);
if (newObject == null) {
write(os, "NULL", encodedCols, columnName);
if (oldObject != null) {
modifiedColumns.put(columnName, "NULL");
}
} else {
write(os, newObject, encodedCols, columnName);
if (oldObject != null) {
if (!(newObject.equals(oldObject))) {
modifiedColumns.put(columnName, newObject);
}
} else {
modifiedColumns.put(columnName, newObject);
}
}
}
/** private method which actually will do all of our work for the sample */
private void executeSample() {
String query = "select anEmployee from staff2";
try {
Statement stmt = _con.createStatement();
;
// Execute the query which will return an Employee object
// We will cast this using the Person interface. Note the
// Person interface class MUST be in your CLASSPATH. You
// Do not need Employee in your CLASSPATH.
ResultSet rs = stmt.executeQuery(query);
output("***Using interface class\n");
while (rs.next()) {
Person aPerson = (Person) rs.getObject(1);
displayMethods(aPerson.getClass());
output(
"The person is: "
+ aPerson.toString()
+ "\nFirst Name= "
+ aPerson.getFirstName()
+ "\nLast Name= "
+ aPerson.getLastName()
+ "\n");
}
// Now execute the same query, but this time we will use
// reflection to access the class. Again, only the interface
// Person is required in the CLASSPATH
rs = stmt.executeQuery(query);
output("***Using reflection\n");
Object theObj = null;
while (rs.next()) {
theObj = rs.getObject(1);
output("The person is: " + theObj.toString() + "\n");
Class theClass = theObj.getClass();
displayMethods(theClass);
Method m1 = theClass.getMethod("toString", new Class[0]);
Method m2 = theClass.getMethod("getFirstName", new Class[0]);
Method m3 = theClass.getMethod("getLastName", new Class[0]);
output(
"The person is: "
+ (Object) m1.invoke(theObj, new Object[0])
+ "\nFirst Name= "
+ (Object) m2.invoke(theObj, new Object[0])
+ "\nLast Name= "
+ (Object) m3.invoke(theObj, new Object[0])
+ "\n");
}
rs.close();
stmt.close();
} catch (SQLException sqe) {
displaySQLEx(sqe);
} catch (Exception e) {
error("Unexpected exception : " + e.toString() + "\n");
e.printStackTrace();
}
}
private double fetchValueOfDouble(String fieldname) {
// As with fetch...String, the point is to handle nulls gracefully.
try {
return (rs_instrument.getObject(fieldname) == null)
? 0
: Double.parseDouble(rs_instrument.getObject(HEIGHT).toString());
} catch (SQLException sqle) {
System.out.println("Unable to fetch value of " + fieldname + ".\n" + sqle);
return -1;
}
}
// some data processing
private String fetchValueOfString(String fieldname) {
// This method reads in a value and translates nulls into an empty string so the constructor
// doesn't choke.
try {
return (rs_instrument.getObject(fieldname) == null)
? ""
: rs_instrument.getObject(fieldname).toString();
} catch (SQLException sqle) {
System.out.println("Unable to fetch value of " + fieldname + ".\n" + sqle);
return "?????";
}
}
@Override
public void reset() throws SQLException {
cellI = 0;
cellJ = 0;
firstRow = false;
// We compute the extend according the first input value
if (isTable) {
Statement statement = connection.createStatement();
ResultSet rs =
statement.executeQuery(
"select ST_Extent("
+ getFirstGeometryField(tableName, connection)
+ ") from "
+ tableName);
try {
rs.next();
Geometry geomExtend = (Geometry) rs.getObject(1);
if (geomExtend == null) {
throw new SQLException("The envelope cannot be null.");
} else {
envelope = geomExtend.getEnvelopeInternal();
initParameters();
}
} finally {
rs.close();
}
} else {
if (envelope == null) {
throw new SQLException("The input geometry used to compute the grid cannot be null.");
} else {
initParameters();
}
}
}
// execute and get results
private void execute(Connection conn, String text, Writer writer, boolean commaSeparator)
throws SQLException {
BufferedWriter buffer = new BufferedWriter(writer);
Statement stmt = conn.createStatement();
stmt.execute(text);
ResultSet rs = stmt.getResultSet();
ResultSetMetaData metadata = rs.getMetaData();
int nbCols = metadata.getColumnCount();
String[] labels = new String[nbCols];
int[] colwidths = new int[nbCols];
int[] colpos = new int[nbCols];
int linewidth = 1;
// read each occurrence
try {
while (rs.next()) {
for (int i = 0; i < nbCols; i++) {
Object value = rs.getObject(i + 1);
if (value != null) {
buffer.write(value.toString());
if (commaSeparator) buffer.write(",");
}
}
}
buffer.flush();
rs.close();
} catch (IOException ex) {
if (Debug.isDebug()) ex.printStackTrace();
// ok, exit from the loop
} catch (SQLException ex) {
if (Debug.isDebug()) ex.printStackTrace();
}
}
private void jTbdescripcionKeyPressed(
java.awt.event.KeyEvent evt) { // GEN-FIRST:event_jTbdescripcionKeyPressed
try {
// se comienza la conexion con la base de datos
try {
con = new Conexion();
} catch (ClassNotFoundException ex) {
Logger.getLogger(Interface.class.getName()).log(Level.SEVERE, null, ex);
} catch (SQLException ex) {
Logger.getLogger(Interface.class.getName()).log(Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
Logger.getLogger(Interface.class.getName()).log(Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
Logger.getLogger(Interface.class.getName()).log(Level.SEVERE, null, ex);
}
String nom = jTbdescripcion.getText();
String sql = "SELECT * FROM productos WHERE nombre_producto LIKE '" + nom + "%'";
rs = con.Consulta(sql);
if (rs == null)
JOptionPane.showMessageDialog(
null, "No se encontro: " + jTbdescripcion.getText() + " en la base de datos.");
// Para establecer el modelo al JTable
DefaultTableModel buscar =
new DefaultTableModel() {
@Override
public boolean isCellEditable(int rowIndex, int vColIndex) {
return false;
}
};
this.jTbuscar.setModel(buscar);
// Obteniendo la informacion de las columnas que estan siendo consultadas
ResultSetMetaData rsMd = rs.getMetaData();
// La cantidad de columnas que tiene la consulta
int cantidadColumnas = rsMd.getColumnCount();
// Establecer como cabezeras el nombre de las colimnas
for (int i = 1; i <= cantidadColumnas; i++) {
buscar.addColumn(rsMd.getColumnLabel(i));
}
while (rs.next()) {
Object[] fila = new Object[cantidadColumnas];
for (int i = 0; i < cantidadColumnas; i++) {
fila[i] = rs.getObject(i + 1);
}
buscar.addRow(fila);
}
} catch (SQLException ex) {
Logger.getLogger(Interface.class.getName()).log(Level.SEVERE, null, ex);
}
} // GEN-LAST:event_jTbdescripcionKeyPressed
@Override
public void batchWrite(BatchUpdateHandler handler, List<String> batchedSQL) throws SQLException {
Statement statement = null;
try {
statement = connection.createStatement();
for (String row : batchedSQL) {
addBatch(statement, row);
}
int[] batchResult = executeBatch(statement);
handler.onBatchResult(Arrays.copyOf(batchResult, batchResult.length));
ResultSet generatedKeys = getGeneratedKeys(statement);
if (generatedKeys != null) {
while (generatedKeys.next()) {
handler.onGeneratedKey(generatedKeys.getObject(1));
}
generatedKeys.close();
}
SQLWarning warning = getWarnings(statement);
if (warning != null) {
handler.onWarning(warning);
}
} finally {
if (statement != null) {
try {
close(statement);
} catch (SQLException e) {
LOGGER.error("Unable to close statement after batch write", e);
}
}
}
}
private Double toDouble(ResultSet rs, String column) throws SQLException {
Object obj = rs.getObject(column);
if (obj instanceof Double) {
return (Double) obj;
}
return null;
}
public Object get_field(String field_name) {
try {
return results.getObject(field_name);
} catch (Exception ex) {
throw new InvalidQueryException("Database access failed");
}
}
/** Creates new form PrincipalCliente */
public ModificarAdmin() {
initComponents();
conexioninicio ci = new conexioninicio();
ci.conectar();
this.setSize(470, 650);
this.setLocationRelativeTo(null); // Centra la ventana Splash
try {
Connection con = DriverManager.getConnection(ci.getURl(), ci.getLogin(), ci.getPassword());
// System.out.println("Conexion a la base de datos cliente realizada con exito! ");
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM tienda.estado ;");
// obteniendo la informacion de las columnas que estan siendo consultadas
ResultSetMetaData rsMd = rs.getMetaData();
// La cantidad de columnas que tiene la consulta
int cantidadColumnas = rsMd.getColumnCount();
// Establecer como cabezeras el nombre de las columnas
// Creando las filas para el Jtable
while (rs.next()) {
Object[] fila = new Object[cantidadColumnas];
for (int i = 1; i < cantidadColumnas; i++) {
jComboBox1.addItem(rs.getObject(i + 1));
}
}
rs.close();
con.close();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Error", JOptionPane.ERROR_MESSAGE);
}
}
/**
* Asserts that we find the expected values in the result set. We don't know the order, since we
* don't always have an order by and we're going through indexes, but we assert that each expected
* result occurs once as expected (in any order).
*/
public static void assertValuesEqualsResultSet(ResultSet rs, List<List<Object>> expectedResults)
throws SQLException {
int expectedCount = expectedResults.size();
int count = 0;
List<List<Object>> actualResults = Lists.newArrayList();
List<Object> errorResult = null;
while (rs.next() && errorResult == null) {
List<Object> result = Lists.newArrayList();
for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
result.add(rs.getObject(i + 1));
}
if (!expectedResults.contains(result)) {
errorResult = result;
}
actualResults.add(result);
count++;
}
assertTrue(
"Could not find "
+ errorResult
+ " in expected results: "
+ expectedResults
+ " with actual results: "
+ actualResults,
errorResult == null);
assertEquals(expectedCount, count);
}
public static void populateTable() {
System.out.println("started");
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "");
stmt = conn.prepareStatement("select * from class");
rs = stmt.executeQuery();
ResultSetMetaData metaData = rs.getMetaData();
System.out.println("connected");
Vector<String> columnNames = new Vector<String>(); // vector to store names of columns
int columnCount = metaData.getColumnCount(); // get number of columns
for (int i = 1; i <= columnCount; i++) {
System.out.println("loop columnams.add");
columnNames.add(metaData.getColumnName(i)); // adding column names in the vector
}
Vector<Vector<Object>> data = new Vector<Vector<Object>>();
while (rs.next()) {
System.out.println("while rs.next");
Vector<Object> vector = new Vector<Object>();
for (int columnIndex = 1; columnIndex <= columnCount; columnIndex++) {
vector.add(rs.getObject(columnIndex));
}
data.add(vector);
}
System.out.println("done loop");
DefaultTableModel temp = new DefaultTableModel(data, columnNames);
// JTable tablez = new JTable(temp);
// System.out.println(tablez);
table.setModel(temp);
table.setModel(temp);
// table = tablez;
// System.out.println();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
/**
* Processes requests for both HTTP <code>GET</code> and <code>POST</code> methods.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String username = request.getParameter("username");
String password = request.getParameter("password");
Statement stmt;
ResultSet rs;
Connection con = null;
try {
Class.forName("com.mysql.jdbc.Driver");
String connectionUrl = "jdbc:mysql://localhost/myflickr?" + "user=root&password=123456";
con = DriverManager.getConnection(connectionUrl);
if (con != null) {
System.out.println("connected to mysql");
}
} catch (SQLException e) {
System.out.println("SQL Exception: " + e.toString());
} catch (ClassNotFoundException cE) {
System.out.println("Class Not Found Exception: " + cE.toString());
}
try {
stmt = con.createStatement();
System.out.println("SELECT * FROM flickrusers WHERE name='" + username + "'");
rs = stmt.executeQuery("SELECT * FROM flickrusers WHERE name='" + username + "'");
while (rs.next()) {
if (rs.getObject(1).toString().equals(username)) {
out.println("<h1>To username pou epileksate uparxei hdh</h1>");
out.println("<a href=\"project3.html\">parakalw dokimaste kapoio allo.</a>");
stmt.close();
rs.close();
return;
}
}
stmt.close();
rs.close();
stmt = con.createStatement();
if (!stmt.execute("INSERT INTO flickrusers VALUES('" + username + "', '" + password + "')")) {
out.println("<h1>Your registration is completed " + username + "</h1>");
out.println("<a href=\"index.jsp\">go to the login menu</a>");
registerListener.Register(username);
} else {
out.println("<h1>To username pou epileksate uparxei hdh</h1>");
out.println("<a href=\"project3.html\">Register</a>");
}
} catch (SQLException e) {
throw new ServletException("Servlet Could not display records.", e);
}
}
/*
* Execute query against a list of sensors
*
* */
public static String executeQuery(
String envelope, String query, String matchingSensors, String format) throws ParseException {
// String matchingSensors = getListOfSensorsAsString(envelope);
String reformattedQuery = reformatQuery(query, matchingSensors);
StringBuilder sb = new StringBuilder();
Connection connection = null;
try {
connection = Main.getDefaultStorage().getConnection();
Statement statement =
connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet results = statement.executeQuery(reformattedQuery);
ResultSetMetaData metaData; // Additional information about the results
int numCols, numRows; // How many rows and columns in the table
metaData = results.getMetaData(); // Get metadata on them
numCols = metaData.getColumnCount(); // How many columns?
results.last(); // Move to last row
numRows = results.getRow(); // How many rows?
String s;
// System.out.println("* Executing query *\n" + reformattedQuery + "\n***");
// headers
// sb.append("# Query: " + query + NEWLINE);
sb.append("# Query: " + reformattedQuery.replaceAll("\n", "\n# ") + NEWLINE);
sb.append("# ");
// System.out.println("ncols: " + numCols);
// System.out.println("nrows: " + numRows);
for (int col = 0; col < numCols; col++) {
sb.append(metaData.getColumnLabel(col + 1));
if (col < numCols - 1) sb.append(SEPARATOR);
}
sb.append(NEWLINE);
for (int row = 0; row < numRows; row++) {
results.absolute(row + 1); // Go to the specified row
for (int col = 0; col < numCols; col++) {
Object o = results.getObject(col + 1); // Get value of the column
// logger.warn(row + " , "+col+" : "+ o.toString());
if (o == null) s = "null";
else s = o.toString();
if (col < numCols - 1) sb.append(s).append(SEPARATOR);
else sb.append(s);
}
sb.append(NEWLINE);
}
} catch (SQLException e) {
sb.append("ERROR in execution of query: " + e.getMessage());
} finally {
Main.getDefaultStorage().close(connection);
}
return sb.toString();
}
public static <K, V> Map<K, V> resultSetToMap(final ResultSet resultSet) {
try {
final Map<K, V> map = new LinkedHashMap<K, V>();
while (resultSet.next()) {
K key = (K) resultSet.getObject(1);
V value = (V) resultSet.getObject(2);
map.put(key, value);
}
return map;
} catch (Exception e) {
throw new IllegalStateException("Unable to transform the resultSet into a Map", e);
}
}
public void calcular(Conectar cn, String fechaInicio, String fechaFin)
throws SQLException, IOException, ParseException {
// Cuenta el número de dispositivos que han pasado por cada nodo, osea cuántas veces un
// dispositivo ha pasado por un nodo determinado.
Statement st1 = cn.crearSt();
String query =
"select paso.idNodo, nodo.nombre, idDispositivo, count(idDispositivo), YEAR(FROM_UNIXTIME(tInicio/1000)) as year, "
+ "MONTH(FROM_UNIXTIME(tInicio/1000)) as month, DAYOFMONTH(FROM_UNIXTIME(tInicio/1000)) as day, "
+ "HOUR(FROM_UNIXTIME(tInicio/1000)) as hour, DAYNAME(FROM_UNIXTIME(tInicio/1000)) as nameDay, FROM_UNIXTIME(tInicio/1000) as fecha from paso, nodo where paso.idNodo=nodo.idNodo "
+ "and FROM_UNIXTIME(tInicio/1000) < '"
+ fechaFin
+ "' and FROM_UNIXTIME(tInicio/1000) > '"
+ fechaInicio
+ "' group by nodo.IdNodo, idDispositivo, year, month, day, hour;";
System.err.println(query);
ResultSet rs = st1.executeQuery(query);
String s;
// DateFormat format = new SimpleDateFormat("MMddyyHHmmss");
while (rs.next()) {
s =
rs.getObject(1)
+ "\t"
+ rs.getObject(2)
+ "\t"
+ rs.getObject(3)
+ "\t"
+ rs.getObject(4)
+ "\t"
+ rs.getObject(5)
+ "\t"
+ rs.getObject(6)
+ "\t"
+ rs.getObject(7)
+ "\t"
+ rs.getObject(8)
+ "\t"
+ rs.getObject(9)
+ "\n";
bw.write(s);
System.err.print(s);
// sumaTiempo=sumaTiempo+Long.parseLong(rs.getObject(2).toString())-Long.parseLong(rs.getObject(1).toString());
}
rs.close();
bw.close();
}
protected Map<String, Object> getARow(
ResultSet resultSet,
boolean convertType,
List<String> colNames,
Map<String, Integer> fieldNameVsType) {
if (resultSet == null) return null;
Map<String, Object> result = new HashMap<>();
for (String colName : colNames) {
try {
if (!convertType) {
// Use underlying database's type information except for BigDecimal and BigInteger
// which cannot be serialized by JavaBin/XML. See SOLR-6165
Object value = resultSet.getObject(colName);
if (value instanceof BigDecimal || value instanceof BigInteger) {
result.put(colName, value.toString());
} else {
result.put(colName, value);
}
continue;
}
Integer type = fieldNameVsType.get(colName);
if (type == null) type = Types.VARCHAR;
switch (type) {
case Types.INTEGER:
result.put(colName, resultSet.getInt(colName));
break;
case Types.FLOAT:
result.put(colName, resultSet.getFloat(colName));
break;
case Types.BIGINT:
result.put(colName, resultSet.getLong(colName));
break;
case Types.DOUBLE:
result.put(colName, resultSet.getDouble(colName));
break;
case Types.DATE:
result.put(colName, resultSet.getTimestamp(colName));
break;
case Types.BOOLEAN:
result.put(colName, resultSet.getBoolean(colName));
break;
case Types.BLOB:
result.put(colName, resultSet.getBytes(colName));
break;
default:
result.put(colName, resultSet.getString(colName));
break;
}
} catch (SQLException e) {
logError("Error reading data ", e);
wrapAndThrow(SEVERE, e, "Error reading data from database");
}
}
return result;
}
public Object getReturnValue() throws SQLException {
if (functionReturnValueViaResultSet) {
rs.next();
Object o = rs.getObject(1);
rs.close();
return o;
} else {
return getObject(returnValueInd);
}
}
private void checkBooleanValue(ResultSet rs, boolean expectedValue, Boolean expectedNull)
throws SQLException {
rs.next();
for (int i = 1; i <= 14; i++) {
assertEquals(expectedValue, rs.getBoolean(i));
if (i == 1 || i == 2) {
assertEquals(expectedNull, rs.getObject(i));
}
}
}
/** @return {@code true} If next row was fetched successfully. */
private boolean fetchNext() {
if (data == null) return false;
try {
if (!data.next()) return false;
for (int c = 0; c < row.length; c++) row[c] = data.getObject(c + 1);
return true;
} catch (SQLException e) {
throw new IgniteException(e);
}
}
public static void dump(ResultSet rs) throws SQLException {
ResultSetMetaData meta = rs.getMetaData();
int colmax = meta.getColumnCount();
int i;
Object o = null;
for (; rs.next(); ) {
for (i = 0; i < colmax; ++i) {
o = rs.getObject(i + 1); // In SQL the first column is indexed with 1 not 0
System.out.print(o.toString() + " ");
}
System.out.println(" ");
}
}
public int applyParamsToInsertAndUpdateStatement(
PreparedStatement pstmt, TemporalEntity sde, Date transactionTime, Date createdTime)
throws Exception {
int idx = applyParamsToInsertStatement(pstmt, sde, transactionTime, createdTime);
currentRS.last();
for (String notUpdateName : notUpdatedColumns) {
Object o = currentRS.getObject(notUpdateName);
pstmt.setObject(idx++, o);
}
return idx;
}
public Object get(ResultSet resultSet, int column) throws SQLException {
switch (this) {
case OBJECT:
return resultSet.getObject(column + 1);
case STRING:
return resultSet.getString(column + 1);
case INT:
return resultSet.getInt(column + 1);
case LONG:
return resultSet.getLong(column + 1);
case DOUBLE:
return resultSet.getDouble(column + 1);
default:
throw Util.unexpected(this);
}
}
public Object getGeneratedKey(Class<?> type) throws SQLException, IllegalAccessException {
ResultSet rs = statement.getGeneratedKeys();
if (rs.next()) { // todo: first try to find by name (mysql does not support name-based return
// keys)
Object value;
if (type == Integer.class) {
value = rs.getInt(1);
} else if (type == Long.class) {
value = rs.getLong(1);
} else {
value = rs.getObject(1);
}
return value;
}
throw new IllegalAccessException("statement has not generated any keys");
}
@Ignore
@Test
public void getObject() throws SQLException {
stat.executeUpdate(
"create table testobj (" + "c1 integer, c2 float, c3, c4 varchar, c5 bit, c6, c7);");
PreparedStatement prep = conn.prepareStatement("insert into testobj values (?,?,?,?,?,?,?);");
prep.setInt(1, Integer.MAX_VALUE);
prep.setFloat(2, Float.MAX_VALUE);
prep.setDouble(3, Double.MAX_VALUE);
prep.setLong(4, Long.MAX_VALUE);
prep.setBoolean(5, false);
prep.setByte(6, (byte) 7);
prep.setBytes(7, b1);
prep.executeUpdate();
ResultSet rs = stat.executeQuery("select c1,c2,c3,c4,c5,c6,c7 from testobj;");
assertTrue(rs.next());
assertEquals(Integer.MAX_VALUE, rs.getInt(1));
assertEquals(Integer.MAX_VALUE, (int) rs.getLong(1));
assertEquals(Float.MAX_VALUE, rs.getFloat(2));
assertEquals(Double.MAX_VALUE, rs.getDouble(3));
assertEquals(Long.MAX_VALUE, rs.getLong(4));
assertFalse(rs.getBoolean(5));
assertEquals((byte) 7, rs.getByte(6));
assertArrayEq(rs.getBytes(7), b1);
assertNotNull(rs.getObject(1));
assertNotNull(rs.getObject(2));
assertNotNull(rs.getObject(3));
assertNotNull(rs.getObject(4));
assertNotNull(rs.getObject(5));
assertNotNull(rs.getObject(6));
assertNotNull(rs.getObject(7));
assertTrue(rs.getObject(1) instanceof Integer);
assertTrue(rs.getObject(2) instanceof Double);
assertTrue(rs.getObject(3) instanceof Double);
assertTrue(rs.getObject(4) instanceof String);
assertTrue(rs.getObject(5) instanceof Integer);
assertTrue(rs.getObject(6) instanceof Integer);
assertTrue(rs.getObject(7) instanceof byte[]);
rs.close();
}
/** getObject. */
public void test() throws Exception {
PreparedStatement statement = connection.prepareStatement(sql);
ResultSet result = statement.executeQuery();
int size = result.getMetaData().getColumnCount();
Vector rows = new Vector();
while (result.next()) {
Vector row = new Vector(size);
for (int column = 1; column <= size; column++) {
Object value = result.getObject(column);
value = ConversionManager.getDefaultManager().convertObject(value, ClassConstants.SQLDATE);
row.add(value);
}
rows.add(row);
}
result.close();
statement.close();
}
@Override
public List<Map<String, Object>> queryByParamsForMapList() throws SQLException {
preStat = getPreparedStatement();
rs = preStat.executeQuery();
mapList.clear();
Map<String, Object> map = null;
ResultSetMetaData rsm = rs.getMetaData();
int cnt = rsm.getColumnCount();
while (rs.next()) {
map = new HashMap<String, Object>(cnt);
for (int i = 0; i < cnt; i++) {
map.put(rsm.getColumnName(i), rs.getObject(i));
}
mapList.add(map);
}
return mapList;
}
/**
* Processes a particular SQL Array object and interprets its value as a ParamValue object.
*
* @param sqlArray SQL Array element.
* @param paramValue Parameter value object initialized to contain an array of ParamValues.
* @return ParamValue object representing the SQL Array.
* @throws SQLException Throws an SQL Exception if the result set is not accessible.
*/
public static ParamValue processSQLArray(Array sqlArray, ParamValue paramValue)
throws SQLException {
ResultSet rs = sqlArray.getResultSet();
while (rs.next()) {
Object arrayEl = rs.getObject(2);
if (arrayEl instanceof Struct) {
paramValue.getArrayValue().add(new ParamValue((Struct) arrayEl));
} else if (arrayEl instanceof Array) {
paramValue
.getArrayValue()
.add(processSQLArray((Array) arrayEl, new ParamValue(ParamValue.PARAM_VALUE_ARRAY)));
} else {
paramValue.getArrayValue().add(new ParamValue(String.valueOf(arrayEl)));
}
}
rs.close();
return paramValue;
}
public <T> List<T> executeAndFetch(Class returnType) {
List list = new ArrayList();
PojoMetadata metadata =
new PojoMetadata(returnType, this.isCaseSensitive(), this.getColumnMappings());
try {
// java.util.Date st = new java.util.Date();
long start = System.currentTimeMillis();
ResultSet rs = statement.executeQuery();
long afterExecQuery = System.currentTimeMillis();
ResultSetMetaData meta = rs.getMetaData();
while (rs.next()) {
Pojo pojo = new Pojo(metadata, this.isCaseSensitive());
// Object obj = returnType.newInstance();
for (int colIdx = 1; colIdx <= meta.getColumnCount(); colIdx++) {
String colName = meta.getColumnName(colIdx);
pojo.setProperty(colName, rs.getObject(colIdx));
}
list.add(pojo.getObject());
}
rs.close();
long afterClose = System.currentTimeMillis();
logger.info(
"total: {} ms, execution: {} ms, reading and parsing: {} ms; executed [{}]",
new Object[] {
afterClose - start,
afterExecQuery - start,
afterClose - afterExecQuery,
this.getName() == null ? "No name" : this.getName()
});
} catch (SQLException ex) {
throw new Sql2oException("Database error", ex);
} finally {
closeConnectionIfNecessary();
}
return list;
}
