Java Examples for com.mysql.jdbc.Driver

protected Connection buildConnection(SchemaConnection schemaConnection) throws SQLException {
    ConnectionDataTranslator translator = ConnectionDataTranslator.create(schemaConnection);
    String url = translator.getUrl();
    Assert.hasText(url, "The specified schema connection has no url.");
    Driver driver = buildDriver();
    Connection connection = driver.connect(url, new Properties());
    Assert.notNull(connection, "The jdbc connection could not be created.");
    return connection;
}

public static Domain getCurrentDomain() {
    Domain domain = new Domain();
    //                domain.setDriver("com.mysql.jdbc.Driver");
    domain.setDriver("org.gjt.mm.mysql.Driver");
    //        domain.setDriver("org.logicalcobwebs.proxool.ProxoolDriver");
    domain.setUrl("jdbc:mysql://localhost:3308/timetracking_dev");
    domain.setUser("root");
    domain.setPwd("root");
    return domain;
}

public static Connection getConnection() {
    String url = "jdbc:mysql://localhost:3306/slipp_dev?useUnicode=true&characterEncoding=utf8";
    String id = "slipp";
    String pw = "password";
    try {
        Class.forName("com.mysql.jdbc.Driver");
        return DriverManager.getConnection(url, id, pw);
    } catch (Exception e) {
        System.out.println(e.getMessage());
        return null;
    }
}

public static Connection createConn() throws ClassNotFoundException, SQLException {
    Connection connection = null;
    String conn_url = Config.get().get("mall.connection.url");
    String username = Config.get().get("mall.connection.username");
    String password = Config.get().get("mall.connection.password");
    Class.forName("com.mysql.jdbc.Driver");
    connection = DriverManager.getConnection(conn_url, username, password);
    return connection;
}

public Connection getConnection() {
    Connection conn = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/news", "root", "123456aa");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}

@Test
public void test001() {
    LocalTxDataSourceDO dsDo = new LocalTxDataSourceDO();
    dsDo.setDsName("test");
    dsDo.setConnectionURL("jdbc:mysql://mypay83307.devdb.alipay.net:3307/zds_switch?useUnicode=true&characterEncoding=gbk");
    dsDo.setUserName("zds_switch");
    dsDo.setPassWord("ali88");
    dsDo.setDriverClass("com.mysql.jdbc.Driver");
    dsDo.setMinPoolSize(0);
    dsDo.setMaxPoolSize(5);
    // dsDo.setExceptionSorterClassName("com.alipay.zdal.datasource.resource.adapter.jdbc.vendor.MySQLExceptionSorter");
    dsDo.setPreparedStatementCacheSize(0);
    try {
        DataSource dataSource = new ZDataSource(dsDo);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void salva(Produto p) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost/tr", "root", "root");
        Statement cmd = con.createStatement();
        cmd.execute("INSERT INTO produtos (descricao) VALUES ('" + p.getDescricao() + "');", Statement.RETURN_GENERATED_KEYS);
        ResultSet generatedKeys = cmd.getGeneratedKeys();
        if (generatedKeys.next()) {
            p.setId(generatedKeys.getInt(1));
            for (SalvaProdutoListener l : listeners) {
                l.produtoSalvo(new ProdutoSalvaEvent(p));
            }
        } else
            throw new RuntimeException("Produto não foi salvo");
        cmd.close();
        con.close();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

private Connection getConnection() throws Exception {
    Properties props = new Properties();
    props.setProperty("user", user);
    props.setProperty("password", pass);
    props.setProperty("zeroDateTimeBehavior", "convertToNull");
    Class.forName("com.mysql.jdbc.Driver").newInstance();
    Connection conn = DriverManager.getConnection(URL + "/" + schema, props);
    return conn;
}

public void test_0() throws Exception {
    String url = "jdbc:mysql://172.22.32.5/beidou?useUnicode=true&characterEncoding=UTF-8";
    Class.forName("com.mysql.jdbc.Driver");
    Connection conn = DriverManager.getConnection(url, "beidou", "mzbSXikh48dTrVX8kuLYtuok1");
    PreparedStatement stmt = conn.prepareStatement("select sysdate");
    stmt.executeBatch();
    String catalog = conn.getCatalog();
    System.out.println(catalog);
    stmt.close();
    conn.close();
}

public static void main(String[] args) throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    String slaveHost = "kgopalak-ld.linkedin.biz";
    String slaveMysqlPort = "5555";
    String userName = "monty";
    String password = "some_pass";
    Connection slaveConnection = DriverManager.getConnection("jdbc:mysql://" + slaveHost + ":" + slaveMysqlPort + "", userName, password);
    slaveConnection.setCatalog("MyDB_0");
    slaveConnection.createStatement().execute("create table MyTable  ( col1 INT, col2 INT ) ");
}

public static void main(String[] args) throws SQLException {
    // TODO Auto-generated method stub
    Connection con = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        con = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "root", "root");
        System.out.println("Connected Successfully........!");
    } catch (Exception e) {
        System.out.println(e);
    }
    Statement stmt = con.createStatement();
    ResultSet rs = stmt.executeQuery("select * from user_data;");
    while (rs.next()) {
        System.out.print("Name:" + rs.getString(1) + "\t");
        System.out.print("Eamil:" + rs.getString(2) + "\t");
        System.out.print("Phone:" + rs.getInt(3) + "\t");
        System.out.println(" ");
    }
    con.close();
}

public static void main(String[] args) throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    String url = "jdbc:mysql://localhost:3306/querydsl";
    Connection conn = DriverManager.getConnection(url, "querydsl", "querydsl");
    MetaDataExporter exporter = new MetaDataExporter();
    exporter.setNamePrefix("S");
    exporter.setPackageName("com.querydsl.jpa.domain.sql");
    exporter.setTargetFolder(new File("../querydsl-jpa/src/test/java"));
    //        exporter.setLowerCase(true);
    exporter.export(conn.getMetaData());
    conn.close();
}

@Test
public void testCheckMandatoryConfsForValidValues() throws HIHOException {
    String[] args = new String[] { "-jdbcDriver", "com.mysql.jdbc.Driver", "-jdbcUrl", "jdbc:mysql://localhost:3306/hiho", "-jdbcUsername", "root", "-jdbcPassword", "newpwd", "-delimiter", ",", "-numberOfMappers", "1", "-tableName", "employee", "-columnNames", "name,genderId,dateId,designation,department", "-inputPath", "/input1,/input2" };
    ExportToDB exportToDB = new ExportToDB();
    Configuration conf = new Configuration();
    exportToDB.populateConfiguration(args, conf);
    exportToDB.checkMandatoryConfs(conf);
}

private Connection getSimpleConnection() {
    try {
        return cpds.getConnection();
    } catch (SQLException e) {
        int code = e.getErrorCode();
        System.err.println("**************************Error Code " + code + " message " + e.getMessage());
        throw new RuntimeException(e);
    }
//        String url = null;
//        Connection result = null;
//        try
//        {
//            Class.forName("com.mysql.jdbc.Driver");
//            url = "jdbc:mysql://localhost/" + ClipConfig.DB_NAME;
//            url = ClipConfig.getInstance().DB_URL +  ClipConfig.getInstance().DB_NAME + "?useUnicode=yes&characterEncoding=UTF-8";
//            result = DriverManager.getConnection(url, ClipConfig.getInstance().DB_USERNAME, ClipConfig.getInstance().DB_PASSWORD);
//        }
//        catch (Exception e)
//        {
//            log.error("Can't get db connection url[" + url + "]",e);
//            SystemStatus.getInstance().setERROR(true);
//            throw new RuntimeException(e);
//        }
//        return result;
}

/**
	 * @param args
	 * @throws Exception 
	 */
public static void main(String[] args) throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test?user=blog&password=blog&useUnicode=true");
    conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
    /*conn.setAutoCommit(false);
		PreparedStatement statment = conn.prepareStatement("select * from account where id > ? and create_time > ?");
		statment.setInt(1,1);
		statment.setDate(2, new Date(Calendar.getInstance().getTime().getTime()));
		
		ResultSet result = statment.executeQuery();
		while(!result.isLast()){
			System.out.println(result.next());
		}
		conn.commit();
		conn.rollback();
		conn.setAutoCommit(true);*/
    conn.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
    conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
}

