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);
}
internal static void DebugRequest(Request request)
{
#if DEBUG
Debug0("request: {0}", RequestToString(request));
#endif
}
/// <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>
/// 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);
}
/// <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;
}
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>
/// 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);
}
public HsqlDataSourceException(HsqlResult result)
: this(new HsqlException(result))
{
}
