/// <summary> /// Raises the <see cref="E:Warning"/> event. /// </summary> /// <param name="warning"> /// The instance containing the event data. /// </param> internal void OnWarning(HsqlWarningEventArgs warning) { HsqlWarningEventHandler handler = this.Warning; if (handler == null) { HsqlConnection connection = this.Connection; if (connection != null) { connection.OnWarning(warning); } } else { try { handler(this, warning); } catch (Exception ex) { if (HsqlDiagnostics.MustRethrowEventProcessingException(ex)) { throw; } } } }
public virtual void ChangeDatabase() { using (HsqlConnection testSubject = new HsqlConnection("DataSource=mem:test2")) { string databaseName = "test1"; testSubject.ChangeDatabase(databaseName); testSubject.Open(); } using (HsqlConnection testSubject = new HsqlConnection("DataSource=mem:test2")) { testSubject.Open(); string databaseName = "test1"; try { testSubject.ChangeDatabase(databaseName); Assert.Fail("it is not expected that it is legal to change database while a connection is open."); } catch (Exception) { } } }
/// <summary> /// Releases, if present, the underlying <c>HsqlStatement</c> and /// makes eligible for garbage collection any related resources. /// </summary> internal void InvalidateStatement() { try { // localize member references to minimize // potential race conditions regarding // null status of instance variables. HsqlConnection connection = m_dbConnection; HsqlStatement statement = m_statement; // Don't leak compiled statement handles if (connection != null && connection.State == ConnectionState.Open && statement != null) { statement.Free(Session); } } finally { m_statement = null; m_tokenList = null; m_storedProcedureCommandText = null; m_tableDirectCommandText = null; } }
public virtual void BeginTransaction() { using (HsqlConnection testSubject = new HsqlConnection()) { testSubject.Open(); using (HsqlTransaction transaction = testSubject.BeginTransaction()) { } } object[] expected = new object[] { IsolationLevel.Chaos, false, IsolationLevel.ReadCommitted, true, IsolationLevel.ReadUncommitted, true, IsolationLevel.RepeatableRead, true, IsolationLevel.Serializable, true, IsolationLevel.Snapshot, true, IsolationLevel.Unspecified, true }; IsolationLevel isolationLevel; bool isolationLevelIsSupported; for (int i = 0; i < expected.Length; i += 2) { isolationLevel = (IsolationLevel)expected[i]; isolationLevelIsSupported = (bool) expected[i+1]; TestBeginTransaction(isolationLevel, isolationLevelIsSupported); } }
public HsqlDataReader( org.hsqldb.Result result, CommandBehavior commandBehavior, HsqlCommand originatingCommand, HsqlConnection originatingConnection) : this(result) { m_commandBehavior = commandBehavior; m_originatingCommand = originatingCommand; m_originatingConnection = originatingConnection; }
/// <summary> /// Initializes a new instance of the /// <see cref="HsqlTransaction"/> class. /// </summary> /// <param name="dbConnection">The db connection.</param> /// <param name="isolationLevel">The isolation level.</param> internal HsqlTransaction( HsqlConnection dbConnection, IsolationLevel isolationLevel) : base() { // PRE: Caller ensures connection is non-null and open. m_connection = dbConnection; // PRE: Caller ensures IsolationLevel is supported. m_isolationLevel = isolationLevel; m_valid = true; }
/// <summary> /// Releases the resources used by this object and /// optionally causes the underlying database transaction to /// be rolled back. /// </summary> /// <param name="rollback"> /// When <c>true</c>, the transaction is rolled back; /// otherwise, the transaction is left in its current state. /// </param> internal void DisposeInternal(bool rollback) { lock (m_syncRoot) { if (m_valid) { if (rollback) { m_connection.EndTransactionInternal(this, true); } m_valid = false; m_connection = null; } } }
/// <summary> /// Constructs a new <c>HsqlCommand</c> instance with the given /// connection, command text and command type. /// </summary> /// <param name="connection"> /// The connection with which this command is initially associated. /// </param> /// <param name="commandText"> /// The initial command text to execute. /// </param> /// <param name="commandType"> /// The way in which to initially interpret the command text. /// </param> public HsqlCommand(HsqlConnection connection, String commandText, CommandType commandType) : this(connection, commandText) { this.CommandType = commandType; }
/// <summary> /// Closes this connection. /// </summary> internal void CloseInternal() { ConnectionState state = m_connectionState; if (state == ConnectionState.Closed) { return; } HsqlSession session = m_session; if (m_session == null) { // Sanity-Check: Should never happen. throw new InvalidOperationException( "HsqlSession is null"); // NOI18N } // Handle dispose/close while enlisted in a system transaction. HsqlTransaction transaction = m_transaction; HsqlEnlistment enlistment = m_enlistment; bool enlisted = (enlistment != null); bool preserveEnlistment = (enlisted && !enlistment.m_disposeConnection); if (preserveEnlistment) { #if DEBUG // Without this, it is difficult to debug // because the m_enlistment's connection // ceases to be this one and this connection // loses its reference to the enlistment // (m_enlistment is set null below). m_enlistment_dbg = m_enlistment; #endif // ...then until it ceases to participate in a // System.Transactions.Transaction, the enlistment // needs a valid local transaction to commit or // rollback HsqlConnection connection = new HsqlConnection(this); connection.m_connectionState = ConnectionState.Open; connection.m_session = session; connection.m_enlistment = enlistment; connection.m_transaction = transaction; enlistment.m_dbConnection = connection; enlistment.m_disposeConnection = true; if (transaction != null) { transaction.m_connection = connection; } } SetStateInternal(ConnectionState.Closed); m_session = null; m_transaction = null; m_enlistment = null; m_dbMetaData = null; m_settings = null; if (!enlisted) { // No need to roll back here. This will happen automatically // a moment later on the back end in response to the // session.Close() call below. if (transaction != null) { transaction.DisposeInternal(/*rollback*/false); } // release the back-end session and any associated resources, // such as network sockets, etc. session.Close(); } }
public virtual void Open() { using (HsqlConnection testSubject = new HsqlConnection()) { testSubject.Open(); try { testSubject.Open(); Assert.Fail("A second Open() invocation should not succeed when a connection is already open."); } catch (Exception) { } } }
public virtual void GetSchema() { using (HsqlConnection testSubject = new HsqlConnection()) { DataTable dataTable = testSubject.GetSchema(); Console.WriteLine("Table Name: " + dataTable.TableName); Console.WriteLine("-----------------------------------"); foreach (DataRow row in dataTable.Rows) { foreach (DataColumn column in dataTable.Columns) { Console.WriteLine(column.Caption + ": " + row[column]); } } //testSubject.GetSchema(""); //testSubject.GetSchema("",new string[]); } }
public virtual void CreateCommand() { using (HsqlConnection testSubject = new HsqlConnection()) { HsqlCommand command = testSubject.CreateCommand(); Assert.AreSame(testSubject, command.Connection); Assert.AreEqual(string.Empty, command.CommandText); Assert.AreEqual(CommandType.Text, command.CommandType); Assert.AreEqual(true, command.DesignTimeVisible); Assert.AreEqual(false, command.IsPrepared); Assert.AreEqual(UpdateRowSource.Both, command.UpdatedRowSource); Assert.AreEqual(null, command.Transaction); } }
/// <summary> /// Initializes a new instance of the <see cref="HsqlDataAdapter"/> class /// with an SQL SELECT statement and a connection string. /// </summary> /// <param name="selectCommandText"> /// The string representation of the SQL SELECT statement or stored procedure /// to be executed by the <see cref="SelectCommand"/> property of this object. /// </param> /// <param name="selectConnectionString"> /// The connection string used to obtain the connection object on which the /// <see cref="SelectCommand"/> property of this object executes. /// </param> public HsqlDataAdapter(string selectCommandText, string selectConnectionString) { HsqlConnection connection = new HsqlConnection(selectConnectionString); SelectCommand = new HsqlCommand(connection, selectCommandText); }
/// <summary> /// Returns the collection of currently valid initial schema names, /// given the specified context. /// </summary> /// <param name="context"> /// An <see cref="ITypeDescriptorContext"></see> whose <c>Instance</c> /// property supplies the <c>HsqlConnectionStringBuilder</c> use to /// connect to a data source to retrieve the currently valid initial /// schema names. /// </param> /// <returns> /// A <see cref="TypeConverter.StandardValuesCollection"/> that holds /// collection of currently valid initial schema names. /// </returns> public override TypeConverter.StandardValuesCollection GetStandardValues( ITypeDescriptorContext context) { if (!IsStandardValuesSupported(context)) { return null; } List<string> values = new List<string>(); try { HsqlConnectionStringBuilder builder = (HsqlConnectionStringBuilder)context.Instance; // TODO: this is sub-optimal, but is currently the best (only?) // solution to the problem of how to avoid creating and/or // leaving open embedded database instances. if (IsEmbeddedProtocol(builder)) { builder = new HsqlConnectionStringBuilder( builder.ConnectionString); builder.AutoShutdown = true; builder.IfExists = true; } using (HsqlConnection connection = new HsqlConnection()) { connection.ConnectionString = builder.ConnectionString; using (HsqlCommand command = new HsqlCommand( connection, SchemaQuery)) { connection.Open(); using (HsqlDataReader reader = command.ExecuteReader()) { while (reader.Read()) { values.Add(reader.GetString(0)); } } } } } catch (Exception exception) { #if DEBUG Debug.WriteLine(exception); #endif } return new TypeConverter.StandardValuesCollection(values); }
/// <summary> /// Contructs a new <c>HsqlConnection</c> with the /// connection string of the other /// <c>HsqlConnection</c> object. /// </summary> /// <param name="other"> /// From which to obtain the connection string. /// </param> internal HsqlConnection(HsqlConnection other) : this(other.ConnectionString) { }
/// <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> /// Closes this connection. /// </summary> internal void CloseInternal() { ConnectionState state = m_connectionState; if (state == ConnectionState.Closed) { return; } HsqlSession session = m_session; if (m_session == null) { // Sanity-Check: Should never happen. throw new InvalidOperationException( "HsqlSession is null"); // NOI18N } // Handle dispose/close while enlisted in a system transaction. HsqlTransaction transaction = m_transaction; HsqlEnlistment enlistment = m_enlistment; bool enlisted = (enlistment != null); bool preserveEnlistment = (enlisted && !enlistment.m_disposeConnection); if (preserveEnlistment) { #if DEBUG // Without this, it is difficult to debug // because the m_enlistment's connection // ceases to be this one and this connection // loses its reference to the enlistment // (m_enlistment is set null below). m_enlistment_dbg = m_enlistment; #endif // ...then until it ceases to participate in a // System.Transactions.Transaction, the enlistment // needs a valid local transaction to commit or // rollback HsqlConnection connection = new HsqlConnection(this); connection.m_connectionState = ConnectionState.Open; connection.m_session = session; connection.m_enlistment = enlistment; connection.m_transaction = transaction; enlistment.m_dbConnection = connection; enlistment.m_disposeConnection = true; if (transaction != null) { transaction.m_connection = connection; } } SetStateInternal(ConnectionState.Closed); m_session = null; m_transaction = null; m_enlistment = null; m_dbMetaData = null; m_settings = null; if (!enlisted) { // No need to roll back here. This will happen automatically // a moment later on the back end in response to the // session.Close() call below. if (transaction != null) { transaction.DisposeInternal(/*rollback*/ false); } // release the back-end session and any associated resources, // such as network sockets, etc. session.Close(); } }
/// <summary> /// Initializes a new instance of the <see cref="HsqlDataAdapter"/> class /// with an SQL SELECT statement and an <see cref="HsqlConnection"/>. /// </summary> /// <param name="selectCommandText"> /// The string representation of the SQL SELECT statement or stored procedure /// to be executed by the <see cref="SelectCommand"/> property of this object. /// </param> /// <param name="selectConnection">The select connection.</param> public HsqlDataAdapter(string selectCommandText, HsqlConnection selectConnection) : this() { SelectCommand = new HsqlCommand(selectConnection, selectCommandText); }
public virtual void Close() { using (HsqlConnection testSubject = new HsqlConnection()) { Assert.That(testSubject.State == ConnectionState.Closed); testSubject.Open(); Assert.That(testSubject.State == ConnectionState.Open); testSubject.Close(); Assert.That(testSubject.State == ConnectionState.Closed); testSubject.Close(); Assert.That(testSubject.State == ConnectionState.Closed); } }
/// <summary> /// Constructs a new <c>HsqlCommand</c> instance that is initially /// associated with the given connection. /// </summary> /// <remarks> /// The initial <c>CommandType</c> is <see cref="System.Data.CommandType.Text"/> /// and the initial <c>CommandText</c> is empty. /// </remarks> /// <param name="connection"> /// The connection with which this command is initially associated. /// </param> public HsqlCommand(HsqlConnection connection) : this() { Connection = connection; }
public virtual void EnlistTransaction() { HsqlConnection testSubject = new HsqlConnection(); using (TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.Required)) { testSubject.Open(); testSubject.EnlistTransaction(Transaction.Current); try { testSubject.BeginTransaction(); Assert.Fail("The test subject allowed a local transaction to be started " + "explicitly while participating in a system transaction"); } catch (Exception) { } transactionScope.Complete(); try { testSubject.BeginTransaction(); Assert.Fail("The test subject allowed a local transaction to be started " + "explicitly while participating in a system transaction"); } catch (Exception) { } } using (HsqlTransaction transaction = testSubject.BeginTransaction()) { transaction.Commit(); } }
/// <summary> /// Constructs a new <c>HsqlCommand</c> instance with the given /// connection and command text. /// </summary> /// <remarks> /// The initial <c>CommandType</c> is <see cref="System.Data.CommandType.Text"/> /// </remarks> /// <param name="connection"> /// The connection with which this command is initially associated. /// </param> /// <param name="commandText"> /// The initial command text. /// </param> public HsqlCommand(HsqlConnection connection, string commandText) : this(connection) { CommandText = commandText; }
void TestBeginTransaction(IsolationLevel isolationLevel, bool isolationLevelIsSupported) { try { using (HsqlConnection testSubject = new HsqlConnection()) { testSubject.Open(); using (HsqlTransaction transaction = testSubject.BeginTransaction(isolationLevel)) { } } Assert.That(isolationLevelIsSupported, "System.Data.IsolationLevel: " + Enum.GetName(typeof(IsolationLevel), isolationLevel)); } catch (Exception) { Assert.That(!isolationLevelIsSupported, "System.Data.IsolationLevel: " + Enum.GetName(typeof(IsolationLevel), isolationLevel)); } }
public virtual void Clone() { string connectionString = "DataSource=mem:test"; using (HsqlConnection testSubject = new HsqlConnection(connectionString)) { HsqlConnection copy = testSubject.Clone(); Assert.AreEqual(connectionString, testSubject.ConnectionString); } }