public SqlResponse Execute(string sql)
{
EnsureInitialized();
SqlResponse result = new SqlResponse();
try
{
DataTable results = Database.GetDataTable(sql, CommandType.Text);
List <object> rows = new List <object>();
foreach (DataRow row in results.Rows)
{
rows.Add(row);
}
result.Results = rows.ToArray();
result.Count = results.Rows.Count;
}
catch (Exception ex)
{
result.Success = false;
result.Message = ex.Message;
result.Results = new object[] { };
}
return(result);
}
private static void RunTestQuery(OracleJavaScriptSqlProvider db)
{
SqlResponse response = db.Execute("SELECT * FROM diamond WHERE ROWNUM <= 100");
Expect.IsTrue(response.Count == 100);
foreach (object result in response.Results)
{
OutLineFormat("{0}\r\n", result.PropertiesToString());
}
}
public static SqlResponse ToSqlResponse(this Exception ex)
{
var otherErrorResponse = new SqlResponse
{
Error = new SqlError
{
Code = -1,
Message = ex.Message
}
};
return(otherErrorResponse);
}
public static SqlResponse ToSqlResponse(this string errorMessage)
{
var otherErrorResponse = new SqlResponse
{
Error = new SqlError
{
Code = -1,
Message = errorMessage
}
};
return(otherErrorResponse);
}
protected async Task ProcessStoredProcedureExecuteResponse(SqlResponse response, AsyncWrappingCommonArgs async)
{
try
{
if (response.Count > 0)
{
OutputParameters.Enqueue(await ReadRow(async).ConfigureAwait(false));
}
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
protected async Task ProcessStoredProcedureExecuteResponse(SqlResponse response, AsyncWrappingCommonArgs async)
{
try
{
if (response.Count > 0)
{
_outputParams.Enqueue(await ReadRow(async).ConfigureAwait(false));
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
_outputParams.Enqueue(ReadRow());
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
this.outputParams.Enqueue(this.ReadDataRow());
}
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
var row = AllocNewRow();
ReadRow(row);
_outputParams.Enqueue(row);
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
public override async ValueTask ExecuteAsync(int timeout, IDescriptorFiller descriptorFiller, CancellationToken cancellationToken = default)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
await SendExecuteToBufferAsync(timeout, descriptorFiller, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1;
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
await ProcessStoredProcedureExecuteResponseAsync(sqlStoredProcedureResponse, cancellationToken).ConfigureAwait(false);
}
numberOfResponses--;
var executeResponse = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
await ProcessExecuteResponseAsync(executeResponse, cancellationToken).ConfigureAwait(false);
}
finally
{
await(Database as GdsDatabase).SafeFinishFetchingAsync(numberOfResponses, cancellationToken).ConfigureAwait(false);
}
// we need to split this in two, to allow server handle op_cancel properly
if (DoRecordsAffected)
{
await SendInfoSqlToBufferAsync(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE, cancellationToken).ConfigureAwait(false);
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
numberOfResponses = 1;
try
{
numberOfResponses--;
var rowsAffectedResponse = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
RecordsAffected = ProcessRecordsAffectedBuffer(await ProcessInfoSqlResponseAsync(rowsAffectedResponse, cancellationToken).ConfigureAwait(false));
}
finally
{
await(Database as GdsDatabase).SafeFinishFetchingAsync(numberOfResponses, cancellationToken).ConfigureAwait(false);
}
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
public override void Execute()
{
if (_state == StatementState.Deallocated)
{
throw new InvalidOperationException("Statement is not correctly created.");
}
Clear();
try
{
RecordsAffected = -1;
SendExecuteToBuffer();
var readRowsAffectedResponse = false;
if (ReturnRecordsAffected &&
(StatementType == DbStatementType.Insert ||
StatementType == DbStatementType.Delete ||
StatementType == DbStatementType.Update ||
StatementType == DbStatementType.StoredProcedure ||
StatementType == DbStatementType.Select))
{
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
readRowsAffectedResponse = true;
}
_database.XdrStream.Flush();
var numberOfResponses =
(StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = _database.ReadSqlResponse();
ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
var executeResponse = _database.ReadGenericResponse();
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = _database.ReadGenericResponse();
}
ProcessExecuteResponse(executeResponse);
if (readRowsAffectedResponse)
{
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(rowsAffectedResponse));
}
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
_state = StatementState.Executed;
}
catch (IOException ex)
{
_state = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
public override void Execute()
{
if (State == StatementState.Deallocated)
{
throw new InvalidOperationException("Statement is not correctly created.");
}
Clear();
try
{
RecordsAffected = -1;
SendExecuteToBuffer();
_database.Xdr.Flush();
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1;
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = _database.ReadResponse <SqlResponse>();
ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
var executeResponse = _database.ReadResponse <GenericResponse>();
ProcessExecuteResponse(executeResponse);
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
// we need to split this in two, to allow server handle op_cancel properly
if (DoRecordsAffected)
{
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
_database.Xdr.Flush();
numberOfResponses = 1;
try
{
numberOfResponses--;
var rowsAffectedResponse = _database.ReadResponse <GenericResponse>();
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(rowsAffectedResponse));
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public override void Execute()
{
if (_state == StatementState.Deallocated)
{
throw new InvalidOperationException("Statement is not correctly created.");
}
// Clear data
Clear();
lock (_database.SyncObject)
{
try
{
RecordsAffected = -1;
SendExecuteToBuffer();
_database.XdrStream.Flush();
// sql?, execute
int numberOfResponses =
(StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1;
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = _database.ReadSqlResponse();
ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
GenericResponse executeResponse = _database.ReadGenericResponse();
ProcessExecuteResponse(executeResponse);
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
//we need to split this in two, to alloow server handle op_cancel properly
// Obtain records affected by query execution
if (ReturnRecordsAffected &&
(StatementType == DbStatementType.Insert ||
StatementType == DbStatementType.Delete ||
StatementType == DbStatementType.Update ||
StatementType == DbStatementType.StoredProcedure ||
StatementType == DbStatementType.Select))
{
// Grab rows affected
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
_database.XdrStream.Flush();
//rows affected
numberOfResponses = 1;
try
{
numberOfResponses--;
GenericResponse rowsAffectedResponse = _database.ReadGenericResponse();
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(rowsAffectedResponse));
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
}
_state = StatementState.Executed;
}
catch (IOException ex)
{
_state = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public CrateDataReader(SqlResponse sqlResponse)
{
_sqlResponse = sqlResponse;
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
this.outputParams.Enqueue(this.ReadDataRow());
}
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
public override async Task Execute(AsyncWrappingCommonArgs async)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
await SendExecuteToBuffer(async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1;
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)await _database.ReadResponse(async).ConfigureAwait(false);
await ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse, async).ConfigureAwait(false);
}
numberOfResponses--;
var executeResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
await ProcessExecuteResponse(executeResponse, async).ConfigureAwait(false);
}
finally
{
numberOfResponses = await SafeFinishFetching(numberOfResponses, async).ConfigureAwait(false);
}
// we need to split this in two, to allow server handle op_cancel properly
if (DoRecordsAffected)
{
await SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE, async).ConfigureAwait(false);
await _database.Xdr.Flush(async).ConfigureAwait(false);
numberOfResponses = 1;
try
{
numberOfResponses--;
var rowsAffectedResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
RecordsAffected = ProcessRecordsAffectedBuffer(await ProcessInfoSqlResponse(rowsAffectedResponse, async).ConfigureAwait(false));
}
finally
{
numberOfResponses = await SafeFinishFetching(numberOfResponses, async).ConfigureAwait(false);
}
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
public override void Execute(int timeout, IDescriptorFiller descriptorFiller)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
SendExecuteToBuffer(timeout, descriptorFiller);
_database.Xdr.Flush();
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1;
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)_database.ReadResponse();
ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
var executeResponse = (GenericResponse)_database.ReadResponse();
ProcessExecuteResponse(executeResponse);
}
finally
{
(Database as GdsDatabase).SafeFinishFetching(numberOfResponses);
}
// we need to split this in two, to allow server handle op_cancel properly
if (DoRecordsAffected)
{
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
_database.Xdr.Flush();
numberOfResponses = 1;
try
{
numberOfResponses--;
var rowsAffectedResponse = (GenericResponse)_database.ReadResponse();
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(rowsAffectedResponse));
}
finally
{
(Database as GdsDatabase).SafeFinishFetching(numberOfResponses);
}
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
public override async Task Execute(AsyncWrappingCommonArgs async)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
await SendExecuteToBuffer(async).ConfigureAwait(false);
var readRowsAffectedResponse = false;
if (DoRecordsAffected)
{
await SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE, async).ConfigureAwait(false);
readRowsAffectedResponse = true;
}
await _database.Xdr.Flush(async).ConfigureAwait(false);
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)await _database.ReadResponse(async).ConfigureAwait(false);
await ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse, async).ConfigureAwait(false);
}
numberOfResponses--;
var executeResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = (GenericResponse)await _database.ReadResponse(async).ConfigureAwait(false);
}
await ProcessExecuteResponse(executeResponse, async).ConfigureAwait(false);
if (readRowsAffectedResponse)
{
RecordsAffected = ProcessRecordsAffectedBuffer(await ProcessInfoSqlResponse(rowsAffectedResponse, async).ConfigureAwait(false));
}
}
finally
{
numberOfResponses = await SafeFinishFetching(numberOfResponses, async).ConfigureAwait(false);
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
protected void ProcessStoredProcedureExecuteResponse(SqlResponse response)
{
try
{
if (response.Count > 0)
{
_outputParams.Enqueue(ReadDataRow());
}
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
public override void Execute()
{
if (this.state == StatementState.Deallocated)
{
throw new InvalidOperationException("Statement is not correctly created.");
}
// Clear data
this.Clear();
lock (this.database.SyncObject)
{
try
{
this.RecordsAffected = -1;
this.SendExecuteToBuffer();
bool readRowsAffectedResponse = false;
// Obtain records affected by query execution
if (this.ReturnRecordsAffected &&
(this.StatementType == DbStatementType.Insert ||
this.StatementType == DbStatementType.Delete ||
this.StatementType == DbStatementType.Update ||
this.StatementType == DbStatementType.StoredProcedure ||
this.StatementType == DbStatementType.Select))
{
// Grab rows affected
this.SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
readRowsAffectedResponse = true;
}
this.database.Flush();
// sql?, execute, rows affected?
int numberOfResponses =
(this.StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (this.StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = this.database.ReadSqlResponse();
this.ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
GenericResponse executeResponse = this.database.ReadGenericResponse();
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = this.database.ReadGenericResponse();
}
this.ProcessExecuteResponse(executeResponse);
if (readRowsAffectedResponse)
{
this.RecordsAffected = this.ProcessRecordsAffectedBuffer(this.ProcessInfoSqlResponse(rowsAffectedResponse));
}
}
finally
{
SafeFinishFetching(ref numberOfResponses);
}
this.state = StatementState.Executed;
}
catch (IOException)
{
this.state = StatementState.Error;
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public override async ValueTask ExecuteAsync(CancellationToken cancellationToken = default)
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
await SendExecuteToBufferAsync(cancellationToken).ConfigureAwait(false);
var readRowsAffectedResponse = false;
if (DoRecordsAffected)
{
await SendInfoSqlToBufferAsync(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE, cancellationToken).ConfigureAwait(false);
readRowsAffectedResponse = true;
}
await _database.Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
await ProcessStoredProcedureExecuteResponseAsync(sqlStoredProcedureResponse, cancellationToken).ConfigureAwait(false);
}
numberOfResponses--;
var executeResponse = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = (GenericResponse)await _database.ReadResponseAsync(cancellationToken).ConfigureAwait(false);
}
await ProcessExecuteResponseAsync(executeResponse, cancellationToken).ConfigureAwait(false);
if (readRowsAffectedResponse)
{
RecordsAffected = ProcessRecordsAffectedBuffer(await ProcessInfoSqlResponseAsync(rowsAffectedResponse, cancellationToken).ConfigureAwait(false));
}
}
finally
{
numberOfResponses = await SafeFinishFetchingAsync(numberOfResponses, cancellationToken).ConfigureAwait(false);
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
public override void Execute()
{
EnsureNotDeallocated();
Clear();
try
{
RecordsAffected = -1;
SendExecuteToBuffer();
var readRowsAffectedResponse = false;
if (DoRecordsAffected)
{
SendInfoSqlToBuffer(RowsAffectedInfoItems, IscCodes.ROWS_AFFECTED_BUFFER_SIZE);
readRowsAffectedResponse = true;
}
_database.Xdr.Flush();
var numberOfResponses = (StatementType == DbStatementType.StoredProcedure ? 1 : 0) + 1 + (readRowsAffectedResponse ? 1 : 0);
try
{
SqlResponse sqlStoredProcedureResponse = null;
if (StatementType == DbStatementType.StoredProcedure)
{
numberOfResponses--;
sqlStoredProcedureResponse = (SqlResponse)_database.ReadResponse();
ProcessStoredProcedureExecuteResponse(sqlStoredProcedureResponse);
}
numberOfResponses--;
var executeResponse = (GenericResponse)_database.ReadResponse();
GenericResponse rowsAffectedResponse = null;
if (readRowsAffectedResponse)
{
numberOfResponses--;
rowsAffectedResponse = (GenericResponse)_database.ReadResponse();
}
ProcessExecuteResponse(executeResponse);
if (readRowsAffectedResponse)
{
RecordsAffected = ProcessRecordsAffectedBuffer(ProcessInfoSqlResponse(rowsAffectedResponse));
}
}
finally
{
numberOfResponses = SafeFinishFetching(numberOfResponses);
}
State = StatementState.Executed;
}
catch (IOException ex)
{
State = StatementState.Error;
throw IscException.ForIOException(ex);
}
}
