public ArrayList<Contract> getContract() { ArrayList<Contract> con = new ArrayList<>(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select * from " + getCONTRACT_CB(); ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); while (rs.next()) { Contract c = new Contract(); c.setID(rs.getShort(1)); c.setName(rs.getNString(2)); c.setMonth(rs.getShort(3)); c.setBHXH(rs.getBoolean(4)); c.setPercent(rs.getFloat(5)); c.setTemplate(rs.getBytes(6)); c.setExtension(rs.getString(7)); con.add(c); } } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return con; }
public void readDataBase(Connection connect) throws Exception { try { // Statements allow to issue SQL queries to the database statement = connect.createStatement(); // Result set get the result of the SQL query rs = statement.executeQuery( "SELECT id, name, address, port, icon, realmflags, timezone, allowedSecurityLevel, population FROM realmlist WHERE (realmflags & 1) = 0 ORDER BY name"); realms.clear(); while (rs.next()) { Realm list = new Realm(); list.setId(rs.getInt("id")); list.setName(rs.getString("Name")); list.setAddress(rs.getString("address")); list.setPort(rs.getShort("port")); list.setIcon(rs.getShort("icon")); list.setRealmflags(rs.getShort("realmflags")); list.setTimezone(rs.getShort("timezone")); list.setAllowedSecurityLevel(rs.getShort("allowedSecurityLevel")); list.setPopulation(rs.getFloat("population")); realms.add(list); } } catch (Exception e) { throw e; } finally { close(); } }
public ArrayList<DocumentsDetails> getDocumentsDetails(String personnelID) { ArrayList<DocumentsDetails> docList = new ArrayList<>(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select " + DOC_COLUMN + " from " + DOC_INFO + " where MaNV = '" + personnelID + "'"; ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); while (rs.next()) { DocumentsDetails doc = new DocumentsDetails(); doc.setName(rs.getNString(1)); doc.setSaveDate(rs.getDate(2)); doc.setFile(rs.getBytes(3)); doc.setExtension(rs.getString(4)); doc.setKindID(rs.getShort(5)); doc.setID_IDENTITY(rs.getShort(6)); docList.add(doc); } } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return docList; }
public static List<Zone> getZoneList(int world_id, int player_id) { List<Zone> zones = new ArrayList<Zone>(); String query = "SELECT * FROM `world_zone` WHERE `world_id` = ? AND `player_id` = ? ORDER BY `zone_id`"; Connection con = null; PreparedStatement pstmt = null; ResultSet rs = null; try { con = GameDB.getConnection(); pstmt = con.prepareStatement(query); pstmt.setInt(1, world_id); pstmt.setInt(2, player_id); rs = pstmt.executeQuery(); while (rs.next()) { Zone zone = new Zone(rs.getInt("zone_id"), rs.getShort("row"), rs.getShort("column")); zone.setTerrainType(rs.getShort("terrain_type")); zone.setVegetationCapacity(rs.getInt("vegetation_capacity")); zone.setOwner(rs.getInt("player_id")); zones.add(zone); } } catch (SQLException ex) { Log.println_e(ex.getMessage()); } finally { GameDB.closeConnection(con, pstmt, rs); } return zones; }
public ArrayList<FamilyDetails> getFamilyDetails(String personnelID) { ArrayList<FamilyDetails> fdList = new ArrayList<>(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select " + FAMILY_COLUMN + " from " + FAMILY + " where MaNV = '" + personnelID + "'"; ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); while (rs.next()) { FamilyDetails fd = new FamilyDetails(); fd.setRelationID(rs.getShort(1)); fd.setPerName(rs.getString(2)); fd.setPerBirth(rs.getDate(3)); fd.setPerJob(rs.getString(4)); fd.setPerAdd(rs.getString(5)); fd.setPerPhone(rs.getString(6)); fd.setID_IDENTITY(rs.getShort(7)); fdList.add(fd); } } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return fdList; }
public ArrayList<Skill> getSkill(String personnelID) { ArrayList<Skill> skList = new ArrayList<>(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select " + SKILL_COLUMN + " from " + SKILL_INFO + " where MaNV = '" + personnelID + "'"; ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); while (rs.next()) { Skill sk = new Skill(); sk.setNameID(rs.getShort(1)); sk.setClassificationID(rs.getShort(2)); sk.setEffectiveDate(rs.getDate(3)); sk.setNote(rs.getString(4)); sk.setID_IDENTITY(rs.getShort(5)); skList.add(sk); } } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return skList; }
public TypeInfo(ResultSet rs) throws SQLException { typeName = rs.getString(1); dataType = rs.getInt(2); precision = rs.getInt(3); literalPrefix = rs.getString(4); literalSuffix = rs.getString(5); createParams = rs.getString(6); nullable = rs.getShort(7); caseSensitive = rs.getBoolean(8); searchable = rs.getShort(9); unsigned = rs.getBoolean(10); fixedPrecScale = rs.getBoolean(11); autoIncrement = rs.getBoolean(12); localTypeName = rs.getString(13); if (rs.getMetaData().getColumnCount() >= 18) { // Some servers provide more information minimumScale = rs.getShort(14); maximumScale = rs.getShort(15); sqlDataType = rs.getInt(16); sqlDatetimeSub = rs.getInt(17); numPrecRadix = rs.getInt(18); } else { // Must initialize final fields minimumScale = 0; maximumScale = 0; sqlDataType = 0; sqlDatetimeSub = 0; numPrecRadix = 0; } normalizedType = normalizeDataType(dataType); distanceFromJdbcType = determineDistanceFromJdbcType(); }
public PersonnelDetails getPersonnelDetails(String personnelID) { PersonnelDetails pd = new PersonnelDetails(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select * from " + PERSONNEL_INFO + " where MaNV = '" + personnelID + "'"; ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); // retrieve data from db by PersonnelID while (rs.next()) { pd.setPersonnelID(rs.getString(1)); pd.setlName(rs.getString(2)); pd.setfName(rs.getString(3)); pd.setNickName(rs.getString(4)); pd.setStatusID(rs.getShort(5)); pd.setKindID(rs.getShort(6)); pd.setContractID(rs.getShort(7)); pd.setPosID(rs.getShort(8)); pd.setOfficeID(rs.getShort(9)); pd.setEnterDate(rs.getDate(10)); pd.setStartDate(rs.getDate(11)); pd.setSex(rs.getBoolean(12)); pd.setPhoneNum(rs.getString(13)); pd.setCompEmail(rs.getString(14)); pd.setEndTraining(rs.getDate(15)); pd.setPic(rs.getBytes(16)); pd.setBirth(rs.getDate(17)); pd.setPlaceOB(rs.getString(18)); pd.setRecentAdd(rs.getString(19)); pd.setFolkID(rs.getShort(20)); pd.setReligionID(rs.getShort(21)); pd.setNationID(rs.getShort(22)); pd.setPersonalEmail(rs.getString(23)); pd.setMariage(rs.getBoolean(24)); pd.setEducation(rs.getString(25)); pd.setAdd(rs.getString(26)); pd.setIDNum(rs.getString(27)); pd.setIDDay(rs.getDate(28)); pd.setRegionID(rs.getShort(29)); // System.out.println(rs.getShort(29)); pd.setBankCode(rs.getString(30)); pd.setBankID(rs.getShort(31)); pd.setIDPlace(rs.getString(32)); pd.setTaxCode(rs.getString(33)); } dbc.close(ps, rs); } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return pd; }
public void refreshForeignKeys(DatabaseMetaData metaData) throws SQLException { foreignKeys.clear(); ResultSet rs = null; try { rs = metaData.getImportedKeys(catalog, schema, name); while (rs.next()) { ForeignKey fk = new ForeignKey(); foreignKeys.add(fk); fk.setOwner(this); fk.setPkTableCatalog(rs.getString("PKTABLE_CAT")); fk.setPkTableSchema(rs.getString("PKTABLE_SCHEM")); fk.setPkTableName(rs.getString("PKTABLE_NAME")); fk.setPkColumnName(rs.getString("PKCOLUMN_NAME")); fk.setColumnName(rs.getString("FKCOLUMN_NAME")); fk.setKeySequence(rs.getShort("KEY_SEQ")); fk.setUpdateRule(rs.getShort("UPDATE_RULE")); fk.setDeleteRule(rs.getShort("DELETE_RULE")); fk.setName(rs.getString("FK_NAME")); fk.setPkName(rs.getString("PK_NAME")); fk.setDeferrability(rs.getShort("DEFERRABILITY")); } } catch (SQLException sqle) { throw sqle; } finally { try { rs.close(); } catch (Exception ex) { } } }
public void initialFill(String month) { try { ResultSet query = dbm.query("SELECT * FROM prcr_margin_dates WHERE month LIKE '" + month + "'"); row = 0; while (query.next()) { division = query.getString("division"); margin = query.getShort("margin"); workingdays = query.getShort("total"); table.setValueAt(division, row, 0); table.setValueAt(margin, row, 2); table.setValueAt(workingdays, row, 1); row++; } if (row == 0) { query = dbm.query("SELECT * FROM division_details"); while (query.next()) { division = query.getString("code"); table.setValueAt(division, row, 0); row++; } } query.close(); } catch (SQLException ex) { Logger.getLogger(PRCR_change_margin_dates.class.getName()).log(Level.SEVERE, null, ex); } }
protected CFSecurityISOCountryLanguageBuff unpackISOCountryLanguageResultSetToBuff( ResultSet resultSet) throws SQLException { final String S_ProcName = "unpackISOCountryLanguageResultSetToBuff"; int idxcol = 1; CFSecurityISOCountryLanguageBuff buff = schema.getFactoryISOCountryLanguage().newBuff(); { String colString = resultSet.getString(idxcol); if (resultSet.wasNull()) { buff.setCreatedAt(null); } else if ((colString == null) || (colString.length() <= 0)) { buff.setCreatedAt(null); } else { buff.setCreatedAt(CFCrmMySqlSchema.convertTimestampString(colString)); } } idxcol++; { String colString = resultSet.getString(idxcol); if (resultSet.wasNull()) { buff.setCreatedByUserId(null); } else if ((colString == null) || (colString.length() <= 0)) { buff.setCreatedByUserId(null); } else { buff.setCreatedByUserId(UUID.fromString(colString)); } } idxcol++; { String colString = resultSet.getString(idxcol); if (resultSet.wasNull()) { buff.setUpdatedAt(null); } else if ((colString == null) || (colString.length() <= 0)) { buff.setUpdatedAt(null); } else { buff.setUpdatedAt(CFCrmMySqlSchema.convertTimestampString(colString)); } } idxcol++; { String colString = resultSet.getString(idxcol); if (resultSet.wasNull()) { buff.setUpdatedByUserId(null); } else if ((colString == null) || (colString.length() <= 0)) { buff.setUpdatedByUserId(null); } else { buff.setUpdatedByUserId(UUID.fromString(colString)); } } idxcol++; buff.setRequiredISOCountryId(resultSet.getShort(idxcol)); idxcol++; buff.setRequiredISOLanguageId(resultSet.getShort(idxcol)); idxcol++; buff.setRequiredRevision(resultSet.getInt(idxcol)); return (buff); }
@Test public void getNullableShortWithColumnNameWorks() throws SQLException { ResultSet mockResultSet = mock(ResultSet.class); when(mockResultSet.getShort("foo")).thenReturn((short) 7); assertEquals(7, ResultSets.getNullableShort(mockResultSet, "foo").shortValue()); assertEquals(7, ResultSets.enhance(mockResultSet).getNullableShort("foo").shortValue()); when(mockResultSet.getShort("foo")).thenReturn((short) 0); when(mockResultSet.wasNull()).thenReturn(true); assertNull(ResultSets.getNullableShort(mockResultSet, "foo")); assertNull(ResultSets.enhance(mockResultSet).getNullableShort("foo")); }
SpellShortcut tryImportSpellShortcut(ResultSet resultSet) throws SQLException { if (resultSet.getString("type").equals("spell")) { return new SpellShortcut( resultSet.getInt("player_id"), resultSet.getInt("slot"), resultSet.getShort("spell_id")); } return null; }
/** @throws Exception If failed. */ public void testShort() throws Exception { ResultSet rs = stmt.executeQuery(SQL); int cnt = 0; while (rs.next()) { if (cnt == 0) { assert rs.getShort("shortVal") == 1; assert rs.getShort(4) == 1; } cnt++; } assert cnt == 1; }
@Override public Pair<User, Account> findUserAccountByApiKey(String apiKey) { Transaction txn = Transaction.currentTxn(); PreparedStatement pstmt = null; Pair<User, Account> userAcctPair = null; try { String sql = FIND_USER_ACCOUNT_BY_API_KEY; pstmt = txn.prepareAutoCloseStatement(sql); pstmt.setString(1, apiKey); ResultSet rs = pstmt.executeQuery(); // TODO: make sure we don't have more than 1 result? ApiKey had better be unique if (rs.next()) { User u = new UserVO(rs.getLong(1)); u.setUsername(rs.getString(2)); u.setAccountId(rs.getLong(3)); u.setSecretKey(DBEncryptionUtil.decrypt(rs.getString(4))); u.setState(State.valueOf(rs.getString(5))); AccountVO a = new AccountVO(rs.getLong(6)); a.setAccountName(rs.getString(7)); a.setType(rs.getShort(8)); a.setDomainId(rs.getLong(9)); a.setState(State.valueOf(rs.getString(10))); userAcctPair = new Pair<User, Account>(u, a); } } catch (Exception e) { s_logger.warn("Exception finding user/acct by api key: " + apiKey, e); } return userAcctPair; }
/** * Convert a <code>ResultSet</code> column into an object. Simple implementations could just call * <code>rs.getObject(index)</code> while more complex implementations could perform type * manipulation to match the column's type to the bean property type. * * <p> * * <p>This implementation calls the appropriate <code>ResultSet</code> getter method for the given * property type to perform the type conversion. If the property type doesn't match one of the * supported <code>ResultSet</code> types, <code>getObject</code> is called. * * @param rs The <code>ResultSet</code> currently being processed. It is positioned on a valid row * before being passed into this method. * @param index The current column index being processed. * @param propType The bean property type that this column needs to be converted into. * @return The object from the <code>ResultSet</code> at the given column index after optional * type processing or <code>null</code> if the column value was SQL NULL. * @throws java.sql.SQLException if a database access error occurs */ protected Object processColumn(ResultSet rs, int index, Class propType) throws SQLException { if (propType.equals(String.class)) { return rs.getString(index); } else if (propType.equals(Integer.TYPE) || propType.equals(Integer.class)) { return new Integer(rs.getInt(index)); } else if (propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) { return new Boolean(rs.getBoolean(index)); } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) { return new Long(rs.getLong(index)); } else if (propType.equals(Double.TYPE) || propType.equals(Double.class)) { return new Double(rs.getDouble(index)); } else if (propType.equals(Float.TYPE) || propType.equals(Float.class)) { return new Float(rs.getFloat(index)); } else if (propType.equals(Short.TYPE) || propType.equals(Short.class)) { return new Short(rs.getShort(index)); } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) { return new Byte(rs.getByte(index)); } else if (propType.equals(Timestamp.class)) { return rs.getTimestamp(index); } else { return rs.getObject(index); } }
@Test public void testAppendLoggingEvent() throws SQLException { ILoggingEvent event = createLoggingEvent(); appender.append(event); StatusPrinter.printInCaseOfErrorsOrWarnings(lc); Statement stmt = connectionSource.getConnection().createStatement(); ResultSet rs = null; rs = stmt.executeQuery("SELECT * FROM logging_event"); if (rs.next()) { assertEquals(event.getTimeStamp(), rs.getLong(DBAppender.TIMESTMP_INDEX)); assertEquals(event.getFormattedMessage(), rs.getString(DBAppender.FORMATTED_MESSAGE_INDEX)); assertEquals(event.getLoggerName(), rs.getString(DBAppender.LOGGER_NAME_INDEX)); assertEquals(event.getLevel().toString(), rs.getString(DBAppender.LEVEL_STRING_INDEX)); assertEquals(event.getThreadName(), rs.getString(DBAppender.THREAD_NAME_INDEX)); assertEquals( DBHelper.computeReferenceMask(event), rs.getShort(DBAppender.REFERENCE_FLAG_INDEX)); assertEquals(String.valueOf(diff), rs.getString(DBAppender.ARG0_INDEX)); StackTraceElement callerData = event.getCallerData()[0]; assertEquals(callerData.getFileName(), rs.getString(DBAppender.CALLER_FILENAME_INDEX)); assertEquals(callerData.getClassName(), rs.getString(DBAppender.CALLER_CLASS_INDEX)); assertEquals(callerData.getMethodName(), rs.getString(DBAppender.CALLER_METHOD_INDEX)); } else { fail("No row was inserted in the database"); } rs.close(); stmt.close(); }
@Override public Collection<ILink> getAdjacentContinuousLinks(INode node) { Collection<ILink> adjacentLinks = new ArrayList<ILink>(); DBResult dbResult = null; try { int nodeId = node.getId(); long start = System.currentTimeMillis(); // Counter dbResult = query.getAdjacentContinuousLinks(nodeId); ResultSet resultSet = dbResult.getResultSet(); while (resultSet.next()) { ILink link; int linkId = resultSet.getInt("ID"); int adjacentNodeId = resultSet.getInt("NODE_ID"); short degree = resultSet.getShort("NODE_DEGREE"); double length = resultSet.getDouble("LENGTH"); if (config.isIncoming()) { link = new ContinuousLink(linkId, adjacentNodeId, nodeId, length); } else { link = new ContinuousLink(linkId, nodeId, adjacentNodeId, length); } addNode(adjacentNodeId, degree); adjacentLinks.add(link); statistic.log(Type.LOADED_CONTINUOUS_LINKS); } statistic.logRuntime(DBType.GET_LINKS, System.currentTimeMillis() - start); } catch (SQLException e) { e.printStackTrace(); } finally { if (dbResult != null) { dbResult.close(); } } return adjacentLinks; }
@Override public ContinuousLink getInitialLink(int linkId) { ContinuousLink link = null; DBResult dbResult = null; try { long start = System.currentTimeMillis(); // Counter if (getMode().equals(Mode.UNIMODAL)) { dbResult = query.getContinuousLink(linkId); } else { dbResult = query.getLink(linkId); } ResultSet resultSet = dbResult.getResultSet(); if (resultSet.next()) { int sourceId = resultSet.getInt("SOURCE"); int targetId = resultSet.getInt("TARGET"); short degree = resultSet.getShort("NODE_DEGREE"); double length = resultSet.getDouble("LENGTH"); link = new ContinuousLink(linkId, sourceId, targetId, length); if (config.isIncoming()) { addNode(sourceId, degree); } else { addNode(targetId, degree); } statistic.log(Type.LOADED_CONTINUOUS_LINKS); } else { throw new NoSuchLinkException(linkId); } statistic.logRuntime(DBType.GET_CONTINUOUS_LINK, System.currentTimeMillis() - start); } catch (SQLException e) { e.printStackTrace(); } finally { if (dbResult != null) dbResult.close(); } return link; }
/** * Initialize index information * * @throws SQLException */ private void initIndexes() throws SQLException { if (isView() || isRemote()) return; // first try to initialize using the index query spec'd in the .properties // do this first because some DB's (e.g. Oracle) do 'bad' things with getIndexInfo() // (they try to do a DDL analyze command that has some bad side-effects) if (initIndexes(properties.getProperty("selectIndexesSql"))) return; // couldn't, so try the old fashioned approach ResultSet rs = null; try { rs = db.getMetaData().getIndexInfo(null, getSchema(), getName(), false, true); while (rs.next()) { if (rs.getShort("TYPE") != DatabaseMetaData.tableIndexStatistic) addIndex(rs); } } catch (SQLException exc) { logger.warning( "Unable to extract index info for table '" + getName() + "' in schema '" + getSchema() + "': " + exc); } finally { if (rs != null) rs.close(); } }
// Fetch position data from slave. private ReplDBMSHeaderData getCurrentSlaveHeader() { ReplDBMSHeaderData header = null; ResultSet rs = null; try { rs = seqnoStatement.executeQuery(); if (rs.next()) { // Construct header data long seqno = rs.getLong("seqno"); short fragno = rs.getShort("fragno"); boolean lastFrag = rs.getBoolean("last_frag"); String sourceId = rs.getString("source_id"); long epochNumber = rs.getLong("epoch_number"); String eventId = rs.getString("eventid"); header = new ReplDBMSHeaderData( seqno, fragno, lastFrag, sourceId, epochNumber, eventId, null, new Timestamp(0)); // Record current slave latency. this.slaveLatency = rs.getLong("applied_latency"); } } catch (SQLException e) { logger.warn(e); } finally { if (rs != null) try { rs.close(); } catch (SQLException e) { } } return header; }
// 根据id查找病人 public Patient queryOne(int id) { Patient p = new Patient(); String sql = "select id,name,sex,doctor,section,entertime,room,bed,cation from patient where id=" + id; PreparedStatement pst = null; Connection conn = null; ResultSet rs = null; try { conn = DBHelp.getConnection(); pst = conn.prepareStatement(sql); rs = pst.executeQuery(); while (rs.next()) { p.setId(rs.getInt(1)); p.setName(rs.getString(2)); p.setSex(rs.getString(3)); p.setDoctor(rs.getString(4)); p.setSection(rs.getString(5)); p.setEnetertime(rs.getDate(6)); p.setRoom(rs.getString(7)); p.setBed(rs.getShort(8)); p.setCation(rs.getString(9)); } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { DBHelp.closeConn(rs); DBHelp.closeConn(pst); DBHelp.closeConn(conn); } return p; }
public ArrayList<PersonnelBasic> getRowPersonnelListTable() { ArrayList<PersonnelBasic> pbList = new ArrayList<>(); PreparedStatement ps; ResultSet rs; if (dbc.connect()) { try { String sqlQuery = "select " + PERSONNEL_BASIC_COLUMN + " from " + PERSONNEL_INFO; ps = dbc.getConnection().prepareStatement(sqlQuery); rs = ps.executeQuery(); while (rs.next()) { PersonnelBasic pb = new PersonnelBasic(); pb.setPersonnelID(rs.getString(1)); pb.setName(rs.getString(2) + " " + rs.getString(3)); pb.setBirth(rs.getString(4)); boolean sex = rs.getBoolean(5); pb.setSex(sex ? "Nam" : "Nữ"); String office = getPersonnelInfo("TenPhongBan", OFFICE_CB, "MaPhongBan", rs.getShort(6)); pb.setOffice(office); String position = getPersonnelInfo("TenChucVu", POSITION_CB, "MaChucVu", rs.getShort(7)); pb.setPosition(position); String kind = getPersonnelInfo("TenLoaiNV", KIND_CB, "MaLoaiNV", rs.getShort(8)); pb.setPerKind(kind); String contract = getPersonnelInfo("TenLoaiHopDong", CONTRACT_CB, "MaLoaiHopDong", rs.getShort(9)); pb.setPerContract(contract); pb.setPhone(rs.getString(10)); pb.setPerEmail(rs.getString(11)); pb.setCompEmail(rs.getString(12)); pbList.add(pb); } dbc.close(ps, rs); } catch (SQLException ex) { Logger.getLogger(PersonnelDAO.class.getName()).log(Level.SEVERE, null, ex); } } return pbList; }
public String[] searchWithReading(String sReading) throws SQLException { if (sReading == null || sReading.equals("")) { return new String[0]; } TreeSet<String> sCharacterSet = new TreeSet<String>(); String sSql = "SELECT hydc3.unicode, hydc4.index, hydc4.pinyin FROM hydc4 AS hydc4, hydc3 AS hydc3 " + "WHERE (LCASE(hydc4.pinyin) = LCASE(?) OR hydc4.zhuyin = ?) " + "AND hydc3.gbk = hydc4.gbk"; PreparedStatement statement = connection.prepareStatement(sSql); int i = 1; statement.setString(i++, sReading); statement.setString(i++, sReading); ResultSet resultSet = statement.executeQuery(); while (resultSet.next()) { int unicode = resultSet.getInt("unicode"); short index = resultSet.getShort("index"); String sPinyin = resultSet.getString("pinyin"); sCharacterSet.add( new String(new int[] {unicode}, 0, 1) + Short.toString(index) + " (" + sPinyin + ")"); } resultSet.close(); statement.close(); sSql = "SELECT hydc3.unicode, hydc6.index, hydc6.pinyin FROM hydc6 AS hydc6, hydc3 AS hydc3 " + "WHERE (UCASE(hydc6.pinyinA) = UCASE(?) OR UCASE(hydc6.pinyinA || hydc6.sisheng) = UCASE(?) " + "OR LCASE(hydc6.pinyin) = LCASE(?) OR hydc6.zhuyin = ?) " + "AND hydc3.gbk = hydc6.gbk"; statement = connection.prepareStatement(sSql); i = 1; statement.setString(i++, sReading); statement.setString(i++, sReading); statement.setString(i++, sReading); statement.setString(i++, sReading); resultSet = statement.executeQuery(); while (resultSet.next()) { int unicode = resultSet.getInt("unicode"); short index = resultSet.getShort("index"); String sPinyin = resultSet.getString("pinyin"); sCharacterSet.add( new String(new int[] {unicode}, 0, 1) + Short.toString(index) + " (" + sPinyin + ")"); } resultSet.close(); statement.close(); return sCharacterSet.toArray(new String[sCharacterSet.size()]); }
/** * Method 'mapRow' * * @param rs * @param row * @throws java.sql.SQLException * @return StatusCode */ public StatusCode mapRow(ResultSet rs, int row) throws SQLException { StatusCode dto = new StatusCode(); dto.setId(rs.getInt(1)); dto.setCodeName(rs.getString(2)); dto.setCodeValue(rs.getString(3)); dto.setDeleteInd(rs.getShort(4)); return dto; }
/** * get 部首 tree view * * @returns root tree node object * @throws SQLException */ public DefaultMutableTreeNode getRadicalTree() throws SQLException { TreeMap<Integer, String> strokesAndRadicalsMap = new TreeMap<Integer, String>(); for (int i = 0; i < RADICAL_STROKES.length; ++i) { String sRadical = "" + HYDC_RADICALS.charAt(i); if (sRadical.equals(" ")) { continue; } int strokes = RADICAL_STROKES[i]; String sRadicals = strokesAndRadicalsMap.get(strokes); if (sRadicals == null) { strokesAndRadicalsMap.put(strokes, sRadicals = ""); } strokesAndRadicalsMap.put(strokes, sRadicals + sRadical); } String sSql = "SELECT parts_strokes, unicode FROM HYDC3 " + "WHERE bushou = ? " + "ORDER BY parts_strokes, unicode"; PreparedStatement statement = connection.prepareStatement(sSql); DefaultMutableTreeNode root = new DefaultMutableTreeNode("畫數 / 部首 / 畫數"); for (Integer strokes : strokesAndRadicalsMap.keySet()) { String sRadicals = strokesAndRadicalsMap.get(strokes); DefaultMutableTreeNode strokesNode = new DefaultMutableTreeNode(strokes.toString() + " : " + sRadicals); for (int i = 0; i < sRadicals.length(); ++i) { String sRadical = sRadicals.substring(i, i + 1); DefaultMutableTreeNode radicalNode = new DefaultMutableTreeNode(sRadical); TreeMap<Integer, String> partsStrokesAndCharactersMap = new TreeMap<Integer, String>(); statement.setString(1, sRadical); ResultSet resultSet = statement.executeQuery(); while (resultSet.next()) { short partsStrokes = resultSet.getShort("parts_strokes"); int unicode = resultSet.getInt("unicode"); String sCharacters = partsStrokesAndCharactersMap.get((Integer) (int) partsStrokes); if (sCharacters == null) { partsStrokesAndCharactersMap.put((Integer) (int) partsStrokes, sCharacters = ""); } sCharacters += new String(new int[] {unicode}, 0, 1); partsStrokesAndCharactersMap.put((Integer) (int) partsStrokes, sCharacters); } resultSet.close(); strokesNode.add(radicalNode); for (Integer partsStrokes : partsStrokesAndCharactersMap.keySet()) { String sCharacters = partsStrokesAndCharactersMap.get(partsStrokes); DefaultMutableTreeNode partsStrokesNode = new DefaultMutableTreeNode(partsStrokes.toString() + " : " + sCharacters); radicalNode.add(partsStrokesNode); } strokesNode.add(radicalNode); } root.add(strokesNode); } statement.close(); return root; }
@Override public short getShort(String columnName) throws SQLException { try { return _res.getShort(columnName); } catch (SQLException e) { handleException(e); return 0; } }
public Object getResult(ResultSet rs, String columnName) throws SQLException { short s = rs.getShort(columnName); if (rs.wasNull()) { return null; } else { return new Short(s); } }
public Object getResult(ResultSet rs, int columnIndex) throws SQLException { short s = rs.getShort(columnIndex); if (rs.wasNull()) { return null; } else { return new Short(s); } }
public static String[][] listVehicles() { try { // create a mysql database connection Connection vehConn = Utills.openDb(); String query1 = "SELECT * from vehicle"; // create the java statement java.sql.Statement st = vehConn.createStatement(); // execute the query, and get a java resultset ResultSet rs = st.executeQuery(query1); int numCounter; for (numCounter = 0; rs.next(); numCounter++) ; vehicles = new String[numCounter][11]; rs.beforeFirst(); numCounter = 0; while (rs.next()) { int id = rs.getInt(1); String regNum = rs.getString(2); String make = rs.getString(3); String model = rs.getString(4); yom = rs.getShort(5); mileage = rs.getInt(6); dateLastServiced = rs.getDate(7); dateDueService = rs.getDate(8); dateLastCert = rs.getDate(9); dateDueCert = rs.getDate(10); currLatLong = rs.getString(11); vehicles[numCounter][0] = String.valueOf(id); vehicles[numCounter][1] = regNum; vehicles[numCounter][2] = make; vehicles[numCounter][3] = model; vehicles[numCounter][4] = String.valueOf(yom); vehicles[numCounter][5] = String.valueOf(mileage); vehicles[numCounter][6] = String.valueOf(dateLastServiced); vehicles[numCounter][7] = String.valueOf(dateDueService); vehicles[numCounter][8] = String.valueOf(dateLastCert); vehicles[numCounter][9] = String.valueOf(dateDueCert); vehicles[numCounter][10] = currLatLong; numCounter++; } vehConn.close(); } catch (Exception e) { System.err.println("Got an exception!"); System.err.println(e.getMessage()); e.printStackTrace(); } return vehicles; }