PreparedStatement 输出SQL语句

最新推荐文章于 2023-08-25 11:24:19 发布
最新推荐文章于 2023-08-25 11:24:19 发布
阅读量1.3k 收藏 3
点赞数
文章标签： sql java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingwin28/article/details/129014291
版权
该代码示例展示了一个Java程序，它使用PreparedStatement与Hive数据库建立连接并执行SQL查询。特别是，它创建了一个LoggableStatement类来包装预编译的SQL语句，以便在执行时保存参数值并生成完整可读的SQL日志。程序还包含了错误处理和资源关闭的逻辑。
摘要由CSDN通过智能技术生成

调用

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Connection con = null;
		PreparedStatement pStmt = null;
		ResultSet res = null;  
        try {
			con =  DriverManager.getConnection("jdbc:hive2://192.168.30.45:10000", "root", "");
	        String sql = "show tables"; // 查询表
	        sql = "select * from IT_BI_PRD_EIS.TE_PM_DASHBD_INST order by Refresh_Ts desc"; // 实际
//	        
	        String sqlInsert =  "INSERT INTO IT_BI_PRD_EIS.TE_PM_DASHBD_INST_BGT"
										 + " VALUES(?,?,?,'2099-12-31','MONTH','SUM','0','1','','HKD','BUDGET',?,'FIN_BGT',?,?,?)";
									 
									 int columnIndex = cell.getColumnIndex();
//									 pStmt = con.prepareStatement( sqlInsert2 );
									pStmt = new LoggableStatement(con, sqlInsert); 
									 System.out.println(cellIndex + ",mmmss-------" + sqlInsert2);
									 pStmt.setString(1, cellID );
									 pStmt.setString(2, cellID+"."+cellYear +"M"+ (columnIndex<10?("0"+columnIndex):columnIndex) );
									 pStmt.setString(3, cellYear+"-01-01" );
									 pStmt.setDouble(4, cell.getNumericCellValue() );
									 pStmt.setString(5, date1 );
									 pStmt.setString(6, date1 );
									 pStmt.setString(7, date0 );
									 
									 System.out.println("目标------- SQL:　"+((LoggableStatement)pStmt).getQueryString());
									 int i = pStmt.executeUpdate();

		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
            if (pStmt != null) {
                try {
                	pStmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                pStmt = null;
            }
            if (con != null) {
                try {
                    con.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                con = null;
            }
        }
        
	}

------ 工具类 ------

package com.xxx.xxxHiveHelper.util;

import java.io.InputStream;    
import java.io.Reader;    
import java.math.BigDecimal;    
import java.net.URL;    
import java.sql.Array;    
import java.sql.Blob;    
import java.sql.Clob;    
import java.sql.Connection;    
import java.sql.Date;    
import java.sql.NClob;  
import java.sql.ParameterMetaData;    
import java.sql.PreparedStatement;    
import java.sql.Ref;    
import java.sql.ResultSet;    
import java.sql.ResultSetMetaData;    
import java.sql.RowId;  
import java.sql.SQLException;    
import java.sql.SQLWarning;    
import java.sql.SQLXML;  
import java.sql.Time;    
import java.sql.Timestamp;    
import java.util.ArrayList;    
import java.util.Calendar;        
 
public class LoggableStatement implements PreparedStatement {    
    
    /** used for storing parameter values needed for producing log */    
    private ArrayList parameterValues;    
    
    /** the query string with question marks as parameter placeholders */    
    private String sqlTemplate;    
    
    /** a statement created from a real database connection */    
    private PreparedStatement wrappedStatement;    
    
    public LoggableStatement(Connection connection, String sql)    
            throws SQLException {    
        // use connection to make a prepared statement    
        wrappedStatement = connection.prepareStatement(sql);    
        sqlTemplate = sql;    
        parameterValues = new ArrayList();    
    }    
    
    private void saveQueryParamValue(int position, Object obj) {    
        String strValue;    
        if (obj instanceof String || obj instanceof Date) {    
            // if we have a String, include '' in the saved value    
            strValue = "'" + obj + "'";    
        } else {    
            if (obj == null) {    
                // convert null to the string null    
                strValue = "null";    
            } else {    
                // unknown object (includes all Numbers), just call toString    
                strValue = obj.toString();    
            }    
        }    
        // if we are setting a position larger than current size of    
        // parameterValues, first make it larger    
        while (position >= parameterValues.size()) {    
    
            parameterValues.add(null);    
        }    
        // save the parameter    
        parameterValues.set(position, strValue);    
    }    
    
    // 这一步是对ArrayList与sql进行处理，输出完整的sql语句    
    public String getQueryString() {    
        int len = sqlTemplate.length();    
        StringBuffer t = new StringBuffer(len * 2);    
    
        if (parameterValues != null) {    
            int i = 1, limit = 0, base = 0;    
    
            while ((limit = sqlTemplate.indexOf('?', limit)) != -1) {    
                t.append(sqlTemplate.substring(base, limit));    
                t.append(parameterValues.get(i));    
                i++;    
                limit++;    
                base = limit;    
            }    
            if (base < len) {    
                t.append(sqlTemplate.substring(base));    
            }    
        }    
        return t.toString();    
    }    
    
    public void addBatch() throws SQLException {    
        wrappedStatement.addBatch();    
    }    
    
    public void clearParameters() throws SQLException {    
        wrappedStatement.clearParameters();    
    }    
    
    public boolean execute() throws SQLException {    
        return wrappedStatement.execute();    
    }    
    
    public ResultSet executeQuery() throws SQLException {    
        return wrappedStatement.executeQuery();    
    }    
    
    public int executeUpdate() throws SQLException {    
        return wrappedStatement.executeUpdate();    
    }    
    
    public ResultSetMetaData getMetaData() throws SQLException {    
        return wrappedStatement.getMetaData();    
    }    
    
    public ParameterMetaData getParameterMetaData() throws SQLException {    
        return wrappedStatement.getParameterMetaData();    
    }    
    
    public void setArray(int i, Array x) throws SQLException {    
        wrappedStatement.setArray(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setAsciiStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setAsciiStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBigDecimal(int parameterIndex, BigDecimal x)    
            throws SQLException {    
        wrappedStatement.setBigDecimal(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBinaryStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setBinaryStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setBlob(int i, Blob x) throws SQLException {    
        wrappedStatement.setBlob(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setBoolean(int parameterIndex, boolean x) throws SQLException {    
        wrappedStatement.setBoolean(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Boolean(x));    
    }    
    
    public void setByte(int parameterIndex, byte x) throws SQLException {    
        wrappedStatement.setByte(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Byte(x));    
    }    
    
    public void setBytes(int parameterIndex, byte[] x) throws SQLException {    
        wrappedStatement.setBytes(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setCharacterStream(int parameterIndex, Reader reader, int length)    
            throws SQLException {    
        wrappedStatement.setCharacterStream(parameterIndex, reader, length);    
        saveQueryParamValue(parameterIndex, reader);    
    }    
    
    public void setClob(int i, Clob x) throws SQLException {    
        wrappedStatement.setClob(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setDate(int parameterIndex, Date x) throws SQLException {    
        wrappedStatement.setDate(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setDate(int parameterIndex, Date x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setDate(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setDouble(int parameterIndex, double x) throws SQLException {    
        wrappedStatement.setDouble(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Double(x));    
    }    
    
    public void setFloat(int parameterIndex, float x) throws SQLException {    
        wrappedStatement.setFloat(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Float(x));    
    }    
    
    public void setInt(int parameterIndex, int x) throws SQLException {    
        wrappedStatement.setInt(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Integer(x));    
    }    
    
    public void setLong(int parameterIndex, long x) throws SQLException {    
        wrappedStatement.setLong(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Long(x));    
    }    
    
    public void setNull(int parameterIndex, int sqlType) throws SQLException {    
        wrappedStatement.setNull(parameterIndex, sqlType);    
        saveQueryParamValue(parameterIndex, new Integer(sqlType));    
    }    
    
    public void setNull(int paramIndex, int sqlType, String typeName)    
            throws SQLException {    
        wrappedStatement.setNull(paramIndex, sqlType, typeName);    
        saveQueryParamValue(paramIndex, new Integer(sqlType));    
    }    
    
    public void setObject(int parameterIndex, Object x) throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setObject(int parameterIndex, Object x, int targetSqlType)    
            throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x, targetSqlType);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setObject(int parameterIndex, Object x, int targetSqlType,    
            int scale) throws SQLException {    
        wrappedStatement.setObject(parameterIndex, x, targetSqlType, scale);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setRef(int i, Ref x) throws SQLException {    
        wrappedStatement.setRef(i, x);    
        saveQueryParamValue(i, x);    
    }    
    
    public void setShort(int parameterIndex, short x) throws SQLException {    
        wrappedStatement.setShort(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, new Short(x));    
    }    
    
    public void setString(int parameterIndex, String x) throws SQLException {    
        wrappedStatement.setString(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTime(int parameterIndex, Time x) throws SQLException {    
        wrappedStatement.setTime(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTime(int parameterIndex, Time x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setTime(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTimestamp(int parameterIndex, Timestamp x)    
            throws SQLException {    
        wrappedStatement.setTimestamp(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)    
            throws SQLException {    
        wrappedStatement.setTimestamp(parameterIndex, x, cal);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setURL(int parameterIndex, URL x) throws SQLException {    
        wrappedStatement.setURL(parameterIndex, x);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void setUnicodeStream(int parameterIndex, InputStream x, int length)    
            throws SQLException {    
        wrappedStatement.setUnicodeStream(parameterIndex, x, length);    
        saveQueryParamValue(parameterIndex, x);    
    }    
    
    public void addBatch(String sql) throws SQLException {    
        wrappedStatement.addBatch(sql);    
    }    
    
    public void cancel() throws SQLException {    
        wrappedStatement.cancel();    
    }    
    
    public void clearBatch() throws SQLException {    
        wrappedStatement.clearBatch();    
    }    
    
    public void clearWarnings() throws SQLException {    
        wrappedStatement.clearWarnings();    
    }    
    
    public void close() throws SQLException {    
        wrappedStatement.close();    
    }    
    
    public boolean execute(String sql) throws SQLException {    
        return wrappedStatement.execute(sql);    
    }    
    
    public boolean execute(String sql, int autoGeneratedKeys)    
            throws SQLException {    
        return wrappedStatement.execute(sql, autoGeneratedKeys);    
    }    
    
    public boolean execute(String sql, int[] columnIndexes) throws SQLException {    
        return wrappedStatement.execute(sql, columnIndexes);    
    }    
    
    public boolean execute(String sql, String[] columnNames)    
            throws SQLException {    
        return wrappedStatement.execute(sql, columnNames);    
    }    
    
    public int[] executeBatch() throws SQLException {    
        return wrappedStatement.executeBatch();    
    }    
    
    public ResultSet executeQuery(String sql) throws SQLException {    
        return wrappedStatement.executeQuery(sql);    
    }    
    
    public int executeUpdate(String sql) throws SQLException {    
        return wrappedStatement.executeUpdate(sql);    
    }    
    
    public int executeUpdate(String sql, int autoGeneratedKeys)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, autoGeneratedKeys);    
    }    
    
    public int executeUpdate(String sql, int[] columnIndexes)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, columnIndexes);    
    }    
    
    public int executeUpdate(String sql, String[] columnNames)    
            throws SQLException {    
        return wrappedStatement.executeUpdate(sql, columnNames);    
    }    
    
    public Connection getConnection() throws SQLException {    
        return wrappedStatement.getConnection();    
    }    
    
    public int getFetchDirection() throws SQLException {    
        return wrappedStatement.getFetchDirection();    
    }    
    
    public int getFetchSize() throws SQLException {    
        return wrappedStatement.getFetchSize();    
    }    
    
    public ResultSet getGeneratedKeys() throws SQLException {    
        return wrappedStatement.getGeneratedKeys();    
    }    
    
    public int getMaxFieldSize() throws SQLException {    
        return wrappedStatement.getMaxFieldSize();    
    }    
    
    public int getMaxRows() throws SQLException {    
        return wrappedStatement.getMaxRows();    
    }    
    
    public boolean getMoreResults() throws SQLException {    
        return wrappedStatement.getMoreResults();    
    }    
    
    public boolean getMoreResults(int current) throws SQLException {    
        return wrappedStatement.getMoreResults(current);    
    }    
    
    public int getQueryTimeout() throws SQLException {    
        return wrappedStatement.getQueryTimeout();    
    }    
    
    public ResultSet getResultSet() throws SQLException {    
        return wrappedStatement.getResultSet();    
    }    
    
    public int getResultSetConcurrency() throws SQLException {    
        return wrappedStatement.getResultSetConcurrency();    
    }    
    
    public int getResultSetHoldability() throws SQLException {    
        return wrappedStatement.getResultSetHoldability();    
    }    
    
    public int getResultSetType() throws SQLException {    
        return wrappedStatement.getResultSetType();    
    }    
    
    public int getUpdateCount() throws SQLException {    
        return wrappedStatement.getUpdateCount();    
    }    
    
    public SQLWarning getWarnings() throws SQLException {    
        return wrappedStatement.getWarnings();    
    }    
    
    public void setCursorName(String name) throws SQLException {    
        wrappedStatement.setCursorName(name);    
    }    
    
    public void setEscapeProcessing(boolean enable) throws SQLException {    
        wrappedStatement.setEscapeProcessing(enable);    
    }    
    
    public void setFetchDirection(int direction) throws SQLException {    
        wrappedStatement.setFetchDirection(direction);    
    }    
    
    public void setFetchSize(int rows) throws SQLException {    
        wrappedStatement.setFetchSize(rows);    
    }    
    
    public void setMaxFieldSize(int max) throws SQLException {    
        wrappedStatement.setMaxFieldSize(max);    
    }    
    
    public void setMaxRows(int max) throws SQLException {    
        wrappedStatement.setMaxFieldSize(max);    
    }    
    
    public void setQueryTimeout(int seconds) throws SQLException {    
        wrappedStatement.setQueryTimeout(seconds);    
    }  
  
    public void setAsciiStream(int parameterIndex, InputStream x)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setAsciiStream(int parameterIndex, InputStream x, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBinaryStream(int parameterIndex, InputStream x)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBinaryStream(int parameterIndex, InputStream x, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBlob(int parameterIndex, InputStream inputStream)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setBlob(int parameterIndex, InputStream inputStream, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setCharacterStream(int parameterIndex, Reader reader)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setCharacterStream(int parameterIndex, Reader reader,  
            long length) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setClob(int parameterIndex, Reader reader) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setClob(int parameterIndex, Reader reader, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNCharacterStream(int parameterIndex, Reader value)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNCharacterStream(int parameterIndex, Reader value,  
            long length) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, NClob value) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, Reader reader) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNClob(int parameterIndex, Reader reader, long length)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setNString(int parameterIndex, String value)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setRowId(int parameterIndex, RowId x) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public void setSQLXML(int parameterIndex, SQLXML xmlObject)  
            throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public boolean isClosed() throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public boolean isPoolable() throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public void setPoolable(boolean poolable) throws SQLException {  
        // TODO Auto-generated method stub  
          
    }  
  
    public boolean isWrapperFor(Class<?> iface) throws SQLException {  
        // TODO Auto-generated method stub  
        return false;  
    }  
  
    public <T> T unwrap(Class<T> iface) throws SQLException {  
        // TODO Auto-generated method stub  
        return null;  
    }

	@Override
	public void closeOnCompletion() throws SQLException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public boolean isCloseOnCompletion() throws SQLException {
		// TODO Auto-generated method stub
		return false;
	}    
}
KingFu28
关注
【JDBC】PreparedStatement执行动态sql语句对象（预编译）
Need not to know
11-30 1140
PreparedStatement执行动态（预编译）sql语句对象   功能：   1.防止sql注入问题 SELECT * FROM 表名 WHERE username = '江河' AND password = 'Foriver' OR 'a' = 'a' - 这里由于添加了OR 'a' = 'a'，使得WHERE表达式的结果恒为true，所以会查询出表中所有的数据，造成安全性问题   2.效率更高（※后期使用PreparedStateme
怎样在控制台或者日志打印输出JDBC执行的sql语句
hu1991die的专栏
03-13 2万+
今天用jdbc preparestatement 写sql语句查询，但是在执行的过程中实际查询出的结果和预期的结果不一致，然后就在想有什么办法能够在控制台或者Log4j日志输出最终执行的SQL语句，以便于调试。如果是hibernate可以通过配置show_sql 为 true 在控制台显示执行的SQL，因为使用的是纯JDBC的写法，然后自己在程序中直接通过System.out.println(sql
如何获得PreparedStatement最终执行的sql语句
03-24
NULL 博文链接：https://huiminchen.iteye.com/blog/1097332
利用JDBC的PrepareStatement打印真实SQL的方法详解
08-29
PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程，下面这篇文章主要给大家介绍了关于利用JDBC的PrepareStatement打印真实SQL的方法，需要的朋友可以参考借鉴，下面来一起看看吧。
使用PreparedStatement时，输出完整的SQL语句
热门推荐
张航的博客
11-03 3万+
使用psstmt时不能打印出完整的sql语句，挺不方便的，找到一个实现方法，记录下来。 package com.zhh.function.util; import java.io.InputStream; import java.io.Reader; import java.math.BigDecimal; import java.net.URL; import java.sq
preparestatment获取sql_java sql: PrepareStatement详解
weixin_42355744的博客
01-28 558
public classDbUtil {public static final String URL = "jdbc:mysql://localhost:3306/imooc";public static final String USER = "liulx";public static final String PASSWORD = "123456";private static Connect...
preparestatment获取sql_使用PreparedStatement时，输出完整的SQL语句
weixin_39702799的博客
12-19 1268
packagecom.zhh.function.util;importjava.io.InputStream;importjava.io.Reader;importjava.math.BigDecimal;importjava.net.URL;importjava.sql.Array;importjava.sql.Blob;importjava.sql.Clob;importja...
基于PreparedStatement抓取带参最终SQL（oracle，mysql，PostgreSQL等通用）
大吉的博客
08-25 2560
在日志中打印所有数据库通用的不带？的原生SQL，放在navicat就能直接执行
PreparedStatement 输出 sql
韩世雷 程序员专栏
09-21 7815
ps = conn.prepareStatement(sql); ((JDBC4PreparedStatement)ps).asSql()或String pstext = ps.toString(); sql.append( pstext.substring(pstext.indexOf(": ")+2) );
sql语句中用问号代替参数
08-02
在SQL语句中，使用问号（`?`）作为参数占位符是一种常见的做法，尤其是在编程语言如Java中与数据库交互时。这种方式被称为预编译语句或参数化查询，它具有重要的安全性和性能优势。 ### SQL参数化查询的概念 参数化...
preparestatment获取sql_如何从Oracle, MySql, PostgreSQL的PreparedStatement获得所执行的sql语句？...
weixin_39630771的博客
12-19 1757
一、问题提出从且只从一个PreparedStatement中获取执行的sql语句(包括运行时绑定的参数值)，是实际工作中经常遇到的一个问题。网上很多文章提到用自定义的增强类或中间件(p6spy, log4jdbc)来实现，但这需要对现有代码进行修改，工作量很大，能不能有更直接的办法？由于java.sql.PreparedStatement并没有提供相应接口，此功能是否实现及如何实现，不同数据库的J...
MySQL中PreparedStatement 获得SQL语句的方法
frivol的专栏
01-21 1630
关于PreparedStatement 获得SQL语句的方法，没有直接的API可用，往往要自己实现或采用SQL profiler之类的工具，但在MySQL中有一个简便的方法： if (statement instanceof com.mysql.jdbc.PreparedStatement) { com.mysql.jdbc.PreparedState
jdbc使用PreparedStatement调用SQL语句
weixin_53387031的博客
01-10 1174
使用PreparedStatement调用SQL语句，实现对数据库的增删改查 最基本的更新数据库的一条操作：（jdbc.properties为配置文件，包含4个参数，移植性好） package preparedstatement.curd; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement;
扩展PreparedStatement,以便输出执行的sql语句,即sql日志
天乙贵人
06-22 3410
<br />package com.boco.eoms.stat.dao; import java.io.InputStream; import java.io.Reader; import java.math.BigDecimal; import java.net.URL; import java.sql.Array; import java.sql.Blob; import java.sql.Clob; import java.sql.Connection; import java
关于PreparedStatement你知道多少
LeBlock的博客
07-21 897
序言  对应PreparedStatement相信大家都很熟悉，那么为什么要用PreparedStatement呢？也许你会回答PreparedStatement为预处理语句，可以提高数据库执行效率。也许还会回答用PreparedStatement可以防止SQL注入。那么再问下，你觉得你对PreparedStatement有足够的了解吗，你在项目中PreparedStatement用对了
preparestatment获取sql_如何获取PreparedStatement的SQL？
weixin_39603117的博客
12-19 2517
它在JDBC API合同中没有任何定义，但是如果你很幸运，有问题的JDBC驱动程序可以通过调用返回完整的SQLPreparedStatement#toString()。即System.out.println(preparedStatement);至少MySQL 5.x和PostgreSQL 8.x JDBC驱动程序支持它。但是，大多数其他JDBC驱动程序不支持它。如果你有这样的，那么你最好的选择...
得到PrepareStatement最终执行的sql语句的方法
06-02 1万+
得到PrepareStatement最终执行的sql语句的方法   在CSDN的JAVA基础版,常常有人问及如何得到PreparedStatement最终执行的SQL语句;或者如何在控制台输出占位符的真实值..... 原因就是PreparedStatement执行的sql语句有大量的占位符?.... 问题诸如JDBC中: 如何得到 conn.prepareSta
preparestatment获取sql_利用JDBC的PrepareStatement打印真实SQL的方法详解
weixin_39716971的博客
12-19 982
前言本文主要给大家介绍了关于利用JDBC的PrepareStatement打印真实SQL的相关内容，分享出来供大家参考学习，下面来一起看看详细的介绍：我们知道，JDBC 的 PrepareStatement 优点多多，通常都是推荐使用 PrepareStatement 而不是其基类 Statment。PrepareStatement 支持 ? 占位符，可以将参数按照类型转自动换为真实的值。既然这一...
使用statement和preparedStatement执行sql语句的代码示例
最新发布
03-25
以下是使用Statement和PreparedStatement执行SQL语句的代码示例： 1. 使用Statement执行SQL语句[^1]： ```java import java.sql.*; public class StatementExample { public static void main(String[] args) { try { // 建立数据库连接 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password"); // 创建Statement对象 Statement stmt = conn.createStatement(); // 执行SQL查询语句 String sql = "SELECT * FROM mytable"; ResultSet rs = stmt.executeQuery(sql); // 处理查询结果 while (rs.next()) { int id = rs.getInt("id"); String name = rs.getString("name"); System.out.println("ID: " + id + ", Name: " + name); } // 关闭连接 rs.close(); stmt.close(); conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } ``` 2. 使用PreparedStatement执行SQL语句[^2]： ```java import java.sql.*; public class PreparedStatementExample { public static void main(String[] args) { try { // 建立数据库连接 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password"); // 创建PreparedStatement对象 String sql = "SELECT * FROM mytable WHERE id = ?"; PreparedStatement pstmt = conn.prepareStatement(sql); // 设置参数 pstmt.setInt(1, 1); // 执行查询 ResultSet rs = pstmt.executeQuery(); // 处理查询结果 while (rs.next()) { int id = rs.getInt("id"); String name = rs.getString("name"); System.out.println("ID: " + id + ", Name: " + name); } // 关闭连接 rs.close(); pstmt.close(); conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值