MysqlSQL PreparedStatement的查询

最新推荐文章于 2024-06-03 13:21:51 发布
最新推荐文章于 2024-06-03 13:21:51 发布
阅读量535 收藏
点赞数
分类专栏： JDBC 文章标签： mysql
JDBC驱动初始化-Mysql:[url]http://donald-draper.iteye.com/blog/2342010[/url]
JDBC连接的获取：[url]http://donald-draper.iteye.com/blog/2342011[/url]
Mysql负载均衡连接的获取：[url]http://donald-draper.iteye.com/blog/2342089[/url]
Mysql主从复制读写分离连接的获取：[url]http://donald-draper.iteye.com/blog/2342108[/url]
ConnectionImp创建MysqlIO ：[url]http://donald-draper.iteye.com/blog/2342959[/url]
Mysql预编译SQL：[url]http://donald-draper.iteye.com/blog/2342960[/url]
MysqlSQL PreparedStatement的查询:[url]http://donald-draper.iteye.com/blog/2343083[/url]
MySQL ServerPreparedStatement查询：[url]http://donald-draper.iteye.com/blog/2343124[/url]
前面几讲，说过mysql的连接获取，MysqlIO，今天来看一下MySQL的PreparedStatement查询
//ConnectionImpl 
 protected PreparedStatement clientPrepareStatement(String sql, int resultSetType, int resultSetConcurrency, boolean processEscapeCodesIfNeeded)
        throws SQLException
    {
        checkClosed();
        String nativeSql = !processEscapeCodesIfNeeded || !getProcessEscapeCodesForPrepStmts() ? sql : nativeSQL(sql);
        com.mysql.jdbc.PreparedStatement pStmt = null;
        if(getCachePreparedStatements())
            synchronized(cachedPreparedStatementParams)
            {
                PreparedStatement.ParseInfo pStmtInfo = (PreparedStatement.ParseInfo)cachedPreparedStatementParams.get(nativeSql);
                if(pStmtInfo == null)
                {
                    pStmt = PreparedStatement.getInstance(this, nativeSql, database);
                    PreparedStatement.ParseInfo parseInfo = pStmt.getParseInfo();
                    if(parseInfo.statementLength < getPreparedStatementCacheSqlLimit())
                    {
                        if(cachedPreparedStatementParams.size() >= getPreparedStatementCacheSize())
                        {
                            Iterator oldestIter = cachedPreparedStatementParams.keySet().iterator();
                            long lruTime = 9223372036854775807L;
                            String oldestSql = null;
                            do
                            {
                                if(!oldestIter.hasNext())
                                    break;
                                String sqlKey = (String)oldestIter.next();
                                PreparedStatement.ParseInfo lruInfo = (PreparedStatement.ParseInfo)cachedPreparedStatementParams.get(sqlKey);
                                if(lruInfo.lastUsed < lruTime)
                                {
                                    lruTime = lruInfo.lastUsed;
                                    oldestSql = sqlKey;
                                }
                            } while(true);
                            if(oldestSql != null)
                                cachedPreparedStatementParams.remove(oldestSql);
                        }
                        cachedPreparedStatementParams.put(nativeSql, pStmt.getParseInfo());
                    }
                } else
                {
                    pStmtInfo.lastUsed = System.currentTimeMillis();
                    pStmt = new com.mysql.jdbc.PreparedStatement(this, nativeSql, database, pStmtInfo);
                }
            }
        else
	   //如果没有缓存，获取PreparedStatement实例
	   pStmt = PreparedStatement.getInstance(this, nativeSql, database);
        pStmt.setResultSetType(resultSetType);
        pStmt.setResultSetConcurrency(resultSetConcurrency);
        return pStmt;
}