public static boolean isAdmin(String email) {
    Connection con = null;
    String driver = "com.mysql.jdbc.Driver";
    try {
        Class.forName(driver);
        con = DriverManager.getConnection(PropertiesManager.getInstance().getProperty(RepositoryConstants.getInstance().REG_DATABASE_URL), PropertiesManager.getInstance().getProperty(RepositoryConstants.getInstance().REG_DATABASE_USER), PropertiesManager.getInstance().getProperty(RepositoryConstants.getInstance().REG_DATABASE_PASSWORD));
        Statement st = con.createStatement();
        try {
            ResultSet result = st.executeQuery("select * from Admin where email='" + email + "'");
            while (result.next()) {
                return true;
            }
        } catch (SQLException s) {
        }
        con.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return false;
}

public static Connection getInstance() {
    if (null == Database.conn) {
        try {
            String sDbConnection = Configuration.get("dbConnection", "");
            String sDbUser = Configuration.get("dbUser", "");
            String sDbPassword = Configuration.get("dbPassword", "");
            if (0 == sDbConnection.length() || 0 == sDbUser.length()) {
                System.err.println("No database connection information was provided by the config file.");
            }
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            Database.conn = DriverManager.getConnection(sDbConnection, sDbUser, sDbPassword);
            if (Database.conn.isClosed()) {
                System.err.println("Couldn't connect to the source database.");
            }
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.exit(1);
        }
    }
    return Database.conn;
}

@Test
@Ignore
public void test1() throws ClassNotFoundException, SQLException {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/diamond?useUnicode=true&&characterEncoding=UTF-8" + "&connectTimeout=3000&socketTimeout=3000&autoReconnect=true", "diamond", "diamond");
    connection.setAutoCommit(false);
    PreparedStatement ps = connection.prepareStatement("insert into miao values(18600110022, 1, now())");
    int rows = ps.executeUpdate();
    System.out.println(rows);
    ps.close();
    connection.close();
}

public Connection getConnection() {
    Connection connection = null;
    try {
        String driverName = "com.mysql.jdbc.Driver";
        Class.forName(driverName);
        connection = DriverManager.getConnection(MYSQL_DB_CONN, MYSQL_DB_USER, MYSQL_DB_PASS);
    } catch (ClassNotFoundException e) {
        System.out.println("Couldnot find the database driver " + e.getMessage());
    } catch (SQLException e) {
        System.out.println(e.getMessage());
    }
    return connection;
}

public static Connection getConnection() {
    String driver = "com.mysql.jdbc.Driver";
    String url = "jdbc:mysql://localhost:3306/cim";
    String user = "root";
    String password = "root";
    Connection conn = null;
    try {
        Class.forName(driver);
        conn = DriverManager.getConnection(url, user, password);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}

// WARNING
public static DriverManagerDataSource createDS(String url, String user, String pass, int type) {
    switch(type) {
        // Oracle
        case 0:
            ds.setDriverClassName("oracle.jdbc.driver.OracleDriver");
            break;
        // SQL SERVER
        case 2:
            ds.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
            break;
        // MYSQL
        case 3:
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            break;
        case 4:
            ds.setDriverClassName("org.postgresql.Driver");
            break;
        case 5:
            ds.setDriverClassName("com.ibm.db2.jcc.DB2Driver");
            break;
    }
    ds.setPassword(pass);
    ds.setUsername(user);
    ds.setUrl(url);
    return ds;
}

@Test
public void create_map_from_properties() {
    Properties properties = new Properties();
    properties.put("database.username", "yourname");
    properties.put("database.password", "encrypted_password");
    properties.put("database.driver", "com.mysql.jdbc.Driver");
    properties.put("database.url", "jdbc:mysql://localhost:3306/sakila?profileSQL=true");
    @SuppressWarnings({ "unchecked", "rawtypes" }) Map<String, String> mapOfProperties = new HashMap(properties);
    assertThat(mapOfProperties.keySet(), containsInAnyOrder("database.username", "database.password", "database.driver", "database.url"));
}

public static void main(String[] args) throws MolgenisModelException {
    // enable log
    BasicConfigurator.configure();
    Logger.getRootLogger().setLevel(Level.ERROR);
    MolgenisOptions options = new MolgenisOptions();
    options.db_driver = "com.mysql.jdbc.Driver";
    options.db_user = "molgenis";
    options.db_password = "molgenis";
    options.db_uri = "jdbc:mysql://localhost/catissue";
    String xml = JDBCModelExtractor.extractXml(options);
    System.out.println(xml);
    Model m = MolgenisModelParser.parseDbSchema(xml);
    String tab = ModelToExcel.write(m);
    System.out.println(tab);
}

public Connection connector() {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        con = DriverManager.getConnection("jdbc:mysql://sql2.freesqldatabase.com/sql24688", "sql24688", "vZ4*gH7%");
        if (con == null) {
            System.out.println("Connection counld not be esstablished");
        } else {
            System.out.println("Connection established");
        }
        return con;
    } catch (Exception e) {
        System.out.println("Error" + e);
    }
    return null;
}

public static void main(String[] args) {
    Connection con = null;
    String url = "jdbc:mysql://localhost:3306/";
    String dbName = "jdbctutorial";
    String driverName = "com.mysql.jdbc.Driver";
    String userName = "root";
    String password = "";
    try {
        Class.forName(driverName).newInstance();
        con = DriverManager.getConnection(url + dbName, userName, password);
        try {
            Statement st = con.createStatement();
            String table = "DROP DATABASE nodedb";
            st.executeUpdate(table);
            System.out.println("Database deleted successfully!");
        } catch (SQLException s) {
            System.out.println("Database does not exist!");
        }
        con.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static Connection getConnection() {
    /** 
	     * String de conexão: 
	     *    Oracle - jdbc:oracle:thin:@<IP>:<PORTA>:<BANCO> 
	     *    Mysql  - jdbc:mysql://<IP>:<PORTA>/<BANCO> 
	     *  
	     * Class Names: 
	     *    Oracle - oracle.jdbc.driver.OracleDriver 
	     *    Mysql  - com.mysql.jdbc.Driver 
	     */
    Connection conn = null;
    try {
        Class.forName("oracle.jdbc.driver.OracleDriver");
        conn = DriverManager.getConnection("jdbc:oracle:thin:java_user/java_user@localhost:1521:xe");
    } catch (ClassNotFoundException c) {
        c.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return conn;
}

public void startConnection(String dbName) {
    try {
        dbName = MysqlMetricsPortlet.dbName;
        userName = MysqlMetricsPortlet.userName;
        password = MysqlMetricsPortlet.password;
        String url = "jdbc:mysql://localhost/" + dbName + "?zeroDateTimeBehavior=convertToNull";
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        conn = DriverManager.getConnection(url, userName, password);
        System.out.println("Database connection established");
    } catch (Exception e) {
        System.err.println("Cannot connect to database server");
        e.printStackTrace();
    } finally {
    }
}

public static Connection getConnection() {
    Connection connect;
    if (user == null || password == null) {
        System.out.println("Performing first time decryption...");
        try {
            Decryption.getUserDetails();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    try {
        Class.forName("com.mysql.jdbc.Driver");
        connect = DriverManager.getConnection("jdbc:mysql://" + address + "/stppstats?" + "user=" + user + "&password=" + password);
        return connect;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static void main(String[] args) {
    Connection conn = null;
    try {
        String userName = "root";
        String password = "sql";
        String url = "jdbc:mysql://9.115.21.74:3306/test";
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        conn = DriverManager.getConnection(url, userName, password);
        System.out.println("Database connection established");
    } catch (Exception e) {
        e.printStackTrace();
        System.err.println("Cannot connect to database server");
    } finally {
        if (conn != null) {
            try {
                conn.close();
                System.out.println("Database connection terminated");
            } catch (Exception e) {
            }
        }
    }
}

public static void createDbInMySql(String dbName) {
    System.out.println("-------- MySQL JDBC Connection Testing ------------");
    try {
        Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException e) {
        System.out.println("Where is your MySQL JDBC Driver?");
        e.printStackTrace();
        return;
    }
    System.out.println("MySQL JDBC Driver Registered!");
    Connection connection = null;
    Statement stmt = null;
    try {
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/", "root", "");
        String sql = "CREATE DATABASE " + dbName;
        stmt = connection.createStatement();
        stmt.executeUpdate(sql);
        System.out.println("Database created successfully...");
    } catch (SQLException e) {
        System.out.println("Connection Failed! Check output console");
        e.printStackTrace();
        return;
    }
}

public static Connection getConnection() {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        con = DriverManager.getConnection("jdbc:mysql://localhost/test", "root", "root");
    } catch (ClassNotFoundException ex) {
        Logger.getLogger(ConFactory.class.getName()).log(Level.SEVERE, null, ex);
    } catch (SQLException ex) {
        Logger.getLogger(ConFactory.class.getName()).log(Level.SEVERE, null, ex);
    }
    return con;
}

/**
     * 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");
    try (PrintWriter out = response.getWriter()) {
        String username = request.getParameter("username");
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        con = DriverManager.getConnection(url, user, password);
        CallableStatement cs = null;
        cs = this.con.prepareCall("{call change_user_approved(?)}");
        cs.setString(1, username);
        cs.executeQuery();
        cs.close();
        con.close();
        RequestDispatcher rd = request.getRequestDispatcher("/homePage");
        rd.forward(request, response);
    } catch (ClassNotFoundException ex) {
        Logger.getLogger(UserApproved.class.getName()).log(Level.SEVERE, null, ex);
    } catch (SQLException ex) {
        Logger.getLogger(UserApproved.class.getName()).log(Level.SEVERE, null, ex);
    } catch (InstantiationException ex) {
        Logger.getLogger(UserApproved.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IllegalAccessException ex) {
        Logger.getLogger(UserApproved.class.getName()).log(Level.SEVERE, null, ex);
    }
}

/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    HttpSession session = request.getSession();
    String name = request.getParameter("name");
    String pwd = request.getParameter("pwd");
    PrintWriter out = response.getWriter();
    if (!(name == null) && !(pwd == null)) {
        Connection con = null;
        Statement stmt = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection("jdbc:mysql://localhost/iprogusers?user=root&password=");
            String qry = "SELECT * FROM users WHERE username='" + name + "' AND userpass='" + pwd + "';";
            stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery(qry);
            if (rs.first())
                session.setAttribute("user", name);
            else
                out.println("This is not a valid user'");
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                stmt.close();
            } catch (SQLException e) {
            }
            try {
                con.close();
            } catch (SQLException e) {
            }
        }
    }
    if (!(session.getAttribute("user") == null)) {
        out.println("Hello " + session.getAttribute("user") + "<br>");
        out.println("IP Address: " + request.getRemoteAddr() + "<br>");
        Cookie[] cookies = request.getCookies();
        int visits = 0;
        String action = request.getParameter("reset");
        if (!(action == null) && action.equals("Reset")) {
            Cookie visitCookie = new Cookie("visits", "");
            visitCookie.setMaxAge(0);
            response.addCookie(visitCookie);
        } else {
            try {
                for (int i = 0; i < cookies.length; i++) if (cookies[i].getName().equals("visits"))
                    visits = Integer.parseInt(cookies[i].getValue());
                visits++;
            } catch (NullPointerException ex) {
            }
            Cookie visitCookie = new Cookie("visits", visits + "");
            response.addCookie(visitCookie);
        }
        out.print("You have visited this page " + visits + " times<br>");
        out.print("<FORM METHOD=GET action = LoginServlet> ");
        out.print("Reset Counter : <INPUT TYPE=SUBMIT NAME=reset VALUE=Reset>");
        out.print("</FORM>");
    }
    out.print("<a href = guestbook.jsp>Guest book </a>");
}

public static ComboPooledDataSource loadDatabase(ConfigurationNode settings) {
    try {
        Logger.info("Initializing database connection pool to [ " + settings.getChild("jbdc").getString() + " ]");
        //Connection Driver
        Class.forName("com.mysql.jdbc.Driver");
        ComboPooledDataSource pool = new ComboPooledDataSource();
        pool.setDriverClass("com.mysql.jdbc.Driver");
        pool.setJdbcUrl(settings.getChild("jbdc").getString());
        //Connection Pooling
        pool.setMaxPoolSize(75);
        pool.setMinPoolSize(1);
        // 3 min after being unused, conn is closed
        pool.setMaxIdleTime(180);
        //1 hr after connection is open, it is closed
        pool.setMaxConnectionAge(60 * 60);
        //Connection Debugging
        pool.setDebugUnreturnedConnectionStackTraces(true);
        //throw an exception if any code holds a connection open for > 6 min
        pool.setUnreturnedConnectionTimeout(6 * 60);
        //Statement caching
        pool.setMaxStatementsPerConnection(10);
        //Connection testing (supports connection reconnecting)
        pool.setTestConnectionOnCheckin(true);
        pool.setTestConnectionOnCheckout(true);
        pool.setPreferredTestQuery("SELECT 1");
        //Timeout acquiring a connection after 30000ms (30s)
        pool.setCheckoutTimeout(1000 * 30);
        //Connection Auth
        Logger.info("Authenticating database connection pool with user [ " + settings.getChild("user").getString() + " ]");
        pool.setUser(settings.getChild("user").getString());
        pool.setPassword(settings.getChild("password").getString());
        return pool;
    } catch (ClassNotFoundException e) {
        Logger.error("No Database driver found!", e);
        return null;
    } catch (PropertyVetoException e) {
        Logger.error("No Database driver found!", e);
        return null;
    }
}

public static void main(String[] args) throws ClassNotFoundException, UnknownHostException, SQLException {
    Class.forName("com.mysql.jdbc.Driver");
    Connection conn = null;
    conn = DriverManager.getConnection(DB_URL, USER, PASS);
    //mysql statement
    Statement stmt = conn.createStatement();
    //To connect to mongodb server
    MongoClient mongoClient = new MongoClient("localhost", 27017);
    //Now connect to your databases
    DB db = mongoClient.getDB("xmodule");
    //System.out.println("Connection to Database Successfull");
    DBCollection coll = db.getCollection("modulestore");
    //System.out.println("Collection Selected Successfull");
    BasicDBObject query = new BasicDBObject("_id.category", "chapter");
    //BasicDBObject query = new BasicDBObject("_id.category", "course").append("_id.course", "CS201");
    DBCursor cursor = coll.find(query);
    String resulta = "", resultb = "";
    while (cursor.hasNext()) {
        DBObject tobj = cursor.next();
        resulta = tobj.get("_id").toString();
        resultb = tobj.get("metadata").toString();
    }
    //System.out.println(resulta);
    String[] temp1 = resulta.split(":");
    String resa = temp1[3];
    String[] resb = resa.split(",");
    String resc = resb[0];
    String resd = resc.substring(2, resc.length() - 2);
    System.out.println(resd);
    //System.out.println(resultb);
    String[] temp2 = resultb.split(":");
    String rese = temp2[1];
    String newsectionname = rese.substring(2, rese.length() - 2);
    System.out.println(newsectionname);
    cursor.close();
    String sql = "select * from mdl_course where idnumber = '" + resd + "'";
    //System.out.println(sql);
    ResultSet rs = stmt.executeQuery(sql);
    int id = 0;
    while (rs.next()) {
        id = rs.getInt("id");
    }
    //System.out.println(id);
    sql = "select * from mdl_course_sections where course = " + id + " and name!='null'";
    //sql = "select * from mdl_course_sections where course = 65 and name!='null'";
    rs = stmt.executeQuery(sql);
    String name = "";
    int flag = 1;
    while (rs.next()) {
        name = rs.getString("name");
        if (name.compareTo(newsectionname) == 0)
            flag = 0;
    }
    if (flag == 1) {
        //System.out.println(sql);
        rs = stmt.executeQuery(sql);
        sql = "select id from mdl_course_sections where section=0 and course = " + id;
        //sql ="select id from mdl_course_sections where section=0 and course = 65";
        rs = stmt.executeQuery(sql);
        int id1 = 0;
        while (rs.next()) {
            id1 = rs.getInt("id");
        }
        sql = "select * from mdl_course_sections where course = " + id + " and name!='null'";
        //sql = "select * from mdl_course_sections where course = 65 and name!='null'";
        rs = stmt.executeQuery(sql);
        while (rs.next()) {
            id1 = rs.getInt("id");
        }
        id1++;
        System.out.println(id1);
        sql = "update mdl_course_sections set name='" + newsectionname + "' where id=" + id1;
        stmt.execute(sql);
    }
}

private ComboPooledDataSource buildPool(Settings mysqlSetting) {
    String url = "jdbc:mysql://{}:{}/{}?useUnicode=true&characterEncoding=utf8";
    url = format(url, mysqlSetting.get("host", "127.0.0.1"), mysqlSetting.get("port", "3306"), mysqlSetting.get("database", "csdn_search_client"));
    try {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(mysqlSetting.get("username"));
        dataSource.setPassword(mysqlSetting.get("password"));
        dataSource.setJdbcUrl(url);
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setInitialPoolSize(5);
        dataSource.setMinPoolSize(5);
        dataSource.setMaxPoolSize(10);
        dataSource.setMaxStatements(50);
        dataSource.setMaxIdleTime(60);
        return dataSource;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

@Override
public PersistenceManager createPersistenceManager(List<Class<?>> classes) throws Exception {
    if (pm == null) {
        Properties p = new Properties();
        String driver = "com.mysql.jdbc.Driver";
        String username = "siena";
        String password = "siena";
        String url = "jdbc:mysql://localhost/siena";
        p.setProperty("driver", driver);
        p.setProperty("user", username);
        p.setProperty("password", password);
        p.setProperty("url", url);
        Class.forName(driver);
        BasicDataSource dataSource = new BasicDataSource();
        dataSource = new BasicDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        // 2 seconds max for wait a connection.
        dataSource.setMaxWait(2000);
        DdlGenerator generator = new DdlGenerator();
        for (Class<?> clazz : classes) {
            generator.addTable(clazz);
        }
        // get the Database model
        Database database = generator.getDatabase();
        Platform platform = PlatformFactory.createNewPlatformInstance("mysql");
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        Connection connection = DriverManager.getConnection(url, username, password);
        System.out.println(platform.getAlterTablesSql(connection, database));
        // this will perform the database changes
        CreationParameters cp = new CreationParameters();
        // to search, it requires MyISAM
        cp.addParameter(database.findTable("discoveries_search"), "ENGINE", "MyISAM");
        cp.addParameter(database.findTable("discoveries_search2"), "ENGINE", "MyISAM");
        platform.alterTables(connection, database, cp, true);
        connection.close();
        pm = new JdbcPersistenceManager();
        pm.init(p);
    }
    return pm;
}

public static String connectToDatabase() {
    System.out.println("MySQL Connect Example.");
    Connection conn = null;
    String url = "jdbc:mysql://instance7904.db.xeround.com:5950/";
    String dbName = "health1";
    String driver = "com.mysql.jdbc.Driver";
    String userName = "sbose78_db1";
    String password = "qwerty";
    try {
        Class.forName(driver).newInstance();
        conn = DriverManager.getConnection(url + dbName, userName, password);
        System.out.println("Connected to the database");
        PreparedStatement pstatement = null;
        String queryString = "INSERT INTO forum(topic,problem_id) VALUES (?, ?)";
        /* createStatement() is used for create statement
                object that is used for 
                    sending sql statements to the specified database. */
        pstatement = conn.prepareStatement(queryString);
        pstatement.setString(1, "BPD in child");
        pstatement.setString(2, "2");
        int updateQuery = pstatement.executeUpdate();
        pstatement.close();
        conn.close();
        System.out.println("Disconnected from database");
    } catch (Exception e) {
        e.printStackTrace();
        return e.toString();
    }
    return "OK";
}

@Override
public void postProcessPersistenceUnitInfo(MutablePersistenceUnitInfo unit) {
/*
        unit.addProperty("hibernate.connection.username", getDbUser());
        unit.addProperty("hibernate.connection.password", getDbPassword());
        String jdbcUrl = String.format("jdbc:mysql://%s/%s", getDbHost(), getDbName());
        unit.addProperty("hibernate.connection.url", jdbcUrl);
        unit.addProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
        unit.addProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect");
        unit.addProperty("org.jboss.logging.provider", "log4j2");
        */
}

@Test
public void deserialize() {
    String xml = "<configuration>\n" + "  <modelDirectory>/tmp/models</modelDirectory>\n" + "  <numProcessorsForTraining>3</numProcessorsForTraining>\n" + "  <storageConfiguration>\n" + "    <jdbcDriverClass>com.mysql.jdbc.Driver</jdbcDriverClass>\n" + "    <jdbcUrl>jdbc:mysql://localhost/plista</jdbcUrl>\n" + "    <username>root</username>\n" + "    <password>secret</password>\n" + "  </storageConfiguration>\n" + "  <itembasedRecommenders>\n" + "    <itembasedRecommender>\n" + "      <name>itembased</name>\n" + "      <similarityClass>org.apache.mahout.cf.taste.impl.similarity.LogLikelihoodSimilarity</similarityClass>\n" + "      <similarItemsPerItem>25</similarItemsPerItem>\n" + "      <retrainCronExpression>0 0 1 * * ?</retrainCronExpression>\n" + "    </itembasedRecommender>\n" + "  </itembasedRecommenders>\n" + "  <factorizationbasedRecommenders>\n" + "    <factorizationbasedRecommender>\n" + "      <name>weighted-mf</name>\n" + "      <usesImplicitFeedback>true</usesImplicitFeedback>\n" + "      <numberOfFeatures>10</numberOfFeatures>\n" + "      <numberOfIterations>10</numberOfIterations>\n" + "      <lambda>0.01</lambda>\n" + "      <alpha>40.0</alpha>\n" + "      <retrainAfterPreferenceChanges>5</retrainAfterPreferenceChanges>\n" + "    </factorizationbasedRecommender>\n" + "  </factorizationbasedRecommenders>\n" + "</configuration>";
    Configuration conf = Configuration.fromXML(xml);
    assertEquals("/tmp/models", conf.getModelDirectory());
    assertEquals(3, conf.getNumProcessorsForTraining());
    StorageConfiguration storageConf = conf.getStorageConfiguration();
    assertNotNull(storageConf);
    assertEquals("com.mysql.jdbc.Driver", storageConf.getJdbcDriverClass());
    assertEquals("jdbc:mysql://localhost/plista", storageConf.getJdbcUrl());
    assertEquals("root", storageConf.getUsername());
    assertEquals("secret", storageConf.getPassword());
    List<ItembasedRecommenderConfig> itembasedRecommenders = conf.getItembasedRecommenders();
    assertNotNull(itembasedRecommenders);
    assertEquals(1, itembasedRecommenders.size());
    ItembasedRecommenderConfig itembasedRecommenderConf = itembasedRecommenders.get(0);
    assertEquals("itembased", itembasedRecommenderConf.getName());
    assertEquals(LogLikelihoodSimilarity.class.getName(), itembasedRecommenderConf.getSimilarityClass());
    assertEquals(25, itembasedRecommenderConf.getSimilarItemsPerItem());
    assertEquals(RecommenderConfig.DONT_RETRAIN_ON_PREFERENCE_CHANGES, itembasedRecommenderConf.getRetrainAfterPreferenceChanges());
    assertEquals("0 0 1 * * ?", itembasedRecommenderConf.getRetrainCronExpression());
    List<FactorizationbasedRecommenderConfig> factorizationbasedRecommenders = conf.getFactorizationbasedRecommenders();
    assertNotNull(factorizationbasedRecommenders);
    assertEquals(1, factorizationbasedRecommenders.size());
    FactorizationbasedRecommenderConfig factorizationbasedRecommenderConf = factorizationbasedRecommenders.get(0);
    assertEquals("weighted-mf", factorizationbasedRecommenderConf.getName());
    assertTrue(factorizationbasedRecommenderConf.isUsesImplicitFeedback());
    assertEquals(10, factorizationbasedRecommenderConf.getNumberOfFeatures());
    assertEquals(10, factorizationbasedRecommenderConf.getNumberOfIterations());
    assertEquals(0.01, factorizationbasedRecommenderConf.getLambda(), 0);
    assertEquals(40, factorizationbasedRecommenderConf.getAlpha(), 0);
    assertEquals(5, factorizationbasedRecommenderConf.getRetrainAfterPreferenceChanges());
    assertNull(factorizationbasedRecommenderConf.getRetrainCronExpression());
}

public void testParser() {
    Datasources datasources = null;
    try {
        datasources = new Datasources("xml/test_xml2datasources.xml", ResourceFinderClasspath.getInstance());
        assertEquals(4, datasources.getDatasourceNames().size());
        assertTrue(datasources.getDatasourceNames().contains("datasource1"));
        assertTrue(datasources.getDatasourceNames().contains("datasource2"));
        assertTrue(datasources.getDatasourceNames().contains("datasource3"));
        Datasource datasource1 = datasources.getDatasource("datasource1");
        assertEquals("org.postgresql.Driver", datasource1.getDriver());
        assertEquals("org.postgresql.Driver", datasource1.getAliasedDriver());
        assertEquals("jdbc:postgresql://localhost:5432/thedb", datasource1.getUrl());
        assertEquals("unittests1", datasource1.getUser());
        assertEquals("password1", datasource1.getPassword());
        assertEquals(5, datasource1.getPoolsize());
        assertTrue(datasource1.isPooled());
        Datasource datasource2 = datasources.getDatasource("datasource2");
        assertEquals("com.mysql.jdbc.Driver", datasource2.getDriver());
        assertEquals("com.mysql.jdbc.Driver", datasource2.getAliasedDriver());
        assertEquals("jdbc:mysql://localhost:3306/thedb", datasource2.getUrl());
        assertEquals("user2", datasource2.getUser());
        assertEquals("pw2", datasource2.getPassword());
        assertEquals(15, datasource2.getPoolsize());
        assertTrue(datasource2.isPooled());
        Datasource datasource3 = datasources.getDatasource("datasource3");
        assertEquals("oracle.jdbc.driver.OracleDriver", datasource3.getDriver());
        assertEquals("oracle.jdbc.driver.OracleDriver", datasource3.getAliasedDriver());
        assertEquals("jdbc:oracle:thin:@10.1.1.2:1521:database", datasource3.getUrl());
        assertEquals("unittests", datasource3.getUser());
        assertEquals("password", datasource3.getPassword());
        assertEquals(0, datasource3.getPoolsize());
        assertTrue(!datasource3.isPooled());
        Datasource datasource4 = datasources.getDatasource("datasource4");
        assertEquals("org.gjt.mm.mysql.Driver", datasource4.getDriver());
        assertEquals("com.mysql.jdbc.Driver", datasource4.getAliasedDriver());
        assertEquals("jdbc:mysql://localhost:3306/thedb", datasource4.getUrl());
        assertEquals("user2", datasource4.getUser());
        assertEquals("pw2", datasource4.getPassword());
        assertEquals(15, datasource4.getPoolsize());
        assertTrue(datasource4.isPooled());
    } catch (DatasourcesException e) {
        assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
    }
}

public static void addResult(String processId, String variableName, String variableResult) {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        connection = DriverManager.getConnection(getConnectionString());
        preparedStatement = connection.prepareStatement("insert into results values (default, ?, ?, ?)");
        preparedStatement.setString(1, processId);
        preparedStatement.setString(2, variableName);
        preparedStatement.setString(3, variableResult);
        preparedStatement.executeUpdate();
    } catch (Exception ex) {
        System.out.println("Failed to store result: " + ex.getMessage());
    } finally {
        try {
            if (preparedStatement != null) {
                preparedStatement.close();
            }
        } catch (Exception ex) {
        }
        try {
            if (connection != null) {
                connection.close();
            }
        } catch (Exception ex) {
        }
    }
}

@Test
public void shouldConfigureJDBC() {
    class DBConfig extends AbstractDBConfig {

        public void init(AppContext appContext) {
            environment("development").testing().jdbc("com.mysql.jdbc.Driver", "jdbc:mysql://localhost/test123", "root", "****");
        }
    }
    DBConfig config = new DBConfig();
    config.init(null);
    ConnectionSpecWrapper wrapper = DbConfiguration.getConnectionSpecWrappers().get(0);
    a(wrapper.getDbName()).shouldBeEqual("default");
    a(wrapper.isTesting()).shouldBeTrue();
    a(wrapper.getEnvironment()).shouldBeEqual("development");
    ConnectionJdbcSpec connectionSpec = (ConnectionJdbcSpec) wrapper.getConnectionSpec();
    a(connectionSpec.getDriver()).shouldBeEqual("com.mysql.jdbc.Driver");
    a(connectionSpec.getUrl()).shouldBeEqual("jdbc:mysql://localhost/test123");
    a(connectionSpec.getUser()).shouldBeEqual("root");
    a(connectionSpec.getPassword()).shouldBeEqual("****");
}

@Bean
public DataSource dataSource() {
    final BoneCPDataSource dataSource = new BoneCPDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/job");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    dataSource.setIdleConnectionTestPeriodInMinutes(1);
    dataSource.setIdleMaxAgeInMinutes(10);
    dataSource.setMaxConnectionsPerPartition(5);
    dataSource.setMinConnectionsPerPartition(1);
    dataSource.setPartitionCount(1);
    dataSource.setAcquireIncrement(1);
    dataSource.setStatementsCacheSize(100);
    dataSource.setReleaseHelperThreads(3);
    return dataSource;
}

public Connection open() {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        this.c = DriverManager.getConnection("jdbc:mysql://" + this.hostname + ":" + this.port + "/" + this.database, this.user, this.password);
        return c;
    } catch (SQLException e) {
        plugin.log("Could not connect to MySQL server! Plugin shutting down. Error: " + e.getMessage());
        shutdown = true;
    } catch (ClassNotFoundException e) {
        plugin.log("JDBC Driver not found!");
        shutdown = true;
    }
    return this.c;
}

private static Map<String, String> getEntityManagerProperties() {
    Map<String, String> properties = new HashMap();
    if (SystemProperty.environment.value() == SystemProperty.Environment.Value.Production) {
        properties.put("javax.persistence.jdbc.driver", "com.mysql.jdbc.GoogleDriver");
        properties.put("javax.persistence.jdbc.url", System.getProperty("cloudsql.url"));
    } else {
        properties.put("javax.persistence.jdbc.driver", "com.mysql.jdbc.Driver");
        properties.put("javax.persistence.jdbc.url", System.getProperty("cloudsql.url.dev"));
    }
    return properties;
}

public static void main(String[] args) throws ClassNotFoundException, SQLException {
    String driverClassName = null;
    String dbUrl = null;
    String dbUser = null;
    String dbPassword = null;
    int count = 100000;
    if (args.length > 0 && args[0].equalsIgnoreCase("MySql")) {
        driverClassName = "com.mysql.jdbc.Driver";
        dbUrl = "jdbc:mysql://localhost:3306/test";
        dbUser = "root";
        dbPassword = "123456";
    } else if (args.length > 0 && args[0].equalsIgnoreCase("PostgreSql")) {
        driverClassName = "org.postgresql.Driver";
        dbUrl = "jdbc:postgresql://localhost:5432/postgres";
        dbUser = "postgres";
        dbPassword = "postgres";
    } else {
        System.out.println("Usage : java me.test.PerpareDB mysql|postgre [count].");
        return;
    }
    if (args.length > 1) {
        try {
            count = Integer.valueOf(args[1]);
        } catch (NumberFormatException e) {
            System.err.println("Could not pars number, using default[" + count + "]");
        }
    }
    System.out.println("Starting prepare data for " + args[0] + ".");
    Class.forName(driverClassName);
    Connection conn = DriverManager.getConnection(dbUrl, dbUser, dbPassword);
    conn.setAutoCommit(false);
    Calendar c = Calendar.getInstance();
    c.set(1985, 7, 1, 0, 0, 0);
    c.set(Calendar.MILLISECOND, 0);
    Date birthday = new Date(c.getTimeInMillis());
    PreparedStatement preStmt = conn.prepareStatement("INSERT INTO PERSON (ID, NAME, BIRTYDAY) VALUES (?,?,?)");
    for (int i = 0; i < count; i++) {
        preStmt.setLong(1, i);
        preStmt.setString(2, "zhang3");
        preStmt.setDate(3, birthday);
        preStmt.execute();
    }
    preStmt.close();
    conn.commit();
    conn.close();
    System.out.println("Done.");
}

public Connection open() {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        this.c = DriverManager.getConnection("jdbc:mysql://" + this.hostname + ":" + this.port + "/" + this.database, this.user, this.password);
        return c;
    } catch (SQLException e) {
        System.out.println("Could not connect to MySQL server! because: " + e.getMessage());
    } catch (ClassNotFoundException e) {
        System.out.println("JDBC Driver not found!");
    }
    return this.c;
}

public static void main(String[] args) throws Exception {
    //Connect to the database
    Class.forName("com.mysql.jdbc.Driver");
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/easyrec_test", "root", "root");
    IDatabaseConnection connection = new DatabaseConnection(conn);
    QueryDataSet partialDataSet = new QueryDataSet(connection);
    //Specify the SQL to run to retrieve the data
    partialDataSet.addTable("actionarchive1", " SELECT * FROM actionarchive1");
    //Specify the location of the flat file(XML)
    // file is stored in /target folder
    FlatXmlWriter datasetWriter = new FlatXmlWriter(new FileOutputStream("easyrec-testutils/target/temp.xml"));
    //Export the data
    datasetWriter.write(partialDataSet);
}

/**
	 * 获�数�库连接对象
	 * @return
	 */
public static Connection getConnection() {
    try {
        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //定义URL
        String url = "jdbc:mysql://localhost:13306/ems?characterEncoding=utf-8";
        //获�连接
        return DriverManager.getConnection(url, "root", "123");
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static JdbcTemplate getJdbcTemplateInstance() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl(TestPropertiesUtil.getProperty(TestPropertiesUtil.KOKU_DS_URL));
    dataSource.setUsername(TestPropertiesUtil.getProperty(TestPropertiesUtil.KOKU_DS_USERNAME));
    dataSource.setPassword(TestPropertiesUtil.getProperty(TestPropertiesUtil.KOKU_DS_PWD));
    return new JdbcTemplate(dataSource);
}

public int createcustomobj(int orgid, String objname) {
    Connection conn = null;
    String url = "jdbc:mysql://localhost:3306/";
    String dbName = "cloudforce";
    String driver = "com.mysql.jdbc.Driver";
    String userName = "root";
    String password = "aj";
    try {
        Class.forName(driver).newInstance();
        conn = DriverManager.getConnection(url + dbName, userName, password);
    } catch (Exception e) {
        return -1;
    }
    Statement st = null;
    try {
        st = conn.createStatement();
    } catch (Exception e) {
        return -1;
    }
    int present = 0;
    try {
        ResultSet rs = st.executeQuery("select count(*) from object where objName='" + objname + "'");
        rs.next();
        present = Integer.parseInt(rs.getString(1));
    } catch (Exception e) {
        return -1;
    }
    int new_orgID = 0;
    if (present == 0) {
        try {
            st.executeUpdate("INSERT INTO object(objID,orgID,objName) VALUES (NULL," + orgid + ",'" + objname + "')", Statement.RETURN_GENERATED_KEYS);
            ResultSet rs = st.executeQuery("SELECT LAST_INSERT_ID()");
            rs.next();
            new_orgID = Integer.parseInt(rs.getString(1));
        } catch (Exception e) {
            return -1;
        }
    }
    return new_orgID;
}

public void printEmployees() {
    Connection conn = null;
    Statement stmt = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        // Get a connection from data source
        InitialContext ctx = new InitialContext();
        DataSource ds = (DataSource) ctx.lookup("jdbc/HSQLDS");
        conn = ds.getConnection("hsqlusername", "hsqlpassword");
        stmt = conn.createStatement();
        String sql = "SELECT id, name, age FROM Employee";
        ResultSet rs = stmt.executeQuery(sql);
        while (rs.next()) {
            int id = rs.getInt("id");
            int age = rs.getInt("age");
            String name = rs.getString("name");
            System.out.print("ID: " + id);
            System.out.print(", Age: " + age);
            System.out.print(", Name: " + name);
        }
        rs.close();
        stmt.close();
        conn.close();
    } catch (SQLException se) {
        se.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (stmt != null) {
                stmt.close();
            }
        } catch (SQLException se2) {
        }
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException se) {
            se.printStackTrace();
        }
    }
}

