// @Test public void testSelect() throws TorqueException, SQLException { Criteria crit = new Criteria(); crit.setDbName("eagle"); crit.addSelectColumn(new ColumnImpl("column1")); crit.addSelectColumn(new ColumnImpl("column2")); crit.addSelectColumn(new ColumnImpl("column2/100")); crit.where(new ColumnImpl("column1"), SqlEnum.GREATER_EQUAL); crit.addFrom("tableName"); crit.addAlias("column1", "c1"); crit.addGroupByColumn(new ColumnImpl("column1")); crit.addAscendingOrderByColumn(new ColumnImpl("column3")); crit.setLimit(1000); Query query = SqlBuilder.buildQuery(crit); String sql = query.toString(); System.out.println(sql); Connection connection = Torque.getConnection(); PreparedStatement statement = connection.prepareStatement(sql); statement.setInt(1, 1000); try { ResultSet result = statement.executeQuery(); } catch (SQLException ex) { LOG.warn(ex.getMessage(), ex); } finally { connection.close(); } }
/** * @param tableName a <code>String</code> value that is used to identify the row * @return a <code>boolean</code> value * @exception TorqueException if a Torque error occurs. * @exception Exception if another error occurs. */ public boolean exists(String tableName) throws Exception { String query = new StringBuffer(100) .append("select ") .append(TABLE_NAME) .append(" where ") .append(TABLE_NAME) .append("='") .append(tableName) .append('\'') .toString(); boolean exists = false; Connection dbCon = null; try { dbCon = Torque.getConnection(databaseName); Statement statement = dbCon.createStatement(); ResultSet rs = statement.executeQuery(query); exists = rs.next(); statement.close(); } finally { // Return the connection to the pool. try { dbCon.close(); } catch (Exception e) { log.error("Release of connection failed.", e); } } return exists; }
/** * Constructor. Provided as long as both Constructors, IDBroker(DatabaseInfo) and * IDBroker(TableMap), are around. * * @param databaseName the name of the database for which this IdBroker provides Ids. */ private IDBroker(String databaseName) { this.databaseName = databaseName; configuration = Torque.getConfiguration(); // Start the housekeeper thread only if prefetch has not been disabled if (configuration.getBoolean(DB_IDBROKER_PREFETCH, true)) { houseKeeperThread = new Thread(this); // Indicate that this is a system thread. JVM will quit only when // there are no more active user threads. Settings threads spawned // internally by Torque as daemons allows commandline applications // using Torque terminate in an orderly manner. houseKeeperThread.setDaemon(true); houseKeeperThread.setName("Torque - ID Broker thread"); houseKeeperThread.start(); } // Check for Transaction support. Give warning message if // IDBroker is being used with a database that does not // support transactions. Connection dbCon = null; try { dbCon = Torque.getConnection(databaseName); } catch (Throwable t) { log.error("Could not open a connection to the database " + databaseName, t); transactionsSupported = false; } try { transactionsSupported = dbCon.getMetaData().supportsTransactions(); } catch (Exception e) { log.warn( "Could not read from connection Metadata" + " whether transactions are supported for the database " + databaseName, e); transactionsSupported = false; } finally { try { // Return the connection to the pool. dbCon.close(); } catch (Exception e) { log.warn( "Could not close the connection which was used " + "for testing whether transactions are supported", e); } } if (!transactionsSupported) { log.warn( "IDBroker is being used with db '" + databaseName + "', which does not support transactions. IDBroker " + "attempts to use transactions to limit the possibility " + "of duplicate key generation. Without transactions, " + "duplicate key generation is possible if multiple JVMs " + "are used or other means are used to write to the " + "database."); } }
/** * Retrieve a multiple objects by pk * * @param pks List of primary keys * @throws TorqueException Any exceptions caught during processing will be rethrown wrapped into a * TorqueException. */ public static List retrieveByPKs(List pks) throws TorqueException { Connection db = null; List retVal = null; try { db = Torque.getConnection(DATABASE_NAME); retVal = retrieveByPKs(pks, db); } finally { Torque.closeConnection(db); } return (retVal); }
/** * Retrieve a multiple objects by pk * * @param pks List of primary keys * @throws TorqueException Any exceptions caught during processing will be rethrown wrapped into a * TorqueException. */ public static List<TRoleListType> retrieveByPKs(List<ObjectKey> pks) throws TorqueException { Connection db = null; List<TRoleListType> retVal = null; try { db = Torque.getConnection(DATABASE_NAME); retVal = retrieveByPKs(pks, db); } finally { Torque.closeConnection(db); } return retVal; }
/** * Retrieve a single object by pk * * @param pk the primary key * @throws TorqueException Any exceptions caught during processing will be rethrown wrapped into a * TorqueException. * @throws NoRowsException Primary key was not found in database. * @throws TooManyRowsException Primary key was not found in database. */ public static Exam retrieveByPK(ObjectKey pk) throws TorqueException, NoRowsException, TooManyRowsException { Connection db = null; Exam retVal = null; try { db = Torque.getConnection(DATABASE_NAME); retVal = retrieveByPK(pk, db); } finally { Torque.closeConnection(db); } return (retVal); }
/** * This method allows you to get the number of ids that are to be cached in memory. This is either * stored in quantityStore or read from the db. (ie the value in ID_TABLE.QUANTITY). Though this * method returns a BigDecimal for the quantity, it is unlikey the system could withstand whatever * conditions would lead to really needing a large quantity, it is retrieved as a BigDecimal only * because it is going to be added to another BigDecimal. * * @param tableName The name of the table we want to query. * @param connection a Connection * @return An int with the number of ids cached in memory. */ private BigDecimal getQuantity(String tableName, Connection connection) { BigDecimal quantity = null; // If prefetch is turned off we simply return 1 if (!configuration.getBoolean(DB_IDBROKER_PREFETCH, true)) { quantity = new BigDecimal((double) 1); } // Initialize quantity, if necessary. else if (quantityStore.containsKey(tableName)) { quantity = (BigDecimal) quantityStore.get(tableName); } else { Connection dbCon = null; try { if (connection == null || configuration.getBoolean(DB_IDBROKER_USENEWCONNECTION, true)) { // Get a connection to the db dbCon = Torque.getConnection(databaseName); } // Read the row from the ID_TABLE. BigDecimal[] results = selectRow(dbCon, tableName); // QUANTITY column. quantity = results[1]; quantityStore.put(tableName, quantity); } catch (Exception e) { quantity = new BigDecimal((double) 10); } finally { // Return the connection to the pool. try { dbCon.close(); } catch (Exception e) { log.error("Release of connection failed.", e); } } } return quantity; }