public override void Execute(string sql, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
string ex = BuildExec(sql);
ExecuteQuery(ex, timeout, wantResults);
}
public override void ExecPrepared(string id, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
bool hasParameters = (Parameters != null && Parameters.Count > 0);
Comm.StartPacket(TdsPacketType.Normal);
Comm.Append((byte)TdsPacketSubType.Dynamic);
Comm.Append((short)(id.Length + 5));
Comm.Append((byte)0x02); // TDS_DYN_EXEC
Comm.Append((byte)(hasParameters ? 0x01 : 0x00));
Comm.Append((byte)id.Length);
Comm.Append(id);
Comm.Append((short)0);
if (hasParameters)
{
SendParamFormat();
SendParams();
}
MoreResults = true;
Comm.SendPacket();
CheckForData(timeout);
if (!wantResults)
{
SkipToEnd();
}
}
public bool BulkCopyStart (TdsMetaParameterCollection parameters)
{
tds.Comm.StartPacket (TdsPacketType.Bulk);
tds.Comm.Append ((byte) TdsPacketSubType.ColumnMetadata);
short count = 0;
foreach (TdsMetaParameter param in parameters) {
if (param.Value != null)
continue;
count++;
}
tds.Comm.Append (count);
if (parameters != null) {
foreach (TdsMetaParameter param in parameters) {
if (param.Value != null)
continue;
tds.Comm.Append ((short) 0x00);
if (param.IsNullable) {
// fNullable = true
// usUpdateable = Unused/Unkown
tds.Comm.Append ((short) 0x09);
} else {
// usUpdateable = Unused/Unkown
tds.Comm.Append ((short) 0x08);
}
WriteParameterInfo (param);
tds.Comm.Append ((byte) param.ParameterName.Length);
tds.Comm.Append (param.ParameterName);
}
}
return true;
}
public override string Prepare(string sql, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
Random rand = new Random();
StringBuilder idBuilder = new StringBuilder();
for (int i = 0; i < 25; i += 1)
{
idBuilder.Append((char)(rand.Next(26) + 65));
}
string id = idBuilder.ToString();
//StringBuilder declare = new StringBuilder ();
sql = String.Format("create proc {0} as\n{1}", id, sql);
short len = (short)((id.Length) + sql.Length + 5);
Comm.StartPacket(TdsPacketType.Normal);
Comm.Append((byte)TdsPacketSubType.Dynamic);
Comm.Append(len);
Comm.Append((byte)0x1); // PREPARE
Comm.Append((byte)0x0); // UNUSED
Comm.Append((byte)id.Length);
Comm.Append(id);
Comm.Append((short)sql.Length);
Comm.Append(sql);
Comm.SendPacket();
MoreResults = true;
SkipToEnd();
return(id);
}
public override void Execute(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
// We are connected to a Sql 7.0 server
if (TdsVersion < TdsVersion.tds80)
{
base.Execute(commandText, parameters, timeout, wantResults);
return;
}
Parameters = parameters;
string sql = commandText;
if (Parameters != null && Parameters.Count > 0)
{
ExecRPC(TdsRpcProcId.ExecuteSql, commandText, parameters, timeout, wantResults);
}
else
{
if (wantResults)
{
sql = BuildExec(commandText);
}
ExecuteQuery(sql, timeout, wantResults);
}
}
public bool BulkCopyStart(TdsMetaParameterCollection parameters)
{
tds.Comm.StartPacket(TdsPacketType.Bulk);
tds.Comm.Append((byte)TdsPacketSubType.ColumnMetadata);
short count = 0;
foreach (TdsMetaParameter param in parameters)
{
if (param.Value != null)
{
continue;
}
count++;
}
tds.Comm.Append(count);
if (parameters != null)
{
foreach (TdsMetaParameter param in parameters)
{
if (param.Value != null)
{
continue;
}
tds.Comm.Append((short)0x00);
tds.Comm.Append((short)0x0a);
WriteParameterInfo(param);
tds.Comm.Append((byte)param.ParameterName.Length);
tds.Comm.Append(param.ParameterName);
}
}
return(true);
}
public override string Prepare(string commandText, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
TdsMetaParameterCollection parms = new TdsMetaParameterCollection();
#if NET_4_5
// FIXME: Passing null or DBNull fails with:
// The incoming tabular data stream (TDS) remote procedure call (RPC) protocol
// stream is incorrect. Parameter 1 ("@Handle"): Data type 0x26 has an invalid
// data length or metadata length.
TdsMetaParameter parm = new TdsMetaParameter("@Handle", "int", -1);
#else
TdsMetaParameter parm = new TdsMetaParameter("@Handle", "int", null);
#endif
parm.Direction = TdsParameterDirection.Output;
parms.Add(parm);
parms.Add(new TdsMetaParameter("@VarDecl", "nvarchar", BuildPreparedParameters()));
parms.Add(new TdsMetaParameter("@Query", "nvarchar", commandText));
ExecProc("sp_prepare", parms, 0, true);
SkipToEnd();
return(OutputParameters[0].ToString());
//if (ColumnValues == null || ColumnValues [0] == null || ColumnValues [0] == DBNull.Value)
// throw new TdsInternalException ();
//return string.Empty;
//return ColumnValues [0].ToString ();
}
public override void Unprepare(string statementId)
{
TdsMetaParameterCollection parms = new TdsMetaParameterCollection();
parms.Add(new TdsMetaParameter("@P1", "int", Int32.Parse(statementId)));
ExecProc("sp_unprepare", parms, 0, false);
}
private void WriteRpcParameterInfo(TdsMetaParameterCollection parameters)
{
if (parameters != null)
{
foreach (TdsMetaParameter param in parameters)
{
if (param.Direction == TdsParameterDirection.ReturnValue)
{
continue;
}
string pname = param.ParameterName;
if (pname != null && pname.Length > 0 && pname [0] == '@')
{
Comm.Append((byte)pname.Length);
Comm.Append(pname);
}
else
{
Comm.Append((byte)(pname.Length + 1));
Comm.Append("@" + pname);
}
short status = 0; // unused
if (param.Direction != TdsParameterDirection.Input)
{
status |= 0x01; // output
}
Comm.Append((byte)status);
WriteParameterInfo(param);
}
}
}
protected void ExecRPC(TdsRpcProcId rpcId, string sql,
TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec();
Comm.StartPacket(TdsPacketType.RPC);
Comm.Append((ushort)0xFFFF);
Comm.Append((ushort)rpcId);
Comm.Append((short)0x02); // no meta data
Comm.Append((byte)0x00); // no param meta data name
Comm.Append((byte)0x00); // no status flags
// Write sql as a parameter value - UCS2
TdsMetaParameter param = new TdsMetaParameter("sql",
sql.Length > 4000 ? "ntext":"nvarchar",
sql);
WriteParameterInfo(param);
// Write Parameter infos - name and type
WritePreparedParameterInfo(parameters);
// Write parameter/value info
WriteRpcParameterInfo(parameters);
Comm.SendPacket();
CheckForData(timeout);
if (!wantResults)
{
SkipToEnd();
}
}
public override void Execute(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
string sql = commandText;
if (wantResults || (Parameters != null && Parameters.Count > 0))
{
sql = BuildExec(commandText);
}
ExecuteQuery(sql, timeout, wantResults);
}
private void Execute(CommandBehavior behavior, bool wantResults)
{
Tds.RecordsAffected = -1;
TdsMetaParameterCollection parms = Parameters.MetaParameters;
if (preparedStatement == null)
{
bool schemaOnly = ((CommandBehavior & CommandBehavior.SchemaOnly) > 0);
bool keyInfo = ((CommandBehavior & CommandBehavior.SchemaOnly) > 0);
StringBuilder sql1 = new StringBuilder();
StringBuilder sql2 = new StringBuilder();
if (schemaOnly || keyInfo)
{
sql1.Append("SET FMTONLY OFF;");
}
if (keyInfo)
{
sql1.Append("SET NO_BROWSETABLE ON;");
sql2.Append("SET NO_BROWSETABLE OFF;");
}
if (schemaOnly)
{
sql1.Append("SET FMTONLY ON;");
sql2.Append("SET FMTONLY OFF;");
}
switch (CommandType)
{
case CommandType.StoredProcedure:
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql1.ToString());
}
Connection.Tds.ExecProc(CommandText, parms, CommandTimeout, wantResults);
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql2.ToString());
}
break;
case CommandType.Text:
string sql = String.Format("{0}{1}{2}", sql1.ToString(), CommandText, sql2.ToString());
Connection.Tds.Execute(sql, parms, CommandTimeout, wantResults);
break;
}
}
else
{
Connection.Tds.ExecPrepared(preparedStatement, parms, CommandTimeout, wantResults);
}
}
public override void ExecPrepared(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
if (Parameters != null && Parameters.Count > 0)
{
ExecRPC(TdsRpcProcId.ExecuteSql, commandText, parameters, timeout, wantResults);
}
else
{
ExecuteQuery(BuildPreparedQuery(commandText), timeout, wantResults);
}
}
protected void ExecRPC(TdsRpcProcId rpcId, string sql,
TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec();
Comm.StartPacket(TdsPacketType.RPC);
Comm.Append((ushort)0xFFFF);
Comm.Append((ushort)rpcId);
Comm.Append((short)0x02); // no meta data
Comm.Append((byte)0x00); // no param meta data name
Comm.Append((byte)0x00); // no status flags
// Convert BigNVarChar values larger than 4000 chars to nvarchar(max)
// Need to do this here so WritePreparedParameterInfo emit the
// correct data type
foreach (TdsMetaParameter param2 in parameters)
{
var colType = param2.GetMetaType();
if (colType == TdsColumnType.BigNVarChar)
{
int size = param2.GetActualSize();
if ((size >> 1) > 4000)
{
param2.Size = -1;
}
}
}
// Write sql as a parameter value - UCS2
TdsMetaParameter param = new TdsMetaParameter("sql",
sql.Length > 4000 ? "ntext":"nvarchar",
sql);
WriteParameterInfo(param);
// Write Parameter infos - name and type
WritePreparedParameterInfo(parameters);
// Write parameter/value info
WriteRpcParameterInfo(parameters);
Comm.SendPacket();
CheckForData(timeout);
if (!wantResults)
{
SkipToEnd();
}
}
public override IAsyncResult BeginExecuteProcedure(string prolog,
string epilog,
string cmdText,
bool IsNonQuery,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
Parameters = parameters;
string pcall = BuildProcedureCall(cmdText);
string sql = String.Format("{0};{1};{2};", prolog, pcall, epilog);
IAsyncResult ar = BeginExecuteQueryInternal(sql, !IsNonQuery, callback, state);
return(ar);
}
public override IAsyncResult BeginExecuteQuery(string cmdText,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
Parameters = parameters;
string sql = cmdText;
if (Parameters != null && Parameters.Count > 0)
{
sql = BuildExec(cmdText);
}
IAsyncResult ar = BeginExecuteQueryInternal(sql, true, callback, state);
return(ar);
}
private void WritePreparedParameterInfo(TdsMetaParameterCollection parameters)
{
if (parameters == null)
{
return;
}
string param = BuildPreparedParameters();
Comm.Append((byte)0x00); // no param meta data name
Comm.Append((byte)0x00); // no status flags
// Type_info - parameter info
WriteParameterInfo(new TdsMetaParameter("prep_params",
param.Length > 4000 ? "ntext" : "nvarchar",
param));
}
public override void Execute(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
string sql = commandText;
if (Parameters != null && Parameters.Count > 0)
{
ExecRPC(TdsRpcProcId.ExecuteSql, commandText, parameters, timeout, wantResults);
}
else
{
if (wantResults)
{
sql = BuildExec(commandText);
}
ExecuteQuery(sql, timeout, wantResults);
}
}
protected override void ExecRPC(string rpcName, TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec();
Comm.StartPacket(TdsPacketType.RPC);
Comm.Append((short)rpcName.Length);
Comm.Append(rpcName);
Comm.Append((short)0); //no meta data
WriteRpcParameterInfo(parameters);
Comm.SendPacket();
CheckForData(timeout);
if (!wantResults)
{
SkipToEnd();
}
}
public bool BulkCopyStart(TdsMetaParameterCollection parameters)
{
tds.Comm.StartPacket(TdsPacketType.Bulk);
tds.Comm.Append((byte)TdsPacketSubType.ColumnMetadata);
short count = 0;
foreach (TdsMetaParameter param in parameters)
{
if (param.Value != null)
{
continue;
}
count++;
}
tds.Comm.Append(count);
if (parameters != null)
{
foreach (TdsMetaParameter param in parameters)
{
if (param.Value != null)
{
continue;
}
tds.Comm.Append((short)0x00);
if (param.IsNullable)
{
// fNullable = true
// usUpdateable = Unused/Unkown
tds.Comm.Append((short)0x09);
}
else
{
// usUpdateable = Unused/Unkown
tds.Comm.Append((short)0x08);
}
WriteParameterInfo(param);
tds.Comm.Append((byte)param.ParameterName.Length);
tds.Comm.Append(param.ParameterName);
}
}
return(true);
}
public override void ExecPrepared(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
// We are connected to a Sql 7.0 server
if (TdsVersion < TdsVersion.tds80 ||
Parameters == null || Parameters.Count < 1)
{
base.ExecPrepared(commandText, parameters, timeout, wantResults);
return;
}
TdsMetaParameterCollection parms = new TdsMetaParameterCollection();
parms.Add(new TdsMetaParameter("@Handle", "int", Int32.Parse(commandText)));
foreach (TdsMetaParameter parm in Parameters)
{
parms.Add(parm);
}
ExecRPC("sp_execute", parms, timeout, wantResults);
}
public override string Prepare(string commandText, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
TdsMetaParameterCollection parms = new TdsMetaParameterCollection();
TdsMetaParameter parm = new TdsMetaParameter("@Handle", "int", null);
parm.Direction = TdsParameterDirection.Output;
parms.Add(parm);
parms.Add(new TdsMetaParameter("@VarDecl", "nvarchar", BuildPreparedParameters()));
parms.Add(new TdsMetaParameter("@Query", "nvarchar", commandText));
ExecProc("sp_prepare", parms, 0, true);
SkipToEnd();
return(OutputParameters[0].ToString());
//if (ColumnValues == null || ColumnValues [0] == null || ColumnValues [0] == DBNull.Value)
// throw new TdsInternalException ();
//return string.Empty;
//return ColumnValues [0].ToString ();
}
public bool BulkCopyStart (TdsMetaParameterCollection parameters)
{
tds.Comm.StartPacket (TdsPacketType.Bulk);
tds.Comm.Append ((byte) TdsPacketSubType.ColumnMetadata);
short count = 0;
foreach (TdsMetaParameter param in parameters) {
if (param.Value != null)
continue;
count++;
}
tds.Comm.Append (count);
if (parameters != null) {
foreach (TdsMetaParameter param in parameters) {
if (param.Value != null)
continue;
tds.Comm.Append ((short) 0x00);
tds.Comm.Append ((short) 0x0a);
WriteParameterInfo (param);
tds.Comm.Append ((byte) param.ParameterName.Length);
tds.Comm.Append (param.ParameterName);
}
}
return true;
}
public override string Prepare(string commandText, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
TdsMetaParameterCollection parms = new TdsMetaParameterCollection();
// Tested with MS SQL 2008 RC2 Express and MS SQL 2012 Express:
// You may pass either -1 or 0, but not null as initial value of @Handle,
// which is an output parameter.
TdsMetaParameter parm = new TdsMetaParameter("@Handle", "int", -1);
parm.Direction = TdsParameterDirection.Output;
parms.Add(parm);
parms.Add(new TdsMetaParameter("@VarDecl", "nvarchar", BuildPreparedParameters()));
parms.Add(new TdsMetaParameter("@Query", "nvarchar", commandText));
ExecProc("sp_prepare", parms, 0, true);
SkipToEnd();
return(OutputParameters[0].ToString());
//if (ColumnValues == null || ColumnValues [0] == null || ColumnValues [0] == DBNull.Value)
// throw new TdsInternalException ();
//return string.Empty;
//return ColumnValues [0].ToString ();
}
public override void Unprepare (string statementId)
{
TdsMetaParameterCollection parms = new TdsMetaParameterCollection ();
parms.Add (new TdsMetaParameter ("@P1", "int", Int32.Parse (statementId)));
ExecProc ("sp_unprepare", parms, 0, false);
}
public override void ExecPrepared (string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
ExecuteQuery (BuildPreparedQuery (commandText), timeout, wantResults);
}
public override void ExecProc(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
ExecRPC(commandText, parameters, timeout, wantResults);
}
public virtual string Prepare (string sql, TdsMetaParameterCollection parameters)
{
throw new NotSupportedException ();
}
private void Execute(CommandBehavior behavior, bool wantResults)
{
int index = 0;
Connection.Tds.RecordsAffected = -1;
TdsMetaParameterCollection parms = Parameters.MetaParameters;
foreach (TdsMetaParameter param in parms)
{
param.Validate(index++);
}
if (preparedStatement == null)
{
bool schemaOnly = ((behavior & CommandBehavior.SchemaOnly) > 0);
bool keyInfo = ((behavior & CommandBehavior.KeyInfo) > 0);
StringBuilder sql1 = new StringBuilder();
StringBuilder sql2 = new StringBuilder();
if (schemaOnly || keyInfo)
{
sql1.Append("SET FMTONLY OFF;");
}
if (keyInfo)
{
sql1.Append("SET NO_BROWSETABLE ON;");
sql2.Append("SET NO_BROWSETABLE OFF;");
}
if (schemaOnly)
{
sql1.Append("SET FMTONLY ON;");
sql2.Append("SET FMTONLY OFF;");
}
switch (CommandType)
{
case CommandType.StoredProcedure:
try {
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql1.ToString());
}
Connection.Tds.ExecProc(CommandText, parms, CommandTimeout, wantResults);
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql2.ToString());
}
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
case CommandType.Text:
string sql;
if (sql2.Length > 0)
{
sql = String.Format("{0}{1};{2}", sql1.ToString(), CommandText, sql2.ToString());
}
else
{
sql = String.Format("{0}{1}", sql1.ToString(), CommandText);
}
try {
Connection.Tds.Execute(sql, parms, CommandTimeout, wantResults);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
}
}
else
{
try {
Connection.Tds.ExecPrepared(preparedStatement, parms, CommandTimeout, wantResults);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
}
}
public override void ExecProc (string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
ExecRPC (commandText, parameters, timeout, wantResults);
}
internal IAsyncResult BeginExecuteInternal(CommandBehavior behavior,
bool wantResults,
AsyncCallback callback,
object state)
{
IAsyncResult ar = null;
Connection.Tds.RecordsAffected = -1;
TdsMetaParameterCollection parms = Parameters.MetaParameters;
if (preparedStatement == null)
{
bool schemaOnly = ((behavior & CommandBehavior.SchemaOnly) > 0);
bool keyInfo = ((behavior & CommandBehavior.KeyInfo) > 0);
StringBuilder sql1 = new StringBuilder();
StringBuilder sql2 = new StringBuilder();
if (schemaOnly || keyInfo)
{
sql1.Append("SET FMTONLY OFF;");
}
if (keyInfo)
{
sql1.Append("SET NO_BROWSETABLE ON;");
sql2.Append("SET NO_BROWSETABLE OFF;");
}
if (schemaOnly)
{
sql1.Append("SET FMTONLY ON;");
sql2.Append("SET FMTONLY OFF;");
}
switch (CommandType)
{
case CommandType.StoredProcedure:
string prolog = "";
string epilog = "";
if (keyInfo || schemaOnly)
{
prolog = sql1.ToString();
}
if (keyInfo || schemaOnly)
{
epilog = sql2.ToString();
}
try {
Connection.Tds.BeginExecuteProcedure(prolog,
epilog,
CommandText,
!wantResults,
parms,
callback,
state);
} catch (TdsTimeoutException ex) {
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
case CommandType.Text:
string sql = String.Format("{0}{1};{2}", sql1.ToString(), CommandText, sql2.ToString());
try {
if (wantResults)
{
ar = Connection.Tds.BeginExecuteQuery(sql, parms, callback, state);
}
else
{
ar = Connection.Tds.BeginExecuteNonQuery(sql, parms, callback, state);
}
} catch (TdsTimeoutException ex) {
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
}
}
else
{
try {
Connection.Tds.ExecPrepared(preparedStatement, parms, CommandTimeout, wantResults);
} catch (TdsTimeoutException ex) {
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
}
return(ar);
}
public virtual void Execute (string sql, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
ExecuteQuery (sql, timeout, wantResults);
}
public override string Prepare (string commandText, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
TdsMetaParameterCollection parms = new TdsMetaParameterCollection ();
// Tested with MS SQL 2008 RC2 Express and MS SQL 2012 Express:
// You may pass either -1 or 0, but not null as initial value of @Handle,
// which is an output parameter.
TdsMetaParameter parm = new TdsMetaParameter ("@Handle", "int", -1);
parm.Direction = TdsParameterDirection.Output;
parms.Add (parm);
parms.Add (new TdsMetaParameter ("@VarDecl", "nvarchar", BuildPreparedParameters ()));
parms.Add (new TdsMetaParameter ("@Query", "nvarchar", commandText));
ExecProc ("sp_prepare", parms, 0, true);
SkipToEnd ();
return OutputParameters[0].ToString () ;
//if (ColumnValues == null || ColumnValues [0] == null || ColumnValues [0] == DBNull.Value)
// throw new TdsInternalException ();
//return string.Empty;
//return ColumnValues [0].ToString ();
}
public override void Execute (string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
string sql = commandText;
if (wantResults || (Parameters != null && Parameters.Count > 0))
sql = BuildExec (commandText);
ExecuteQuery (sql, timeout, wantResults);
}
public virtual IAsyncResult BeginExecuteProcedure (string prolog,
string epilog,
string cmdText,
bool IsNonQuery,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
throw new NotImplementedException ("should not be called!");
}
private void WriteRpcParameterInfo (TdsMetaParameterCollection parameters)
{
if (parameters != null) {
foreach (TdsMetaParameter param in parameters) {
if (param.Direction == TdsParameterDirection.ReturnValue)
continue;
string pname = param.ParameterName;
if (pname != null && pname.Length > 0 && pname [0] == '@') {
Comm.Append ( (byte) pname.Length);
Comm.Append (pname);
} else {
Comm.Append ( (byte) (pname.Length + 1));
Comm.Append ("@" + pname);
}
short status = 0; // unused
if (param.Direction != TdsParameterDirection.Input)
status |= 0x01; // output
Comm.Append ( (byte) status);
WriteParameterInfo (param);
}
}
}
public virtual IAsyncResult BeginExecuteQuery (string sql,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
// abstract, kept to be backward compatiable.
throw new NotImplementedException ("should not be called!");
}
public virtual void ExecProc (string sql, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
ExecuteQuery (String.Format ("exec {0}", sql), timeout, wantResults);
}
internal SqlParameterCollection(SqlCommand command)
{
this.command = command;
metaParameters = new TdsMetaParameterCollection();
}
public virtual void ExecPrepared (string sql, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
throw new NotSupportedException ();
}
protected virtual void ExecRPC (string rpcName, TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
Comm.StartPacket (TdsPacketType.DBRPC);
byte [] rpcNameBytes = Comm.Encoder.GetBytes (rpcName);
byte rpcNameLength = (byte) rpcNameBytes.Length;
ushort mask = 0x0000;
ushort packetLength = (ushort) (sizeof (byte) + rpcNameLength +
sizeof (ushort));
Comm.Append (packetLength);
Comm.Append (rpcNameLength);
Comm.Append (rpcNameBytes);
Comm.Append (mask);
try {
Comm.SendPacket ();
CheckForData (timeout);
if (!wantResults)
SkipToEnd ();
} catch (IOException ex) {
connected = false;
throw new TdsInternalException ("Server closed the connection.", ex);
}
}
protected override void ExecRPC (string rpcName, TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec ();
Comm.StartPacket (TdsPacketType.RPC);
Comm.Append ( (short) rpcName.Length);
Comm.Append (rpcName);
Comm.Append ( (short) 0); //no meta data
WriteRpcParameterInfo (parameters);
Comm.SendPacket ();
CheckForData (timeout);
if (!wantResults)
SkipToEnd ();
}
public override void ExecPrepared(string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
ExecuteQuery(BuildPreparedQuery(commandText), timeout, wantResults);
}
public override void Execute (string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
string sql = commandText;
if (Parameters != null && Parameters.Count > 0) {
ExecRPC (TdsRpcProcId.ExecuteSql, commandText, parameters, timeout, wantResults);
} else {
if (wantResults)
sql = BuildExec (commandText);
ExecuteQuery (sql, timeout, wantResults);
}
}
internal TdsParameterCollection(TdsCommand command)
{
this.command = command;
metaParameters = new TdsMetaParameterCollection();
}
public override string Prepare (string commandText, TdsMetaParameterCollection parameters)
{
Parameters = parameters;
TdsMetaParameterCollection parms = new TdsMetaParameterCollection ();
TdsMetaParameter parm = new TdsMetaParameter ("@Handle", "int", null);
parm.Direction = TdsParameterDirection.Output;
parms.Add (parm);
parms.Add (new TdsMetaParameter ("@VarDecl", "nvarchar", BuildPreparedParameters ()));
parms.Add (new TdsMetaParameter ("@Query", "nvarchar", commandText));
ExecProc ("sp_prepare", parms, 0, true);
SkipToEnd ();
return OutputParameters[0].ToString () ;
//if (ColumnValues == null || ColumnValues [0] == null || ColumnValues [0] == DBNull.Value)
// throw new TdsInternalException ();
//return string.Empty;
//return ColumnValues [0].ToString ();
}
private void WritePreparedParameterInfo (TdsMetaParameterCollection parameters)
{
if (parameters == null)
return;
string param = BuildPreparedParameters ();
Comm.Append ((byte) 0x00); // no param meta data name
Comm.Append ((byte) 0x00); // no status flags
// Type_info - parameter info
WriteParameterInfo (new TdsMetaParameter ("prep_params",
param.Length > 4000 ? "ntext" : "nvarchar",
param));
}
protected void ExecRPC (TdsRpcProcId rpcId, string sql,
TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec ();
Comm.StartPacket (TdsPacketType.RPC);
Comm.Append ((ushort) 0xFFFF);
Comm.Append ((ushort) rpcId);
Comm.Append ((short) 0x02); // no meta data
Comm.Append ((byte) 0x00); // no param meta data name
Comm.Append ((byte) 0x00); // no status flags
// Convert BigNVarChar values larger than 4000 chars to nvarchar(max)
// Need to do this here so WritePreparedParameterInfo emit the
// correct data type
foreach (TdsMetaParameter param2 in parameters) {
var colType = param2.GetMetaType ();
if (colType == TdsColumnType.BigNVarChar) {
int size = param2.GetActualSize ();
if ((size >> 1) > 4000)
param2.Size = -1;
}
}
// Write sql as a parameter value - UCS2
TdsMetaParameter param = new TdsMetaParameter ("sql",
sql.Length > 4000 ? "ntext":"nvarchar",
sql);
WriteParameterInfo (param);
// Write Parameter infos - name and type
WritePreparedParameterInfo (parameters);
// Write parameter/value info
WriteRpcParameterInfo (parameters);
Comm.SendPacket ();
CheckForData (timeout);
if (!wantResults)
SkipToEnd ();
}
public override IAsyncResult BeginExecuteQuery (string cmdText,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
Parameters = parameters;
string sql = cmdText;
if (Parameters != null && Parameters.Count > 0)
sql = BuildExec (cmdText);
IAsyncResult ar = BeginExecuteQueryInternal (sql, true, callback, state);
return ar;
}
private void ExecRPC (TdsRpcProcId rpcId, string sql,
TdsMetaParameterCollection parameters,
int timeout, bool wantResults)
{
// clean up
InitExec ();
Comm.StartPacket (TdsPacketType.RPC);
Comm.Append ((ushort) 0xFFFF);
Comm.Append ((ushort) rpcId);
Comm.Append ((short) 0x02); // no meta data
Comm.Append ((byte) 0x00); // no param meta data name
Comm.Append ((byte) 0x00); // no status flags
// Write sql as a parameter value - UCS2
TdsMetaParameter param = new TdsMetaParameter ("sql",
sql.Length > 4000 ? "ntext":"nvarchar",
sql);
WriteParameterInfo (param);
// Write Parameter infos - name and type
WritePreparedParameterInfo (parameters);
// Write parameter/value info
WriteRpcParameterInfo (parameters);
Comm.SendPacket ();
CheckForData (timeout);
if (!wantResults)
SkipToEnd ();
}
private void Execute(bool wantResults)
{
int index = 0;
Connection.Tds.RecordsAffected = -1;
TdsMetaParameterCollection parms = Parameters.MetaParameters;
foreach (TdsMetaParameter param in parms)
{
param.Validate(index++);
}
if (preparedStatement == null)
{
bool schemaOnly = ((behavior & CommandBehavior.SchemaOnly) > 0);
bool keyInfo = ((behavior & CommandBehavior.KeyInfo) > 0);
StringBuilder sql1 = new StringBuilder();
StringBuilder sql2 = new StringBuilder();
if (schemaOnly || keyInfo)
{
sql1.Append("SET FMTONLY OFF;");
}
if (keyInfo)
{
sql1.Append("SET NO_BROWSETABLE ON;");
sql2.Append("SET NO_BROWSETABLE OFF;");
}
if (schemaOnly)
{
sql1.Append("SET FMTONLY ON;");
sql2.Append("SET FMTONLY OFF;");
}
switch (CommandType)
{
case CommandType.StoredProcedure:
try {
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql1.ToString());
}
Connection.Tds.ExecProc(CommandText, parms, CommandTimeout, wantResults);
if (keyInfo || schemaOnly)
{
Connection.Tds.Execute(sql2.ToString());
}
} catch (TdsTimeoutException ex) {
// If it is a timeout exception there can be many reasons:
// 1) Network is down/server is down/not reachable
// 2) Somebody has an exclusive lock on Table/DB
// In any of these cases, don't close the connection. Let the user do it
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
case CommandType.Text:
string sql;
if (sql2.Length > 0)
{
sql = String.Format("{0}{1};{2}", sql1.ToString(), CommandText, sql2.ToString());
}
else
{
sql = String.Format("{0}{1}", sql1.ToString(), CommandText);
}
try {
Connection.Tds.Execute(sql, parms, CommandTimeout, wantResults);
} catch (TdsTimeoutException ex) {
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
break;
}
}
else
{
try {
Connection.Tds.ExecPrepared(preparedStatement, parms, CommandTimeout, wantResults);
} catch (TdsTimeoutException ex) {
Connection.Tds.Reset();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
} catch (TdsInternalException ex) {
Connection.Close();
throw SqlException.FromTdsInternalException((TdsInternalException)ex);
}
}
}
public override IAsyncResult BeginExecuteProcedure (string prolog,
string epilog,
string cmdText,
bool IsNonQuery,
TdsMetaParameterCollection parameters,
AsyncCallback callback,
object state)
{
Parameters = parameters;
string pcall = BuildProcedureCall (cmdText);
string sql = String.Format ("{0};{1};{2};", prolog, pcall, epilog);
IAsyncResult ar = BeginExecuteQueryInternal (sql, !IsNonQuery, callback, state);
return ar;
}
internal SybaseParameterCollection(SybaseCommand command)
{
this.command = command;
metaParameters = new TdsMetaParameterCollection();
}
public override void ExecPrepared (string commandText, TdsMetaParameterCollection parameters, int timeout, bool wantResults)
{
Parameters = parameters;
if (Parameters != null && Parameters.Count > 0)
ExecRPC (TdsRpcProcId.ExecuteSql, commandText, parameters, timeout, wantResults);
else
ExecuteQuery (BuildPreparedQuery (commandText), timeout, wantResults);
}