来看PreparedStatement的构造
//PreparedStatement 
public class PreparedStatement extends StatementImpl
    implements java.sql.PreparedStatement
{
  protected static PreparedStatement getInstance(ConnectionImpl conn, String sql, String catalog)
        throws SQLException
    {
        if(!Util.isJdbc4())
            return new PreparedStatement(conn, sql, catalog);
        else
            return (PreparedStatement)Util.handleNewInstance(JDBC_4_PSTMT_3_ARG_CTOR, new Object[] {
                conn, sql, catalog
            }, conn.getExceptionInterceptor());
    }
    public PreparedStatement(ConnectionImpl conn, String sql, String catalog)
        throws SQLException
    {
        super(conn, catalog);
        batchHasPlainStatements = false;
        dbmd = null;
        firstCharOfStmt = '\0';
        hasLimitClause = false;
        isLoadDataQuery = false;
        isNull = null;
        isStream = null;
        numberOfExecutions = 0;
        originalSql = null;
        parameterStreams = null;
	//参数值
        parameterValues = (byte[][])null;
	//参数类型
        parameterTypes = null;
        staticSqlStrings = (byte[][])null;
        streamConvertBuf = new byte[4096];
        streamLengths = null;
        tsdf = null;
        useTrueBoolean = false;
        hasCheckedForRewrite = false;
        canRewrite = false;
        compensateForOnDuplicateKeyUpdate = false;
        batchCommandIndex = -1;
        if(sql == null)
            throw SQLError.createSQLException(Messages.getString("PreparedStatement.0"), "S1009", getExceptionInterceptor());
        originalSql = sql;
        if(originalSql.startsWith("/* ping */"))
            doPingInstead = true;
        else
            doPingInstead = false;
	//获取数据库MetaData
        dbmd = connection.getMetaData();
        useTrueBoolean = connection.versionMeetsMinimum(3, 21, 23);
	//构建Statement的
        parseInfo = new ParseInfo(sql, connection, dbmd, charEncoding, charConverter);
        initializeFromParseInfo();
        compensateForOnDuplicateKeyUpdate = connection.getCompensateOnDuplicateKeyUpdateCounts();
        if(conn.getRequiresEscapingEncoder())
            charsetEncoder = Charset.forName(conn.getEncoding()).newEncoder();
    }
}

构造PreparedStatement完毕，来看一下，如何查询 
 public ResultSet executeQuery()
        throws SQLException
    {
        checkClosed();
        ConnectionImpl locallyScopedConn = connection;
        checkForDml(originalSql, firstCharOfStmt);
        CachedResultSetMetaData cachedMetadata = null;
        synchronized(locallyScopedConn.getMutex())
        {
            clearWarnings();
            boolean doStreaming = createStreamingResultSet();
            batchedGeneratedKeys = null;
            if(doStreaming && connection.getNetTimeoutForStreamingResults() > 0)
                locallyScopedConn.execSQL(this, "SET net_write_timeout=" + connection.getNetTimeoutForStreamingResults(), -1, null, 1003, 1007, false, currentCatalog, null, false);
            Buffer sendPacket = fillSendPacket();
            if(results != null && !connection.getHoldResultsOpenOverStatementClose() && !holdResultsOpenOverClose)
                results.realClose(false);
            String oldCatalog = null;
            if(!locallyScopedConn.getCatalog().equals(currentCatalog))
            {
                oldCatalog = locallyScopedConn.getCatalog();
                locallyScopedConn.setCatalog(currentCatalog);
            }
            if(locallyScopedConn.getCacheResultSetMetadata())
                cachedMetadata = locallyScopedConn.getCachedMetaData(originalSql);
            Field metadataFromCache[] = null;
            if(cachedMetadata != null)
                metadataFromCache = cachedMetadata.fields;
            if(locallyScopedConn.useMaxRows())
            {
                if(hasLimitClause)
                {
		    //没有分页语句的查询
                    results = executeInternal(maxRows, sendPacket, createStreamingResultSet(), true, metadataFromCache, false);
                } else
                {
                    if(maxRows <= 0)
                        executeSimpleNonQuery(locallyScopedConn, "SET OPTION SQL_SELECT_LIMIT=DEFAULT");
                    else
                        executeSimpleNonQuery(locallyScopedConn, "SET OPTION SQL_SELECT_LIMIT=" + maxRows);
                    results = executeInternal(-1, sendPacket, doStreaming, true, metadataFromCache, false);
                    if(oldCatalog != null)
                        connection.setCatalog(oldCatalog);
                }
            } else
            {
                results = executeInternal(-1, sendPacket, doStreaming, true, metadataFromCache, false);
            }
            if(oldCatalog != null)
                locallyScopedConn.setCatalog(oldCatalog);
            if(cachedMetadata != null)
                locallyScopedConn.initializeResultsMetadataFromCache(originalSql, cachedMetadata, results);
            else
            if(locallyScopedConn.getCacheResultSetMetadata())
                locallyScopedConn.initializeResultsMetadataFromCache(originalSql, null, results);
        }
        lastInsertId = results.getUpdateID();
        return results;
    }