/**
	 * Creates a new data source based on the specified credentials.
	 * 
	 * @param credentials
	 *            The database credentials.
	 * 
	 * @return The data source.
	 */
public static BasicDataSource createDataSource(DatabaseLoginCredentials credentials) {
    BasicDataSource dataSource;
    dataSource = new BasicDataSource();
    switch(credentials.getDbType()) {
        case POSTGRESQL:
            dataSource.setDriverClassName("org.postgresql.Driver");
            dataSource.setUrl("jdbc:postgresql://" + credentials.getHost() + "/" + credentials.getDatabase());
            break;
        case MYSQL:
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://" + credentials.getHost() + "/" + credentials.getDatabase());
            break;
        default:
            throw new OsmosisRuntimeException("Unknown database type " + credentials.getDbType() + ".");
    }
    dataSource.setUsername(credentials.getUser());
    dataSource.setPassword(credentials.getPassword());
    return dataSource;
}

public void connect() {
    try {
        String userName = "test";
        String password = "test";
        String url = "jdbc:mysql://fromvalue.greatamerica.corp.yahoo.com:3306/timeline";
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        conn = DriverManager.getConnection(url, userName, password);
        System.out.println("Database connection established");
    } catch (Exception e) {
        System.err.println("Cannot connect to database server");
    }
}

