/// <summary>
/// Contructs a new <c>HsqlConnection</c>
/// with the default connection string.
/// </summary>
public HsqlConnection() : base()
{
m_id = idseq++;
m_settings = new HsqlConnectionStringBuilder();
GC.SuppressFinalize(this);
}
public virtual void ShouldSerialize()
{
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
bool actual = testSubject.ShouldSerialize("foo");
Assert.Fail("TODO");
}
public virtual void Remove()
{
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
bool actual = testSubject.Remove("foo");
Assert.Fail("TODO");
}
public virtual void Clear()
{
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
testSubject.Clear();
Assert.Fail("TODO");
}
public virtual void ContainsKey()
{
// Create Constructor Parameters
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
testSubject.ContainsKey("foo");
Assert.Fail("TODO");
}
public virtual void EquivalentTo()
{
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
bool expected = true;
bool actual = testSubject.EquivalentTo(testSubject);
Assert.AreEqual(expected, actual);
Assert.Fail("TODO");
}
/// <summary>
/// Determines whether the given builder specifies an
/// embedded connection protocol
/// </summary>
/// <param name="builder">The builder.</param>
/// <returns>
/// <c>true</c> if the builder specified an embedded connection protocol;
/// otherwise, <c>false</c>.
/// </returns>
public static bool IsEmbeddedProtocol(HsqlConnectionStringBuilder builder)
{
switch (builder.Protocol)
{
case ConnectionProtocol.File:
case ConnectionProtocol.Mem:
case ConnectionProtocol.Res:
{
return true;
}
default:
{
return false;
}
}
}
public virtual void TryGetValue()
{
HsqlConnectionStringBuilder testSubject = new HsqlConnectionStringBuilder();
object value;
bool success = false;
try
{
success = testSubject.TryGetValue("foo", out value);
}
catch (Exception)
{
}
Assert.Fail("TODO");
}
/// <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>
/// Converts the given <c>HsqlConnectionStringBuilder</c>
/// to an instance descriptor.
/// </summary>
/// <param name="builder">The builder.</param>
/// <returns>
/// An instance descriptor representing the given
/// <c>HsqlConnectionStringBuilder</c>.
/// </returns>
private InstanceDescriptor ConvertToInstanceDescriptor(
HsqlConnectionStringBuilder builder)
{
return new InstanceDescriptor(
typeof(HsqlConnectionStringBuilder).GetConstructor(types),
new object[] { builder.ConnectionString });
}
/// <summary>
/// Returns the collection of standard values for
/// the <see cref="HsqlConnectionStringBuilder.DataSource"/>
/// property.
/// </summary>
/// <param name="context">Which may hold</param>
/// <returns>
/// The standard set of valid values.
/// </returns>
public override TypeConverter.StandardValuesCollection GetStandardValues(
ITypeDescriptorContext context)
{
DataTable dataSources = DSEC.GetDataSources();
DataRowCollection rows = dataSources.Rows;
int rowCount = rows.Count;
string[] array;
if (context != null && context.Instance != null)
{
// might be a connection string builder or wrapper for one.
try
{
HsqlConnectionStringBuilder csb
= new HsqlConnectionStringBuilder(
Convert.ToString(context.Instance));
array = new string[rowCount + 1];
array[rowCount] = csb.DataSource;
}
catch (Exception)
{
array = new string[rowCount];
}
}
else
{
array = new string[rowCount];
}
for (int i = 0; i < rowCount; i++)
{
DataRow row = rows[i];
string prefix = row[DSEC.ServerNameColumnOrdinal] as string;
string suffix = row[DSEC.InstanceNameColumnOrdinal] as string;
string version = row[DSEC.VersionColumnOrdinal] as string;
if (string.IsNullOrEmpty(version) ||
version.StartsWith("1.8.0", StringComparison.Ordinal))
{
array[i] = (string.IsNullOrEmpty(suffix))
? prefix.Replace('\\', '/')
: new StringBuilder(prefix)
.Replace('\\', '/')
.Append('/')
.Append(suffix.Replace('\\', '/').TrimStart('/'))
.ToString();
}
else
{
array[i] = string.Empty;
}
}
org.hsqldb.lib.HashSet set = new org.hsqldb.lib.HashSet();
set.addAll(array);
set.remove(string.Empty);
if (array.Length != set.size())
{
array = new string[set.size()];
}
set.toArray(array);
Array.Sort<string>(array);
return new TypeConverter.StandardValuesCollection(array);
}
/// <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();
}
}