来看没有分页语句的查询executeInternal 
 protected ResultSetInternalMethods executeInternal(int maxRowsToRetrieve, Buffer sendPacket, boolean createStreamingResultSet, boolean queryIsSelectOnly, Field metadataFromCache[], boolean isBatch)
        throws SQLException
    {
        ConnectionImpl locallyScopedConnection;
        resetCancelledState();
        locallyScopedConnection = connection;
        numberOfExecutions++;
        if(!doPingInstead)
            break MISSING_BLOCK_LABEL_36;
        doPingInstead();
        return results;
        StatementImpl.CancelTask timeoutTask = null;
        ResultSetInternalMethods rs;
        if(locallyScopedConnection.getEnableQueryTimeouts() && timeoutInMillis != 0 && locallyScopedConnection.versionMeetsMinimum(5, 0, 0))
        {
            timeoutTask = new StatementImpl.CancelTask(this, this);
	    //连接定时任务执行器Timer，等待timeoutInMillis毫秒后，执行查询定时任务timeoutTask
            ConnectionImpl.getCancelTimer().schedule(timeoutTask, timeoutInMillis);
        }
	//执行查询，并返回结果集
        rs = locallyScopedConnection.execSQL(this, null, maxRowsToRetrieve, sendPacket, resultSetType, resultSetConcurrency, createStreamingResultSet, currentCatalog, metadataFromCache, isBatch);
        if(timeoutTask != null)
        {
            timeoutTask.cancel();
            if(timeoutTask.caughtWhileCancelling != null)
                throw timeoutTask.caughtWhileCancelling;
            timeoutTask = null;
        }
        synchronized(cancelTimeoutMutex)
        {
            if(wasCancelled)
            {
                SQLException cause = null;
                if(wasCancelledByTimeout)
                    cause = new MySQLTimeoutException();
                else
                    cause = new MySQLStatementCancelledException();
                resetCancelledState();
                throw cause;
            }
        }
        if(timeoutTask != null)
            timeoutTask.cancel();
        break MISSING_BLOCK_LABEL_242;
        Exception exception1;
        exception1;
        if(timeoutTask != null)
            timeoutTask.cancel();
        throw exception1;
        return rs;
        NullPointerException npe;
        npe;
        checkClosed();
        throw npe;
    }

我们来看一下这一段都做了些什么？ 
if(locallyScopedConnection.getEnableQueryTimeouts() && timeoutInMillis != 0 && locallyScopedConnection.versionMeetsMinimum(5, 0, 0))
{
       timeoutTask = new StatementImpl.CancelTask(this, this);
       //连接定时任务执行器Timer，等待timeoutInMillis毫秒后，执行查询定时任务timeoutTask
        ConnectionImpl.getCancelTimer().schedule(timeoutTask, timeoutInMillis);
}

//StatementImpl 
public class StatementImpl
    implements com.mysql.jdbc.Statement
{
    class CancelTask extends TimerTask
    {

        public void run()
        {
            Thread cancelThread = new Thread() {

                public void run()
                {
                    com.mysql.jdbc.Connection cancelConn = null;
                    Statement cancelStmt = null;
                    try
                    {
                        synchronized(cancelTimeoutMutex)
                        {
			    //复制connection
                            cancelConn = connection.duplicate();
			    //创建Statement
                            cancelStmt = cancelConn.createStatement();
                            cancelStmt.execute("KILL QUERY " + connectionId);
                            toCancel.wasCancelled = true;
                            toCancel.wasCancelledByTimeout = true;
                        }
                    }
                    catch(SQLException sqlEx)
                    {
                        caughtWhileCancelling = sqlEx;
                    }
                    catch(NullPointerException npe) { }
                    finally
                    {
                        if(cancelStmt != null)
                            try
                            {
                                cancelStmt.close();
                            }
                            catch(SQLException sqlEx)
                            {
                                throw new RuntimeException(sqlEx.toString());
                            }
                        if(cancelConn != null)
                            try
                            {
                                cancelConn.close();
                            }
                            catch(SQLException sqlEx)
                            {
                                throw new RuntimeException(sqlEx.toString());
                            }
                    }
                }

            };
            cancelThread.start();
        }

        long connectionId;
        SQLException caughtWhileCancelling;
        StatementImpl toCancel;


        CancelTask(StatementImpl cancellee)
            throws SQLException
        {
            connectionId = 0L;
            caughtWhileCancelling = null;
            connectionId = connection.getIO().getThreadId();
            toCancel = cancellee;
        }
    }
}

//创建Statement 
cancelStmt = cancelConn.createStatement();

//ConnectionImpl
public Statement createStatement()
        throws SQLException
    {
        return createStatement(1003, 1007);
    }
public Statement createStatement(int resultSetType, int resultSetConcurrency)
        throws SQLException
    {
        checkClosed();
        StatementImpl stmt = new StatementImpl(this, database);
        stmt.setResultSetType(resultSetType);
        stmt.setResultSetConcurrency(resultSetConcurrency);
        return stmt;
    }

//连接定时任务执行器Timer，等待timeoutInMillis毫秒后，执行查询定时任务timeoutTask
ConnectionImpl.getCancelTimer().schedule(timeoutTask, timeoutInMillis);
//ConnectionImpl 
  protected static Timer getCancelTimer()
    {
        //private static Timer cancelTimer;
        return cancelTimer;
    }