//        static Logger logger = Logger.getLogger("ftl.DataAccess");
//  public static String ConfigFileName = "C:\\Program Files\\Apache Software Foundation\\Tomcat 5.5\\webapps\\FTWeb\\WEB-INF\\web.xml";
public static Connection getConnection() throws Exception {
    try {
        // Config config = new Config();
        // AppConfigParser ACP =  new AppConfigParser(ConfigFileName);
        //  config.DataSource =
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        return DriverManager.getConnection(DataSource, Username, Password);
    } catch (ClassNotFoundException e) {
        throw new SQLException("No driver found for " + "com.mysql.jdbc.Driver");
    } catch (InstantiationException e) {
        throw new SQLException("Driver " + "com.mysql.jdbc.Driver" + " could not be instantiated.");
    } catch (IllegalAccessException e) {
        throw new SQLException("Driver " + "com.mysql.jdbc.Driver" + " could not be instantiated: " + e.getMessage());
    } catch (Exception e) {
        throw new Exception(e.getMessage());
    }
}

private static DataSource makeDataSource() {
    final Properties connectionProperties = new Properties();
    connectionProperties.setProperty("driver", "com.mysql.jdbc.Driver");
    connectionProperties.setProperty("url", "jdbc:mysql://localhost:3306/schemacrawler;useInformationSchema=true");
    connectionProperties.setProperty("user", "root");
    connectionProperties.setProperty("password", "");
    return new PropertiesDataSource(connectionProperties);
}

