private static IDbDataParameter ConvertToNativeParameter(DbParameter dbParameter, CommandType cmdType) { IDbDataParameter clone = new OracleParameter() { IsNullable = dbParameter.IsNullable }; // Remove leading ':' character for stored procedures. if (cmdType == CommandType.StoredProcedure) { string name = parameterRenderer.RenderParameterName(dbParameter); if (name.StartsWith(":", StringComparison.Ordinal)) name = name.Substring(1, name.Length - 1); clone.ParameterName = name; } else { clone.ParameterName = parameterRenderer.RenderParameterName(dbParameter); } if (dbParameter.PassMode == SpArgumentPassMode.DataTableFilledByAdapter) ((OracleParameter)clone).OracleDbType = OracleDbType.RefCursor; else clone.DbType = dbParameter.DbType; clone.Direction = dbParameter.Direction; clone.Precision = dbParameter.Precision; clone.Scale = dbParameter.Scale; clone.Size = dbParameter.Size; clone.SourceColumn = dbParameter.SourceColumn; clone.SourceVersion = dbParameter.SourceVersion; clone.Value = dbParameter.Value; return clone; }
public static SqlCommand GenerateCommand(SqlConnection Connection, MethodInfo Method, object[] Values, CommandType SQLCommandType, string SQLCommandText) { if (Method == null) { Method = (MethodInfo)new StackTrace().GetFrame(1).GetMethod(); } SqlCommand command = new SqlCommand(); command.Connection = Connection; command.CommandType = SQLCommandType; if (SQLCommandText.Length == 0) { command.CommandText = Method.Name; } else { command.CommandText = SQLCommandText; } if (command.CommandType == CommandType.StoredProcedure) { GenerateCommandParameters(command, Method, Values); command.Parameters.Add(ReturnValueParameterName, SqlDbType.Int).Direction = ParameterDirection.ReturnValue; } return command; }
public static DataSet ExecuteDataSet(CommandType cmdType, string strProcedureName, SqlParameter[] objParameters) { DataSet dset = new DataSet(); SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["db1ConnectionString"].ToString()); con.Open(); try { SqlCommand cmd = new SqlCommand(); cmd.Connection = con; cmd.CommandType = cmdType; cmd.CommandText = strProcedureName; AttachParameters(cmd, objParameters); SqlDataAdapter ad = new SqlDataAdapter(cmd); ad.Fill(dset); return dset; } catch (Exception ex) { return dset; } finally { con.Close(); } }
public static void ExecuteNonQuery( CommandType cmdType, string strProcedureName, SqlParameter[] objParameters) { SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["db1ConnectionString"].ToString()); con.Open(); try { SqlCommand cmd = new SqlCommand(); cmd.Connection = con; cmd.CommandType = cmdType; cmd.CommandText = strProcedureName; AttachParameters(cmd, objParameters); cmd.ExecuteNonQuery(); } catch (Exception ex) { } finally { con.Close(); } }
// This function will be used to execute CUD(CRUD) operation of parameterized commands internal static bool ExecuteNonQuery(string CommandName, CommandType cmdType, SqlParameter[] pars) { int result = 0; using (SqlConnection con = new SqlConnection(CONNECTION_STRING)) { using (SqlCommand cmd = con.CreateCommand()) { cmd.CommandType = cmdType; cmd.CommandText = CommandName; cmd.Parameters.AddRange(pars); try { if (con.State != ConnectionState.Open) { con.Open(); } result = cmd.ExecuteNonQuery(); } catch { throw; } } } return (result > 0); }
public DataTable ExecuteParamerizedSelectCommand(string CommandName, CommandType cmdType, SqlParameter[] param) { SqlCommand cmd = null; DataTable table = new DataTable(); cmd = con.CreateCommand(); cmd.CommandType = cmdType; cmd.CommandText = CommandName; cmd.Parameters.AddRange(param); try { con.Open(); SqlDataAdapter da = null; using (da = new SqlDataAdapter(cmd)) { da.Fill(table); } } catch (Exception ex) { throw ex; } finally { cmd.Dispose(); cmd = null; con.Close(); } return table; }
// This function will be used to execute R(CRUD) operation of parameterized commands internal static DataTable ExecuteParamerizedSelectCommand(string CommandName, CommandType cmdType, SqlParameter[] param) { DataTable table = new DataTable(); using (SqlConnection con = new SqlConnection(CONNECTION_STRING)) { using (SqlCommand cmd = con.CreateCommand()) { cmd.CommandType = cmdType; cmd.CommandText = CommandName; cmd.Parameters.AddRange(param); try { if (con.State != ConnectionState.Open) { con.Open(); } using (SqlDataAdapter da = new SqlDataAdapter(cmd)) { da.Fill(table); } } catch { throw; } } } return table; }
/// <summary> /// execute a query£¬return DataSet /// </summary> /// <param name="SQLString"></param> /// <returns>DataSet</returns> public static DataSet Query(string connectionString, CommandType cmdType, string SQLString, params OracleParameter[] cmdParms) { using (OracleConnection connection = new OracleConnection(connectionString)) { OracleCommand cmd = new OracleCommand(); PrepareCommand(cmd, connection, null, cmdType, SQLString, cmdParms); using (OracleDataAdapter da = new OracleDataAdapter(cmd)) { DataSet ds = new DataSet(); //try //{ da.Fill(ds, "ds"); cmd.Parameters.Clear(); //} //catch (System.Data.OracleClient.OracleException ex) //{ // throw new Exception(ex.Message); //} //finally //{ // if (connection.State != ConnectionState.Closed) // { // connection.Close(); // } //} return ds; } } }
/// <summary> /// 1.带参数查询,返回bool,直接SQL语句 /// </summary> /// <param name="sqlTypeString"></param> /// <param name="cmdType"></param> /// <param name="parameters"></param> /// <returns></returns> public static bool CheckIsExist(string sqlTypeString, CommandType cmdType, params SqlParameter[] parameters) { bool flag = false; SqlDataReader reader = null; try { using (SqlCommand cmd = new SqlCommand(sqlTypeString, Connection)) { cmd.CommandType = cmdType; cmd.Parameters.AddRange(parameters); reader = cmd.ExecuteReader(); if (reader.HasRows && reader.Read()) { flag = true; } } } catch (SqlException ex) { flag = false; throw ex; } finally { if (reader != null) reader.Close(); } return flag; }
public static DataTable ExecuteData(CommandType cmdCommandType, string cmdCommandString, params SqlParameter[] cmdParameters) { SqlCommand cmdCommand = new SqlCommand(); SqlConnection connect = new SqlConnection(ConnectionString.Text); try { DataTable dattTopic = new DataTable(); SqlDataAdapter dataTopic = new SqlDataAdapter(cmdCommand); PrepareCommand(cmdCommand, connect, null, cmdCommandType, cmdCommandString, cmdParameters); cmdCommand.ExecuteNonQuery(); dataTopic.Fill(dattTopic); cmdCommand.Parameters.Clear(); if (connect.State == ConnectionState.Open) connect.Close(); return dattTopic; } catch (SqlException ex) { if (connect.State == ConnectionState.Open) { connect.Close(); SqlConnection.ClearPool(connect); } throw ex; } }
public SqlCommand GetDBCommand(SqlConnection sqlcn, String CmdText, CommandType CmdType, CommandBehavior CmdBehavior, SqlParameter[] sqlParam) { SqlCommand sqlcmd = null; try { sqlcmd = new SqlCommand(CmdText, sqlcn); sqlcmd.CommandType = CmdType; sqlcmd.CommandTimeout = GetCommandTimeout(); Utilities.DebugLogging.Log("CONNECTION STRING " + sqlcn.ConnectionString); Utilities.DebugLogging.Log("COMMAND TEXT " + CmdText); Utilities.DebugLogging.Log("COMMAND TYPE " + CmdType.ToString()); if (sqlParam != null) Utilities.DebugLogging.Log("NUMBER OF PARAMS " + sqlParam.Length); AddSQLParameters(sqlcmd, sqlParam); } catch (Exception ex) { Utilities.DebugLogging.Log(ex.Message); Utilities.DebugLogging.Log(ex.StackTrace); } return sqlcmd; }
protected override void HandleObjectCommand(CommandType command, GameObject targetObject) { if (isSelected) { switch (command) { case CommandType.Attack: { currentTarget = targetObject.GetComponent<Commandable>(); currentCommand = command; UpdatePath(); } break; case CommandType.Follow: { } break; case CommandType.Patrol: { } break; case CommandType.Mine: { currentResourceTarget = targetObject.GetComponent<Resource>(); currentCommand = command; UpdatePath(); } break; default: break; } } }
/// <summary> /// 查询操作方法 /// </summary> /// <param name="sql">执行的sql语句</param> /// <param name="cmdType">sql语句类型</param> /// <param name="paras">传入的参数</param> /// <returns>返回执行结果的首行首列</returns> public static object ExecuteScalar(string sql, CommandType cmdType, params SqlParameter[] paras) { using (SqlConnection conn = new SqlConnection(serverPath)) { using (SqlCommand cmd = new SqlCommand(sql, conn)) { if (paras != null) { cmd.Parameters.AddRange(paras); } cmd.CommandType = cmdType; try { conn.Open(); return cmd.ExecuteScalar(); } catch (Exception ex) { conn.Close(); conn.Dispose(); throw ex; } } } }
public ChatMessage(MessageType type, CommandType command, string channel, string message) { this.message = message; this.type = (int)type; this.channel = channel; this.command = (int)command; }
public bool ExecuteNonQuery(string CommandName, CommandType cmdType, SqlParameter[] pars) { SqlCommand cmd = null; int res = 0; cmd = con.CreateCommand(); cmd.CommandType = cmdType; cmd.CommandText = CommandName; cmd.Parameters.AddRange(pars); try { con.Open(); res = cmd.ExecuteNonQuery(); } catch (Exception ex) { throw ex; } finally { cmd.Dispose(); cmd = null; con.Close(); } if (res >= 1) { return true; } return false; }
//返回SqlDataReader的方法 public static SqlDataReader ExecuteReader(String sql, CommandType cmdType, params SqlParameter[] pms) { //连接对象 SqlConnection con = new SqlConnection(constr); //执行命令 using (SqlCommand cmd = new SqlCommand(sql, con)) { cmd.CommandType = cmdType; if (pms != null) { cmd.Parameters.AddRange(pms); } try { con.Open(); // sqldata关掉不能用 return cmd.ExecuteReader(CommandBehavior.CloseConnection); } catch { //关闭连接 con.Close(); //释放连接 con.Dispose(); throw; } } }
/// <summary> /// Start a new command of a speicifc type with a global and/or local buffer on the EV3 brick /// </summary> /// <param name="commandType">The type of the command to start</param> /// <param name="globalSize">The size of the global buffer in bytes (maximum of 1024 bytes)</param> /// <param name="localSize">The size of the local buffer in bytes (maximum of 64 bytes)</param> public void Initialize(CommandType commandType, ushort globalSize, int localSize) { if(globalSize > 1024) throw new ArgumentException("Global buffer must be less than 1024 bytes", "globalSize"); if(localSize > 64) throw new ArgumentException("Local buffer must be less than 64 bytes", "localSize"); _stream = new MemoryStream(); _writer = new BinaryWriter(_stream); Response = ResponseManager.CreateResponse(); CommandType = commandType; // 2 bytes (this gets filled in later when the user calls ToBytes()) _writer.Write((ushort)0xffff); // 2 bytes _writer.Write(Response.Sequence); // 1 byte _writer.Write((byte)commandType); if(commandType == CommandType.DirectReply || commandType == CommandType.DirectNoReply) { // 2 bytes (llllllgg gggggggg) _writer.Write((byte)globalSize); // lower bits of globalSize _writer.Write((byte)((localSize << 2) | (globalSize >> 8) & 0x03)); // upper bits of globalSize + localSize } }
/// <summary> /// Execute a SqlCommand that returns a resultset against the database specified in the connection string /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteAdapter(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24)); /// </remarks> /// <param name="connectionString">a valid connection string for a SqlConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-SQL command</param> /// <param name="commandParameters">an array of SqlParamters used to execute the command</param> /// <returns>A Dataset containing the results</returns> public static DataSet ExecuteAdapter(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters) { DataSet ds = new DataSet(); SqlCommand cmd = new SqlCommand(); SqlConnection conn = new SqlConnection(connectionString); // we use a try/catch here because if the method throws an exception we want to // close the connection throw code, because no datareader will exist, hence the // commandBehaviour.CloseConnection will not work try { PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters); using (SqlDataAdapter da = new SqlDataAdapter(cmd)) { da.Fill(ds); cmd.Parameters.Clear(); conn.Close(); //added by lk in 2010-05-21 begin foreach (DataTable dt in ds.Tables) { foreach (DataRow dr in dt.Rows) { foreach (DataColumn dc in dt.Columns) { if (dc.DataType == Type.GetType("System.String")) { // NULL -> ""; + TRIM() dr[dc] = dr[dc].ToString().Trim(); } else if (dc.DataType == Type.GetType("System.DateTime")) { if (Convert.IsDBNull(dr[dc]) || dr[dc].ToString().Equals("")) { dr[dc] = DateTime.MinValue; } } else if (dc.DataType == Type.GetType("System.Decimal") || dc.DataType == Type.GetType("System.Int32") || dc.DataType == Type.GetType("System.Int64")) { if (Convert.IsDBNull(dr[dc])) { dr[dc] = 0; } } } } } //added by lk in 2010-05-21 end return ds; } } catch { if (conn.State != ConnectionState.Closed) { conn.Close(); } throw; } }
internal LocalCommand(string commandText, SqlParameterCollection parameters, int returnParameterIndex, CommandType cmdType) { Debug.Assert(0 <= commandText.Length, "no text"); this.CommandText = commandText; this.Parameters = parameters; this.ReturnParameterIndex = returnParameterIndex; this.CmdType = cmdType; }
private static void ExecuteCommand(CommandType command, DirectoryInfo baseDirectory, Lazy<Uri> url, string userName, string password) { var engine = Engine.CreateStandard(baseDirectory); switch (command) { case CommandType.Help: break; case CommandType.Generate: var generatedDocuments = engine.Generate(); foreach (var generatedDocument in generatedDocuments) { System.Console.WriteLine(generatedDocument); System.Console.WriteLine(); } break; case CommandType.Check: var haveChanged = engine.CheckIfChanged(url.Value, userName, password); System.Console.WriteLine(haveChanged? "Changed": "Have not changed"); break; case CommandType.Push: engine.PushIfChanged(url.Value, userName, password); break; case CommandType.Purge: engine.PurgeDatabase(url.Value, userName, password); break; default: throw new ArgumentOutOfRangeException(); } }
internal static void PrepareCommand(SQLiteCommand command, SQLiteConnection connection, SQLiteTransaction transaction, CommandType commandType, string commandText, SQLiteParameter[] commandParameters, out bool mustCloseConnection) { if (command == null) throw new ArgumentNullException("command"); if (string.IsNullOrEmpty(commandText)) throw new ArgumentNullException("commandText"); if (connection.State == ConnectionState.Open) mustCloseConnection = false; else { mustCloseConnection = true; connection.Open(); } command.Connection = connection; command.CommandText = commandText; if (transaction != null) { if (transaction.Connection == null) throw new ArgumentException( "The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); command.Transaction = transaction; } command.CommandType = commandType; if (commandParameters != null) AttachParameters(command, commandParameters); return; }
/// <summary> /// Constructs a SqlCommand with the given parameters. This method is normally called /// from the other methods and not called directly. But here it is if you need access /// to it. /// </summary> /// <param name="qry">SQL query or stored procedure name</param> /// <param name="type">Type of SQL command</param> /// <param name="args"> /// Query arguments. Arguments should be in pairs where one is the /// name of the parameter and the second is the value. The very last argument can /// optionally be a SqlParameter object for specifying a custom argument type /// </param> /// <returns></returns> public SqlCommand CreateCommand(string qry, CommandType type, params object[] args) { var cmd = new SqlCommand(qry, Conn); // Associate with current transaction, if any if (Trans != null) cmd.Transaction = Trans; // Set command type cmd.CommandType = type; // Construct SQL parameters for (var i = 0; i < args.Length; i++) { if (args[i] is string && i < (args.Length - 1)) { var parm = new SqlParameter(); parm.ParameterName = (string) args[i]; parm.Value = args[++i]; cmd.Parameters.Add(parm); } else if (args[i] is SqlParameter) { cmd.Parameters.Add((SqlParameter) args[i]); } else throw new ArgumentException("Invalid number or type of arguments supplied"); } return cmd; }
/// <summary> /// 执行数据库查询,返回DataSet对象 /// </summary> /// <param name="connectionString">连接字符串</param> /// <param name="commandText">执行语句或存储过程名</param> /// <param name="commandType">执行类型</param> /// <returns>DataSet对象</returns> public DataSet ExecuteDataSet(string connectionString, string commandText, CommandType commandType) { if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString"); if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText"); DataSet ds = new DataSet(); SQLiteConnection con = new SQLiteConnection(connectionString); SQLiteCommand cmd = new SQLiteCommand(); SQLiteTransaction trans = null; PrepareCommand(cmd, con, ref trans, false, commandType, commandText); try { SQLiteDataAdapter sda = new SQLiteDataAdapter(cmd); sda.Fill(ds); } catch (Exception ex) { throw ex; } finally { if (con != null) { if (con.State == ConnectionState.Open) { con.Close(); } } } return ds; }
private int Process(CommandType command) { var options = new Options { DatabaseUrl = DatabaseUrl.Text, BaseDirectory = BaseDirectory.Text, Command = command }; var directoryPath = !string.IsNullOrWhiteSpace(options.BaseDirectory) ? options.BaseDirectory : Environment.CurrentDirectory; var baseDirectory = new DirectoryInfo(directoryPath); if (!baseDirectory.Exists) { MessageBox.Show(@"Provided directory {0} does not exist.", options.BaseDirectory); return IncorrectOptionsReturnCode; } var password = Environment.GetEnvironmentVariable(PasswordEnvVar); var url = new Lazy<Uri>(() => ParseDatabaseUrl(options)); try { ExecuteCommand(options.Command, baseDirectory, url, password); } catch (Exception e) { MessageBox.Show(e.ToString()); return UnknownErrorReturnCode; } return OkReturnCode; }
/// <summary> /// Registers the specified command /// </summary> /// <param name="cmd"></param> /// <param name="type"></param> /// <param name="callback"></param> public void RegisterCommand(string cmd, CommandType type, CommandCallback callback) { // Is it a console command? if (type == CommandType.Console) return; // Convert to lowercase var command_name = cmd.ToLowerInvariant(); // Check if it already exists if (CommandManager.RegisteredCommands.ContainsKey(command_name)) { throw new CommandAlreadyExistsException(command_name); } // Register it var commandAttribute = new CommandAttribute("/" + command_name, string.Empty) { Method = info => { var player = HurtworldCovalenceProvider.Instance.PlayerManager.GetPlayer(info.PlayerId.ToString()); callback(info.Label, CommandType.Chat, player, info.Args); } }; CommandManager.RegisteredCommands[command_name] = commandAttribute; }
/// <summary> /// Gets a data reader. /// </summary> /// <param name="query">The query.</param> /// <param name="commandType">Type of the command.</param> /// <param name="parameters">The parameters.</param> /// <returns></returns> public static IDataReader GetDataReader( string query, CommandType commandType, Dictionary<string, object> parameters ) { string connectionString = GetConnectionString(); if ( !string.IsNullOrWhiteSpace( connectionString ) ) { SqlConnection con = new SqlConnection( connectionString ); con.Open(); SqlCommand sqlCommand = new SqlCommand( query, con ); sqlCommand.CommandType = commandType; if ( parameters != null ) { foreach ( var parameter in parameters ) { SqlParameter sqlParam = new SqlParameter(); sqlParam.ParameterName = parameter.Key.StartsWith( "@" ) ? parameter.Key : "@" + parameter.Key; sqlParam.Value = parameter.Value; sqlCommand.Parameters.Add( sqlParam ); } } return sqlCommand.ExecuteReader( CommandBehavior.CloseConnection ); } return null; }
/// <summary> /// 返回DataSet /// </summary> /// <param name="cmdText">命令字符串</param> /// <param name="cmdType">命令类型</param> /// <param name="commandParameters">可变参数</param> /// <returns> DataSet </returns> public static DataSet ExecuteDataSet(string cmdText, CommandType cmdType, params MySqlParameter[] commandParameters) { DataSet result = null; using (MySqlConnection conn = GetConnection) { try { MySqlCommand command = new MySqlCommand(); PrepareCommand(command, conn, cmdType, cmdText, commandParameters); MySqlDataAdapter adapter = new MySqlDataAdapter(); adapter.SelectCommand = command; result = new DataSet(); adapter.Fill(result); } catch (Exception ex) { throw new Exception(ex.Message); } finally { if (conn != null && conn.State != ConnectionState.Closed) conn.Close(); } } return result; }
public static DataTable Execute_DataTable(SqlParameter[] prm, string Query, string TableName, CommandType CmnType,SqlConnection con) { dt = new DataTable(TableName); cmn = new SqlCommand(); cmn.CommandType = CmnType; cmn.CommandText = Query.Replace("@DbName", SCMDBNAME).Replace("@FrmNo", FRMNO).Replace("@DnmNo", DNMNO); cmn.Connection = con; foreach (SqlParameter item in prm) { cmn.Parameters.AddWithValue(item.ParameterName, item.Value); } try { adp = new SqlDataAdapter(cmn); adp.Fill(dt); cmn.Dispose(); adp.Dispose(); } catch (Exception ex) { cmn.Dispose(); adp.Dispose(); } return dt; }
/// <summary> /// Create a new Command object for the given destination, type, and optional argument. /// </summary> /// <param name="destination">a ZObject that denotes the destination for this command</param> /// <param name="type">the CommandType of the new command</param> /// <param name="arg">an Object to comprise the argument for the command (optional)</param> public Command([CanBeNull] ZObject destination, CommandType type, [CanBeNull] object arg = null) : this() { Destination = destination; CommandType = type; Arg = arg; }
public abstract XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText);
//////////////////////////////////////////////////////////////////////// // ExecuteDataSet Methods //////////////////////////////////////////////////////////////////////// protected DataSet ExecuteDataSet(string cmdText, CommandType cmdType, params IDataParameter[] procParams) { SqlCommand cmd; return(ExecuteDataSet(out cmd, cmdText, cmdType, procParams)); }
private DbCommand GetCommand(DbConnection conn, string cmdText, IDbDataParameter[] parameters = null, CommandType cmdType = CommandType.Text) { using var cmd = conn.CreateCommand(); cmd.CommandText = cmdText; cmd.CommandType = cmdType; if (parameters != null) cmd.Parameters.AddRange(parameters); return cmd; }
/// <summary> /// 准备执行一个命令 /// </summary> /// <param name="cmd">sql命令</param> /// <param name="conn">OleDb连接</param> /// <param name="trans">OleDb事务</param> /// <param name="cmdType">命令类型例如 存储过程或者文本</param> /// <param name="cmdText">命令文本,例如:Select * from Products</param> /// <param name="cmdParms">执行命令的参数</param> private static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, MySqlParameter[] cmdParms) { if (conn.State != ConnectionState.Open) { conn.Open(); } cmd.Connection = conn; cmd.CommandText = cmdText; if (trans != null) { cmd.Transaction = trans; } cmd.CommandType = cmdType; if (cmdParms != null) { foreach (MySqlParameter parm in cmdParms) { cmd.Parameters.Add(parm); } } }
protected override DataTable GetProcedureSchema(DataConnection dataConnection, string commandText, CommandType commandType, DataParameter[] parameters) { try { return(base.GetProcedureSchema(dataConnection, commandText, commandType, parameters)); } catch (Exception ex) { if (ex.Message.Contains("SQL error code = -84")) // procedure XXX does not return any values { return(null); } throw; } }
private void PrepareCommand(IDbCommand command, IDbConnection connection, IDbTransaction transaction, CommandType commandType, string commandText, IDbDataParameter[] commandParameters) { //command.Connection = connection; //command.CommandText = commandText; //command.CommandType = commandType; //if (transaction != null) //{ // command.Transaction = transaction; //} //if (commandParameters != null) //{ // AttachParameters(command, commandParameters); //} try { if (providerType == DataProvider.SqlServer && commandText != null && commandText != "" && commandText.IndexOf("set dateformat dmy") == -1 && commandType != CommandType.StoredProcedure) { commandText = "set dateformat dmy " + commandText; } command.Connection = connection; command.CommandText = commandText; command.CommandType = commandType; command.CommandTimeout = 300; if (transaction != null) { command.Transaction = transaction; } if (commandParameters != null) { AttachParameters(command, commandParameters); } else { //Dongpv:22/04/2018 LogMessage.Trace(commandText + "\n", "TRANCE_SQL"); } } catch (Exception ex) { ErrorHandler.ThrowError(ex); } }
public override int GetHashCode() { int hash = 1; if (ID != 0L) { hash ^= ID.GetHashCode(); } if (CommandType != 0) { hash ^= CommandType.GetHashCode(); } if (MoveDirection != 0) { hash ^= MoveDirection.GetHashCode(); } if (MoveDuration != 0) { hash ^= MoveDuration.GetHashCode(); } if (ThrowDistance != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ThrowDistance); } if (ThrowAngle != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ThrowAngle); } if (IsThrowDish != false) { hash ^= IsThrowDish.GetHashCode(); } if (UseType != 0) { hash ^= UseType.GetHashCode(); } if (SpeakText.Length != 0) { hash ^= SpeakText.GetHashCode(); } if (Parameter1 != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Parameter1); } if (Parameter2 != 0D) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Parameter2); } if (IsSetTalent != false) { hash ^= IsSetTalent.GetHashCode(); } if (Talent != 0) { hash ^= Talent.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public static DbCommand SetCommandParameters(this DbCommand cmd, string command, CommandType type, int?timeout) { #pragma warning disable CA2100 // Review SQL queries for security vulnerabilities cmd.CommandText = command; #pragma warning restore CA2100 // Review SQL queries for security vulnerabilities cmd.CommandType = type; if (timeout != null) { cmd.CommandTimeout = timeout.Value; } return(cmd); }
public async Task ExecuteReaderAsync(string cmdText, IEnumerable<DBReaderHandler> readerHandlers, IDbDataParameter[] parameters = null, CommandType cmdType = CommandType.Text) { using var conn = GetConnection(); using var cmd = GetCommand(conn, cmdText, parameters, cmdType); using var reader = await cmd.ExecuteReaderAsync(); foreach (var handler in readerHandlers) { if (handler.IsFirstResult || (!handler.IsFirstResult && await reader.NextResultAsync())) while (await reader.ReadAsync()) handler.Handler.Invoke(reader); } }
public async Task<object> ExecuteScalarAsync(string cmdText, IDbDataParameter[] parameters = null, CommandType cmdType = CommandType.Text) { using var conn = GetConnection(); return await GetCommand(conn, cmdText, parameters, cmdType).ExecuteScalarAsync(); }
public T Get <T>(string sp, DynamicParameters parms, CommandType commandType = CommandType.Text) { using IDbConnection db = new SqlConnection(this.config.GetConnectionString(this.connectionstring)); return(db.Query <T>(sp, parms, commandType: commandType).FirstOrDefault()); }
public List <T> GetAll <T>(string sp, object parms, CommandType commandType = CommandType.StoredProcedure) { using IDbConnection db = new SqlConnection(this.config.GetConnectionString(this.connectionstring)); return(db.Query <T>(sp, parms, commandType: commandType).ToList()); }
public void GetSQLMultipleData <T1, T2, T3, T4, T5, T6>(string sql, List <T1> t1, List <T2> t2 = null, List <T3> t3 = null, List <T4> t4 = null, List <T5> t5 = null, List <T6> t6 = null, object parameters = null, CommandType type = CommandType.StoredProcedure) { parameters = TransformArrayParametersToTableValuedParameters(parameters); using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings[_connectionString].ConnectionString)) { conn.Open(); var res = conn.QueryMultiple(sql, parameters, commandType: type); t1.AddRange(res.Read <T1>()); if (t2 != null) { t2.AddRange(res.Read <T2>()); } if (t3 != null) { t3.AddRange(res.Read <T3>()); } if (t4 != null) { t4.AddRange(res.Read <T4>()); } if (t5 != null) { t5.AddRange(res.Read <T5>()); } if (t6 != null) { t6.AddRange(res.Read <T6>()); } } }
private static void PrepareCommand(SqlConnection conn, SqlCommand cmd, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] commandParameters) { if (conn.State != ConnectionState.Open) { conn.Open(); } cmd.Connection = conn; cmd.CommandText = cmdText; if (trans != null) { cmd.Transaction = trans; } cmd.CommandType = cmdType; if (commandParameters != null) { AttachParameters(cmd, commandParameters); } }
public static void db2PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, CommandType cmdType, string cmdText, OleDbParameter[] cmdParms) { try { if (conn.State != ConnectionState.Open) { try { conn.Open(); } catch (Exception exception) { Log4netHelper.Error(exception, "db2error", "db2Openerror"); } } cmd.Connection = conn; cmd.CommandText = cmdText; if (trans != null) { cmd.Transaction = trans; } cmd.CommandType = cmdType; if (cmdParms != null) { foreach (OleDbParameter parameter in cmdParms) { cmd.Parameters.Add(parameter); } } } catch (Exception exception2) { Log4netHelper.Error(exception2, "db2error", "db2Commanderror"); } }
public void GetSQLMultipleData <T1, T2>(string sql, List <T1> t1, List <T2> t2 = null, object parameters = null, CommandType type = CommandType.StoredProcedure) { GetSQLMultipleData <T1, T2, int, int, int, int>(sql, t1, t2, null, null, null, null, parameters, type); }
public int Delete(string sqlQuery, DynamicParameters param, CommandType commandType) { return(_businessRepository.Delete(sqlQuery, param, commandType)); }
private static void Connection_UnknownCommandReceived(CommandType cmdType, uint cmdId, uint cmdVer, byte[] data) { Console.WriteLine("Unknown command received"); }
public abstract object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters);
public abstract XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters);
public abstract object ExecuteScalar(string connectionString, CommandType commandType, string commandText);
public bool MyExecuteNonQuery(ref string err, ref int rows, string commandText, CommandType commandType, params SqlParameter[] param) { bool result = false; try { //Mo ket noi if (connect.State == ConnectionState.Open) { connect.Close(); } connect.Open(); //khoi tao command command = new SqlCommand() { Connection = connect, CommandText = commandText, CommandType = commandType, CommandTimeout = 600 }; if (param != null) { foreach (SqlParameter item in param) { command.Parameters.Add(item); } } rows = command.ExecuteNonQuery(); result = true; } catch (Exception ex) { err = ex.Message; } finally { connect.Close(); }// dung dong ket noi return(result); }
public abstract SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText);
public abstract XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText);
public abstract SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText);
public abstract object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters);
public abstract SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters);
public abstract SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters);
public abstract object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText);
public abstract object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText);
private static void PrepareCommand( DbCommand command, DbConnection connection, DbTransaction transaction, CommandType commandType, string commandText, DbParameter[] commandParameters) { if (command == null) throw new ArgumentNullException("command"); if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText"); command.Connection = connection; command.CommandText = commandText; command.CommandType = commandType; if (transaction != null) { if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction"); command.Transaction = transaction; } if (commandParameters != null) { AttachParameters(command, commandParameters); } return; }