从上面这一段可以看出，如果延时查询的话，就创建StatementImpl.CancelTask（TimeTask）定时任务，并由ConnectionImpl的cancelTimer（Timer）去调度。
回到executeInternal方法，
来看执行查询，返回结果集，这个时调用ConnectionImpl的execSQL
//ConnectionImpl 
ResultSetInternalMethods execSQL(StatementImpl callingStatement, String sql, int maxRows, Buffer packet, int resultSetType, int resultSetConcurrency, boolean streamResults, 
            String catalog, Field cachedMetadata[], boolean isBatch)
        throws SQLException
    {
        Object obj = mutex;
        JVM INSTR monitorenter ;
        long queryStartTime;
        int endOfQueryPacketPosition;
        queryStartTime = 0L;
        endOfQueryPacketPosition = 0;
        if(packet != null)
            endOfQueryPacketPosition = packet.getPosition();
        if(getGatherPerformanceMetrics())
            queryStartTime = System.currentTimeMillis();
        lastQueryFinishedTime = 0L;
        if(!failedOver || !autoCommit || isBatch || !shouldFallBack() || executingFailoverReconnect)
            break MISSING_BLOCK_LABEL_151;
        executingFailoverReconnect = true;
	//创建MysqlIO，这个我们在前面ServerPrepareStatement中讲过
        createNewIO(true);
        String connectedHost = io.getHost();
        if(connectedHost != null && hostList.get(0).equals(connectedHost))
        {
            failedOver = false;
            queriesIssuedFailedOver = 0L;
            setReadOnlyInternal(false);
        }
        if((getHighAvailability() || failedOver) && (autoCommit || getAutoReconnectForPools()) && needsPing && !isBatch)
            try
            {
                pingInternal(false, 0);
                needsPing = false;
            }
            catch(Exception Ex)
            {
                createNewIO(true);
            }
        ResultSetInternalMethods resultsetinternalmethods1;
        if(packet != null)
            break MISSING_BLOCK_LABEL_267;
        String encoding = null;
        if(getUseUnicode())
            encoding = getEncoding();
	//关键在这一句MysqlIO执行查询
        resultsetinternalmethods1 = io.sqlQueryDirect(callingStatement, sql, encoding, null, maxRows, resultSetType, resultSetConcurrency, streamResults, catalog, cachedMetadata);
        return resultsetinternalmethods1;
        ResultSetInternalMethods resultsetinternalmethods;
        try
        {
            resultsetinternalmethods = io.sqlQueryDirect(callingStatement, null, null, packet, maxRows, resultSetType, resultSetConcurrency, streamResults, catalog, cachedMetadata);
        }
        return resultsetinternalmethods;
    }