public static ArrayList<myPair> get_sorted(ArrayList<String> result1) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/PriorityDB", "root", "jiit@62");
        Statement stmt = con.createStatement();
        ArrayList<myPair> priority = new ArrayList<myPair>();
        int x = 0;
        for (Object ob : result1) {
            try {
                String s = "SELECT * from maintable WHERE Path = '" + (String) ob + "'";
                ResultSet rs = stmt.executeQuery(s);
                while (rs.next()) {
                    String a = rs.getString("Path");
                    x = rs.getInt("Score");
                    priority.add(new myPair((String) ob, -1 * x));
                }
                x++;
            } catch (Exception e) {
            }
        }
        Collections.sort(priority, new myPair());
        return priority;
    } catch (Exception e) {
        System.out.println(e);
        return null;
    }
}

/**
	 * http://d2.naver.com/helloworld/1321
	 * http://kwonnam.pe.kr/wiki/database/mysql/jdbc
	 * @param args
	 */
public static void main(String[] args) {
    try {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://192.168.29.138:34306/tadpole20?connectTimeout=4000&socketTimeout=5000", "root", "tadpole");
        CallableStatement stat = conn.prepareCall("call simpleproc(?)");
        stat.registerOutParameter(1, Types.TINYINT);
        stat.execute();
        System.out.println(stat.getInt(1));
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@Override
public void execute() throws Exception {
    DataSource ds = EmbeddedHelper.newDataSource("com.mysql.jdbc.Driver", "jdbc:mysql://localhost:3306/test", "jdv_user", "jdv_pass");
    init("translator-mysql", new MySQL5ExecutionFactory());
    server.addConnectionFactory("java:/accounts-ds", ds);
    start(false);
    server.deployVDB(new FileInputStream(new File("vdb/mysql-vdb.xml")));
    conn = server.getDriver().connect("jdbc:teiid:MysqlVDB", null);
    JDBCUtil.executeQuery(conn, "SELECT AVG(TIMESTAMPDIFF(SQL_TSI_SECOND, tf.start_time, tf.end_time)) FROM time_function_test tf GROUP BY id");
    System.out.println(conn);
}

public static boolean Start() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    try {
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        conn = DriverManager.getConnection("jdbc:mysql://localhost/" + Configuration.GetEntryValue("dbName") + "?" + "user=" + Configuration.GetEntryValue("dbUser") + "&password=" + Configuration.GetEntryValue("dbPass") + "");
        return true;
    } catch (SQLException ex) {
        Main.Log("[DATABASE]", ex.getMessage());
        Main.Log("[ERROR]", "SQLException: " + ex.getMessage());
        Main.Log("[ERROR]", "SQLState: " + ex.getSQLState());
        Main.Log("[ERROR]", "VendorError: " + ex.getErrorCode());
        return false;
    }
}

/**
     * 
     * @param driverClass
     * @return
     */
public static Dialect inferDialect(String driverClass) {
    if (driverClass == null) {
        return null;
    }
    switch(driverClass) {
        case "org.postgresql.Driver":
            return new PostgresDialect();
        case "org.h2.Driver":
            return new H2Dialect();
        case "com.mysql.jdbc.Driver":
            return new MysqlDialect();
        case "oracle.jdbc.driver.OracleDriver":
            return new OracleDialect();
        case "com.microsoft.sqlserver.jdbc.SQLServerDriver":
            return new MssqlDialect();
        case "com.ibm.db2.jcc.DB2Driver":
            return new Db2Dialect();
        case "org.hsqldb.jdbcDriver":
            return new HsqldbDialect();
        case "org.sqlite.JDBC":
            return new SqliteDialect();
        default:
            return null;
    }
}

public static void main(String[] args) throws AddressException, MessagingException {
    System.out.println("-------- MySQL JDBC Connection Testing ------------");
    try {
        Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException e) {
        System.out.println("Where is your MySQL JDBC Driver?");
        e.printStackTrace();
        return;
    }
    System.out.println("MySQL JDBC Driver Registered!");
    Connection connection = null;
    try {
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mkyongcom", "root", "password");
    } catch (SQLException e) {
        System.out.println("Connection Failed! Check output console");
        e.printStackTrace();
        return;
    }
    if (connection != null) {
        System.out.println("You made it, take control your database now!");
    } else {
        System.out.println("Failed to make connection!");
    }
}

@Test
public void testDbVersionInfo() throws SQLException {
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost", "root", "toor");
    Statement stmt = conn.createStatement();
    System.out.println("Dropping dbversiontest");
    stmt.executeUpdate("DROP DATABASE IF EXISTS dbversiontest");
    System.out.println("Creating dbversiontest");
    stmt.executeUpdate("CREATE DATABASE dbversiontest");
    DbVersionInit dbviTask = new DbVersionInit();
    dbviTask.setLoaderSpecClass(JarLoader.class);
    dbviTask.setUserid("root");
    dbviTask.setPassword("toor");
    dbviTask.setUrl("jdbc:mysql://localhost/dbversiontest");
    dbviTask.setDriver("com.mysql.jdbc.Driver");
    dbviTask.setForceInit(true);
    Property prop = new Property();
    prop.setName("jar.path");
    prop.setValue("com/napkindrawing/test-sql.jar");
    dbviTask.addConfiguredLoaderProperty(prop);
    System.out.println("created DbVersionInit task, calling init");
    dbviTask.init();
    System.out.println("initialized DbVersionInit task, executing");
    dbviTask.execute();
    System.out.println("Number of profiles: " + dbviTask.getProfiles().size());
    DbVersionUpgrade dbvuTask = new DbVersionUpgrade();
    dbvuTask.setLoaderSpecClass(JarLoader.class);
    dbvuTask.setUserid("root");
    dbvuTask.setPassword("toor");
    dbvuTask.setUrl("jdbc:mysql://localhost/dbversiontest");
    dbvuTask.setDriver("com.mysql.jdbc.Driver");
    dbvuTask.setProfileNames("bar,foo,something-dash");
    dbvuTask.setProject(new Project());
    Property propu = new Property();
    propu.setName("jar.path");
    propu.setValue("com/napkindrawing/test-sql.jar");
    dbvuTask.addConfiguredLoaderProperty(propu);
    dbvuTask.init();
    dbvuTask.execute();
}

public static void doMain(String[] args) {
    String job = "java:writingEntityWithJdbc";
    String host = "127.0.0.1";
    int port = 3306;
    String driverClass = "com.mysql.jdbc.Driver";
    String user = "root";
    String password = "root";
    String database = "test";
    String inputTable = "test_table";
    String outputTable = "test_table_output";
    // Creating the Deep Context where args are Spark Master and Job Name
    ContextProperties p = new ContextProperties(args);
    DeepSparkContext deepContext = new DeepSparkContext(p.getCluster(), job, p.getSparkHome(), p.getJars());
    JdbcDeepJobConfig inputConfigCell = JdbcConfigFactory.createJdbc(MessageTestEntity.class).host(host).port(port).username(user).password(password).driverClass(driverClass).database(database).table(inputTable);
    inputConfigCell.initialize();
    RDD<MessageTestEntity> inputRDDEntity = deepContext.createRDD(inputConfigCell);
    LOG.info("count : " + inputRDDEntity.count());
    LOG.info("prints first entity  : " + inputRDDEntity.first());
    JdbcDeepJobConfig outputConfigEntity = JdbcConfigFactory.createJdbc(MessageTestEntity.class).host(host).port(port).username(user).password(password).driverClass(driverClass).database(database).table(outputTable);
    inputConfigCell.initialize();
    deepContext.saveRDD(inputRDDEntity, outputConfigEntity);
    deepContext.stop();
}

public void start() {
    log.trace("start()");
    try {
        DGridClient gridClient = ((DGridPluginContext) super.context).getGridClient();
        jdbcDriverClass = gridClient.getSetting("dataSource.driverClass", "com.mysql.jdbc.Driver");
        jdbcUrl = gridClient.getSetting("dataSource.url", "jdbc:mysql://192.168.1.116/e20");
        jdbcUsername = gridClient.getSetting("dataSource.username", "e20");
        jdbcPassword = gridClient.getSetting("dataSource.password", "phpsux");
    } catch (TransportException e) {
        log.warn("TransportException in start(). DataSourcePlugin will be disabled", e);
        throw (new RuntimeException(e));
    } catch (InvalidApiKey e) {
        log.warn("TransportException in start(). DataSourcePlugin will be disabled", e);
        throw (new RuntimeException(e));
    } finally {
    }
}

@SuppressWarnings("unused")
private void createDatabase(String backendDB) {
    if (backendDB.equals("MySQL")) {
        String JDBC_DRIVER = "com.mysql.jdbc.Driver";
        String DB_URL = "jdbc:mysql://localhost/";
        //static final
        // String USER = "root";
        // String PASS = "root";
        Connection conn = null;
        Statement stmt = null;
        try {
            //STEP 2: Register JDBC driver
            Class.forName("com.mysql.jdbc.Driver");
            //STEP 3: Open a connection
            System.out.println("Connecting to database...");
            conn = DriverManager.getConnection(DB_URL, DBConfig.username, DBConfig.password);
            //STEP 4: Execute a query
            System.out.println("Creating database...");
            stmt = conn.createStatement();
            String sql = "CREATE DATABASE IF NOT EXISTS epcis";
            stmt.executeUpdate(sql);
            System.out.println("Database created successfully...");
            Configuration.connect = true;
        } catch (SQLException se) {
            se.printStackTrace();
            String message = se.getMessage();
            JOptionPane.showMessageDialog(null, message);
        } catch (Exception e) {
            e.printStackTrace();
            String message = e.getMessage();
            JOptionPane.showMessageDialog(null, message);
        } finally {
            //finally block used to close resources
            try {
                if (stmt != null)
                    stmt.close();
            } catch (SQLException se2) {
            }
            // nothing we can do
            try {
                if (conn != null)
                    conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
                String message = se.getMessage();
                JOptionPane.showMessageDialog(null, message);
            }
        //end finally try
        //end try
        }
    } else if (backendDB.equals("PostgreSQL")) {
    } else if (backendDB.equals("MariaDB")) {
    }
}

@Override
protected DataSource createDataSource(Properties customProperties) throws Exception {
    String user = customProperties.getProperty("mysql.user", "flyway");
    String password = customProperties.getProperty("mysql.password", "flyway");
    String url = customProperties.getProperty("mysql.cloudsql_url", "jdbc:mysql://localhost:3306/flyway_cloudsql_db");
    LocalRdbmsServiceTestConfig config = new LocalRdbmsServiceTestConfig();
    config.setServerType(LocalRdbmsService.ServerType.LOCAL);
    ClassUtils.instantiate("com.mysql.jdbc.Driver", Thread.currentThread().getContextClassLoader());
    config.setDriverClass("com.mysql.jdbc.Driver");
    config.setJdbcConnectionStringFormat(url);
    config.setUser(user);
    config.setPassword(password);
    helper = new LocalServiceTestHelper(config);
    helper.setUp();
    return new DriverDataSource(Thread.currentThread().getContextClassLoader(), null, "jdbc:google:rdbms://localhost/flyway_cloudsql_db", "", "", null);
}

@Ignore("Requires MySQL server and a driver.")
@Test
public void shouldRegisterDynamicallyLoadedDriver() throws Exception {
    int before = countRegisteredDrivers();
    ClassLoader driverClassLoader = null;
    UnpooledDataSource dataSource = null;
    driverClassLoader = new URLClassLoader(new URL[] { new URL("jar:file:/PATH_TO/mysql-connector-java-5.1.25.jar!/") });
    dataSource = new UnpooledDataSource(driverClassLoader, "com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1/test", "root", "");
    dataSource.getConnection();
    assertEquals(before + 1, countRegisteredDrivers());
    driverClassLoader = new URLClassLoader(new URL[] { new URL("jar:file:/PATH_TO/mysql-connector-java-5.1.25.jar!/") });
    dataSource = new UnpooledDataSource(driverClassLoader, "com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1/test", "root", "");
    dataSource.getConnection();
    assertEquals(before + 1, countRegisteredDrivers());
}

@Ignore("Requires MySQL server and a driver.")
@Test
public void shouldRegisterDynamicallyLoadedDriver() throws Exception {
    int before = countRegisteredDrivers();
    ClassLoader driverClassLoader = null;
    UnpooledDataSource dataSource = null;
    driverClassLoader = new URLClassLoader(new URL[] { new URL("jar:file:/PATH_TO/mysql-connector-java-5.1.25.jar!/") });
    dataSource = new UnpooledDataSource(driverClassLoader, "com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1/test", "root", "");
    dataSource.getConnection();
    assertEquals(before + 1, countRegisteredDrivers());
    driverClassLoader = new URLClassLoader(new URL[] { new URL("jar:file:/PATH_TO/mysql-connector-java-5.1.25.jar!/") });
    dataSource = new UnpooledDataSource(driverClassLoader, "com.mysql.jdbc.Driver", "jdbc:mysql://127.0.0.1/test", "root", "");
    dataSource.getConnection();
    assertEquals(before + 1, countRegisteredDrivers());
}

private static Connection getConnection() {
    /*
		String url = "jdbc:mysql://192.168.16.32:3306/";
		String dbName = "miniolap";
		String driver = "com.mysql.jdbc.Driver";
		String userName = "miniolap"; 
		String password = "1";
		*/
    String url = "jdbc:mysql://vs201.intranet.asf.ro/";
    String dbName = "nemo";
    String driver = "com.mysql.jdbc.Driver";
    String userName = "nemo";
    String password = "eschiuel3^";
    try {
        Class.forName(driver).newInstance();
        return DriverManager.getConnection(url + dbName, userName, password);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

@SuppressWarnings("unused")
private void createDatabase(String backendDB) {
    if (backendDB.equals("MySQL")) {
        String JDBC_DRIVER = "com.mysql.jdbc.Driver";
        String DB_URL = "jdbc:mysql://localhost/";
        //static final
        // String USER = "root";
        // String PASS = "root";
        Connection conn = null;
        Statement stmt = null;
        try {
            //STEP 2: Register JDBC driver
            Class.forName("com.mysql.jdbc.Driver");
            //STEP 3: Open a connection
            System.out.println("Connecting to database...");
            conn = DriverManager.getConnection(DB_URL, DBConfig.username, DBConfig.password);
            //STEP 4: Execute a query
            System.out.println("Creating database...");
            stmt = conn.createStatement();
            String sql = "CREATE DATABASE IF NOT EXISTS epcis";
            stmt.executeUpdate(sql);
            System.out.println("Database created successfully...");
            Configuration.connect = true;
        } catch (SQLException se) {
            se.printStackTrace();
            String message = se.getMessage();
            JOptionPane.showMessageDialog(null, message);
        } catch (Exception e) {
            e.printStackTrace();
            String message = e.getMessage();
            JOptionPane.showMessageDialog(null, message);
        } finally {
            //finally block used to close resources
            try {
                if (stmt != null)
                    stmt.close();
            } catch (SQLException se2) {
            }
            // nothing we can do
            try {
                if (conn != null)
                    conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
                String message = se.getMessage();
                JOptionPane.showMessageDialog(null, message);
            }
        //end finally try
        //end try
        }
    } else if (backendDB.equals("PostgreSQL")) {
    } else if (backendDB.equals("MariaDB")) {
    }
}

public static void insertNumeric() throws ClassNotFoundException, SQLException {
    Class.forName("com.mysql.jdbc.Driver");
    Properties from = new Properties();
    from.put("user", "root");
    from.put("password", "root");
    from.put("characterEncoding", "utf8");
    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/erosa", from);
    PreparedStatement pst = conn.prepareStatement("insert into unsignednumeric(id,id1,id2,id3) values (?,?,?,?)");
    pst.setLong(1, Integer.MAX_VALUE * 2L);
    pst.setLong(2, Integer.MIN_VALUE);
    pst.setBigDecimal(3, new BigDecimal("18446744073709551614"));
    pst.setBigDecimal(4, new BigDecimal(Long.MIN_VALUE + ""));
    pst.executeUpdate();
    pst.close();
    conn.close();
}

public int insert(String query) {
    int key = -1;
    PreparedStatement preparedStatement;
    try {
        preparedStatement = con.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
        preparedStatement.executeUpdate();
        ResultSet keys = preparedStatement.getGeneratedKeys();
        keys.next();
        key = keys.getInt(1);
        keys.close();
        preparedStatement.close();
    } catch (SQLException e) {
        System.err.println(e.toString());
        e.printStackTrace();
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            con = DriverManager.getConnection(url, username, password);
            preparedStatement = con.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
            preparedStatement.executeUpdate();
            ResultSet keys = preparedStatement.getGeneratedKeys();
            keys.next();
            key = keys.getInt(1);
            keys.close();
            preparedStatement.close();
        } catch (SQLException e1) {
            e1.printStackTrace();
            System.exit(2);
        } catch (InstantiationException e1) {
            e1.printStackTrace();
            System.exit(2);
        } catch (IllegalAccessException e1) {
            e1.printStackTrace();
            System.exit(2);
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
            System.exit(2);
        }
    }
    return key;
}

@Test
public void testMySqlQueryOffsetNoWhere() {
    DataSourceBasedLimitResultsUtil dataSourceBasedLimitResultsUtil = new DataSourceBasedLimitResultsUtil("com.mysql.jdbc.Driver");
    SearchTerm limitClauseToSearchTerm = dataSourceBasedLimitResultsUtil.createLimitClauseToSearchTerm(new StatusTerm(6), 4, 10);
    assertEquals("SELECT * FROM Article WHERE Article.refStatus = 6 limit 10,4", limitClauseToSearchTerm.getQuery("*"));
}

@Override
public Connection openConnection() throws SQLException, ClassNotFoundException {
    if (checkConnection()) {
        return this.connection;
    }
    Class.forName("com.mysql.jdbc.Driver");
    PS.debug("jdbc:mysql://" + this.hostname + ':' + this.port + '/' + this.database + "?useSSL=false");
    this.connection = DriverManager.getConnection("jdbc:mysql://" + this.hostname + ':' + this.port + '/' + this.database + "?useSSL=false", this.user, this.password);
    return this.connection;
}

public List<Episode> getEpisodes() {
    List<Episode> listOfEpisode = new ArrayList<Episode>();
    try {
        Connection connection = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://127.0.0.1:3306/test?user=root";
            String queryEpisode = "SELECT * FROM episode";
            connection = DriverManager.getConnection(url);
            PreparedStatement statement = connection.prepareStatement(queryEpisode);
            ResultSet rs = statement.executeQuery();
            if (!rs.isBeforeFirst())
                return null;
            while (rs.next()) {
                Episode episode = new Episode();
                episode.guid = rs.getString("guid");
                episode.uid = rs.getString("uid");
                episode.title = rs.getString("title");
                episode.image = rs.getString("image");
                episode.description = rs.getString("description");
                episode.transcript = rs.getString("transcript");
                listOfEpisode.add(episode);
            }
        } finally {
            connection.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
        LOG.severe("Error getting episodes getEpisodes:");
    }
    return listOfEpisode;
}

@Override
public String getDocument() {
    return //$NON-NLS-1$
    "There are two type parameters\n\n" + //$NON-NLS-1$
    "One(Example) :\n" + //$NON-NLS-1$
    "driverClassName=com.mysql.jdbc.Driver&url=jdbc:mysql://localhost:3306/brick&username=root&password=null&transformer=item2actionform" + //$NON-NLS-1$
    "\n\n\n" + //$NON-NLS-1$
    "Two(Example) :\n" + //$NON-NLS-1$
    "<parameters>\n" + //$NON-NLS-1$
    "   <driverClassName>com.mysql.jdbc.Driver</driverClassName>\n" + //$NON-NLS-1$
    "   <url>jdbc:mysql://localhost:3306/brick</url>\n" + //$NON-NLS-1$
    "   <username>root</username>\n" + //$NON-NLS-1$
    "   <password>null</password>\n" + //$NON-NLS-1$
    "   <transformer>item2actionform</transformer>\n" + //$NON-NLS-1$
    "</parameters>\n\n\n" + //$NON-NLS-1$
    "Notice :\n" + //$NON-NLS-1$
    "The transformer should expect to receive the content of the Item sent to the transformer in the DEFAULT variable \n" + //$NON-NLS-1$
    "with a content-type of text/xml.\nThe transformer convert Item to an ActionContent Xml Form of JDBC Adpter.\n";
}

public PluginProperty[] getPluginProperties() {
    PluginProperty[] properties = new PluginProperty[] { new PluginProperty("formDataTable", "Form Data Table", PluginProperty.TYPE_TEXTFIELD, null, ""), new PluginProperty("driverClassName", "Driver Class Name", PluginProperty.TYPE_TEXTFIELD, null, "com.mysql.jdbc.Driver"), new PluginProperty("url", "Target DB URL", PluginProperty.TYPE_TEXTFIELD, null, "jdbc:mysql://localhost/"), new PluginProperty("username", "Username", PluginProperty.TYPE_TEXTFIELD, null, "root"), new PluginProperty("password", "Password", PluginProperty.TYPE_PASSWORD, null, ""), new PluginProperty("query", "Query", PluginProperty.TYPE_TEXTAREA, null, null) };
    return properties;
}

public boolean createSchema(String hostname, String username, String password, String schema, Hashtable options, String adminUsername, String adminPassword) {
    int port = 3306;
    //System.out.println("In CreateSchema");
    if (options != null && options.size() > 0 && (options.containsKey("port") || options.containsKey("PORT"))) {
        try {
            port = Integer.parseInt((String) options.get("port"));
        } catch (Exception e1) {
            try {
                port = Integer.parseInt((String) options.get("PORT"));
            } catch (Exception e2) {
            }
        }
    }
    try {
        Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException e) {
        return false;
    }
    Connection tempConn = null;
    try {
        tempConn = DriverManager.getConnection("jdbc:mysql://" + hostname + ":" + port + "/?user=" + adminUsername + "&password=" + adminPassword);
        tempConn.setAutoCommit(false);
    } catch (SQLException e) {
        return false;
    }
    Statement s;
    String sql;
    try {
        s = tempConn.createStatement();
    } catch (SQLException e) {
        return false;
    }
    try {
        sql = "CREATE DATABASE " + schema;
        s.execute(sql);
    } catch (SQLException e) {
    }
    // create the global user
    try {
        sql = "CREATE USER " + username + " IDENTIFIED BY '" + escapeString(password) + "'";
        s.execute(sql);
    } catch (SQLException e) {
    }
    // create the localhost user
    try {
        sql = "CREATE USER `" + username + "`@`localhost` IDENTIFIED BY '" + escapeString(password) + "'";
        s.execute(sql);
    } catch (SQLException e) {
    }
    // grant all to the global user
    try {
        sql = "GRANT ALL ON " + schema + ".* TO " + username;
        s.execute(sql);
    } catch (SQLException e) {
    }
    // grant all to the localhost user
    try {
        sql = "GRANT ALL ON " + schema + ".* TO `" + username + "`@`localhost`";
        s.execute(sql);
    } catch (SQLException e) {
    }
    try {
        tempConn.commit();
    } catch (SQLException e) {
        return false;
    }
    return true;
}

public ResultSet ExecuteQuery(String sql) {
    ResultSet result = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        String connectionURL = connectionString;
        Connection connection = DriverManager.getConnection(connectionURL, userName, password);
        Statement stmt = connection.createStatement();
        String mysql = sql;
        result = stmt.executeQuery(mysql);
    } catch (Exception ex) {
        Logger.getLogger(MySqlConnectionManager.class.getName()).log(Level.SEVERE, null, ex);
    }
    return result;
}

/**
     * Test of load method, of class DriverLoader.
     *
     * @throws java.sql.SQLException thrown if there is an error de-registering
     * the driver
     */
@Test
public void testLoad_String() throws SQLException {
    String className = "org.h2.Driver";
    Driver d = null;
    try {
        d = DriverLoader.load(className);
    } catch (DriverLoadException ex) {
        fail(ex.getMessage());
    } finally {
        if (d != null) {
            DriverManager.deregisterDriver(d);
        }
    }
}

@Test
public void testSql() {
    JdbcSupport support = new JdbcSupport();
    JdbcInfo info = support.new JdbcInfo("mysql", "MySQL", "com.mysql.jdbc.Driver", "jdbc:mysql://{host}/{database}", LIMIT_TYPE.LIMIT);
    assertEquals("Select * from specimen LIMIT 10", info.addLimit("Select * from specimen", 10));
    assertEquals(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true LIMIT 10", info.addLimit(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true limit 100000", 10));
    assertEquals(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true group by fake LIMIT 10", info.addLimit(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true group by fake", 10));
    assertEquals("select * from specimen union select * from observation LIMIT 10", info.addLimit("select * from specimen union select * from observation", 10));
    assertEquals("select * from specimen where country in (select country from countries where public=true) LIMIT 10", info.addLimit("select * from specimen where country in (select country from countries where public=true)", 10));
    info = support.new JdbcInfo("mysql", "MySQL", "com.mysql.jdbc.Driver", "jdbc:mysql://{host}/{database}", LIMIT_TYPE.TOP);
    assertEquals(" SELECT TOP 10 * from specimen", info.addLimit("Select * from specimen", 10));
    assertEquals(" SELECT TOP 10 * from specimen union SELECT TOP 10 * from observation", info.addLimit("select * from specimen union select * from observation", 10));
    assertEquals(" SELECT TOP 10 s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true", info.addLimit(" SELECT top 23415 s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true", 10));
    assertEquals(" SELECT TOP 10 s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true group by fake", info.addLimit(" SELECT top 100000 s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE s.public=true group by fake", 10));
    info = support.new JdbcInfo("mysql", "MySQL", "com.mysql.jdbc.Driver", "jdbc:mysql://{host}/{database}", LIMIT_TYPE.ROWNUM);
    assertEquals("Select * from specimen WHERE rownum <= 10", info.addLimit("Select * from specimen", 10));
    assertEquals("Select * from specimen WHERE rownum <= 10 AND s.public=true", info.addLimit("Select * from specimen where s.public=true", 10));
    assertEquals("Select * from specimen Where   rownum <= 10  and s.public=true group by fake", info.addLimit("Select * from specimen Where   ROWNUM<=99 and s.public=true group by fake", 10));
    assertEquals("Select * from specimen where   rownum <= 10  and s.public=true group by fake", info.addLimit("Select * from specimen where   ROWNUM <= 99 and s.public=true group by fake", 10));
    assertEquals("Select * from specimen   WHERE rownum <= 10  and s.public=true group by fake", info.addLimit("Select * from specimen   WHERE ROWNUM <=  99 and s.public=true group by fake", 10));
    assertEquals(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id WHERE rownum <= 10 AND s.public=true", info.addLimit(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id where s.public=true", 10));
    assertEquals(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id Where rownum <= 10  and s.public=true group by fake", info.addLimit(" SELECT s.id,sciname,genus,lat,lon from specimen s join location l on s.location_fk=l.id Where ROWNUM <=  10 and s.public=true group by fake", 10));
}

