internal void GetParameters()
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ParameterData.GetParameters()");
for (int i = 0; i < parameters.Count; i++)
{
VirtuosoParameter param = (VirtuosoParameter)parameters[i];
if (param.Direction == ParameterDirection.ReturnValue ||
param.Direction == ParameterDirection.Output ||
param.Direction == ParameterDirection.InputOutput)
{
int dataLength = Marshal.ReadInt32(buffer.Handle, 4 * i);
if (dataLength > length[i])
{
dataLength = length[i];
}
if (dataLength == (int)CLI.LengthCode.SQL_NULL_DATA)
{
param.paramData = DBNull.Value;
}
else
{
param.paramData = param.bufferType.NativeToManaged(
buffer.GetAddress(offset[i]), dataLength);
}
}
}
}
public void OutputParameters(TestCaseResult result)
{
DropProcedure();
ExecuteNonQuery(
"create procedure bar (in x integer, out y integer, inout z integer)\n" +
"{\n" +
" y := x * 2;\n" +
" z := z * 2;\n" +
" return y + z;\n" +
"}\n"
);
VirtuosoCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "bar";
VirtuosoParameter returnValue = command.CreateParameter();
returnValue.ParameterName = "ReturnValue";
returnValue.Direction = ParameterDirection.ReturnValue;
returnValue.VirtDbType = VirtDbType.Integer;
command.Parameters.Add(returnValue);
VirtuosoParameter x = command.CreateParameter();
x.ParameterName = "x";
x.Direction = ParameterDirection.Input;
x.VirtDbType = VirtDbType.Integer;
x.Value = 2;
command.Parameters.Add(x);
VirtuosoParameter y = command.CreateParameter();
y.ParameterName = "y";
y.Direction = ParameterDirection.Output;
y.VirtDbType = VirtDbType.Integer;
command.Parameters.Add(y);
VirtuosoParameter z = command.CreateParameter();
z.ParameterName = "z";
z.Direction = ParameterDirection.InputOutput;
z.VirtDbType = VirtDbType.Integer;
z.Value = 3;
command.Parameters.Add(z);
try
{
command.ExecuteNonQuery();
result.FailIfNotEqual(this, "Return Value", 10, returnValue.Value);
result.FailIfNotEqual(this, "Out Parameter", 4, y.Value);
result.FailIfNotEqual(this, "InOut Parameter", 6, z.Value);
}
finally
{
command.Dispose();
}
}
private void CheckParameter(VirtuosoParameter value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
CheckParameterInner(value);
}
private void CheckParameterInner(VirtuosoParameter value)
{
string name = value.ParameterName;
if (name == null || name.Length == 0)
{
throw new ArgumentException("parameter must be named");
}
}
public void SetParameters(VirtuosoParameterCollection parameters)
{
this.parameters = parameters;
if (parameters == null)
{
parameterValues = new object[0];
return;
}
parameterValues = new object[parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{
VirtuosoParameter param = (VirtuosoParameter)parameters[i];
Debug.WriteLineIf(Switch.Enabled, " param: " + param.paramName);
object value = null;
if (param.Direction == ParameterDirection.Input ||
param.Direction == ParameterDirection.InputOutput)
{
value = param.Value;
if (param.bufferType == null)
{
if (param.paramType != null)
{
param.bufferType = param.paramType.bufferType;
}
else if (value == null || Convert.IsDBNull(value))
{
param.bufferType = VirtuosoParameter.defaultType.bufferType;
}
else
{
param.bufferType = BufferTypes.InferBufferType(value);
}
if (param.bufferType == null)
{
throw new InvalidOperationException("Cannot infer parameter type");
}
}
value = param.bufferType.ConvertValue(param.Value);
}
Debug.WriteLineIf(Switch.Enabled, " value: " + param.Value);
if (value is System.String)
{
BoxTag tag = (param.DbType == DbType.AnsiString ? BoxTag.DV_STRING : BoxTag.DV_WIDE);
parameterValues[i] = ExplicitString.CreateExplicitString((String)value, tag, connection);
}
else
{
parameterValues[i] = value;
}
}
}
private void AddParameter(
VirtuosoCommand command,
ColumnData column,
DataRowVersion version,
DataTableMapping mapping,
DataRow row)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "VirtuosoCommandBuilder.AddParameter()");
VirtuosoParameter parameter = new VirtuosoParameter();
string name = String.Format("p{0}", command.Parameters.Count);
object value = null;
if (row != null)
{
Debug.WriteLineIf(Switch.Enabled, " row != null");
//string datasetColumn = column.columnName;
if (mapping != null)
{
Debug.WriteLineIf(Switch.Enabled, " mapping != null");
DataColumnMapping columnMapping = mapping.GetColumnMappingBySchemaAction(
column.columnName,
adapter.MissingMappingAction);
if (columnMapping != null)
{
Debug.WriteLineIf(Switch.Enabled, " columnMapping != null");
DataColumn dataColumn = columnMapping.GetDataColumnBySchemaAction(
row.Table,
column.columnType.bufferType.type,
adapter.MissingSchemaAction);
if (dataColumn != null)
{
Debug.WriteLineIf(Switch.Enabled, " dataColumn != null");
value = row[dataColumn, version];
}
}
}
}
Debug.WriteLineIf(Switch.Enabled, " value: " + value);
parameter.ParameterName = name;
parameter.VirtDbType = column.columnType.vdbType;
parameter.Precision = (byte)column.precision;
parameter.Scale = (byte)column.scale;
parameter.Size = 0;
parameter.IsNullable = column.IsNullable;
parameter.Direction = ParameterDirection.Input;
parameter.SourceColumn = column.columnName;
parameter.SourceVersion = version;
parameter.Value = value;
command.Parameters.Add(parameter);
}
private void CheckParameter(
TestCaseResult result,
VirtuosoParameter parameter,
string parameterName,
ParameterDirection direction,
VirtDbType vdbType,
DbType dbType,
int size,
byte precision,
byte scale)
{
result.FailIfNotEqual(this, "ParameterName", parameterName, parameter.ParameterName);
result.FailIfNotEqual(this, parameterName + ".Direction", direction, parameter.Direction);
result.FailIfNotEqual(this, parameterName + ".VirtDbType", vdbType, parameter.VirtDbType);
result.FailIfNotEqual(this, parameterName + ".DbType", dbType, parameter.DbType);
result.FailIfNotEqual(this, parameterName + ".Size", size, parameter.Size);
result.FailIfNotEqual(this, parameterName + ".Precision", precision, parameter.Precision);
result.FailIfNotEqual(this, parameterName + ".Scale", scale, parameter.Scale);
}
public void GetParameters()
{
if (parameters != null && parameters.Count > 0)
{
while (GetNextResult())
{
;
}
for (int i = 0; i < parameters.Count; i++)
{
VirtuosoParameter param = (VirtuosoParameter)parameters[i];
if (param.Direction == ParameterDirection.ReturnValue ||
param.Direction == ParameterDirection.Output ||
param.Direction == ParameterDirection.InputOutput)
{
object data = parameterValues[i];
if (param.bufferType == null)
{
if (param.paramType != null)
{
param.bufferType = param.paramType.bufferType;
}
else if (data == null || Convert.IsDBNull(data))
{
param.bufferType = VirtuosoParameter.defaultType.bufferType;
}
else
{
param.bufferType = BufferTypes.InferBufferType(data);
}
if (param.bufferType == null)
{
throw new InvalidOperationException("Cannot infer parameter type");
}
}
data = param.bufferType.ConvertValue(data);
param.paramData = data;
}
}
}
}
object ICloneable.Clone()
{
VirtuosoParameter p = new VirtuosoParameter();
p.paramName = paramName;
if (paramData != null && paramData is ICloneable)
{
p.paramData = ((ICloneable)paramData).Clone();
}
else
{
p.paramData = paramData;
}
p.paramType = paramType;
p.bufferType = bufferType;
p.direction = direction;
p.isNullable = isNullable;
p.precision = precision;
p.scale = scale;
p.size = size;
p.sourceColumn = sourceColumn;
p.sourceVersion = sourceVersion;
return(p);
}
internal void SetParameters(VirtuosoConnection connection, IntPtr hstmt)
{
Debug.WriteLineIf(CLI.FnTrace.Enabled, "ParameterData.SetParameters()");
for (int i = 0; i < parameters.Count; i++)
{
VirtuosoParameter param = (VirtuosoParameter)parameters[i];
Debug.WriteLineIf(Switch.Enabled, " param: " + param.paramName);
CLI.InOutType ioType;
switch (param.Direction)
{
default:
// case ParameterDirection.Input:
ioType = CLI.InOutType.SQL_PARAM_INPUT;
break;
case ParameterDirection.InputOutput:
ioType = CLI.InOutType.SQL_PARAM_INPUT_OUTPUT;
break;
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
ioType = CLI.InOutType.SQL_PARAM_OUTPUT;
break;
}
Debug.WriteLineIf(Switch.Enabled, " direction: " + param.Direction);
IntPtr paramBuffer = buffer.GetAddress(offset[i]);
int bufferLength = length[i];
int lengthOffset = 4 * i;
CLI.SqlType sqlType = (param.paramType != null ? param.paramType.sqlType : CLI.SqlType.SQL_UNKNOWN_TYPE);
CLI.ReturnCode rc = (CLI.ReturnCode)CLI.SQLBindParameter(
hstmt, (ushort)(i + 1),
(short)ioType, (short)param.bufferType.sqlCType, (short)sqlType,
(IntPtr)param.Size, param.Scale,
paramBuffer, (IntPtr)bufferLength, buffer.GetAddress(lengthOffset));
if (rc != CLI.ReturnCode.SQL_SUCCESS)
{
Diagnostics.HandleResult(rc, CLI.HandleType.SQL_HANDLE_STMT, hstmt, connection);
}
if (param.Direction == ParameterDirection.Input || param.Direction == ParameterDirection.InputOutput)
{
object value = param.bufferType.ConvertValue(param.Value);
Debug.WriteLineIf(Switch.Enabled, " value: " + param.Value);
int dataLength;
if (value == null)
{
dataLength = (int)CLI.LengthCode.SQL_NULL_DATA;
}
else if (Convert.IsDBNull(value))
{
dataLength = (int)CLI.LengthCode.SQL_NULL_DATA;
}
else
{
dataLength = param.bufferType.ManagedToNative(value, paramBuffer, bufferLength);
}
Marshal.WriteInt32(buffer.Handle, lengthOffset, dataLength);
}
}
}
private void CheckParameterInner (VirtuosoParameter value)
{
string name = value.ParameterName;
if (name == null || name.Length == 0)
throw new ArgumentException("parameter must be named");
}
private void Initialize()
{
offset = new int[parameters.Count];
length = new int[parameters.Count];
int totalLength = 4 * parameters.Count;
for (int i = 0; i < parameters.Count; i++)
{
VirtuosoParameter param = (VirtuosoParameter)parameters[i];
object value = param.Value;
if (param.bufferType == null)
{
if (param.paramType != null)
{
param.bufferType = param.paramType.bufferType;
}
else if (value == null || Convert.IsDBNull(value))
{
param.bufferType = VirtuosoParameter.defaultType.bufferType;
}
else
{
param.bufferType = BufferTypes.InferBufferType(value);
if (param.bufferType == null)
{
throw new InvalidOperationException("Cannot infer parameter type");
}
}
}
value = param.bufferType.ConvertValue(value);
int paramLength = 0;
if (param.Direction == ParameterDirection.Input)
{
if (value == null || Convert.IsDBNull(value))
{
continue;
}
int valueLength = param.bufferType.GetBufferSize(value);
if (param.Size == 0)
{
paramLength = valueLength;
}
else
{
paramLength = param.bufferType.GetBufferSize(param.Size);
if (paramLength > valueLength)
{
paramLength = valueLength;
}
}
}
else
{
if (param.Size == 0)
{
if (!param.bufferType.isFixedSize)
{
if (param.Direction != ParameterDirection.InputOutput ||
value == null || Convert.IsDBNull(value))
{
throw new InvalidOperationException("Cannot determine the parameter size.");
}
}
paramLength = param.bufferType.GetBufferSize(value);
}
else
{
paramLength = param.bufferType.GetBufferSize(param.Size);
}
}
if (param.bufferType.alignment > 1)
{
totalLength += param.bufferType.alignment - 1;
totalLength -= totalLength % param.bufferType.alignment;
}
offset[i] = totalLength;
length[i] = paramLength;
totalLength += paramLength;
}
buffer = new MemoryHandle(totalLength);
}
public int Add(VirtuosoParameter value)
{
CheckParameter(value);
return(items.Add(value));
}
object ICloneable.Clone ()
{
VirtuosoParameter p = new VirtuosoParameter ();
p.paramName = paramName;
if (paramData != null && paramData is ICloneable)
p.paramData = ((ICloneable) paramData).Clone ();
else
p.paramData = paramData;
p.paramType = paramType;
p.bufferType = bufferType;
p.direction = direction;
p.isNullable = isNullable;
p.precision = precision;
p.scale = scale;
p.size = size;
p.sourceColumn = sourceColumn;
p.sourceVersion = sourceVersion;
return p;
}
private void InsertRow(int id)
{
object i, si, d, r, n, year, month, day, dt, tm, dtm, str, bin;
if (id == 0)
{
i = si = d = r = n = year = month = day = dt = tm = dtm = str = bin = DBNull.Value;
}
else
{
i = id + 1000;
si = (short)(id + 2000);
d = id * 1000.0001;
r = (float)(id * 100.001);
n = (decimal)id * 10000001;
year = 1990 + id;
month = (id - 1) % 12 + 1;
day = (id - 1) % DateTime.DaysInMonth((int)year, (int)month) + 1;
dt = new DateTime((int)year, (int)month, (int)day);
tm = new TimeSpan(id % 24, id % 60, id % 60);
dtm = new DateTime((int)year, (int)month, (int)day, id % 24, id % 60, id % 60);
int length = id % 128;
char[] chars = new char[length];
byte[] bytes = new byte[length];
for (int count = 0; count < length; count++)
{
chars[count] = (char)('a' + (id + count) % 26 - 1);
bytes[count] = (byte)(id + count);
}
str = new String(chars);
bin = bytes;
}
VirtuosoCommand insert = connection.CreateCommand();
insert.CommandText =
"insert into foo "
+ "(id, i, si, d, r, n, dt, tm, dtm, c, vc, lvc, nc, nvc, lnvc, b, vb, lvb) "
+ "values "
+ "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
VirtuosoParameterCollection parameters = insert.Parameters;
VirtuosoParameter idParam = insert.CreateParameter();
idParam.ParameterName = "id";
idParam.DbType = DbType.Int32;
idParam.Value = id;
parameters.Add(idParam);
VirtuosoParameter iParam = insert.CreateParameter();
iParam.ParameterName = "i";
iParam.DbType = DbType.Int32;
iParam.Value = i;
parameters.Add(iParam);
VirtuosoParameter siParam = insert.CreateParameter();
siParam.ParameterName = "si";
siParam.DbType = DbType.Int16;
siParam.Value = si;
parameters.Add(siParam);
VirtuosoParameter dParam = insert.CreateParameter();
dParam.ParameterName = "d";
dParam.DbType = DbType.Double;
dParam.Value = d;
parameters.Add(dParam);
VirtuosoParameter rParam = insert.CreateParameter();
rParam.ParameterName = "r";
rParam.DbType = DbType.Single;
rParam.Value = r;
parameters.Add(rParam);
VirtuosoParameter nParam = insert.CreateParameter();
nParam.ParameterName = "n";
nParam.DbType = DbType.Decimal;
nParam.Value = n;
parameters.Add(nParam);
VirtuosoParameter dtParam = insert.CreateParameter();
dtParam.ParameterName = "dt";
dtParam.DbType = DbType.Date;
dtParam.Value = dt;
parameters.Add(dtParam);
VirtuosoParameter tmParam = insert.CreateParameter();
tmParam.ParameterName = "tm";
tmParam.DbType = DbType.Time;
tmParam.Value = tm;
parameters.Add(tmParam);
VirtuosoParameter dtmParam = insert.CreateParameter();
dtmParam.ParameterName = "dtm";
dtmParam.DbType = DbType.DateTime;
dtmParam.Value = dtm;
parameters.Add(dtmParam);
VirtuosoParameter cParam = insert.CreateParameter();
cParam.ParameterName = "c";
cParam.DbType = DbType.AnsiStringFixedLength;
cParam.Value = str;
parameters.Add(cParam);
VirtuosoParameter vcParam = insert.CreateParameter();
vcParam.ParameterName = "vc";
vcParam.DbType = DbType.AnsiString;
vcParam.Value = str;
parameters.Add(vcParam);
VirtuosoParameter lvcParam = insert.CreateParameter();
lvcParam.ParameterName = "lvc";
lvcParam.DbType = DbType.AnsiString;
lvcParam.Value = str;
parameters.Add(lvcParam);
VirtuosoParameter ncParam = insert.CreateParameter();
ncParam.ParameterName = "nc";
ncParam.DbType = DbType.StringFixedLength;
ncParam.Value = str;
parameters.Add(ncParam);
VirtuosoParameter nvcParam = insert.CreateParameter();
nvcParam.ParameterName = "nvc";
nvcParam.DbType = DbType.String;
nvcParam.Value = str;
parameters.Add(nvcParam);
VirtuosoParameter lnvcParam = insert.CreateParameter();
lnvcParam.ParameterName = "lnvc";
lnvcParam.DbType = DbType.String;
lnvcParam.Value = str;
parameters.Add(lnvcParam);
VirtuosoParameter bParam = insert.CreateParameter();
bParam.ParameterName = "b";
bParam.DbType = DbType.Binary;
bParam.Value = bin;
parameters.Add(bParam);
VirtuosoParameter vbParam = insert.CreateParameter();
vbParam.ParameterName = "vb";
vbParam.DbType = DbType.Binary;
vbParam.Value = bin;
parameters.Add(vbParam);
VirtuosoParameter lvbParam = insert.CreateParameter();
lvbParam.ParameterName = "lvb";
lvbParam.DbType = DbType.Binary;
lvbParam.Value = bin;
parameters.Add(lvbParam);
try
{
insert.ExecuteNonQuery();
}
finally
{
insert.Dispose();
insert = null;
}
DataRow row = checkTable.NewRow();
row["id"] = id;
row["i"] = i;
row["si"] = si;
row["d"] = d;
row["r"] = r;
row["n"] = n;
row["dt"] = dt;
row["tm"] = tm;
row["dtm"] = dtm;
row["c"] = str;
row["vc"] = str;
row["lvc"] = str;
row["nc"] = str;
row["nvc"] = str;
row["lnvc"] = str;
row["b"] = bin;
row["vb"] = bin;
row["lvb"] = bin;
checkTable.Rows.Add(row);
}
private void CheckParameter (VirtuosoParameter value)
{
if (value == null)
throw new ArgumentNullException ("value");
CheckParameterInner (value);
}
private void InsertRow(int id)
{
object c, nc, b;
if (id == 0)
{
c = nc = b = DBNull.Value;
}
else
{
int length = 1 << (id - 1);
char[] chars = new char[length];
byte[] bytes = new byte[length];
for (int i = 0; i < length; i++)
{
chars[i] = (char)(' ' + i % (127 - ' '));
bytes[i] = (byte)(i % 256);
}
c = nc = new String(chars);
b = bytes;
}
VirtuosoCommand insert = connection.CreateCommand();
insert.CommandText =
"insert into foo "
+ "(id, c, nc, b) "
+ "values "
+ "(?, ?, ?, ?)";
VirtuosoParameterCollection parameters = insert.Parameters;
VirtuosoParameter idParam = insert.CreateParameter();
idParam.ParameterName = "id";
idParam.DbType = DbType.Int32;
idParam.Value = id;
parameters.Add(idParam);
VirtuosoParameter cParam = insert.CreateParameter();
cParam.ParameterName = "c";
cParam.DbType = DbType.AnsiString;
cParam.Value = c;
parameters.Add(cParam);
VirtuosoParameter ncParam = insert.CreateParameter();
ncParam.ParameterName = "nc";
ncParam.DbType = DbType.String;
ncParam.Value = nc;
parameters.Add(ncParam);
VirtuosoParameter bParam = insert.CreateParameter();
bParam.ParameterName = "b";
bParam.DbType = DbType.Binary;
bParam.Value = b;
parameters.Add(bParam);
try
{
insert.ExecuteNonQuery();
}
finally
{
insert.Dispose();
insert = null;
}
DataRow row = checkTable.NewRow();
row["id"] = id;
row["c"] = c;
row["nc"] = nc;
row["b"] = b;
checkTable.Rows.Add(row);
}
public static void DeriveParameters(VirtuosoCommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (command.CommandType != CommandType.StoredProcedure)
{
throw new InvalidOperationException("DeriveParameters supports only stored procedures.");
}
VirtuosoConnection connection = (VirtuosoConnection)command.Connection;
if (connection == null)
{
throw new InvalidOperationException("The Connection property is not set.");
}
if (connection.State == ConnectionState.Closed)
{
throw new InvalidOperationException("The connection is closed.");
}
IInnerCommand innerCommand = null;
VirtuosoDataReader reader = null;
try
{
innerCommand = connection.innerConnection.CreateInnerCommand(null);
innerCommand.GetProcedureColumns(command.CommandText);
reader = new VirtuosoDataReader(connection, innerCommand, null, CommandBehavior.Default, false);
command.Parameters.Clear();
while (reader.Read())
{
CLI.InOutType iotype = (CLI.InOutType)reader.GetInt16(reader.GetOrdinal("COLUMN_TYPE"));
ParameterDirection direction;
switch (iotype)
{
case CLI.InOutType.SQL_PARAM_INPUT:
direction = ParameterDirection.Input;
break;
case CLI.InOutType.SQL_PARAM_OUTPUT:
direction = ParameterDirection.Output;
break;
case CLI.InOutType.SQL_PARAM_INPUT_OUTPUT:
direction = ParameterDirection.InputOutput;
break;
case CLI.InOutType.SQL_PARAM_RETURN_VALUE:
direction = ParameterDirection.ReturnValue;
break;
default:
#if MONO
direction = ParameterDirection.Input;
#endif
continue;
}
string name = reader.GetString(reader.GetOrdinal("COLUMN_NAME"));
if (name == "" && iotype == CLI.InOutType.SQL_PARAM_RETURN_VALUE)
{
name = "ReturnValue";
}
CLI.SqlType sqlType = (CLI.SqlType)reader.GetInt16(reader.GetOrdinal("DATA_TYPE"));
DataType type = DataTypeInfo.MapSqlType(sqlType);
if (type == null)
{
throw new SystemException("Unknown data type");
}
int sizeOrdinal = reader.GetOrdinal("COLUMN_SIZE");
if (sizeOrdinal < 0)
{
sizeOrdinal = reader.GetOrdinal("PRECISION");
}
int size = reader.IsDBNull(sizeOrdinal) ? 0 : reader.GetInt32(sizeOrdinal);
int scaleOrdinal = reader.GetOrdinal("DECIMAL_DIGITS");
if (scaleOrdinal < 0)
{
scaleOrdinal = reader.GetOrdinal("SCALE");
}
short scale = reader.IsDBNull(scaleOrdinal) ? (short)0 : reader.GetInt16(scaleOrdinal);
int nullableOrdinal = reader.GetOrdinal("NULLABLE");
CLI.Nullable nullable = (CLI.Nullable)reader.GetInt16(nullableOrdinal);
bool isNullable = (nullable != CLI.Nullable.SQL_NO_NULLS);
VirtuosoParameter parameter = (VirtuosoParameter)command.CreateParameter();
parameter.ParameterName = name;
parameter.Direction = direction;
parameter.VirtDbType = type.vdbType;
parameter.Size = type.GetFieldSize(size);
parameter.Precision = type.GetPrecision(size);
parameter.Scale = (byte)scale;
parameter.IsNullable = isNullable;
command.Parameters.Add(parameter);
}
}
finally
{
if (reader != null)
{
reader.Close();
}
if (innerCommand != null)
{
innerCommand.Dispose();
}
}
}
public void ResultSetAndOutputParameters(TestCaseResult result)
{
DropProcedure();
DropProcedure();
ExecuteNonQuery(
"create procedure bar (out x integer)\n" +
"{\n" +
" declare i int;\n" +
" result_names (i);\n" +
" result (1);\n" +
" result (2);\n" +
" x := 3;\n" +
" return 4;\n" +
"}\n"
);
VirtuosoCommand command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "bar";
VirtuosoParameter returnValue = command.CreateParameter();
returnValue.ParameterName = "ReturnValue";
returnValue.Direction = ParameterDirection.ReturnValue;
returnValue.VirtDbType = VirtDbType.Integer;
command.Parameters.Add(returnValue);
VirtuosoParameter x = command.CreateParameter();
x.ParameterName = "x";
x.Direction = ParameterDirection.Output;
x.VirtDbType = VirtDbType.Integer;
command.Parameters.Add(x);
VirtuosoDataReader reader = null;
bool closed = false;
try
{
reader = command.ExecuteReader();
result.FailIfNotEqual(1, reader.FieldCount);
result.FailIfNotEqual("i", reader.GetName(0).ToLower());
result.FailIfNotEqual(typeof(int), reader.GetFieldType(0));
result.FailIfNotEqual(true, reader.Read());
result.FailIfNotEqual(1, reader["i"]);
result.FailIfNotEqual(true, reader.Read());
result.FailIfNotEqual(2, reader["i"]);
result.FailIfNotEqual(false, reader.Read());
reader.Close();
closed = true;
result.FailIfNotEqual("Out Parameter", 3, x.Value);
result.FailIfNotEqual("Return Value", 4, returnValue.Value);
}
finally
{
if (reader != null && !closed)
{
reader.Close();
}
command.Dispose();
}
}
public int Add (VirtuosoParameter value)
{
CheckParameter (value);
return items.Add (value);
}