来看MysqlIO执行查询
//MysqlIO 
final ResultSetInternalMethods sqlQueryDirect(StatementImpl callingStatement, String query, String characterEncoding, Buffer queryPacket, int maxRows, int resultSetType, int resultSetConcurrency, 
            boolean streamResults, String catalog, Field cachedMetadata[])
        throws Exception
    {
        statementExecutionDepth++;
	//返回结果集
        ResultSetInternalMethods resultsetinternalmethods;
        if(statementInterceptors == null)
            break MISSING_BLOCK_LABEL_47;
	//拦截器处理
        ResultSetInternalMethods interceptedResults = invokeStatementInterceptorsPre(query, callingStatement);
        if(interceptedResults == null)
            break MISSING_BLOCK_LABEL_47;
        resultsetinternalmethods = interceptedResults;
        statementExecutionDepth--;
        return resultsetinternalmethods;
        ResultSetInternalMethods resultsetinternalmethods1;
        long queryStartTime = 0L;
        long queryEndTime = 0L;
        if(query != null)
        {
            int packLength = 5 + query.length() * 2 + 2;
            String statementComment = connection.getStatementComment();
            byte commentAsBytes[] = null;
            if(statementComment != null)
            {
                commentAsBytes = StringUtils.getBytes(statementComment, null, characterEncoding, connection.getServerCharacterEncoding(), connection.parserKnowsUnicode(), getExceptionInterceptor());
                packLength += commentAsBytes.length;
                packLength += 6;
            }
            if(sendPacket == null)
                sendPacket = new Buffer(packLength);
            else
                sendPacket.clear();
            sendPacket.writeByte((byte)3);
            if(commentAsBytes != null)
            {
	        //将注释添加的查询包中
                sendPacket.writeBytesNoNull(Constants.SLASH_STAR_SPACE_AS_BYTES);
                sendPacket.writeBytesNoNull(commentAsBytes);
                sendPacket.writeBytesNoNull(Constants.SPACE_STAR_SLASH_SPACE_AS_BYTES);
            }
            if(characterEncoding != null)
            {
	        //如果有编码信息，则将查询编码后，组装到包中
                if(platformDbCharsetMatches)
                    sendPacket.writeStringNoNull(query, characterEncoding, connection.getServerCharacterEncoding(), connection.parserKnowsUnicode(), connection);
                else
                if(StringUtils.startsWithIgnoreCaseAndWs(query, "LOAD DATA"))
                    sendPacket.writeBytesNoNull(query.getBytes());
                else
                    sendPacket.writeStringNoNull(query, characterEncoding, connection.getServerCharacterEncoding(), connection.parserKnowsUnicode(), connection);
            } else
            {
                sendPacket.writeStringNoNull(query);
            }
            queryPacket = sendPacket;
        }
        byte queryBuf[] = null;
        int oldPacketPosition = 0;
        if(needToGrabQueryFromPacket)
        {
            queryBuf = queryPacket.getByteBuffer();
            oldPacketPosition = queryPacket.getPosition();
            queryStartTime = getCurrentTimeNanosOrMillis();
        }
        if(autoGenerateTestcaseScript)
        {
            String testcaseQuery = null;
            if(query != null)
                testcaseQuery = query;
            else
                testcaseQuery = new String(queryBuf, 5, oldPacketPosition - 5);
            StringBuffer debugBuf = new StringBuffer(testcaseQuery.length() + 32);
            connection.generateConnectionCommentBlock(debugBuf);
            debugBuf.append(testcaseQuery);
            debugBuf.append(';');
            connection.dumpTestcaseQuery(debugBuf.toString());
        }
	//MysqlIO发送查询包到Server，获取返回结果
        Buffer resultPacket = sendCommand(3, null, queryPacket, false, null, 0);
        long fetchBeginTime = 0L;
        long fetchEndTime = 0L;
        String profileQueryToLog = null;
        boolean queryWasSlow = false;
        if(profileSql || logSlowQueries)
        {
            queryEndTime = System.currentTimeMillis();
            boolean shouldExtractQuery = false;
            if(profileSql)
                shouldExtractQuery = true;
            else
            if(logSlowQueries)
            {
                long queryTime = queryEndTime - queryStartTime;
                boolean logSlow = false;
                if(useAutoSlowLog)
                {
                    logSlow = queryTime > (long)connection.getSlowQueryThresholdMillis();
                } else
                {
                    logSlow = connection.isAbonormallyLongQuery(queryTime);
                    connection.reportQueryTime(queryTime);
                }
                if(logSlow)
                {
                    shouldExtractQuery = true;
                    queryWasSlow = true;
                }
            }
            if(shouldExtractQuery)
            {
                boolean truncated = false;
                int extractPosition = oldPacketPosition;
                if(oldPacketPosition > connection.getMaxQuerySizeToLog())
                {
                    extractPosition = connection.getMaxQuerySizeToLog() + 5;
                    truncated = true;
                }
                profileQueryToLog = new String(queryBuf, 5, extractPosition - 5);
                if(truncated)
                    profileQueryToLog = profileQueryToLog + Messages.getString("MysqlIO.25");
            }
            fetchBeginTime = queryEndTime;
        }
	//从中resultPacket，获取返回结果
        ResultSetInternalMethods rs = readAllResults(callingStatement, maxRows, resultSetType, resultSetConcurrency, streamResults, catalog, resultPacket, false, -1L, cachedMetadata);
        if(queryWasSlow && !serverQueryWasSlow)
        {
            StringBuffer mesgBuf = new StringBuffer(48 + profileQueryToLog.length());
            mesgBuf.append(Messages.getString("MysqlIO.SlowQuery", new Object[] {
                new Long(slowQueryThreshold), queryTimingUnits, new Long(queryEndTime - queryStartTime)
            }));
            mesgBuf.append(profileQueryToLog);
            ProfilerEventHandler eventSink = ProfilerEventHandlerFactory.getInstance(connection);
            eventSink.consumeEvent(new ProfilerEvent((byte)6, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), (int)(queryEndTime - queryStartTime), queryTimingUnits, null, new Throwable(), mesgBuf.toString()));
            if(connection.getExplainSlowQueries())
                if(oldPacketPosition < 1048576)
                    explainSlowQuery(queryPacket.getBytes(5, oldPacketPosition - 5), profileQueryToLog);
                else
                    connection.getLog().logWarn(Messages.getString("MysqlIO.28") + 1048576 + Messages.getString("MysqlIO.29"));
        }
        if(logSlowQueries)
        {
            ProfilerEventHandler eventSink = ProfilerEventHandlerFactory.getInstance(connection);
            if(queryBadIndexUsed)
                eventSink.consumeEvent(new ProfilerEvent((byte)6, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), queryEndTime - queryStartTime, queryTimingUnits, null, new Throwable(), Messages.getString("MysqlIO.33") + profileQueryToLog));
            if(queryNoIndexUsed)
                eventSink.consumeEvent(new ProfilerEvent((byte)6, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), queryEndTime - queryStartTime, queryTimingUnits, null, new Throwable(), Messages.getString("MysqlIO.35") + profileQueryToLog));
            if(serverQueryWasSlow)
                eventSink.consumeEvent(new ProfilerEvent((byte)6, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), queryEndTime - queryStartTime, queryTimingUnits, null, new Throwable(), Messages.getString("MysqlIO.ServerSlowQuery") + profileQueryToLog));
        }
        if(profileSql)
        {
            fetchEndTime = getCurrentTimeNanosOrMillis();
            ProfilerEventHandler eventSink = ProfilerEventHandlerFactory.getInstance(connection);
            eventSink.consumeEvent(new ProfilerEvent((byte)3, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), queryEndTime - queryStartTime, queryTimingUnits, null, new Throwable(), profileQueryToLog));
            eventSink.consumeEvent(new ProfilerEvent((byte)5, "", catalog, connection.getId(), callingStatement == null ? 999 : callingStatement.getId(), ((ResultSetImpl)rs).resultId, System.currentTimeMillis(), fetchEndTime - fetchBeginTime, queryTimingUnits, null, new Throwable(), null));
        }
        if(hadWarnings)
            scanForAndThrowDataTruncation();
        if(statementInterceptors != null)
        {
            ResultSetInternalMethods interceptedResults = invokeStatementInterceptorsPost(query, callingStatement, rs);
            if(interceptedResults != null)
                rs = interceptedResults;
        }
        resultsetinternalmethods1 = rs;
        statementExecutionDepth--;
        return resultsetinternalmethods1;  
}

