rem stringlengths 0 477k | add stringlengths 0 313k | context stringlengths 6 599k |
|---|---|---|
double optimizerEstimatedCost, GeneratedMethod closeCleanup) | double optimizerEstimatedCost) | public HashScanResultSet(long conglomId, StaticCompiledOpenConglomInfo scoci, Activation activation, GeneratedMethod resultRowAllocator, int resultSetNumber, GeneratedMethod startKeyGetter, int startSearchOperator, GeneratedMethod stopKeyGetter, int stopSearchOperator, boolean sameStartStopPosition, Qualif... |
this.closeCleanup = closeCleanup; | public HashScanResultSet(long conglomId, StaticCompiledOpenConglomInfo scoci, Activation activation, GeneratedMethod resultRowAllocator, int resultSetNumber, GeneratedMethod startKeyGetter, int startSearchOperator, GeneratedMethod stopKeyGetter, int stopSearchOperator, boolean sameStartStopPosition, Qualif... | |
if (closeCleanup != null) { closeCleanup.invoke(activation); } | public void close() throws StandardException { beginTime = getCurrentTimeMillis(); if ( isOpen ) { // we don't want to keep around a pointer to the // row ... so it can be thrown away. // REVISIT: does this need to be in a finally // block, to ensure that it is executed? clearCurrentRow(); if (clo... | |
currentRow = null; | public void close() throws StandardException { beginTime = getCurrentTimeMillis(); if ( isOpen ) { // we don't want to keep around a pointer to the // row ... so it can be thrown away. // REVISIT: does this need to be in a finally // block, to ensure that it is executed? clearCurrentRow(); if (clo... | |
return (connection_.xaState_ == Connection.XA_T0_NOT_ASSOCIATED) ; | return (connection_.getXAState() == Connection.XA_T0_NOT_ASSOCIATED) ; | private boolean willTickleServer(int number, boolean allowAutoCommits) throws SqlException { boolean requiresAutocommit = false; if (resultSetList_ != null) { for (int i = 0; i < number; i++) { if (resultSetList_[i] != null) { if (resultSetList_[i].openOnSe... |
if ((securityMechanism != CodePoint.SECMEC_EUSRIDPWD) && | if (((securityMechanism != CodePoint.SECMEC_EUSRIDPWD) || (securityMechanism == CodePoint.SECMEC_EUSRIDPWD && !server.supportsEUSRIDPWD()) ) && | private int parseACCSEC() throws DRDAProtocolException { int securityCheckCode = 0; int securityMechanism = 0; byte [] secTokenIn = null; reader.markCollection(); int codePoint = reader.getCodePoint(); while (codePoint != -1) { switch(codePoint) { //optional case CodePoint.SECMGRNM: // this is de... |
writer.writeScalar2Bytes(CodePoint.SECMEC, CodePoint.SECMEC_EUSRIDPWD); | if ( server.supportsEUSRIDPWD()) writer.writeScalar2Bytes(CodePoint.SECMEC, CodePoint.SECMEC_EUSRIDPWD); | private void writeACCSECRD(int securityCheckCode) throws DRDAProtocolException { writer.createDssReply(); writer.startDdm(CodePoint.ACCSECRD); if (securityCheckCode != CodePoint.SECCHKCD_NOTSUPPORTED) writer.writeScalar2Bytes(CodePoint.SECMEC, database.securityMechanism); else { // if server doesnt... |
failedProps_.setProperty(firstKey_, ""+ClientInfoException. REASON_UNKNOWN_PROPERTY); | failedProps_.put(firstKey_, ClientInfoStatus.REASON_UNKNOWN_PROPERTY); | public FailedProperties40(Properties props) { if (props == null || props.isEmpty()) { firstKey_ = null; firstValue_ = null; return; } Enumeration e = props.keys(); firstKey_ = (String)e.nextElement(); firstValue_ = props.getProperty(firstKey_); ... |
failedProps_.setProperty((String)e.nextElement(), ""+ClientInfoException. REASON_UNKNOWN_PROPERTY); | failedProps_.put((String)e.nextElement(), ClientInfoStatus.REASON_UNKNOWN_PROPERTY); | public FailedProperties40(Properties props) { if (props == null || props.isEmpty()) { firstKey_ = null; firstValue_ = null; return; } Enumeration e = props.keys(); firstKey_ = (String)e.nextElement(); firstValue_ = props.getProperty(firstKey_); ... |
public Properties getProperties() { return failedProps_; } | public Map<String,ClientInfoStatus> getProperties() { return failedProps_; } | public Properties getProperties() { return failedProps_; } |
if (owner.getTransaction() == null) throw StandardException.newException(SQLState.DATA_CONTAINER_CLOSED); | public void initStream() throws StandardException { /* We might want to use the mode and isolation level of the container. This would have the advantage that, if the isolation level is READ_COMMITTED, resources would be freed if blobs/clob finalizers are called (e.g. they are g... | |
public ContainerHandle openContainer( ContainerKey containerId, LockingPolicy locking, int mode) | public ContainerHandle openContainer(ContainerKey containerId, int mode) | public ContainerHandle openContainer( ContainerKey containerId, LockingPolicy locking, int mode) throws StandardException; |
if (joinClause.isParameterNode()) | if (joinClause.requiresTypeFromContext()) | private void deferredBindExpressions(FromList fromListParam) throws StandardException { /* Bind the expressions in the join clause */ subqueryList = (SubqueryList) getNodeFactory().getNode( C_NodeTypes.SUBQUERY_LIST, getContextManager()); aggregateVector = new Vector(); /* ON clause */ if (... |
retVN = gbc.getColumnReference().remapColumnReferencesToExpressions(); | retVN = gbc.getColumnExpression().remapColumnReferencesToExpressions(); | public void remapColumnReferencesToExpressions() throws StandardException { GroupByColumn gbc; int size = size(); /* This method is called when flattening a FromTable. We should * not be flattening a FromTable if the underlying expression that * will get returned out, after chopping out the redundant Result... |
gbc.setColumnReference((ColumnReference) retVN); | gbc.setColumnExpression(retVN); | public void remapColumnReferencesToExpressions() throws StandardException { GroupByColumn gbc; int size = size(); /* This method is called when flattening a FromTable. We should * not be flattening a FromTable if the underlying expression that * will get returned out, after chopping out the redundant Result... |
public LocalizedInput(InputStream i, String encode) throws UnsupportedEncodingException{ super(i,encode); | public LocalizedInput(InputStream i){ super(i); | public LocalizedInput(InputStream i, String encode) throws UnsupportedEncodingException{ super(i,encode); this.in = i; } |
SQLBinary(byte[] val) | SQLBinary() | SQLBinary(byte[] val) { dataValue = val; } |
dataValue = val; | SQLBinary(byte[] val) { dataValue = val; } | |
public final void setValue(DataValueDescriptor dvd) throws StandardException { if (dvd.isNull()) { setToNull(); return; } try { setFrom(dvd); } catch (StandardException se) { String msgId = se.getMessageId(); if (SQLState.LANG_OUTSIDE_RANGE_FOR_DATATYPE.equals(msgId)) throw outOfRange(); if (SQLState.LANG_FORMAT_EX... | public void setValue(Time theValue) throws StandardException { setValue( theValue, (Calendar) null); | public final void setValue(DataValueDescriptor dvd) throws StandardException { if (dvd.isNull()) { setToNull(); return; } try { setFrom(dvd); } catch (StandardException se) { String msgId = se.getMessageId(); if (SQLState.LANG_OUTSIDE_RANGE_FOR_DATATYPE.equals(msgId)) throw outOfRange(); if (SQLSta... |
jira125Test(conn); | public static void main (String args[]) { try { System.out.println("prepStmt Test Starts"); ij.getPropertyArg(args); conn = ij.startJBMS(); if (conn == null) { System.out.println("conn didn't work"); return; } Statement cleanstmt = conn.createStatement(); TestUtil.cleanUpTest(cleanstmt, testO... | |
return getConnection().createObjectMessage(body); | Serializable value = (object != null) ? object : getBodyText(); return getConnection().createObjectMessage(value); | protected Message createMessage() throws Exception { return getConnection().createObjectMessage(body); } |
if (joinOrderStrategyProperties != null) mb.push(PropertyUtil.sortProperties(joinOrderStrategyProperties)); else mb.pushNull("java.lang.String"); | private int getJoinArguments(ActivationClassBuilder acb, MethodBuilder mb, ValueNode joinClause) throws StandardException { int numArgs = getNumJoinArguments(); leftResultSet.generate(acb, mb); // arg 1 mb.push(leftResultSet.resultColumns.size()); // arg 2 rightResultSet.generate(acb, mb)... | |
return 12; | return 13; | protected int getNumJoinArguments() { return 12; } |
Object tableProperties) | Object tableProperties, Object joinOrderStrategyProperties) | public void init( Object leftResult, Object rightResult, Object onClause, Object usingClause, Object selectList, Object tableProperties) throws StandardException { super.init(leftResult, rightResult, tableProperties); resultColumns = (ResultColumnList) selectList; joinClause = (ValueNode) ... |
this.joinOrderStrategyProperties = (Properties)joinOrderStrategyProperties; | public void init( Object leftResult, Object rightResult, Object onClause, Object usingClause, Object selectList, Object tableProperties) throws StandardException { super.init(leftResult, rightResult, tableProperties); resultColumns = (ResultColumnList) selectList; joinClause = (ValueNode) ... | |
closeMethodArgument(acb, mb); mb.callMethod(VMOpcode.INVOKEINTERFACE, (String) null, resultSet, ClassName.NoPutResultSet, 10); | mb.callMethod(VMOpcode.INVOKEINTERFACE, (String) null, resultSet, ClassName.NoPutResultSet, 9); | private void genGroupedAggregateResultSet(ActivationClassBuilder acb, MethodBuilder mb) throws StandardException { /* Generate the (Distinct)GroupedAggregateResultSet: * arg1: childExpress - Expression for childResult * arg2: isInSortedOrder - true if source result set in sorted order * arg3:... |
* arg12: closeCleanup | private void genScalarAggregateResultSet(ActivationClassBuilder acb, MethodBuilder mb) { /* Generate the (Distinct)ScalarAggregateResultSet: * arg1: childExpress - Expression for childResult * arg2: isInSortedOrder - true if source result set in sorted order * arg3: aggregateItem - entry in save... | |
closeMethodArgument(acb, mb); mb.callMethod(VMOpcode.INVOKEINTERFACE, (String) null, resultSet, ClassName.NoPutResultSet, 11); | mb.callMethod(VMOpcode.INVOKEINTERFACE, (String) null, resultSet, ClassName.NoPutResultSet, 10); | private void genScalarAggregateResultSet(ActivationClassBuilder acb, MethodBuilder mb) { /* Generate the (Distinct)ScalarAggregateResultSet: * arg1: childExpress - Expression for childResult * arg2: isInSortedOrder - true if source result set in sorted order * arg3: aggregateItem - entry in save... |
ResultColumnDescriptor[] cols, String type | ResultDescription inputResultDescription, int[] theCols | public ResultDescription getResultDescription ( ResultColumnDescriptor[] cols, String type ); |
public AggregatorInfo ( String aggregateName, String aggregatorClassName, int inputColNum, int outputColNum, int aggregatorColNum, boolean isDistinct, ResultDescription rd ) { this.aggregateName = aggregateName; this.aggregatorClassName = aggregatorClassName; this.inputColumn = inputColNum; this.o... | public AggregatorInfo() {} | public AggregatorInfo ( String aggregateName, String aggregatorClassName, int inputColNum, int outputColNum, int aggregatorColNum, boolean isDistinct, ResultDescription rd ) { this.aggregateName = aggregateName; this.aggregatorClassName = aggregatorClassName; this.inputColumn = inputCo... |
Section section) throws SQLException { | Section section) throws SqlException { | public PreparedStatement40(Agent agent, Connection connection, String sql, Section section) throws SQLException { super(agent, connection,sql,section); } |
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBlob", parameterIndex, inputStream, new Long(length)); } if(length > Integer.MAX_VALUE) throw new SqlException(agent_.logW... | public void setBlob(int parameterIndex, java.sql.Blob x) throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBlob", parameterIndex, x); | public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBlob", parameterIndex, inputStream, new Long(length)); ... |
catch ( SqlException se ) { throw se.getSQLException(); } | public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBlob", parameterIndex, inputStream, new Long(length)); ... | |
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setClob", parameterIndex, reader, new Long(length)); | public void setClob(int parameterIndex, java.sql.Clob x) throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setClob", parameterIndex, x); } setClobX(parameterIndex, x); | public void setClob(int parameterIndex, Reader reader, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setClob", parameterIndex, reader, new Long(length)); } ... |
try { checkForClosedStatement(); } catch (SqlException se) { throw se.getSQLException(); } if(length > Integer.MAX_VALUE) throw new SqlException(agent_.logWriter_, new ClientMessageId(SQLState.BLOB_TOO_LARGE_FOR_CLIENT), new Long(length), new Integer(Integer.MAX_VALUE)).getSQLException(); else setInput(parameterIndex, ... | } catch ( SqlException se ) { throw se.getSQLException(); | public void setClob(int parameterIndex, Reader reader, long length) throws SQLException{ synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setClob", parameterIndex, reader, new Long(length)); } ... |
if (endPosition == LOG_FILE_HEADER_SIZE) { if (SanityManager.DEBUG) { Monitor.logMessage("not switching from an empty log file (" + logFileNumber + ")"); } return; } | private void switchLogFile() throws StandardException { boolean switchedOver = false; ///////////////////////////////////////////////////// // Freeze the log for the switch over to a new log file. // This blocks out any other threads from sending log // record to the log stream. // // The switching of the log ... | |
boolean waited = false; | private void switchLogFile() throws StandardException { boolean switchedOver = false; ///////////////////////////////////////////////////// // Freeze the log for the switch over to a new log file. // This blocks out any other threads from sending log // record to the log stream. // // The switching of the log ... | |
} if (endPosition == LOG_FILE_HEADER_SIZE) { if (SanityManager.DEBUG) { Monitor.logMessage("not switching from an empty log file (" + logFileNumber + ")"); } return; | private void switchLogFile() throws StandardException { boolean switchedOver = false; ///////////////////////////////////////////////////// // Freeze the log for the switch over to a new log file. // This blocks out any other threads from sending log // record to the log stream. // // The switching of the log ... | |
public CheckpointOperation(long redoLWM, long undoLWM, TruncationPoint[] tpoints, Formatable ttab) | public CheckpointOperation(long redoLWM, long undoLWM, Formatable ttab) | public CheckpointOperation(long redoLWM, long undoLWM, TruncationPoint[] tpoints, Formatable ttab) { this.redoLWM = redoLWM; this.undoLWM = undoLWM; this.truncationLWM = tpoints; this.transactionTable = ttab; } |
this.truncationLWM = tpoints; | public CheckpointOperation(long redoLWM, long undoLWM, TruncationPoint[] tpoints, Formatable ttab) { this.redoLWM = redoLWM; this.undoLWM = undoLWM; this.truncationLWM = tpoints; this.transactionTable = ttab; } | |
public CursorInfo ( int updateMode, ExecCursorTableReference targetTable, ResultColumnDescriptor[] targetColumns, String[] updateColumns ) | public CursorInfo() | public CursorInfo ( int updateMode, ExecCursorTableReference targetTable, ResultColumnDescriptor[] targetColumns, String[] updateColumns ) { this.updateMode = updateMode; this.targetTable = targetTable; this.targetColumns = targetColumns; this.updateColumns = updateColumns; } |
this.updateMode = updateMode; this.targetTable = targetTable; this.targetColumns = targetColumns; this.updateColumns = updateColumns; | public CursorInfo ( int updateMode, ExecCursorTableReference targetTable, ResultColumnDescriptor[] targetColumns, String[] updateColumns ) { this.updateMode = updateMode; this.targetTable = targetTable; this.targetColumns = targetColumns; this.updateColumns = updateColumns; } | |
throw new SqlException(agent_.logWriter_, "Invalid argument: parameter index " + parameterIndex + " is not an OUT or INOUT parameter."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.PARAM_NOT_OUT_OR_INOUT), new Integer(parameterIndex)); | private void checkForValidOutParameter(int parameterIndex) throws SqlException { if (parameterMetaData_ == null || parameterMetaData_.sqlxParmmode_[parameterIndex - 1] < java.sql.ParameterMetaData.parameterModeInOut) { throw new SqlException(agent_.logWriter_, "Invalid argument: parameter index " ... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Array getArray(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getArray", parameterIndex); } super.checkForClosedStatement(); parameterIndex = c... |
throw new SqlException(agent_.logWriter_, "jdbc 2 method is not yet implemented"); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.JDBC2_METHOD_NOT_IMPLEMENTED)); | public java.sql.Array getArray(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getArray", parameterIndex); } super.checkForClosedStatement(); parameterIndex = c... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Blob getBlob(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getBlob", parameterIndex); } super.checkForClosedStatement(); parameterIndex = chec... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public byte[] getBytes(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getBytes", parameterIndex); } super.checkForClosedStatement(); parameterIndex = checkForE... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Clob getClob(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getClob", parameterIndex); } super.checkForClosedStatement(); parameterIndex = chec... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Date getDate(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getDate", parameterIndex); } super.checkForClosedStatement(); parameterIndex = chec... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Ref getRef(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getRef", parameterIndex); } super.checkForClosedStatement(); parameterIndex = checkFo... |
throw new SqlException(agent_.logWriter_, "jdbc 2 method is not yet implemented"); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.JDBC2_METHOD_NOT_IMPLEMENTED)); | public java.sql.Ref getRef(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getRef", parameterIndex); } super.checkForClosedStatement(); parameterIndex = checkFo... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Time getTime(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getTime", parameterIndex); } super.checkForClosedStatement(); parameterIndex = chec... |
throw new SqlException(agent_.logWriter_, "Invalid method call: parameter 1 is an integer OUT parameter returned by the stored procedure, use getInt call."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.INVALID_PARAM_USE_GETINT)); | public java.sql.Timestamp getTimestamp(int parameterIndex) throws SqlException { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getTimestamp", parameterIndex); } super.checkForClosedStatement(); parame... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public java.net.URL getURL(int parameterIndex) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "getURL", parameterIndex); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet suppor... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setAsciiStream(String parameterName, java.io.InputStream x, int length) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setAsciiStream", parameterName, x, length); } super.checkForClosedStatement(); throw new SqlException(ag... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setBigDecimal(String parameterName, java.math.BigDecimal x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBigDecimal", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDB... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setBinaryStream(String parameterName, java.io.InputStream x, int length) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBinaryStream", parameterName, x, length); } super.checkForClosedStatement(); throw new SqlException(... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setBoolean(String parameterName, boolean x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBoolean", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called -... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setByte(String parameterName, byte x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setByte", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet ... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setBytes(String parameterName, byte x[]) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setBytes", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not ... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setCharacterStream(String parameterName, java.io.Reader reader, int length) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setCharacterStream", parameterName, reader, length); } super.checkForClosedStatement(); throw new Sq... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setDate(String parameterName, java.sql.Date x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setDate", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called -... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setDouble(String parameterName, double x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setDouble", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - no... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setFloat(String parameterName, float x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setFloat", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not y... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setInt(String parameterName, int x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setInt", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet sup... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setLong(String parameterName, long x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setLong", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet ... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setNull(String parameterName, int sqlType) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setNull", parameterName, sqlType); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setObject", parameterName, x, targetSqlType, scale); } super.checkForClosedStatement(); throw new SqlExc... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setShort(String parameterName, short x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setShort", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not y... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setString(String parameterName, String x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setString", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - no... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setTime(String parameterName, java.sql.Time x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setTime", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called -... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setTimestamp(String parameterName, java.sql.Timestamp x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setTimestamp", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 ... |
throw new SqlException(agent_.logWriter_, "JDBC 3 method called - not yet supported"); | throw jdbc3MethodNotSupported(); | public void setURL(String parameterName, java.net.URL x) throws SqlException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "setURL", parameterName, x); } super.checkForClosedStatement(); throw new SqlException(agent_.logWriter_, "JDBC 3 method called - no... |
throw new SqlException(agent_.logWriter_, "Invalid operation: wasNull() called with no data retrieved."); | throw new SqlException(agent_.logWriter_, new MessageId(SQLState.WASNULL_INVALID)); | private boolean wasNullX() throws SqlException { super.checkForClosedStatement(); if (wasNull_ == WAS_NULL_UNSET) { throw new SqlException(agent_.logWriter_, "Invalid operation: wasNull() called with no data retrieved."); } return wasNull_ == WAS_NULL; } |
public boolean execute() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "execute"); } boolean b = executeX(); if (agent_.loggingEnabled()) { agent_.logWriter_.traceExit(this, "execute", b); } return b; } | public boolean execute(String sql) throws SQLException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "execute", sql); | public boolean execute() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "execute"); } boolean b = executeX(); if (agent_.loggingEnabled(... |
catch ( SqlException se ) { checkStatementValidity(se); throw se.getSQLException(); } | throw new SqlException(agent_.logWriter_, new ClientMessageId(SQLState.NOT_FOR_PREPARED_STATEMENT), "execute(String)").getSQLException(); | public boolean execute() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "execute"); } boolean b = executeX(); if (agent_.loggingEnabled(... |
public java.sql.ResultSet executeQuery() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeQuery"); } ResultSet resultSet = executeQueryX(); if (agent_.loggingEnabled()) { agent_.logWriter_.traceExit(this, "executeQuery", resultSet); } ret... | public java.sql.ResultSet executeQuery(String sql) throws SQLException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeQuery", sql); | public java.sql.ResultSet executeQuery() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeQuery"); } ResultSet resultSet = executeQueryX(); ... |
catch ( SqlException se ) { checkStatementValidity(se); throw se.getSQLException(); } | throw new SqlException(agent_.logWriter_, new ClientMessageId(SQLState.NOT_FOR_PREPARED_STATEMENT), "executeQuery(String)").getSQLException(); | public java.sql.ResultSet executeQuery() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeQuery"); } ResultSet resultSet = executeQueryX(); ... |
public int executeUpdate() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeUpdate"); } int updateValue = executeUpdateX(); if (agent_.loggingEnabled()) { agent_.logWriter_.traceExit(this, "executeUpdate", updateValue); } return updateVal... | public int executeUpdate(String sql) throws SQLException { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeUpdate", sql); | public int executeUpdate() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeUpdate"); } int updateValue = executeUpdateX(); if (ag... |
catch ( SqlException se ) { checkStatementValidity(se); throw se.getSQLException(); } | throw new SqlException(agent_.logWriter_, new ClientMessageId(SQLState.NOT_FOR_PREPARED_STATEMENT), "executeUpdate(String)").getSQLException(); | public int executeUpdate() throws SQLException { try { synchronized (connection_) { if (agent_.loggingEnabled()) { agent_.logWriter_.traceEntry(this, "executeUpdate"); } int updateValue = executeUpdateX(); if (ag... |
throw new SqlException(agent_.logWriter_, "not yet implemented"); | throw new SqlException(agent_.logWriter_, new MessageId (SQLState.NOT_IMPLEMENTED), "getArray(int)"); | public final java.sql.Array getArray(int column) throws SqlException { throw new SqlException(agent_.logWriter_, "not yet implemented"); } |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.math.BigDecimal"); | final java.math.BigDecimal getBigDecimal(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getBigDecimalFromBoolean( getBoolean(column) ); case java.sql.Types.DECIMAL: return get_DECIMAL(colum... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.sql.Blob"); | public final java.sql.Blob getBlob(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case Types.BLOB: return getBlobColumn_(column, agent_); default: throw new ColumnTypeConversionException(agent_.logWriter_); } } |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "boolean"); | final boolean getBoolean(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return get_BOOLEAN(column); case java.sql.Types.SMALLINT: return agent_.crossConverters_.getBooleanFromShort(get_SMALLINT(column)); case java... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "byte"); | final byte getByte(int column) throws SqlException { // This needs to be changed to use jdbcTypes[] switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getByteFromBoolean( getBoolean(column) ); case java.sql.Types.SMALLINT: ... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "byte[]"); | final byte[] getBytes(int column) throws SqlException { try { switch (jdbcTypes_[column - 1]) { case java.sql.Types.BINARY: return get_CHAR_FOR_BIT_DATA(column); case java.sql.Types.VARBINARY: case java.sql.Types.LONGVARBINARY: return ... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.sql.Clob"); | public final java.sql.Clob getClob(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case Types.CLOB: return getClobColumn_(column, agent_); default: throw new ColumnTypeConversionException(agent_.logWriter_); } } |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.sql.Date"); | final java.sql.Date getDate(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case java.sql.Types.DATE: return getDATE(column); case java.sql.Types.TIMESTAMP: return getDateFromTIMESTAMP(column); case java.sql.Types.CHAR: return agent_.c... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "double"); | final double getDouble(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getDoubleFromBoolean( getBoolean(column) ); case java.sql.Types.REAL: double d = (double) get_FLOAT(column); ... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "float"); | final float getFloat(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getFloatFromBoolean( getBoolean(column) ); case java.sql.Types.REAL: return get_FLOAT(column); case java.sql.Types... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "int"); | final int getInt(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getIntFromBoolean( getBoolean(column) ); case java.sql.Types.SMALLINT: return (int) get_SMALLINT(column); case java.sq... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "long"); | final long getLong(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getLongFromBoolean( getBoolean(column) ); case java.sql.Types.SMALLINT: return (long) get_SMALLINT(column); case jav... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "Object"); | public final Object getObject(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return new Boolean( getBoolean(column) ); case java.sql.Types.SMALLINT: return new Integer(get_SMALLINT(column)); // See Table 4 in JDBC 1 spec... |
throw new SqlException(agent_.logWriter_, "not yet implemented"); | throw new SqlException(agent_.logWriter_, new MessageId (SQLState.NOT_IMPLEMENTED), "getRef(int)"); | public final java.sql.Ref getRef(int column) throws SqlException { throw new SqlException(agent_.logWriter_, "not yet implemented"); } |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "short"); | final short getShort(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getShortFromBoolean( getBoolean(column) ); case java.sql.Types.SMALLINT: return get_SMALLINT(column); case java.sq... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "String"); | final String getString(int column) throws SqlException { try { String tempString = null; switch (jdbcTypes_[column - 1]) { case JDBC30Translation.BOOLEAN: return agent_.crossConverters_.getStringFromBoolean( getBoolean(column) ); case java.sql.Types.... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.sql.Time"); | final java.sql.Time getTime(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case java.sql.Types.TIME: return getTIME(column); case java.sql.Types.TIMESTAMP: return getTimeFromTIMESTAMP(column); case java.sql.Types.CHAR: return agent_.c... |
throw new ColumnTypeConversionException(agent_.logWriter_); | throw new ColumnTypeConversionException(agent_.logWriter_, "java.sql.Types " + jdbcTypes_[column -1], "java.sql.Timestamp"); | final java.sql.Timestamp getTimestamp(int column) throws SqlException { switch (jdbcTypes_[column - 1]) { case java.sql.Types.TIMESTAMP: return getTIMESTAMP(column); case java.sql.Types.DATE: return getTimestampFromDATE(column); case java.sql.Types.TIME: ... |
int type, int concurrency, int holdability, int autoGeneratedKeys, String[] columnNames) throws SqlException { super.resetStatement(agent, connection, type, concurrency, holdability, autoGeneratedKeys, columnNames); | Section section) throws SqlException { super.resetStatement(agent, connection); | public void resetPreparedStatement(Agent agent, Connection connection, String sql, int type, int concurrency, int holdability, int autoGeneratedKeys, String[] columnNames) throws SqlException { s... |
initPreparedStatement(sql); | initPreparedStatement(sql, section); | public void resetPreparedStatement(Agent agent, Connection connection, String sql, int type, int concurrency, int holdability, int autoGeneratedKeys, String[] columnNames) throws SqlException { s... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.