private Connection openConnection(Class<? extends Driver> driverClass, Properties properties) throws Exception { assert properties != null; try { return DriverManager.getConnection(url, properties); } catch (Exception e) { // if the current class loader can not access the driver class, create driver class directly try { Driver driverObject = driverClass.getConstructor().newInstance(); Connection connection = driverObject.connect(url, properties); if (connection == null) { throw new IllegalStateException( MessageFormat.format( "Driver class {0} may not support {1}", driverClass.getName(), url)); } return connection; } catch (RuntimeException inner) { LOG.debug( MessageFormat.format( "Failed to resolve driver class (internal error): {0} (on {1})", driverClass.getName(), driverClass.getClassLoader()), e); } catch (Exception inner) { LOG.debug( MessageFormat.format( "Failed to resolve driver class: {0} (on {1})", driverClass.getName(), driverClass.getClassLoader()), e); } throw e; } }
@Override public Connection connect(String url, Properties info) throws SQLException { if (!url.startsWith("jdbc:quantumdb:")) { return null; } url = url.substring(0, 4) + ":" + url.substring(15, url.length()); try { Class.forName("org.postgresql.Driver"); } catch (ClassNotFoundException e) { throw new SQLException("Could not locate delegate driver.", e); } String version = parseVersion(url); if (version != null) { String applicationName = info.getProperty("ApplicationName"); if (applicationName != null && !applicationName.equals("")) { applicationName += " - " + version; } else { applicationName = "QuantumDB driver - " + version; } info.setProperty("ApplicationName", applicationName); } this.delegate = DriverManager.getDriver(url); Connection connection = delegate.connect(url, info); QueryRewriter queryRewriter = new PostgresqlQueryRewriter(); this.transformer = new Transformer(connection, queryRewriter, version); return new ProxyConnection(connection, transformer); }
@Override public void run() { Connection conn = null; try { Driver d = new SimpleDriver(); conn = d.connect("jdbc:simpledb://localhost", null); // conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); Statement stmt = conn.createStatement(); // try { // Thread.sleep(5000); // } catch (InterruptedException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } for (int i = 0; i < 3; i++) { String cmd; if (i % 2 == 0) cmd = "update STUDENT set MajorId=30 " + "where SName = 'amy'"; else cmd = "update STUDENT set MajorId=20 " + "where SName = 'amy'"; stmt.executeUpdate(cmd); System.out.println("Amy's major changed."); } } catch (SQLException e) { e.printStackTrace(); } finally { try { System.out.println(conn.getTransactionIsolation()); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } }
public static void main(String[] args) { try { Driver d = new SimpleDriver(); conn = d.connect("jdbc:simpledb://localhost", null); Reader rdr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(rdr); while (true) { // process one line of input System.out.print("\nSQL> "); String cmd = br.readLine().trim(); System.out.println(); if (cmd.startsWith("exit")) break; else if (cmd.startsWith("select")) doQuery(cmd); else doUpdate(cmd); } } catch (Exception e) { e.printStackTrace(); } finally { try { if (conn != null) conn.close(); } catch (Exception e) { e.printStackTrace(); } } }
/** * Open (if necessary) and return a database connection for use by this class. * * @exception SQLException if a database error occurs */ protected Connection getConnection() throws SQLException { if (connectionURL == null) connectionURL = this.extraProperties.getProperty("jdbc.connectionURL"); if (connectionName == null) connectionName = this.extraProperties.getProperty("jdbc.connectionName"); if (connectionPassword == null) connectionPassword = this.extraProperties.getProperty("jdbc.connectionPassword"); if (driverName == null) driverName = this.extraProperties.getProperty("jdbc.driverName"); Connection conn = null; // Instantiate our database driver if necessary if (driver == null) { try { Class clazz = Class.forName(driverName); driver = (Driver) clazz.newInstance(); } catch (Throwable e) { throw new SQLException(e.getMessage()); } } // Open a new connection Properties props = new Properties(); if (connectionName != null) props.put("user", connectionName); if (connectionPassword != null) props.put("password", connectionPassword); conn = driver.connect(connectionURL, props); conn.setAutoCommit(false); return (conn); }
public static void main(String[] args) { Connection conn = null; try { // Step 1: connect to database server Driver d = new SimpleDriver(); conn = d.connect("jdbc:simpledb://localhost", null); // Step 2: execute the query Statement stmt = conn.createStatement(); String qry = "select SName, DName " + "from DEPT, STUDENT " + "where MajorId = DId"; ResultSet rs = stmt.executeQuery(qry); // Step 3: loop through the result set System.out.println("Name\tMajor"); while (rs.next()) { String sname = rs.getString("SName"); String dname = rs.getString("DName"); System.out.println(sname + "\t" + dname); } rs.close(); } catch (SQLException e) { e.printStackTrace(); } finally { // Step 4: close the connection try { if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } } }
/** * Get a Connection to the database from the underlying driver that this DriverSpy is spying on. * If logging is not enabled, an actual Connection to the database returned. If logging is * enabled, a ConnectionSpy object which wraps the real Connection is returned. * * @param url JDBC connection URL . * @param info a list of arbitrary string tag/value pairs as connection arguments. Normally at * least a "user" and "password" property should be included. * @return a <code>Connection</code> object that represents a connection to the URL. * @throws SQLException if a database access error occurs */ public Connection connect(String url, Properties info) throws SQLException { Driver d = getUnderlyingDriver(url); if (d == null) { return null; } // get actual URL that the real driver expects // (strip off "jdbc:log4" from url) url = url.substring(9); lastUnderlyingDriverRequested = d; Connection c = d.connect(url, info); if (c == null) { throw new SQLException("invalid or unknown driver url: " + url); } if (log.isJdbcLoggingEnabled()) { ConnectionSpy cspy = new ConnectionSpy(c); RdbmsSpecifics r = null; String dclass = d.getClass().getName(); if (dclass != null && dclass.length() > 0) { r = (RdbmsSpecifics) rdbmsSpecifics.get(dclass); } if (r == null) { r = defaultRdbmsSpecifics; } cspy.setRdbmsSpecifics(r); return cspy; } else { return c; } }
/** {@inheritDoc} */ public void connect(InetAddress address, int port, int timeout) throws IOException, Exception { log().info("connecting to JDBC on " + address); if (log().isDebugEnabled()) { log().debug("Loading JDBC driver: '" + getDbDriver() + "'"); } Driver driver = (Driver) Class.forName(getDbDriver()).newInstance(); if (log().isDebugEnabled()) { log().debug("JDBC driver loaded: '" + getDbDriver() + "'"); } String url = DBTools.constructUrl(getUrl(), address.getCanonicalHostName()); if (log().isDebugEnabled()) { log().debug("Constructed JDBC url: '" + url + "'"); } Properties props = new Properties(); props.setProperty("user", getUser()); props.setProperty("password", getPassword()); props.setProperty("timeout", String.valueOf(timeout / 1000)); m_connection = driver.connect(url, props); if (log().isDebugEnabled()) { log() .debug( "Got database connection: '" + m_connection + "' (" + url + ", " + getUser() + ", " + getPassword() + ")"); } }
private void testLobInFiles() throws Exception { deleteDb("oldVersion"); Connection conn; Statement stat; conn = driver.connect("jdbc:h2:" + getBaseDir() + "/oldVersion", null); stat = conn.createStatement(); stat.execute("create table test(id int primary key, b blob, c clob)"); PreparedStatement prep = conn.prepareStatement("insert into test values(?, ?, ?)"); prep.setInt(1, 0); prep.setNull(2, Types.BLOB); prep.setNull(3, Types.CLOB); prep.execute(); prep.setInt(1, 1); prep.setBytes(2, new byte[0]); prep.setString(3, ""); prep.execute(); prep.setInt(1, 2); prep.setBytes(2, new byte[5]); prep.setString(3, "\u1234\u1234\u1234\u1234\u1234"); prep.execute(); prep.setInt(1, 3); prep.setBytes(2, new byte[100000]); prep.setString(3, new String(new char[100000])); prep.execute(); conn.close(); conn = DriverManager.getConnection("jdbc:h2:" + getBaseDir() + "/oldVersion", new Properties()); stat = conn.createStatement(); checkResult(stat.executeQuery("select * from test order by id")); stat.execute("create table test2 as select * from test"); checkResult(stat.executeQuery("select * from test2 order by id")); stat.execute("delete from test"); conn.close(); }
public static void connectToDB() throws Exception { if (connection == null) { info = new Properties(); info.load(new FileInputStream("src/java-test/tests.properties")); url = info.getProperty("url"); driver = (Driver) Class.forName( DatabaseFactory.getInstance().findDefaultDriver(url), true, Thread.currentThread().getContextClassLoader()) .newInstance(); connection = driver.connect(url, info); if (connection == null) { throw new DatabaseException( "Connection could not be created to " + url + " with driver " + driver.getClass().getName() + ". Possibly the wrong driver for the given database URL"); } jdbcConnection = new JdbcConnection(connection); } }
@Test public void testStateNotSupportedException() throws SQLException { RuntimeException runtimeException = new RuntimeException(new SQLException("test", HiveDriver.SQL_STATE_NOT_SUPPORTED, null)); when(delegate.acceptsURL(testUrl)).thenReturn(true); when(delegate.connect(testUrl, properties)).thenThrow(runtimeException); assertNull(hiveDriver.connect(testUrl, properties)); verify(delegate).connect(testUrl, properties); }
/** ��ͼ����һ������ URL ����ݿ����ӡ� */ public Connection connect(String url, Properties info) throws SQLException { Properties p = new Properties(); p.putAll(info); Connection conn = driver.connect(url, p); CharsetParameter param = new CharsetParameter(); param.setClientEncoding(this.getClientEncoding()); param.setServerEncoding(this.getServerEncoding()); return factory.getConnection(param, conn); }
public static Connection get(NameValuePairs nvp) { try { nvp.merge(props); return driver.connect(url, nvp.toProperties()); } catch (java.sql.SQLException e) { e.printStackTrace(); } return null; }
public void close() { Connection connection = (Connection) getRawConnection(); if (connection == null) { return; } synchronized (sDerbyConnections) { int count = ((Integer) sConnectionReferenceCount.get(connection)).intValue(); if (count == 1) { /* * If this is the last reference to the connection, close the * connection. */ String baseDBURL = getBaseDBURL(); try { /* The particulars of closing the connection. */ String driverClass = getDriverDefinition() .getProperty(IJDBCDriverDefinitionConstants.DRIVER_CLASS_PROP_ID); Driver driver = (Driver) connection.getClass().getClassLoader().loadClass(driverClass).newInstance(); driver.connect( baseDBURL + ";shutdown=true", // $NON-NLS-1$ new Properties()); } catch (InstantiationException e) { /* * We shouldn't see this, because we needed this to create * the connection */ } catch (IllegalAccessException e) { /* * We shouldn't see this, because we needed this to create * the connection */ } catch (ClassNotFoundException e) { /* * We shouldn't see this, because we needed this to create * the connection */ } catch (SQLException e) { // Successfully closed the connection sConnectionReferenceCount.remove(connection); sDerbyConnections.remove(baseDBURL); } catch (Exception e) { /* * Can't get the driver. This might happen if the user * modified or deleted the driver definition in the time * since this connection was created. */ } } else { /* Otherwise, just decrement the reference count. */ sConnectionReferenceCount.put(connection, new Integer(--count)); } } }
public synchronized void serialEvent(SerialPortEvent oEvent) { try { switch (oEvent.getEventType()) { case SerialPortEvent.DATA_AVAILABLE: if (input == null) { System.out.println("here11"); input = new BufferedReader(new InputStreamReader(serialPort.getInputStream())); } String inputLine = input.readLine(); // System.out.println(input.readLine().trim()); if (inputLine.equals("")) { } else { String url = "jdbc:mysql://localhost/secureplanet"; Properties prop = new Properties(); prop.setProperty("user", "root"); prop.setProperty("password", "toor"); Driver d = new com.mysql.jdbc.Driver(); Connection conn = d.connect(url, prop); if (conn == null) { System.out.println("connection failed"); return; } DatabaseMetaData dm = conn.getMetaData(); String dbversion = dm.getDatabaseProductVersion(); String dbname = dm.getDatabaseProductName(); System.out.println("name:" + dbname); System.out.println("version:" + dbversion); String rfidtoken = inputLine.trim(); Statement stmt = conn.createStatement(); Double lat = 17.4416; Double lng = 78.3826; String sql = "INSERT INTO smarttracking " + "VALUES ('" + rfidtoken + "','" + lat + "','" + lng + "')"; stmt.executeUpdate(sql); } break; default: break; } } catch (Exception e) { e.printStackTrace(); } }
@Test(expected = RuntimeException.class) public void testException() throws SQLException { RuntimeException runtimeException = new RuntimeException(); when(delegate.acceptsURL(testUrl)).thenReturn(true); when(delegate.connect(testUrl, properties)).thenThrow(runtimeException); try { hiveDriver.connect(testUrl, properties); } catch (Exception e) { assertEquals(runtimeException, e); throw e; } }
@Override public Connection connect(final String url, final Properties info) throws SQLException { String translatedUrl = translate(url); for (Driver driver : getAllDrivers()) { if (driver.acceptsURL(translatedUrl)) { Connection conn = driver.connect(translatedUrl, info); if (conn != null) { return conn; } } } return null; }
/** * 对于Weblogic连接池 * * @return boolean */ private boolean getWeblogicPoolConnection() { try { Driver myDriver = (Driver) (Class.forName("weblogic.jdbc.pool.Driver").newInstance()); /*weblogic的连接池重写了close()方法*/ con = myDriver.connect(JUrl.getJdbcUrl(), null); Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); stmt.execute("alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'"); stmt.close(); } catch (Exception ex) { System.out.println("$$$$$$$$WebLogicPool Connect Failed$$$$$"); return false; } return true; }
@Override public void test() throws Exception { if (config.mvStore) { return; } cl = getClassLoader("file:ext/h2-1.2.127.jar"); driver = getDriver(cl); if (driver == null) { println("not found: ext/h2-1.2.127.jar - test skipped"); return; } Connection conn = driver.connect("jdbc:h2:mem:", null); assertEquals("1.2.127 (2010-01-15)", conn.getMetaData().getDatabaseProductVersion()); conn.close(); testLobInFiles(); testOldClientNewServer(); }
@Before public void setup() throws SQLException { testUrl = "testUrl"; majorVersion = 10; minorVersion = 11; lazyDelegatingDriver = new LazyDelegatingDriver(driverRegistry, hasRegisterDriver); drivers = new ArrayList<>(); drivers.add(makeEntry(badDriverServiceReference, badDriver)); drivers.add(makeEntry(goodDriverServiceReference, driver)); when(driver.connect(testUrl, null)).thenReturn(connection); when(driver.acceptsURL(testUrl)).thenReturn(true); when(driver.getPropertyInfo(testUrl, null)) .thenReturn(new DriverPropertyInfo[] {driverPropertyInfo}); when(driver.getMajorVersion()).thenReturn(majorVersion); when(driver.getMinorVersion()).thenReturn(minorVersion); when(driver.getParentLogger()).thenReturn(logger); when(driverRegistry.getDrivers()).thenReturn(drivers.iterator()); }
@Test public void testRetrieveFromDriverManager() throws Exception { DriverManager.registerDriver(driver); EasyMock.expect(driver.connect((String) EasyMock.notNull(), (Properties) EasyMock.notNull())) .andReturn(connection); connection.setAutoCommit(false); connection.setHoldability(1); props.put(JdbcDataSource.DRIVER, driver.getClass().getName()); props.put(JdbcDataSource.URL, "jdbc:fakedb"); props.put("holdability", "HOLD_CURSORS_OVER_COMMIT"); mockControl.replay(); Connection conn = jdbcDataSource.createConnectionFactory(context, props).call(); mockControl.verify(); assertSame("connection", conn, connection); }
// query HBase table for threshold for the stock symbol that was tweeted about private int findThresholdForStock(String hashtag) { int threshold = DEFAULT_ALERT_THRESHOLD; try { conn = phoenixDriver.connect( "jdbc:phoenix:sandbox.hortonworks.com:2181:/hbase-unsecure", new Properties()); ResultSet rst = conn.createStatement() .executeQuery( "select tweet_threshold from securities where lower(symbol)='" + hashtag + "'"); while (rst.next()) { threshold = rst.getInt(1); System.out.println("Found threshold in Hbase: " + threshold + " for: " + hashtag); } if (threshold == 0) { System.out.println( "Unable to find threshold in HBase for: " + hashtag + ". Setting to default: " + DEFAULT_ALERT_THRESHOLD); threshold = DEFAULT_ALERT_THRESHOLD; } } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(e); } finally { try { if (conn != null) conn.close(); } catch (Exception e) { throw new RuntimeException(e); } } return threshold; }
/** @param args */ public static void main(String[] args) throws Exception { String driverClassName = "sybase.jdbc4.sqlanywhere.IDriver"; Class<?> c = Class.forName(driverClassName); Driver driver = (Driver) c.newInstance(); String url = "jdbc:sqlanywhere:eng=kawansoft_example"; Properties properties = new Properties(); properties.put("user", "user1"); properties.put("password", "password1"); Connection connection = driver.connect(url, properties); if (connection == null) { System.err.println("driverClassName: " + driverClassName); System.err.println("url : " + url); throw new IllegalArgumentException( "Connection is null after driver.connect(url, properties)!"); } else { System.out.println("Connected!"); } }
@Override Connection openConnection( final File databaseDirectory, final String driverClasspath, final Map<String, String> initParams) throws LocalDBException { final String filePath = databaseDirectory.getAbsolutePath() + File.separator + "localdb-h2"; final String connectionString = "jdbc:h2:split:" + filePath + ";" + makeInitStringParams(initParams); try { driver = (Driver) Class.forName(H2_CLASSPATH).newInstance(); final Properties connectionProps = new Properties(); final Connection connection = driver.connect(connectionString, connectionProps); connection.setAutoCommit(true); return connection; } catch (Throwable e) { final String errorMsg = "error opening DB: " + e.getMessage(); LOGGER.error(errorMsg, e); throw new LocalDBException( new ErrorInformation(PwmError.ERROR_LOCALDB_UNAVAILABLE, errorMsg)); } }
/** * Open (if necessary) and return a database connection for use by this Realm. * * @throws SQLException if a database error occurs */ protected Connection open() throws SQLException { // Do nothing if there is a database connection already open if (dbConnection != null) return (dbConnection); // Instantiate our database driver if necessary if (driver == null) { try { Class clazz = Class.forName(driverName); driver = (Driver) clazz.newInstance(); } catch (Throwable e) { throw new SQLException(e.getMessage()); } } // Open a new connection Properties props = new Properties(); if (connectionName != null) props.put("user", connectionName); if (connectionPassword != null) props.put("password", connectionPassword); dbConnection = driver.connect(connectionURL, props); dbConnection.setAutoCommit(false); return (dbConnection); }
protected Connection createConnection() throws SQLException { final Driver driverInstance = newDriver(); final Properties info = prepareConnectionProperties(); Connection conn = null; try { _log.info("...Connecting to database by data source:"); conn = driverInstance.connect(_url, info); } catch (SQLException e) { String msg = "Failed to connect: url=" + _url + " user="******"The driver didn't understand the URL: " + _url; throw new DfJDBCException(msg); } try { conn.setAutoCommit(_autoCommit); } catch (SQLException e) { String msg = "Failed to set auto commit: autocommit=" + _autoCommit; throw new DfJDBCException(msg, e); } return conn; }
@Test public void testSuccess() throws SQLException { when(delegate.acceptsURL(testUrl)).thenReturn(true); when(delegate.connect(testUrl, properties)).thenReturn(connection); assertEquals(connection, hiveDriver.connect(testUrl, properties)); }
/** * Connect to MySQL * * @return if the connection was succesful */ public boolean connect() throws Exception { if (connection != null) { return true; } if (currentType == null || currentType == Type.NONE) { log("Invalid database engine"); return false; } // load the database jar ClassLoader classLoader; if (currentType == Type.SQLite) { classLoader = new URLClassLoader( new URL[] { new URL( "jar:file:" + new File(Updater.DEST_LIBRARY_FOLDER + currentType.getDriver()).getPath() + "!/") }); } else { classLoader = Bukkit.getServer().getClass().getClassLoader(); } // What class should we try to load? String className = ""; if (currentType == Type.MySQL) { className = "com.mysql.jdbc.Driver"; } else { className = "org.sqlite.JDBC"; } // Load the driver class Driver driver = (Driver) classLoader.loadClass(className).newInstance(); // Create the properties to pass to the driver Properties properties = new Properties(); // if we're using mysql, append the database info if (currentType == Type.MySQL) { LWC lwc = LWC.getInstance(); properties.put("autoReconnect", "true"); properties.put("user", lwc.getConfiguration().getString("database.username")); properties.put("password", lwc.getConfiguration().getString("database.password")); } // Connect to the database try { connection = driver.connect( "jdbc:" + currentType.toString().toLowerCase() + ":" + getDatabasePath(), properties); connected = true; return true; } catch (SQLException e) { log("Failed to connect to " + currentType); e.printStackTrace(); return false; } }
private Connection openDB(final DBConfiguration dbConfiguration) throws DatabaseException { final String connectionURL = dbConfiguration.getConnectionString(); final String jdbcClassName = dbConfiguration.getDriverClassname(); try { final byte[] jdbcDriverBytes = dbConfiguration.getJdbcDriver(); if (jdbcDriverBytes != null) { LOGGER.debug("loading JDBC database driver stored in configuration"); final JarClassLoader jarClassLoader = new JarClassLoader(); jarClassLoader.add(new ByteArrayInputStream(jdbcDriverBytes)); final JclObjectFactory jclObjectFactory = JclObjectFactory.getInstance(); // Create object of loaded class driver = (Driver) jclObjectFactory.create(jarClassLoader, jdbcClassName); LOGGER.debug( "successfully loaded JDBC database driver '" + jdbcClassName + "' from application configuration"); } } catch (Throwable e) { final String errorMsg = "error registering JDBC database driver stored in configuration: " + e.getMessage(); final ErrorInformation errorInformation = new ErrorInformation(PwmError.ERROR_DB_UNAVAILABLE, errorMsg); LOGGER.error(errorMsg, e); throw new DatabaseException(errorInformation); } if (driver == null) { try { LOGGER.debug("loading JDBC database driver from classpath: " + jdbcClassName); driver = (Driver) Class.forName(jdbcClassName).newInstance(); LOGGER.debug("successfully loaded JDBC database driver from classpath: " + jdbcClassName); } catch (Throwable e) { final String errorMsg = e.getClass().getName() + " error loading JDBC database driver from classpath: " + e.getMessage(); final ErrorInformation errorInformation = new ErrorInformation(PwmError.ERROR_DB_UNAVAILABLE, errorMsg); throw new DatabaseException(errorInformation); } } try { LOGGER.debug("opening connection to database " + connectionURL); final Properties connectionProperties = new Properties(); if (dbConfiguration.getUsername() != null && !dbConfiguration.getUsername().isEmpty()) { connectionProperties.setProperty("user", dbConfiguration.getUsername()); } if (dbConfiguration.getPassword() != null) { connectionProperties.setProperty( "password", dbConfiguration.getPassword().getStringValue()); } final Connection connection = driver.connect(connectionURL, connectionProperties); final Map<PwmAboutProperty, String> debugProps = getConnectionDebugProperties(connection); ; LOGGER.debug( "successfully opened connection to database " + connectionURL + ", properties: " + JsonUtil.serializeMap(debugProps)); connection.setAutoCommit(true); return connection; } catch (Throwable e) { final String errorMsg = "error connecting to database: " + Helper.readHostileExceptionMessage(e); final ErrorInformation errorInformation = new ErrorInformation(PwmError.ERROR_DB_UNAVAILABLE, errorMsg); if (e instanceof IOException) { LOGGER.error(errorInformation); } else { LOGGER.error(errorMsg, e); } throw new DatabaseException(errorInformation); } }
public Connection connect(String u, Properties p) throws SQLException { return driver.connect(u, p); }