//从缓冲区，去除结果集
ResultSetImpl readAllResults(StatementImpl callingStatement, int maxRows, int resultSetType, int resultSetConcurrency, boolean streamResults, String catalog, Buffer resultPacket, 
            boolean isBinaryEncoded, long preSentColumnCount, Field metadataFromCache[])
        throws SQLException
    {
        resultPacket.setPosition(resultPacket.getPosition() - 1);
        ResultSetImpl topLevelResultSet = readResultsForQueryOrUpdate(callingStatement, maxRows, resultSetType, resultSetConcurrency, streamResults, catalog, resultPacket, isBinaryEncoded, preSentColumnCount, metadataFromCache);
        ResultSetImpl currentResultSet = topLevelResultSet;
        boolean checkForMoreResults = (clientParam & 131072L) != 0L;
        boolean serverHasMoreResults = (serverStatus & 8) != 0;
        if(serverHasMoreResults && streamResults)
        {
            if(topLevelResultSet.getUpdateCount() != -1L)
                tackOnMoreStreamingResults(topLevelResultSet);
            reclaimLargeReusablePacket();
            return topLevelResultSet;
        }
        for(boolean moreRowSetsExist = checkForMoreResults & serverHasMoreResults; moreRowSetsExist; moreRowSetsExist = (serverStatus & 8) != 0)
        {
            Buffer fieldPacket = checkErrorPacket();
            fieldPacket.setPosition(0);
	    //读取结果集
            ResultSetImpl newResultSet = readResultsForQueryOrUpdate(callingStatement, maxRows, resultSetType, resultSetConcurrency, streamResults, catalog, fieldPacket, isBinaryEncoded, preSentColumnCount, metadataFromCache);
            currentResultSet.setNextResultSet(newResultSet);
            currentResultSet = newResultSet;
        }

        if(!streamResults)
            clearInputStream();
        reclaimLargeReusablePacket();
        return topLevelResultSet;
    }

总结：
[color=blue]PreparedStatement执行查询，实际上是通过ConnectionImpl的execSQL，而ConnectionImpl的执行查询，实际上是通过MysqlIO，MysqlIO执行查询，就是将Sql查询，组成Mysql的查询包，通过socket的发送给Server，Server返回查询结果缓存区，然后MysqlIO将结果缓存区转换为ResultSetInternalMethods（ResultSetImpl），就是我们需要的结果集，即ResultSet。[/color] 
public class ResultSetImpl
    implements ResultSetInternalMethods
{
public float getFloat(int columnIndex)
        throws SQLException
    {
        if(!isBinaryEncoded)
        {
            String val = null;
	    //获取columnIndex对应的String值
            val = getString(columnIndex);
	    //将String转换为Float
            return getFloatFromString(val, columnIndex);
        } else
        {
            return getNativeFloat(columnIndex);
        }
    }
    public float getFloat(String columnName)
        throws SQLException
    {
        return getFloat(findColumn(columnName));
    }
    //获取columnIndex对应的String值
    public String getString(int columnIndex)
        throws SQLException
    {
        String stringVal = getStringInternal(columnIndex, true);
        if(padCharsWithSpace && stringVal != null)
        {
            Field f = fields[columnIndex - 1];
            if(f.getMysqlType() == 254)
            {
                int fieldLength = (int)f.getLength() / f.getMaxBytesPerCharacter();
                int currentLength = stringVal.length();
                if(currentLength < fieldLength)
                {
                    StringBuffer paddedBuf = new StringBuffer(fieldLength);
                    paddedBuf.append(stringVal);
                    int difference = fieldLength - currentLength;
                    paddedBuf.append(EMPTY_SPACE, 0, difference);
                    stringVal = paddedBuf.toString();
                }
            }
        }
        return stringVal;
   }
}

