public HsqlDataReader(org.hsqldb.Result result) { if (result == null) { throw new ArgumentNullException("result"); } else if (result.isError()) { throw new HsqlDataSourceException(result); } else if (result.isUpdateCount()) { m_recordsAffected = result.getUpdateCount(); } else if (result.isData()) { m_recordsAffected = -1; m_result = result; m_fieldCount = result.getColumnCount(); m_metaData = result.metaData; m_columnTypes = m_metaData.colTypes; } else { throw new InvalidOperationException( "Unhandled Result Mode: " + result.mode); } }
/// <summary> /// Executes the given SQL character sequence directly, /// returning a scalar value. /// </summary> /// <param name="sql"> /// The SQL character sequence to execute. /// </param> /// <returns> /// A scalar value representing the result of the execution. /// </returns> internal object ExecuteScalarDirect(string sql) { Request request = s_protocol.CreateExecuteDirectRequest(sql); s_protocol.SetMaxRows(request, 1); Response response = Execute(request); if (response.isUpdateCount() || 0 >= response.getColumnCount() || response.isEmpty()) { return(null); } object value = response.rRoot.data[0]; if (value == null) { return(null); } else if (value is string) { return(value); } else { int type = response.metaData.colTypes[0]; return(HsqlConvert.FromJava.ToObject(value, type)); } }
/// <summary> /// Constructs a new <c>HsqlTcpClient</c> instance /// with the given host, port, etc. /// </summary> /// <param name="host">The server host name or IP address.</param> /// <param name="port">The server listen port.</param> /// <param name="path">The database remote open path. (presently unused/unsupported)</param> /// <param name="database">The server alias for one of its mounted databases</param> /// <param name="tls">The Transport Layer Security flag</param> /// <param name="user">The initial database user name.</param> /// <param name="password">The initial database user password.</param> /// <exception cref="HsqlException"> /// </exception> internal HsqlTcpClient( string host, int port, string path, string database, bool tls, string user, string password) { m_host = host; m_port = port; m_path = path; m_database = database; m_tls = tls; InitializeInstance(); InitializeConnection(host, port, tls); Request loginRequest = m_Protocol.CreateTcpClientLoginRequest( user, password, database); Response loginResponse = Session.execute(loginRequest); if (loginResponse.isError()) { throw Trace.error(loginResponse); } m_sessionId = m_Protocol.GetSessionId(loginResponse); m_databaseId = m_Protocol.GetDatabaseId(loginResponse); }
/// <summary> /// Executes the prepared non query request. /// </summary> /// <param name="request">The request.</param> /// <returns> /// The number of rows affected. /// </returns> internal int ExecuteNonQueryPrepared(Request request) { s_protocol.SetMaxRows(request, 1); Response response = Execute(request); return(s_protocol.GetUpdateCount(response)); }
/// <summary> /// Performs common instance-scope initialization. /// </summary> protected void InitializeInstance() { HsqlDiagnostics.Debug("..."); m_rowOutput = new RowOutputBinary(m_buffer); m_rowInput = new RowInputBinary(m_rowOutput); m_request = m_Protocol.CreateAttributeRequest(); m_autoCommit = true; }
/// <summary> /// Reads a response. /// </summary> /// <returns>An object representing the response.</returns> /// <exception cref="java.io.IOException"></exception> /// <exception cref="org.hsqldb.HsqlException"></exception> //[CLSCompliant(false)] protected Response ReadResponse() { Response response = Response.read(m_rowInput, m_dataInput); m_rowOutput.setBuffer(m_buffer); m_rowInput.resetRow(m_buffer.Length); return(response); }
/// <summary> /// Executes the given prepared statement. /// </summary> /// <param name="statementId">The statement identifier.</param> /// <param name="parameterTypes">The parameter types.</param> /// <param name="parameterData">The parameter data.</param> /// <returns></returns> internal object ExecuteScalarPrepared(int statementId, int[] parameterTypes, object[] parameterData) { Request request = new Request(RequestType.SQLEXECUTE, parameterTypes, statementId); s_protocol.SetParameterData(request, parameterData); return(ExecuteScalarPrepared(request)); }
/// <summary> /// Executes the given SQL character sequence directly, /// returning a count of the rows affected. /// </summary> /// <param name="sql"> /// The SQL character sequence to execute. /// </param> /// <returns> /// The count of the rows affected. /// </returns> internal int ExecuteNonQueryDirect(string sql) { Request request = s_protocol.CreateExecuteDirectRequest(sql); s_protocol.SetMaxRows(request, 1); Response response = Execute(request); return(s_protocol.GetUpdateCount(response)); }
public HsqlDataReader( org.hsqldb.Result result, CommandBehavior commandBehavior, HsqlCommand originatingCommand, HsqlConnection originatingConnection) : this(result) { m_commandBehavior = commandBehavior; m_originatingCommand = originatingCommand; m_originatingConnection = originatingConnection; }
/// <summary> /// Gets the value of the session attribute with the given identifier. /// </summary> /// <param name="attributeId">The attribute identifier.</param> /// <returns>The attribute value</returns> private object GetAttribute(int attributeId) { m_Protocol.SetType(m_request, RequestType.GETSESSIONATTR); Response response = Session.execute(m_request); if (response.isError()) { throw Trace.error(response); } switch (attributeId) { case SessionInfo.INFO_AUTOCOMMIT: { return(m_Protocol.GetAttributeAutoCommit(response)); } case SessionInfo.INFO_CONNECTION_READONLY: { return(m_Protocol.GetAttributeConnectionReadOnly( response)); } case SessionInfo.INFO_DATABASE: { return(m_Protocol.GetAttributeDatabase(response)); } case SessionInfo.INFO_DATABASE_READONLY: { return(m_Protocol.GetAttributeDatabaseReadOnly( response)); } case SessionInfo.INFO_ISOLATION: { return(m_Protocol.GetAttributeIsolation(response)); } case SessionInfo.INFO_USER: { return(m_Protocol.GetAttributeUser(response)); } default: { throw new ArgumentException( "attributeId", "Unknown Attribute Id: " + attributeId); } } }
/// <summary> /// Releases all result row storage, making it elligible /// for garbage collection. /// </summary> internal void DisposeResult() { org.hsqldb.Result result = m_result; if (result != null) { result.clear(); } m_recordsAffectedCounts = s_NoUpdateCounts; m_recordsAffectedIndex = 0; }
public static void WriteResult(Stream stream, org.hsqldb.Result result) { JavaOutputStreamAdapter outputStream = new JavaOutputStreamAdapter(stream); org.hsqldb.rowio.RowOutputBinary rowOutput = new org.hsqldb.rowio.RowOutputBinary(); org.hsqldb.Result.write( result, rowOutput, outputStream); }
/// <summary> /// Executes the prepared statement with the given identifier, /// parameter types and parameter values, returning the count of /// the rows affected. /// </summary> /// <param name="statementId">The statement identifier.</param> /// <param name="parameterTypes">The parameter types.</param> /// <param name="parameterData">The parameter data.</param> /// <returns>The count of the rows affected.</returns> internal int ExecuteNonQueryPrepared( int statementId, int[] parameterTypes, object[] parameterData) { Request request = new Request(RequestType.SQLEXECUTE, parameterTypes, statementId); request.setParameterData(parameterData); return(ExecuteNonQueryPrepared(request)); }
/// <summary> /// Executes the given batch of non-query SQL /// character sequences directly. /// </summary> /// <param name="sql"> /// The batch of non-query SQL character sequences. /// </param> /// <returns> /// An array representing the number of rows /// affected by each element of the batch /// execution. /// </returns> internal int[] ExecuteNonQueryBatchDirect(string[] sql) { int batchSize = sql.Length; Request request = s_protocol.CreateExecuteBatchDirectRequest(); for (int i = 0; i < batchSize; i++) { object[] batchItem = new object[] { sql[i] }; request.add(batchItem); } return(ExecuteNonQueryBatchDirect(request, batchSize)); }
/// <summary> /// Executes the prepared non-query batch. /// </summary> /// <param name="request"> /// The prepared batch request. /// </param> /// <param name="expectedUpdateCounts"> /// The expected number of update counts. /// </param> /// <returns> /// An array representing the number of rows /// affected by each element of the batch /// execution. /// </returns> internal int[] ExecuteNonQueryBatchPrepared(Request request, int expectedUpdateCounts) { Response response = Execute(request); int[] updateCounts = s_protocol.GetUpdateCounts(response); if (updateCounts.Length != expectedUpdateCounts) { throw new HsqlBatchUpdateException(updateCounts); } return(updateCounts); }
/// <summary> /// Sets the value of the attribute denoted by the given identifier. /// </summary> /// <param name="value">The attribute value.</param> /// <param name="attributeId">The attribute identifier.</param> /// <exception cref="HsqlException"> /// </exception> private void SetAttribute(object value, int attributeId) { m_Protocol.SetType(m_request, RequestType.SETSESSIONATTR); m_Protocol.ClearAttributes(m_request); switch (attributeId) { case SessionInfo.INFO_AUTOCOMMIT: { m_Protocol.SetAttributeAutoCommit( m_request, (bool)value); break; } case SessionInfo.INFO_CONNECTION_READONLY: { m_Protocol.SetAttributeConnectionReadOnly( m_request, (bool)value); break; } case SessionInfo.INFO_ISOLATION: { m_Protocol.SetAttributeIsolation( m_request, (int)value); break; } default: { throw new System.ArgumentException( "attributeId", "Invalid Attribute Id: " + attributeId); } } Response response = Session.execute(m_request); if (response.isError()) { throw Trace.error(response); } }
static HsqlResult NewResult() { int columnCount = columns.GetUpperBound(1); HsqlResult result = new HsqlResult(columnCount); object[] row = new object[columnCount]; int i = 0; const int TypeOrdinal = 0; const int ValueOrdinal = 1; result.add(row); foreach (object[] column in columns) { HsqlProviderType dataType = (HsqlProviderType)column[TypeOrdinal]; row[i] = column[ValueOrdinal]; int scale = 0; switch (dataType) { case HsqlProviderType.Decimal: case HsqlProviderType.Numeric: { scale = 4; break; } } int size = HsqlTypes.getPrecision((int)dataType); result.metaData.catalogNames[i] = "mem:test"; result.metaData.classNames[i] = HsqlTypes.getTypeName((int)dataType); result.metaData.colLabels[i] = "COLUMN_" + i; result.metaData.colNames[i] = "C" + i; result.metaData.colNullable[i] = (int)BaseColumnNullability.Nullable; result.metaData.colScales[i] = scale; result.metaData.colSizes[i] = size; result.metaData.colTypes[i] = (int)dataType; result.metaData.isIdentity[i] = false; result.metaData.isLabelQuoted[i] = false; result.metaData.isWritable[i] = false; result.metaData.paramMode[i] = (int)ParameterMode.Unknown; result.metaData.schemaNames[i] = "PUBLIC"; result.metaData.tableNames[i] = "ALL_COL_TYPES"; } return(result); }
/// <summary> /// Resets this session. /// </summary> /// <remarks> /// Used to reset the remote session object. In case of /// failure, the underlying TPC connection is physically /// closed. When a pooled database connection's close() /// method is called, it should delegate to this method /// instead of ISession.close() and return this object /// to the pool upon success. In this way, a remote session /// proxy object can be reused with no further /// initialisation. /// </remarks> /// <exception cref="HsqlException"> /// </exception> void ISession.resetSession() { Request request = new Request(RequestType.HSQLRESETSESSION); Response response = Session.execute(request); if (response.isError()) { m_closed = true; CloseConnection(); throw Trace.error(response); } m_sessionId = m_Protocol.GetSessionId(response); m_databaseId = m_Protocol.GetDatabaseId(response); }
/// <summary> /// Executes the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns> /// The result of executing the specified request. /// </returns> internal Response Execute(Request request) { try { Response response = m_session.execute(request); if (response.isError()) { throw new HsqlDataSourceException(response); } return(response); } catch (HsqlException e) { throw new HsqlDataSourceException(e); } }
/// <summary> /// Initializes a new instance of the /// <see cref="HsqlStatement"/> class. /// </summary> /// <param name="statementId"> /// The statement identifier. /// </param> /// <param name="resultDescriptor"> /// The result meta data descriptor. /// </param> /// <param name="parameterDescriptor"> /// The parameter meta data descriptor. /// </param> internal HsqlStatement( int statementId, ResultDescriptor resultDescriptor, ParameterDescriptor parameterDescriptor) { m_statementId = statementId; m_resultDescriptor = resultDescriptor; m_parameterDescriptor = parameterDescriptor; m_request = new Request( RequestType.SQLEXECUTE, m_parameterDescriptor.metaData.colTypes, m_statementId); m_batchRequest = new Request( RequestType.SQLEXECUTE, m_parameterDescriptor.metaData.colTypes, m_statementId); }
//private int m_maxRows = 0; #endregion #region Constructors #region HsqlStatement(int,Result,Result) /// <summary> /// Initializes a new instance of the /// <see cref="HsqlStatement"/> class. /// </summary> /// <param name="statementId"> /// The statement identifier. /// </param> /// <param name="resultDescriptor"> /// The result meta data descriptor. /// </param> /// <param name="parameterDescriptor"> /// The parameter meta data descriptor. /// </param> internal HsqlStatement( int statementId, ResultDescriptor resultDescriptor, ParameterDescriptor parameterDescriptor) { m_statementId = statementId; m_resultDescriptor = resultDescriptor; m_parameterDescriptor = parameterDescriptor; m_request = new Request( RequestType.SQLEXECUTE, m_parameterDescriptor.metaData.colTypes, m_statementId); m_batchRequest = new Request( RequestType.SQLEXECUTE, m_parameterDescriptor.metaData.colTypes, m_statementId); }
/// <summary> /// Executes the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> /// <exception cref="HsqlException"> /// </exception> Response ISession.execute(Request request) { lock (this) { try { m_Protocol.SetSessionId(request, m_sessionId); m_Protocol.SetDatabaseId(request, m_databaseId); WriteRequest(request); return(ReadResponse()); } catch (System.Exception e) { throw Trace.error( Trace.CONNECTION_IS_BROKEN, e.ToString()); } } }
/// <summary> /// Prepares the specified SQL character sequence, /// returning an <see cref="HsqlStatement"/> /// object encapsulating the compiled form. /// </summary> /// <param name="sql">The SQL character sequence to prepare.</param> /// <returns> /// The compiled form of the given SQL character sequence. /// </returns> internal HsqlStatement PrepareStatement(string sql) { Request request = s_protocol.CreatePrepareStatementRequest(sql); Response response = Execute(request); // TODO: A bit messy to sit here on the .NET side? // Perhaps encapsulate some of this in HsqlProtocol org.hsqldb.Record root = response.rRoot; PrepareAck pAck = (PrepareAck)root.data[0]; int statementId = s_protocol.GetStatementId(pAck); ResultDescriptor resultDescriptor = (ResultDescriptor)root.next.data[0]; ParameterDescriptor parameterDescriptor = (ParameterDescriptor)root.next.next.data[0]; return(new HsqlStatement(statementId, resultDescriptor, parameterDescriptor)); }
/// <summary> /// Executes the given prepared request, returning a scalar value. /// </summary> /// <param name="request">The prepared request.</param> /// <returns> /// The scalar value. This is the first column of first row; /// <c>null</c> when the result has no columns or no rows. /// </returns> internal object ExecuteScalarPrepared(Request request) { s_protocol.SetMaxRows(request, 1); Response response = Execute(request); if (response.isUpdateCount() || (0 >= response.getColumnCount()) || response.isEmpty()) { return(null); } // No check for null pointers or array bounds violation. // We cannot get this far and still // have a rRoot == null, rRoot.data == null or // rRoot.data.Length < 1 condition, unless // there is an actual (and serious) bug in the // underlying libraries. object value = response.rRoot.data[0]; if (value == null) { return(null); } else if (value is string) { return(value); } else { int type = response.metaData.colTypes[0]; return(HsqlConvert.FromJava.ToObject(value, type)); } }
public HsqlDataSourceException(HsqlResult result) : this(new HsqlException(result)) { }
/// <summary> /// Executes the prepared statement with the given identifier, /// parameter types and parameter values, returning the count of /// the rows affected. /// </summary> /// <param name="statementId">The statement identifier.</param> /// <param name="parameterTypes">The parameter types.</param> /// <param name="parameterData">The parameter data.</param> /// <returns>The count of the rows affected.</returns> internal int ExecuteNonQueryPrepared( int statementId, int[] parameterTypes, object[] parameterData) { Request request = new Request(RequestType.SQLEXECUTE, parameterTypes, statementId); request.setParameterData(parameterData); return ExecuteNonQueryPrepared(request); }
/// <summary> /// Retrieves a <see cref="System.String"/> value /// describing the given <c>request</c>. /// </summary> /// <param name="request"> /// For which to retrieve the <c>String</c> value. /// </param> /// <returns> /// The corresponding value. /// </returns> internal static string RequestToString(Request request) { StringBuilder sb = new StringBuilder(); int requestType = s_protocol.GetType(request); switch (requestType) { case RequestType.SQLPREPARE: { sb.AppendFormat( "SQLCLI:SQLPREPARE {0}", s_protocol.GetCommandText(request)); break; } case RequestType.SQLEXECDIRECT: { if (request.getSize() <= 1) { sb.Append(s_protocol.GetCommandText(request)); } else { sb.AppendLine("SQLCLI:SQLEXECDIRECT:BATCHMODE"); Iterator it = request.iterator(); while (it.hasNext()) { object[] data = (object[])it.next(); sb.Append(data[0]).Append('\n'); } } break; } case RequestType.SQLEXECUTE: { sb.Append("SQLCLI:SQLEXECUTE:"); if (request.getSize() > 1) { sb.Append("BATCHMODE:"); } sb.Append(s_protocol.GetStatementId(request)); break; } case RequestType.SQLFREESTMT: { sb.Append("SQLCLI:SQLFREESTMT:") .Append(s_protocol.GetStatementId(request)); break; } case RequestType.GETSESSIONATTR: { sb.Append("HSQLCLI:GETSESSIONATTR"); break; } case RequestType.SETSESSIONATTR: { // TODO - make this clean object autoCommit = request.rRoot.data[4]; object readOnly = request.rRoot.data[6]; sb.Append("HSQLCLI:SETSESSIONATTR:"); if (autoCommit != null) { sb.AppendFormat( " AUTOCOMMIT {0}", autoCommit); } if (readOnly != null) { sb.AppendFormat( " CONNECTION_READONLY {0}", readOnly); } break; } case RequestType.SQLENDTRAN: { sb.Append("SQLCLI:SQLENDTRAN:"); int endTranType = s_protocol.GetEndTranType( request); switch (endTranType) { case RequestType.COMMIT: { sb.Append("COMMIT"); break; } case RequestType.ROLLBACK: { sb.Append("ROLLBACK"); break; } case RequestType.SAVEPOINT_NAME_RELEASE: { sb.AppendFormat( "SAVEPOINT_NAME_RELEASE {0}", s_protocol.GetSavepointName(request)); break; } case RequestType.SAVEPOINT_NAME_ROLLBACK: { sb.AppendFormat( "SAVEPOINT_NAME_ROLLBACK {0}", s_protocol.GetSavepointName(request)); break; } case RequestType.COMMIT_AND_CHAIN: { sb.Append("COMMIT_AND_CHAIN"); break; } case RequestType.ROLLBACK_AND_CHAIN: { sb.Append("ROLLBACK_AND_CHAIN"); break; } default: { sb.Append(endTranType); break; } } break; } case RequestType.SQLSTARTTRAN: { sb.Append("SQLCLI:SQLSTARTTRAN"); break; } case RequestType.SQLDISCONNECT: { sb.Append("SQLCLI:SQLDISCONNECT"); break; } case RequestType.SQLSETCONNECTATTR: { sb.Append("SQLCLI:SQLSETCONNECTATTR:"); int attributeType = s_protocol.GetAttributeType( request); switch (attributeType) { case RequestType.SQL_ATTR_SAVEPOINT_NAME: { sb.AppendFormat( "SQL_ATTR_SAVEPOINT_NAME {0}", s_protocol.GetSavepointName(request)); break; } default: { sb.Append(attributeType); break; } } break; } default: { sb.AppendFormat("SQLCLI:MODE:{0}", requestType); break; } } return sb.ToString(); }
/// <summary> /// Writes the specified request. /// </summary> /// <param name="request">The request.</param> /// <exception cref="java.io.IOException"></exception> /// <exception cref="org.hsqldb.HsqlException"></exception> //[CLSCompliant(false)] protected void WriteRequest(Request request) { HsqlDiagnostics.DebugRequest(request); Request.write(request, m_rowOutput, m_dataOutput); }
/// <summary> /// Retrieves a <see cref="System.String"/> value /// describing the given <c>request</c>. /// </summary> /// <param name="request"> /// For which to retrieve the <c>String</c> value. /// </param> /// <returns> /// The corresponding value. /// </returns> internal static string RequestToString(Request request) { StringBuilder sb = new StringBuilder(); int requestType = s_protocol.GetType(request); switch (requestType) { case RequestType.SQLPREPARE: { sb.AppendFormat( "SQLCLI:SQLPREPARE {0}", s_protocol.GetCommandText(request)); break; } case RequestType.SQLEXECDIRECT: { if (request.getSize() <= 1) { sb.Append(s_protocol.GetCommandText(request)); } else { sb.AppendLine("SQLCLI:SQLEXECDIRECT:BATCHMODE"); Iterator it = request.iterator(); while (it.hasNext()) { object[] data = (object[])it.next(); sb.Append(data[0]).Append('\n'); } } break; } case RequestType.SQLEXECUTE: { sb.Append("SQLCLI:SQLEXECUTE:"); if (request.getSize() > 1) { sb.Append("BATCHMODE:"); } sb.Append(s_protocol.GetStatementId(request)); break; } case RequestType.SQLFREESTMT: { sb.Append("SQLCLI:SQLFREESTMT:") .Append(s_protocol.GetStatementId(request)); break; } case RequestType.GETSESSIONATTR: { sb.Append("HSQLCLI:GETSESSIONATTR"); break; } case RequestType.SETSESSIONATTR: { // TODO - make this clean object autoCommit = request.rRoot.data[4]; object readOnly = request.rRoot.data[6]; sb.Append("HSQLCLI:SETSESSIONATTR:"); if (autoCommit != null) { sb.AppendFormat( " AUTOCOMMIT {0}", autoCommit); } if (readOnly != null) { sb.AppendFormat( " CONNECTION_READONLY {0}", readOnly); } break; } case RequestType.SQLENDTRAN: { sb.Append("SQLCLI:SQLENDTRAN:"); int endTranType = s_protocol.GetEndTranType( request); switch (endTranType) { case RequestType.COMMIT: { sb.Append("COMMIT"); break; } case RequestType.ROLLBACK: { sb.Append("ROLLBACK"); break; } case RequestType.SAVEPOINT_NAME_RELEASE: { sb.AppendFormat( "SAVEPOINT_NAME_RELEASE {0}", s_protocol.GetSavepointName(request)); break; } case RequestType.SAVEPOINT_NAME_ROLLBACK: { sb.AppendFormat( "SAVEPOINT_NAME_ROLLBACK {0}", s_protocol.GetSavepointName(request)); break; } case RequestType.COMMIT_AND_CHAIN: { sb.Append("COMMIT_AND_CHAIN"); break; } case RequestType.ROLLBACK_AND_CHAIN: { sb.Append("ROLLBACK_AND_CHAIN"); break; } default: { sb.Append(endTranType); break; } } break; } case RequestType.SQLSTARTTRAN: { sb.Append("SQLCLI:SQLSTARTTRAN"); break; } case RequestType.SQLDISCONNECT: { sb.Append("SQLCLI:SQLDISCONNECT"); break; } case RequestType.SQLSETCONNECTATTR: { sb.Append("SQLCLI:SQLSETCONNECTATTR:"); int attributeType = s_protocol.GetAttributeType( request); switch (attributeType) { case RequestType.SQL_ATTR_SAVEPOINT_NAME: { sb.AppendFormat( "SQL_ATTR_SAVEPOINT_NAME {0}", s_protocol.GetSavepointName(request)); break; } default: { sb.Append(attributeType); break; } } break; } default: { sb.AppendFormat("SQLCLI:MODE:{0}", requestType); break; } } return(sb.ToString()); }
/// <summary> /// Executes the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns> /// The result of executing the specified request. /// </returns> internal Response Execute(Request request) { try { Response response = m_session.execute(request); if (response.isError()) { throw new HsqlDataSourceException(response); } return response; } catch (HsqlException e) { throw new HsqlDataSourceException(e); } }
/// <summary> /// Executes the prepared non-query batch. /// </summary> /// <param name="request"> /// The prepared batch request. /// </param> /// <param name="expectedUpdateCounts"> /// The expected number of update counts. /// </param> /// <returns> /// An array representing the number of rows /// affected by each element of the batch /// execution. /// </returns> internal int[] ExecuteNonQueryBatchPrepared(Request request, int expectedUpdateCounts) { Response response = Execute(request); int[] updateCounts = s_protocol.GetUpdateCounts(response); if (updateCounts.Length != expectedUpdateCounts) { throw new HsqlBatchUpdateException(updateCounts); } return updateCounts; }
internal static void DebugRequest(Request request) { #if DEBUG Debug0("request: {0}", RequestToString(request)); #endif }
/// <summary> /// Executes the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> /// <exception cref="HsqlException"> /// </exception> Response ISession.execute(Request request) { lock (this) { try { m_Protocol.SetSessionId(request, m_sessionId); m_Protocol.SetDatabaseId(request, m_databaseId); WriteRequest(request); return ReadResponse(); } catch (System.Exception e) { throw Trace.error( Trace.CONNECTION_IS_BROKEN, e.ToString()); } } }
/// <summary> /// Retrieves a <c>DataTable</c> object representing the column /// metadata of the given data reader's current result. /// </summary> /// <param name="reader"> /// A reader object for which to retrieve the column metadata. /// </param> /// <returns> /// A <c>DataTable</c> object representing the column metadata of the /// given data reader's current result. /// </returns> /// <exception cref="HsqlDataSourceException"> /// If a data access error occurs. /// </exception> public static DataTable CreateSchemaTable(HsqlDataReader reader) { Result result = reader.m_result; int columnCount = result.getColumnCount(); ResultMetaData metaData = result.metaData; DataTable table = CreateTable(columnCount); bool includeKeyInfo = reader.HasCommandBehavior(CommandBehavior.KeyInfo); Dictionary <ColumnIdentifier, KeyInfo> keyInfoMap = (includeKeyInfo) ? HsqlResultSetMetaData.GetKeyInfo(reader) : null; string catalogName = reader.OriginatingConnection.Database; for (int i = 0; i < columnCount; i++) { bool isAutoIncrement = metaData.isIdentity[i]; string columnName = metaData.colLabels[i]; int columnOrdinal = i; int columnSize = metaData.colSizes[i]; int numericPrecision = metaData.colSizes[i]; int numericScale = metaData.colScales[i]; bool isUnique = false; // isAutoIncrement; bool isKey = isAutoIncrement; string baseServerName = null; string baseCatalogName = catalogName;//metaData.catalogNames[i]; string baseColumnName = metaData.colNames[i]; string baseSchemaName = metaData.schemaNames[i]; string baseTableName = metaData.tableNames[i]; int providerType = metaData.colTypes[i]; Type dataType = HsqlConvert.ToDataType(providerType); int nullability = metaData.colNullable[i]; bool allowDBNull = isAutoIncrement || (nullability != 0); bool isAliased = (columnName != baseColumnName); bool isExpression = string.IsNullOrEmpty(baseTableName); bool isIdentity = isAutoIncrement; bool isRowVersion = false; bool isHidden = false; bool isLong = HsqlConvert.ToIsLongProviderType(providerType); bool isReadOnly = !metaData.isWritable[i]; if ((columnSize == 0) && HsqlTypes.isCharacterType(providerType)) { columnSize = HsqlTypes.getPrecision(providerType); } if ((numericPrecision == 0) && HsqlTypes.isNumberType(providerType)) { numericPrecision = HsqlTypes.getPrecision(providerType); } if (includeKeyInfo) { if (!(string.IsNullOrEmpty(baseTableName) || string.IsNullOrEmpty(baseColumnName))) { ColumnIdentifier key = new ColumnIdentifier( baseSchemaName, baseTableName, baseColumnName); KeyInfo keyInfo; if (keyInfoMap.TryGetValue(key, out keyInfo)) { isKey = keyInfo.m_isKey; isUnique = keyInfo.m_isUnique; } } } HsqlResultSetMetaData.AddRow(table, columnName, columnOrdinal, columnSize, numericPrecision, numericScale, isUnique, isKey, baseServerName, baseCatalogName, baseColumnName, baseSchemaName, baseTableName, dataType, allowDBNull, providerType, isAliased, isExpression, isIdentity, isAutoIncrement, isRowVersion, isHidden, isLong, isReadOnly); } DataColumnCollection columns = table.Columns; int count = columns.Count; for (int i = 0; i < count; i++) { columns[i].ReadOnly = true; } return(table); }
/// <summary> /// Provides the core logic for the /// <see cref="ExecuteReader(CommandBehavior)"/> method. /// </summary> /// <param name="behavior">The requested behavior.</param> /// <returns> /// The result generated by executing the query. /// </returns> internal HsqlDataReader ExecuteReaderInternal(CommandBehavior behavior) { if (Behavior.IsSchemaOnly(behavior)) { bool wasAlreadyPrepared = IsPrepared; if (!wasAlreadyPrepared) { Prepare(); // already correctly locked. } Result descriptor = m_statement.ResultDescriptor; HsqlCommand originatingCommand = this; HsqlConnection originatingConnection = m_dbConnection; HsqlDataReader reader0 = new HsqlDataReader(descriptor, behavior, originatingCommand, originatingConnection); if (Behavior.IsKeyInfo(behavior)) { // Do it now, so that it does not fail later if // originating connection is closed before first // client invocation of reader.GetSchemaTable(). reader0.GetSchemaTable(); } if (!wasAlreadyPrepared) { UnPrepare(); } return(reader0); } Result result; int maxRows = (Behavior.IsSingleRow(behavior)) ? 1 : 0; if (IsPrepared) { ApplyParameters(); HsqlSession session = Session; session.MaxRows = maxRows; result = m_statement.Execute(session); } else { HsqlSession session = Session; session.MaxRows = maxRows; result = session.ExecuteDirect(StaticallyBoundCommandText); } HsqlDataReader reader = new HsqlDataReader(result, behavior, this, this.m_dbConnection); if (Behavior.IsKeyInfo(behavior)) { // Do it now, so that it does not fail later if // originating connection is closed before first // client invocation of reader.GetSchemaTable(). reader.GetSchemaTable(); } return(reader); }
/// <summary> /// Executes the given prepared request, returning a scalar value. /// </summary> /// <param name="request">The prepared request.</param> /// <returns> /// The scalar value. This is the first column of first row; /// <c>null</c> when the result has no columns or no rows. /// </returns> internal object ExecuteScalarPrepared(Request request) { s_protocol.SetMaxRows(request, 1); Response response = Execute(request); if (response.isUpdateCount() || (0 >= response.getColumnCount()) || response.isEmpty()) { return null; } // No check for null pointers or array bounds violation. // We cannot get this far and still // have a rRoot == null, rRoot.data == null or // rRoot.data.Length < 1 condition, unless // there is an actual (and serious) bug in the // underlying libraries. object value = response.rRoot.data[0]; if (value == null) { return null; } else if (value is string) { return value; } else { int type = response.metaData.colTypes[0]; return HsqlConvert.FromJava.ToObject(value, type); } }
static HsqlResult NewResult() { int columnCount = columns.GetUpperBound(1); HsqlResult result = new HsqlResult(columnCount); object[] row = new object[columnCount]; int i = 0; const int TypeOrdinal = 0; const int ValueOrdinal = 1; result.add(row); foreach (object[] column in columns) { HsqlProviderType dataType = (HsqlProviderType)column[TypeOrdinal]; row[i] = column[ValueOrdinal]; int scale = 0; switch(dataType) { case HsqlProviderType.Decimal: case HsqlProviderType.Numeric: { scale = 4; break; } } int size = HsqlTypes.getPrecision((int)dataType); result.metaData.catalogNames[i] = "mem:test"; result.metaData.classNames[i] = HsqlTypes.getTypeName((int)dataType); result.metaData.colLabels[i] = "COLUMN_" + i; result.metaData.colNames[i] = "C" + i; result.metaData.colNullable[i] = (int) BaseColumnNullability.Nullable; result.metaData.colScales[i] = scale; result.metaData.colSizes[i] = size; result.metaData.colTypes[i] = (int) dataType; result.metaData.isIdentity[i] = false; result.metaData.isLabelQuoted[i] = false; result.metaData.isWritable[i] = false; result.metaData.paramMode[i] = (int) ParameterMode.Unknown; result.metaData.schemaNames[i] = "PUBLIC"; result.metaData.tableNames[i] = "ALL_COL_TYPES"; } return result; }
/// <summary> /// Executes the given prepared statement. /// </summary> /// <param name="statementId">The statement identifier.</param> /// <param name="parameterTypes">The parameter types.</param> /// <param name="parameterData">The parameter data.</param> /// <returns></returns> internal object ExecuteScalarPrepared(int statementId, int[] parameterTypes, object[] parameterData) { Request request = new Request(RequestType.SQLEXECUTE, parameterTypes, statementId); s_protocol.SetParameterData(request, parameterData); return ExecuteScalarPrepared(request); }
internal static void DebugResponse(Response response) { #if DEBUG int responseType = s_protocol.GetType(response); switch (responseType) { case ResponseType.UPDATECOUNT: { Debug0("response: updatecount: {0}", s_protocol.GetUpdateCount(response)); break; } case ResponseType.DATA: { Debug0("response: data:\n {0}", ResultMetaDataToString(response.metaData)); break; } case ResponseType.ERROR: { HsqlException hex = new HsqlException(response); int errorCode = hex.getErrorCode(); string sqlState = hex.getSQLState(); string message = hex.getMessage(); Debug0("response: error: [{0}] [{1}] {2}", errorCode, sqlState, message); break; } case ResponseType.MULTI: { Debug0("response: multi..."); Record record = response.rRoot; int count = 0; while (record != null) { response = record.data[0] as Response; if (response != null) { count++; Debug0("multi response {0}:", count); DebugResponse(response); } } break; } case ResponseType.SQLEXECUTE: { Debug0("response: sqlexecute"); // TODO: // // Basically, we need to know the responseType of // request to which this is a response, before we // can interpret the rest of the response // properly. The request could have been // to prepare a statement, to execute a batch, // etc. break; } default: { Debug0("response: responseType {0}", responseType); break; } } #endif }
/// <summary> /// Executes the prepared non query request. /// </summary> /// <param name="request">The request.</param> /// <returns> /// The number of rows affected. /// </returns> internal int ExecuteNonQueryPrepared(Request request) { s_protocol.SetMaxRows(request,1); Response response = Execute(request); return s_protocol.GetUpdateCount(response); }