/**
	* @Title: testJdbc1 
	* @Description: 测试jdbc的连接 
	* @return:void   
	* @throws 
	* @author peace w_peace@163.com
	 */
@Test
public void testJdbc1() {
    //定义驱动引用 使用java.sql中的接�
    Driver driver = null;
    //连接引用 使用java.sql中的接�
    Connection conn = null;
    try {
        //实例化mysql的驱动，辞去用的是mysql中的类
        driver = new com.mysql.jdbc.Driver();
        //设置用户å??和密ç ?
        //创建属性
        Properties props = new Properties();
        //设置user的值
        props.setProperty("user", user);
        //设置密�的值
        props.setProperty("password", password);
        //2.连接数�库，返回连接对象
        //获得连接，通过url，账户，密�
        conn = driver.connect(url, props);
        //输出连接结果
        System.out.println(conn);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        //关闭连接
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
	 * Executes the passed SQL query, enforcing select only if that parameter is set Load the jdbc
	 * driver class for the database which is specified by the connectionUrl and connectionDriver
	 * parameters <br/>
	 * <br/>
	 * This is only needed when loading up a jdbc connection manually for the first time. This is
	 * not needed by most users and development practices with the openmrs API.
	 * 
	 * @param connectionUrl the connection url for the database, such as
	 *            "jdbc:mysql://localhost:3306/..."
	 * @param connectionDriver the database driver class name, such as "com.mysql.jdbc.Driver"
	 * @throws ClassNotFoundException
	 */
public static String loadDatabaseDriver(String connectionUrl, String connectionDriver) throws ClassNotFoundException {
    if (StringUtils.hasText(connectionDriver)) {
        Class.forName(connectionDriver);
        log.debug("set user defined Database driver class: " + connectionDriver);
    } else {
        if (connectionUrl.contains("mysql")) {
            Class.forName("com.mysql.jdbc.Driver");
            connectionDriver = "com.mysql.jdbc.Driver";
        } else if (connectionUrl.contains("hsqldb")) {
            Class.forName("org.hsqldb.jdbcDriver");
            connectionDriver = "org.hsqldb.jdbcDriver";
        } else if (connectionUrl.contains("postgresql")) {
            Class.forName("org.postgresql.Driver");
            connectionDriver = "org.postgresql.Driver";
        } else if (connectionUrl.contains("oracle")) {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            connectionDriver = "oracle.jdbc.driver.OracleDriver";
        } else if (connectionUrl.contains("jtds")) {
            Class.forName("net.sourceforge.jtds.jdbc.Driver");
            connectionDriver = "net.sourceforge.jtds.jdbc.Driver";
        } else if (connectionUrl.contains("sqlserver")) {
            Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
            connectionDriver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
        }
    }
    log.info("Set database driver class as " + connectionDriver);
    return connectionDriver;
}

/**
	 * Executes the passed SQL query, enforcing select only if that parameter is set Load the jdbc
	 * driver class for the database which is specified by the connectionUrl and connectionDriver
	 * parameters <br/>
	 * <br/>
	 * This is only needed when loading up a jdbc connection manually for the first time. This is
	 * not needed by most users and development practices with the openmrs API.
	 * 
	 * @param connectionUrl the connection url for the database, such as
	 *            "jdbc:mysql://localhost:3306/..."
	 * @param connectionDriver the database driver class name, such as "com.mysql.jdbc.Driver"
	 * @throws ClassNotFoundException
	 */
public static String loadDatabaseDriver(String connectionUrl, String connectionDriver) throws ClassNotFoundException {
    if (StringUtils.hasText(connectionDriver)) {
        Class.forName(connectionDriver);
        log.debug("set user defined Database driver class: " + connectionDriver);
    } else {
        if (connectionUrl.contains("mysql")) {
            Class.forName("com.mysql.jdbc.Driver");
            connectionDriver = "com.mysql.jdbc.Driver";
        } else if (connectionUrl.contains("hsqldb")) {
            Class.forName("org.hsqldb.jdbcDriver");
            connectionDriver = "org.hsqldb.jdbcDriver";
        } else if (connectionUrl.contains("postgresql")) {
            Class.forName("org.postgresql.Driver");
            connectionDriver = "org.postgresql.Driver";
        } else if (connectionUrl.contains("oracle")) {
            Class.forName("oracle.jdbc.driver.OracleDriver");
            connectionDriver = "oracle.jdbc.driver.OracleDriver";
        } else if (connectionUrl.contains("jtds")) {
            Class.forName("net.sourceforge.jtds.jdbc.Driver");
            connectionDriver = "net.sourceforge.jtds.jdbc.Driver";
        } else if (connectionUrl.contains("sqlserver")) {
            Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
            connectionDriver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
        }
    }
    log.info("Set database driver class as " + connectionDriver);
    return connectionDriver;
}

public static final void first() throws JAXBException {
    JAXBContext context = JAXBContext.newInstance(DBList.class);
    Marshaller mar = context.createMarshaller();
    DBList list = new DBList();
    ArrayList<DBConf> dbs = new ArrayList<DBConf>();
    DBConf db = new DBConf("Mysql", "org.hibernate.dialect.MySQLDialect", "com.mysql.jdbc.Driver", "username", "password", "jdbc:mysql://<host>/<database name>");
    dbs.add(db);
    db = new DBConf("Mysql5InnoDB - Bits are converted to Integers", "hjb4u.database.NoBitsMySQL5InnoDBDialect", "com.mysql.jdbc.Driver", "username", "password", "jdbc:mysql://<host>/<database name>");
    dbs.add(db);
    list.setDbs(dbs);
    mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    mar.marshal(list, System.out);
}

private java.sql.Connection getConnection() throws Exception {
    if (masterServer == null)
        masterServer = "localhost";
    Class driverClass = Class.forName("com.mysql.jdbc.Driver");
    this.jdbcMasterConnection = DriverManager.getConnection("jdbc:mysql://" + masterServer + "/" + dbRelease, dbUser, dbPassword);
    return jdbcMasterConnection;
}

public String driver() {
    Properties p = config.getProperties("mtwilson.db.protocol", "mtwilson.db.driver", "mtwilson.db.port");
    String protocol = p.getProperty("mtwilson.db.protocol", "");
    String driver = p.getProperty("mtwilson.db.driver", "");
    String port = p.getProperty("mtwilson.db.port", "");
    if (driver.isEmpty() && !protocol.isEmpty()) {
        if (protocol.contains("postgresql")) {
            driver = "org.postgresql.Driver";
        }
        if (protocol.contains("mysql")) {
            driver = "com.mysql.jdbc.Driver";
        }
    }
    if (driver.isEmpty() && !port.isEmpty()) {
        if (port.equals("5432")) {
            driver = "org.postgresql.Driver";
        }
        if (port.equals("3306")) {
            driver = "com.mysql.jdbc.Driver";
        }
    }
    return driver;
}

public static void main(String[] args) throws SQLException, ClassNotFoundException {
    //¹Ì¶¨Ð´·¨£ºÐ­Òé+Ö÷»ú+¶Ë¿ÚºÅ(Ö¸¶¨ÄĸöÊý¾Ý¿â£¬ÕâÀïÊÇ3306mysqlÓ¦ÓóÌÐò)+ʹÓõÄÊý¾Ý¿âÃû
    String url = "jdbc:mysql://localhost:3306/jdbc_demo";
    String username = "root";
    String password = "root";
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    try {
        //1,DriverManager.registerDriver(new com.mysql.jdbc.Driver());·½·¨²¢²»½¨ÒéʹÓã¬Õâ»áµ¼ÖÂmysqlÇý¶¯»á±»¼ÓÔØÁ½´Î
        //ʹÓÃÕâÖÖ·½·¨²»»áÔì³ÉmysqlÇý¶¯±»¼ÓÔØÁ½´Î£¬¶øÇÒÖ»ÐèÒªÖªµÀÒ»¸öÇý¶¯×Ö·û´®£¬¾Í¿ÉÒÔ±£Ö¤Çý¶¯ÀàÖ»¼ÓÔØÒ»´Î
        Class.forName("com.mysql.jdbc.Driver");
        //2,»ñµÃÊý¾Ý¿âµÄÁ´½Óµ¼Èëimport java.sql.Connection;°ü
        //ÊÔͼ½¨Á¢µ½¸ø¶¨Êý¾Ý¿âurlµÄÁ´½Ó
        conn = DriverManager.getConnection(url, username, password);
        //3£¬Á´½ÓÉÏÊý¾Ý¿âÖ®ºó£¬´´½¨ÏòÊý¾Ý¿â·¢ËÍsqlÓï¾äµÄstatementµÄ¶ÔÏó
        st = conn.createStatement();
        //4£¬ÏòÊý¾Ý¿â·¢ËÍsqlÓï¾ä£¬»ñÈ¡Êý¾Ý¿â·µ»ØµÄ½á¹û¼¯
        rs = st.executeQuery("select * from users");
        //5£¬´Ó½á¹û¼¯ÖлñµÃÊý¾Ý
        while (//³õʼµÄnextº¬ÒåÊǽ«Óαê´Ó±íÍ·Òƶ¯µ½µÚÒ»Ìõ¼Ç¼ÐÐÉÏ£¬Èç¹û¸ÃÐÐÓмǼ·µ»Øtrue,·ñÔò·µ»Øfalse
        rs.next()) {
            //½«´ÓÊý¾Ý¿âÖлñµÃÊý¾Ý·â×°µ½Ò»¸öbeanÖÐ
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            user.setPassword(rs.getString("password"));
            user.setEmail(rs.getString("email"));
            user.setBirthday(rs.getDate("birthday"));
            System.out.println("id=" + rs.getObject("id"));
            System.out.println("name=" + rs.getObject("name"));
            System.out.println("email=" + rs.getObject("password"));
            System.out.println("email=" + rs.getObject("email"));
            System.out.println("birthday=" + rs.getObject("birthday"));
            System.out.println("-------------------------------------");
        }
    } finally {
        //6£¬ÊÍ·Å×ÊÔ´£¬Ö÷ÒªÊÇ·ÅÁ´½Ó,°ÑÁ´½Ó»¹¸øÊý¾Ý¿â
        if (rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if (st != null) {
            try {
                st.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            st = null;
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}

@BeforeClass
public static void config() {
    Bootstrap b = new Bootstrap("com.mysql.jdbc.Driver", "jdbc:mysql:localhost/opensocial", "opensocial", "opensocial", "1", "1");
    // Bootstrap b = new
    // Bootstrap("com.mysql.jdbc.Driver",
    // "jdbc:mysql://localhost/sakaikernel?useUnicode=true&characterEncoding=UTF-8",
    // "sakaikernel","sakaikernel","1","1");
    entityManager = b.getEntityManager("hibernate");
}

/**
     * Opens a Connection to the database
     * 
     * @return the database connection
     * @throws SQLException if a database access error occurs or this method is called on a closed Statement
     */
@Override
public Connection openConnection() throws SQLException {
    con = null;
    // Get an instance of the database driver
    try {
        Logger.getLogger("at.tuwien.ifs.somtoolbox").info("Loading JDBC driver....");
        Class.forName("com.mysql.jdbc.Driver");
        Logger.getLogger("at.tuwien.ifs.somtoolbox").info("done!");
        // driver found - proceed
        String connectionString = "jdbc:mysql://" + databaseUrl + ":3306/" + databaseName + "?user=" + user;
        String connectionStringDBServer = "jdbc:mysql://" + databaseUrl + ":3306/" + "?user=" + user;
        if (password != null && !password.equals("")) {
            connectionString += "&password=" + password;
            connectionStringDBServer += "&password=" + password;
        }
        // create database if needed
        Logger.getLogger("at.tuwien.ifs.somtoolbox").info("Opening connection to " + connectionStringDBServer);
        con = DriverManager.getConnection(connectionStringDBServer);
        con.createStatement().execute("CREATE DATABASE IF NOT EXISTS " + databaseName);
        Logger.getLogger("at.tuwien.ifs.somtoolbox").info("Opening connection to " + connectionString);
        con = DriverManager.getConnection(connectionString);
        Logger.getLogger("at.tuwien.ifs.somtoolbox").info("Opened connection.");
        return con;
    } catch (// If no driver is found - terminate
    ClassNotFoundException // If no driver is found - terminate
    e) {
        Logger.getLogger("at.tuwien.ifs.somtoolbox").severe("Unable to find appropriate MySQL database driver 'com.mysql.jdbc.Driver'. Aborting.");
        e.printStackTrace();
        throw new SQLException(e);
    }
}

public static void main(String[] args) {
    String geoNameUsername = "x";
    TimeZoneGetter tzGetter = new CompositeTimeZoneGetter(new CachingTimeZoneGetter(new GeoNameTimeZoneGetter(geoNameUsername)), new StupidTimeZoneGetter());
    String pass = PASS;
    if (args.length == 1) {
        pass = args[0];
    }
    Connection conn = null;
    try {
        // STEP 2: Register JDBC driver
        Class.forName("com.mysql.jdbc.Driver");
        // STEP 3: Open a connection
        conn = DriverManager.getConnection(DB_URL, USER, pass);
        String sql = "select * from events";
        PreparedStatement pstmt = conn.prepareStatement(sql);
        PreparedStatement pstmt2 = conn.prepareStatement("select * from images where event_id=? limit 1");
        ResultSet rs = pstmt.executeQuery();
        DateTimeFormatter ferMatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.S Z");
        while (rs.next()) {
            Long id = rs.getLong("id");
            String ts = rs.getString("event_start_time");
            ts = ts + " -0000";
            DateTime whenDT = ferMatter.parseDateTime(ts);
            //				Date start = rs.getTimestamp("event_start_time");
            //				DateTime whenDT = new DateTime(start);
            pstmt2.setLong(1, id);
            DateTime dsTimeChange = new DateTime(2014, 3, 9, 5, 0);
            ResultSet rs2 = pstmt2.executeQuery();
            if (rs2.next()) {
                double lat = rs2.getDouble("lat");
                double lon = rs2.getDouble("lon");
                // convert whenDT to LOCAL time...
                DateTime localTZWhen = whenDT;
                DateTimeZone zone = localTZWhen.getZone();
                DateTimeZone utcZone = DateTimeZone.forID("Etc/UTC");
                if (zone.equals(utcZone)) {
                    if (whenDT.isAfter(dsTimeChange)) {
                        localTZWhen = whenDT.minusHours(7);
                    } else {
                        localTZWhen = whenDT.minusHours(8);
                    }
                }
                TypeOfDay x = HibernateDataStore.makeTimeOfDay(localTZWhen, lat, lon, tzGetter, log);
                update(conn, id, x);
                System.out.println(ts + " is " + x);
            }
        //				TypeOfDay tod = ds.dayNightTwilight(ie, ie.getImageRecords()
        //						.first());
        //				System.out.println("New TOD for " + ie + "  is  " + tod);
        //				ie.setTypeOfDay(tod);
        }
    } catch (SQLExceptionClassNotFoundException |  e) {
        System.out.println("oops could not do something " + e.getMessage());
    }
}

@Test
public void shouldReportURLIfCannotConnect() {
    replaceError();
    try {
        Base.open("com.mysql.jdbc.Driver", "jdbc:mysql://doesnotexist/", "root", "blah");
    } catch (Exception e) {
        e.printStackTrace();
    }
    a(getSystemErr()).shouldContain("Failed to connect to JDBC URL: jdbc:mysql://doesnotexist/");
    restoreSystemErr();
}

@Override
public void initConfig(Section database) {
    boolean hasUrl = Strings.emptyToNull(database.get("url")) != null;
    database.string("URL", "url", null);
    guessDriver(database);
    database.string("Driver class name", "driver", null);
    database.string("Database username", "username", hasUrl ? null : username());
    database.password("username", "password");
}

public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
    res.setContentType("text/plain");
    String url = null;
    try {
        if (SystemProperty.environment.value() == SystemProperty.Environment.Value.Production) {
            // Load the class that provides the new "jdbc:google:mysql://" prefix.
            Class.forName("com.mysql.jdbc.GoogleDriver");
            url = System.getProperty("cloudsql.url");
        } else {
            Class.forName("com.mysql.jdbc.Driver");
            url = System.getProperty("cloudsql.url.dev");
        }
    } catch (Exception e) {
        e.printStackTrace();
        return;
    }
    try {
        Connection conn = DriverManager.getConnection(url);
        try {
            Statement st = conn.createStatement();
            ResultSet rs = st.executeQuery("SHOW DATABASES");
            while (rs.next()) {
                res.getWriter().println(rs.getString(1));
            }
            res.getWriter().println("-- done --");
        } finally {
            conn.close();
        }
    } catch (SQLException e) {
        res.getWriter().println("SQLException: " + e.getMessage());
    }
}

@Before
public void setUp() throws Exception {
    ServerConfig serverConfig = getServerConfig();
    DataSourceConfig dataSourceConfig = serverConfig.getDataSourceConfig();
    dataSourceConfig.setUrl("jdbc:mysql://127.0.0.1:3306/test");
    dataSourceConfig.setPassword("");
    dataSourceConfig.setUsername("travis");
    dataSourceConfig.setDriver("com.mysql.jdbc.Driver");
    dataSourceConfig.setIsolationLevel(8);
    setDatabaseLoader(serverConfig);
}

private static Connection getConnection() {
    try {
        Class.forName("com.mysql.jdbc.Driver").newInstance();
    } catch (Exception ex) {
        System.out.println(ex);
        System.exit(0);
    }
    try {
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost/exemplo?user=root&password=root");
        return con;
    } catch (SQLException ex) {
        System.out.println("SQLException: " + ex.getMessage());
        System.out.println("SQLState: " + ex.getSQLState());
        System.out.println("VendorError: " + ex.getErrorCode());
        System.exit(0);
    }
    return null;
}

/**
     * @param args
     */
public static void main(String[] args) {
    try {
        BasicDataSource ds = new BasicDataSource();
        ds.setUsername("test");
        ds.setPassword("");
        ds.setUrl("jdbc:mysql://10.20.153.178:9066/");
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setMaxActive(-1);
        ds.setMinIdle(0);
        ds.setTimeBetweenEvictionRunsMillis(600000);
        ds.setNumTestsPerEvictionRun(Integer.MAX_VALUE);
        ds.setMinEvictableIdleTimeMillis(GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
        Connection conn = ds.getConnection();
        Statement stm = conn.createStatement();
        stm.execute("show @@version");
        ResultSet rst = stm.getResultSet();
        rst.next();
        String version = rst.getString("VERSION");
        System.out.println(version);
    } catch (Exception exception) {
        System.out.println("10.20.153.178:9066   " + exception.getMessage() + exception);
    }
}

@Override
public String getConnectionString() throws SQLException {
    try {
        Class.forName(com.mysql.jdbc.Driver.class.getName());
    } catch (ClassNotFoundException ex) {
        throw new SQLException("Cannot load MySQL. Check your installation and try again");
    }
    try {
        return "jdbc:mysql://" + host + ":" + port + "/" + database + "?generateSimpleParameterMetadata=true" + "&jdbcCompliantTruncation=false" + (username == null ? "" : "&user=" + URLEncoder.encode(username, "UTF-8")) + (password == null ? "" : "&password=" + URLEncoder.encode(password, "UTF-8"));
    } catch (UnsupportedEncodingException ex) {
        throw new Error();
    }
}

public static ResultSet executeSQL(String dbServ, String db, String sql) {
    String driver = "com.mysql.jdbc.Driver";
    String url = dbServ + db;
    String user = "oihadmin";
    String password = "";
    try {
        Class.forName(driver);
        Connection conn = DriverManager.getConnection(url, user, password);
        if (!conn.isClosed())
            System.out.println("Succeeded connecting to the Database!");
        Statement statement = conn.createStatement();
        ResultSet rs = statement.executeQuery(sql);
        return rs;
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return null;
}