//ResultSetInternalMethods 
public interface ResultSetInternalMethods
    extends ResultSet
{
    public abstract ResultSetInternalMethods copy()
        throws SQLException;
    public abstract boolean reallyResult();
    public abstract Object getObjectStoredProc(int i, int j)
        throws SQLException;
    public abstract Object getObjectStoredProc(int i, Map map, int j)
        throws SQLException;
    public abstract Object getObjectStoredProc(String s, int i)
        throws SQLException;
    public abstract Object getObjectStoredProc(String s, Map map, int i)
        throws SQLException;
    public abstract String getServerInfo();
    public abstract long getUpdateCount();
    public abstract long getUpdateID();
    public abstract void realClose(boolean flag)
        throws SQLException;
    public abstract void setFirstCharOfQuery(char c);
    public abstract void setOwningStatement(StatementImpl statementimpl);
    public abstract char getFirstCharOfQuery();
    public abstract void clearNextResult();
    public abstract ResultSetInternalMethods getNextResultSet();
    public abstract void setStatementUsedForFetchingRows(PreparedStatement preparedstatement);
    public abstract void setWrapperStatement(Statement statement);
    public abstract void buildIndexMapping()
        throws SQLException;
    public abstract void initializeWithMetadata()
        throws SQLException;
    public abstract void redefineFieldsForDBMD(Field afield[]);
    public abstract void populateCachedMetaData(CachedResultSetMetaData cachedresultsetmetadata)
        throws SQLException;
    public abstract void initializeFromCachedMetaData(CachedResultSetMetaData cachedresultsetmetadata);
}
iteye_11587
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql prepare 模糊查询_java mysql prepareStatement模糊查询like使用注意
weixin_42300302的博客
01-19 689
今天在使用mysql 的like语句是，发现prepareStatement的like语句和一般的=写法有一样。当要使用prepareStatement的like查询时，按照一般写法，都会写成：String sql = "select * from tablename like '%?%'";String sqlParasValue = "2015-03-23";pStmt=conn.prepa...
mysql preparedstatement 查询_使用PreparedStatement接口实现数据表的查询操作
weixin_39526651的博客
02-01 231
package mysql;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;/** 使用PreparedStatement接口实现数据表的查询操作* 查询建议用PreparedStatement具有高效*/publ...
JDBC 用PreparedStatement实现MySQL增删改查
weixin_46409629的博客
03-07 145
JDBC 用PreparedStatement实现MySQL增删改查
mysql 中prepare statement（预处理）
果汁华的博客
08-18 6816
  今天前同事问了一个sql语法优化问题，后来查资料的过程中，发现了一个prepare statement 这玩意。使用并测试了下性能，感觉未来能用上。记录下。 当时我在解决一个大表，分页问题。目前的分页sql一般有这几种(原文)： --方法1: 直接使用数据库提供的SQL语句 ---语句样式: MySQL中,可用如下方法: SELECT * FROM 表名称 LIMIT M,N ---适...
深入理解mysql中的各种超时属性
最新发布
小伍的程序之路
06-03 1238
连接超时: 登录超时: Socket网络超时，即读超时: sql执行超时:spring事务超时:innodb锁等待超时:mysql server网络回包写超时(针对大量数据查询的sql)
php mysqlsql 查询组件
03-19
SQL（Structured Query Language）是用于管理关系数据库的标准语言，包括创建、更新、查询和管理数据。PHP提供了多种方法来执行SQL查询，例如使用mysqli或PDO（PHP Data Objects）扩展。 1. **mysqli扩展**：MySQL ...
MySQLSQL语句优化技巧
02-01
2、对查询进行优化，应尽量避免全表扫描，首先应考虑在where及orderby涉及的列上建立索引。 3、应尽量避免在where子句中对字段进行null值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：...
mysqlsql语句大全
07-23
资源名称：mysql sql语句大全资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
mysqlSQL语法.pdf
09-30
MySQL SQL语法是数据库管理系统中用于操作数据的核心语言，它提供了创建、更新、查询和管理数据库的命令。在本文中，我们将深入探讨MySQL的一些主要语法结构。 1. **DDL（Data Definition Language）**：DDL用于...
MySQLSQL入门(一).pdf
05-01
复杂查询：连接查询(JOIN)、子查询、事务处理。 索引：索引的概念、创建和管理索引。 视图：创建和使用视图来简化复杂查询。 存储过程和函数：编写和执行存储过程和函数。 用户权限管理：用户账户创建、权限分配和...
常见反编译错误
ZF101201的专栏
12-10 1998
常见错误 一try--catch--catch--finally public class test{    public HashMap f5()            {                          Connection conn = null;          HashMap map = new HashMa
文件通道解析二（文件锁，关闭通道）
Donald_Draper的专栏
05-16 332
操作，通道数据传输操作，先来回顾一下： 文件通道的构造，主要是初始化通道读写模式，追加模式append及文件分发器，FileDispatcherImpl。 文件通道的读写操作的实际操作都是由IOUtil协助FileDispatcherImpl完成，这一点和SocketChannel通道读写思路基本相同。 文件通道传输方法transferTo，首先确保当前文件通道是否打开，是否可读，然后检查目的通道是否关闭，是否可写；然后先调用文件通道本地方法传输通道的数据到目的通道，如果失败，
DatagramChannelImpl 解析二（报文发送与接收）
Donald_Draper的专栏
05-09 439
mpl中的socket分发器原理基本相同，报文socket分发器可以理解为报文通道的静态代理；网络协议family表示当前报文通道的网络协议family；多播关系注册器MembershipRegistry，主要是通过一个Map-HashMap来管理多播组和多播组成员关系key的映射（关系）；通道本地读写线程记录器，及读写锁控制通道读写，一个状态锁，当通道状态改变时，需要获取状态锁。DatagramChannelImpl构造方法，主要是初始化读写线程，及读写锁和状态锁，初始化网络协议family，及报文通道描
MySQL Prepared Statement
gcl的博客
12-06 700
MySQL Prepared Statement
Java实现关系型数据库工具类JdbcUtils系列四：PreparedStatement执行sql语句实现查询
zhengzaifeidelushang的博客
12-11 1332
Java实现关系型数据库工具类JdbcUtils系列四：PreparedStatement执行sql语句实现查询一、建表语句二、JdbcUtils实现建立连接和关闭连接三、PreparedStatement实现查询 一、建表语句 CREATE TABLE `stuinfo` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '学生自增id', `stunum` int(11) NOT NULL COMMENT '学号', `name` varchar(
三、利用PreparedStatement实现数据库的连接和【查询】sql操作
陈大大的博客
11-24 581
一、PreparedStatementUpdaeTest.java package com.atguigu3.preparedstatement; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import org.junit.Test; import com.atguigu3.bean.Customer; import com.atguigu3.util.JDBCUt
使用PreparedStatement进行数据库查询
热门推荐
J_2ian的博客
09-11 1万+
例：模糊查询 import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; public class PreparedStatementDemo{ //MySQL数据库驱动 public static final...
java反编 break label_java反编译出break MISSING_BLOCK_LABEL_*应该怎么改？可追加金币。...
weixin_32242475的博客
02-25 964
publicvoid*()throwsException{………………breakMISSING_BLOCK_LABEL_229;Exceptionexception;exception;…………throwexception;…………}比如这样：privatevoidcreateData(Configc...public void *() throws Exception {………………break ...
break MISSING_BLOCK_LABEL_160; 看源代码出现的，源代码是反编译的
weixin_30462049的博客
06-02 148
break MISSING_BLOCK_LABEL_160; FileNotFoundException fnfe; fnfe; out.close(); throw fnfe; in.close(); break MISSING_BLOCK_LABEL_268; fnfe; fnfe.printStackTrace(); in.close(); break MISSING_...
mysqlsql 查询距今半年内的数据
03-25
您好，我是ChitGPT，下面是针对您的问题的回答： 要查询距今半年内的数据，您可以使用MySQL中的DATE_SUB函数和NOW函数。DATE_SUB函数用于减去指定时间间隔，NOW函数用于获取当前的日期和时间。 以下是示例代码： SELECT * FROM your_table_name WHERE your_date_column_name >= DATE_SUB(NOW(), INTERVAL 6 MONTH); 请将your_table_name替换为您要查询的表名，your_date_column_name替换为包含日期的列名。这条SQL语句将返回距今半年以内的所有行。 希望这可以帮助您解决问题。如果您有其他问题，请随时提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值