网络上复制的SQLHelp类
OracleHELP命令
OracleHELP命令Oracle HELP命令SQL*Plus有许多命令，而且每个命令都有大量的选项，要记住每一个命令的所有选项是很困难的。
不过SQL*Plus提供了内建的帮助系统，用户可以在需要的时候，随时可以使用HELP命令查询相关的命令信息。
但是SQL*Plus的内建帮助只是提供了部分命令信息，SQL*Plus 帮助系统可以向用户提供下面一些信息：●命令标题。
●命令作用描述的文件。
●命令的缩写形式。
●命令中使用的强制参数和可选参数。
HELP命令的语法形式如下所示：help [topic]在上面的语法中，TOPIC参数表示将要查询的命令名称。
使用HELP INDEX命令，则显示可以通过HELP命令查看的SQL*Plus命令清单。
该命令的执行结果如下：SQL> help indexEnter Help [topic] for help.@ COPY PAUSE SHUTDOWN@@ DEFINE PRINT SPOOL/ DEL PROMPT SQLPLUSACCEPT DESCRIBE QUIT STARTAPPEND DISCONNECT RECOVER STARTUPARCHIVE LOG EDIT REMARK STOREA TTRIBUTE EXECUTE REPFOOTER TIMINGBREAK EXIT REPHEADER TTITLEBTITLE GET RESERVED WORDS (SQL) UNDEFINECHANGE HELP RESERVED WORDS (PL/SQL) V ARIABLECLEAR HOST RUN WHENEVER OSERRORCOLUMN INPUT SA VE WHENEVER SQLERRORCOMPUTE LIST SET XQUERYCONNECT PASSWORD SHOWSHUTDOWN命令可以关闭数据库实例。
使有HELP命令可以查看SHUTDOWN命令的使用方式。
SqlServerDBHelper类
SqlServerDBHelper类using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Data;using System.Data.SqlClient;namespace DAL{/// <summary>/// 连接数据库类/// </summary>public class SqlServerDBHelper{/// <summary>/// 连接数据库/// </summary>/// <returns></returns>public static SqlConnection GetConnection(){string conString = System.Configuration.ConfigurationManager.ConnectionStrings["connstring"].ToString();//定义连接数据库字符集 return new SqlConnection(conString);//返回连接数据库对象}/// <summary>/// ⽤数据填充的⽅法查询/// </summary>/// <param name="type"></param>/// <param name="sql"></param>/// <param name="pares"></param>/// <returns></returns>public DataSet GetDataSet(CommandType type, string sql, params SqlParameter[] pares){SqlConnection con = GetConnection();DataSet ds = new DataSet();SqlDataAdapter da = new SqlDataAdapter(sql, con);mandType = type;if (pares != null){foreach (SqlParameter pare in pares){da.SelectCommand.Parameters.Add(pare);}}da.Fill(ds);return ds;}public DataSet GetDataSet(string sql, params SqlParameter[] pares){return GetDataSet(CommandType.Text, sql, pares);}public SqlDataReader GetSqlDataReader(CommandType type, string sql,out SqlConnection con, params SqlParameter[] pares){con = GetConnection();SqlCommand cmd = new SqlCommand(sql, con);mandType = type;con.Open();if (pares != null){foreach (SqlParameter pare in pares){cmd.Parameters.Add(pare);}}return cmd.ExecuteReader(CommandBehavior.CloseConnection);}public SqlDataReader GetSqlDataReader(string sql,out SqlConnection con, params SqlParameter[] pares) {return GetSqlDataReader(CommandType.Text, sql,out con, pares);}public bool MidfyDB(CommandType type, string sql, params SqlParameter[] pares){bool falg = false;SqlConnection con = GetConnection();SqlCommand cmd = new SqlCommand(sql, con);mandType = type;if (pares != null){foreach (SqlParameter pare in pares){cmd.Parameters.Add(pare);}}SqlTransaction trans = null;try{con.Open();trans = con.BeginTransaction();cmd.Transaction = trans;cmd.ExecuteNonQuery();mit();falg = true;}catch (Exception e){trans.Rollback();throw e;}finally{con.Close();}return falg;}public bool MidfyDB(string sql, params SqlParameter[] pares){return MidfyDB(CommandType.Text, sql, pares);}/// <summary>/// 查询聚合函数类/// </summary>/// <param name="type">数据库操作的类型如:StoredProcedure(存储过程)、Text(⽂本)</param>/// <param name="sql">数据库操作字符集</param>/// <param name="paras">查询数据库时所⽤的参数</param>/// <returns>object(⼀般为单个值)</returns>public object GetScalar(CommandType type, string sql, params SqlParameter[] paras){SqlConnection con = GetConnection();//创建数据集对象SqlCommand cmd = new SqlCommand(sql, con);//操作数据库对象mandType = type;//数据库操作的类型//如果参数不为空if (paras != null){//遍历参数数组foreach (SqlParameter para in paras){cmd.Parameters.Add(para);//给操作数据库对象加上参数}}con.Open();//打开数据库连接object obj = cmd.ExecuteScalar();//返回⼀个⼀⾏⼀列的植con.Close();//关闭数据库连接return obj;}public object GetScalar(string sql, params SqlParameter[] paras){return GetScalar(CommandType.Text, sql, paras);}#region 数据填充DataTablepublic static DataTable DataFill(SqlCommand cmd){DataTable dt = new DataTable();cmd.Connection = GetConnection();SqlDataAdapter _da = new SqlDataAdapter(cmd);_da.Fill(dt);return dt;}#endregion//public DataTable DateTel(string sql)//{// SqlConnection con = GetConnection();// SqlCommand cmd = new SqlCommand(sql, con);// SqlDataAdapter da = new SqlDataAdapter(cmd);// DataTable dt = new DataTable();// da.Fill(dt);// return dt;//}internal DataSet GetDataSet(string sql, int UID){throw new NotImplementedException();}public static SqlCommand GetCommand(string text){SqlCommand cmdObject = new SqlCommand();mandText = text;return cmdObject;}public static void PreparedCommand(SqlCommand cmd, SqlParameter[] pars) {foreach (SqlParameter p in pars){cmd.Parameters.Add(p);}}}}。
mysql复制数据库sql语句
mysql复制数据库sql语句MySQL复制数据库SQL语句复制（也称为复制、复制）是将一个数据库的内容复制到另一个数据库的过程。
MySQL数据库提供了一种非常简单且强大的方法来复制数据库，只需使用一些SQL语句即可完成。
本文将指导您一步一步完成MySQL数据库的复制过程。
一、创建目标数据库在开始复制数据库之前，首先需要在目标服务器上创建一个空的目标数据库。
您可以使用以下SQL语句创建目标数据库：CREATE DATABASE 目标数据库名;在这里，您需要将“目标数据库名”替换为您要创建的实际目标数据库的名称。
二、检查源数据库的复制权限在源数据库中，您需要检查是否有对源数据库进行复制的权限。
如果没有，您可以使用以下SQL语句为您的数据库用户添加复制权限：GRANT REPLICATION SLAVE ON *.* TO '用户''' IDENTIFIED BY '密码';在这里，您需要将“用户”和“密码”替换为您实际的数据库用户和密码。
三、备份源数据库在进行数据库复制之前，最好先对源数据库进行备份。
这样，在复制过程中如果出现任何错误，您可以轻松地还原源数据库。
您可以使用以下SQL语句备份源数据库：mysqldump -u 用户名-p 源数据库名> 备份文件名.sql在这里，您需要将“用户名”、“源数据库名”和“备份文件名”替换为您实际的数据库用户名、源数据库名称和备份文件名。
四、启动源数据库的二进制日志功能在源数据库上，您需要启动二进制日志功能，以记录对数据库的所有更改。
您可以使用以下SQL语句启动二进制日志功能：SET GLOBAL LOG_BIN = ON;五、获取源数据库的二进制日志文件和位置在源数据库上，您需要获取二进制日志文件和位置。
您可以使用以下SQL语句获取二进制日志文件和位置：SHOW MASTER STATUS;这将显示当前二进制日志文件的名称和位置。
sql复制技术类型
sql复制技术类型SQL复制技术类型在数据库管理系统中，数据复制是一种常见的技术，用于将一个数据库的数据复制到另一个数据库中。
这种技术被广泛应用于数据备份、高可用性和数据分析等场景。
在SQL（Structured Query Language）中，也存在着多种数据复制技术类型。
本文将介绍几种常见的SQL复制技术类型，并探讨它们的特点和应用场景。
1. 基于物理复制的SQL复制技术基于物理复制的SQL复制技术是通过复制数据库文件来实现数据的复制。
它将源数据库的数据文件直接复制到目标数据库中，实现了数据的完全复制。
这种技术的优点是复制速度快，复制过程中不会对源数据库产生负载。
然而，由于需要复制整个数据库文件，因此需要足够的存储空间，并且在复制期间需要停止源数据库的写操作。
基于物理复制的SQL复制技术适用于数据备份和恢复的场景。
2. 基于逻辑复制的SQL复制技术基于逻辑复制的SQL复制技术是通过复制数据库的逻辑结构和数据更改操作来实现数据的复制。
它将源数据库的数据更改操作记录下来，并在目标数据库上重放这些操作，从而实现数据的复制。
这种技术的优点是可以在复制过程中对源数据库进行读写操作，不会对源数据库产生负载，同时可以对复制的数据进行过滤和转换。
然而，由于需要记录和重放数据更改操作，因此复制的速度相对较慢。
基于逻辑复制的SQL复制技术适用于数据同步和数据分析的场景。
3. 基于增量复制的SQL复制技术基于增量复制的SQL复制技术是在已有的数据复制基础上，只复制发生变化的数据。
它通过记录数据的变化情况，仅将变化的部分进行复制，从而减少了复制的数据量。
这种技术的优点是可以减少网络带宽的占用和复制的时间，提高了复制的效率。
然而，由于需要记录数据的变化情况，增量复制的实现相对复杂。
基于增量复制的SQL复制技术适用于大规模数据复制和高可用性的场景。
4. 基于异步复制的SQL复制技术基于异步复制的SQL复制技术是在源数据库执行数据更改操作后，不立即复制数据到目标数据库，而是将数据更改操作记录到日志中，然后由复制进程异步地将数据复制到目标数据库。
SqlHelp使用指南（转）
SqlHelp使⽤指南（转）摘要：Data Access Application Block 是⼀个 .NET 组件，包含优化的数据访问代码，可以帮助⽤户调⽤存储过程以及向 SQL Server 数据库发出 SQL ⽂本命令。
它返回 SqlDataReader、DataSet 和 XmlReader 对象。
您可以在⾃⼰的 .NET 应⽤程序中将其作为构造块来使⽤，以减少需要创建、测试和维护的⾃定义代码的数量。
您可以下载完整的 C# 和 Visual Basic .NET 源代码以及综合⽂档。
简介您是否正在从事 .NET 应⽤程序数据访问代码的设计和开发？您是否觉得⾃⼰总是在反复编写相同的数据访问代码？您是否曾经将数据访问代码包装在 Helper 函数中，以便能够在⼀⾏中调⽤存储过程？如果是，那么 Microsoft® Data Access Application Block for .NET 正是为您设计的。
Data Access Application Block 将访问 Microsoft SQL Server™ 数据库的性能和资源管理⽅⾯的最佳经验封装在⼀起。
您可以很⽅便地在⾃⼰的 .NET 应⽤程序中将其作为构造块使⽤，从页减少了需要创建、测试和维护的⾃定义代码的数量。
尤其是，Data Access Application Block 可以帮助您：调⽤存储过程或 SQL ⽂本命令。
指定参数详细信息。
返回 SqlDataReader、DataSet 或 XmlReader 对象。
例如，在引⽤了 Data Access Application Block 的应⽤程序中，您可以简单地在⼀⾏代码中调⽤存储过程并⽣成 DataSet，如下所⽰：[Visual Basic]Dim ds As DataSet = SqlHelper.ExecuteDataset( _connectionString, _CommandType.StoredProcedure, _"getProductsByCategory", _new SqlParameter("@CategoryID", categoryID))[C#]DataSet ds = SqlHelper.ExecuteDataset(connectionString,CommandType.StoredProcedure,"getProductsByCategory",new SqlParameter("@CategoryID", categoryID));注意： Application Block for .NET（⽤于 .NET 的应⽤程序块）是基于对成功的 .NET 应⽤程序进⾏详细研究⽽设计的。
SqlHelp详解
SqlHelp详解SqlHelper 类实现详细信息SqlHelper 类用于通过一组静态方法来封装数据访问功能。
该类不能被继承或实例化，因此将其声明为包含专用构造函数的不可继承类。
在 SqlHelper 类中实现的每种方法都提供了一组一致的重载。
这提供了一种很好的使用 SqlHelper 类来执行命令的模式，同时为开发人员选择访问数据的方式提供了必要的灵活性。
每种方法的重载都支持不同的方法参数，因此开发人员可以确定传递连接、事务和参数信息的方式。
在 SqlHelper 类中实现的方法包括：ExecuteNonQuery。
此方法用于执行不返回任何行或值的命令。
这些命令通常用于执行数据库更新，但也可用于返回存储过程的输出参数。
ExecuteReader。
此方法用于返回 SqlDataReader 对象，该对象包含由某一命令返回的结果集。
ExecuteDataset。
此方法返回 DataSet 对象，该对象包含由某一命令返回的结果集。
ExecuteScalar。
此方法返回一个值。
该值始终是该命令返回的第一行的第一列。
ExecuteXmlReader。
此方法返回 FOR XML 查询的 XML 片段。
除了这些公共方法外，SqlHelper 类还包含一些专用函数，用于管理参数和准备要执行的命令。
不管客户端调用什么样的方法实现，所有命令都通过 SqlCommand 对象来执行。
在 SqlCommand 对象能够被执行之前，所有参数都必须添加到 Parameters 集合中，并且必须正确设置 Connection、CommandType、CommandText 和 Transaction 属性。
SqlHelper 类中的专用函数主要用于提供一种一致的方式，以便向 SQL Server 数据库发出命令，而不考虑客户端应用程序调用的重载方法实现。
SqlHelper 类中的专用实用程序函数包括：AttachParameters：该函数用于将所有必要的 SqlParameter 对象连接到正在运行的 SqlCommand。
sqlhelper的用法
sqlhelper的用法SQLhelper是一个工具类，用于简化与数据库的交互操作。
它主要提供了一些通用的方法，用于执行SQL语句、查询数据等。
使用SQLhelper，需要先创建一个SQLhelper对象。
可以通过以下方式创建：1. 创建一个数据库连接：```SqlConnection connection = newSqlConnection(connectionString);```其中，`connectionString`是连接数据库的字符串，包括数据库服务器地址、用户名、密码等信息。
2. 创建一个SQLhelper对象：```SQLhelper sqlHelper = new SQLhelper(connection);```传入数据库连接对象作为参数。
创建SQLhelper对象后，就可以使用它提供的方法来执行SQL 语句了。
以下是一些常用的方法：1. 执行SQL语句（增删改操作）：```int rowsAffected = sqlHelper.ExecuteNonQuery(sql);```其中，`sql`是要执行的SQL语句，`rowsAffected`是受影响的行数。
2. 执行SQL语句（查询操作）：```DataTable result = sqlHelper.ExecuteDataTable(sql);```其中，`sql`是要执行的SQL语句，`result`是查询结果，以DataTable的形式返回。
3. 执行SQL语句（查询操作，返回单个值）：```object result = sqlHelper.ExecuteScalar(sql);```其中，`sql`是要执行的SQL语句，`result`是查询结果的第一行第一列的值。
4. 执行带参数的SQL语句：```SqlParameter[] parameters = new SqlParameter[]{new SqlParameter("@Param1", value1),new SqlParameter("@Param2", value2),// ...};int rowsAffected = sqlHelper.ExecuteNonQuery(sql, parameters); ```其中，`parameters`是参数数组，`@Param1`、`@Param2`等是SQL语句中的参数名。
sqlhelper知识点总结
sqlhelper知识点总结
SQLHelper是一个用于帮助执行SQL语句的工具类。
它封装
了一些常用的数据库操作，使得执行SQL语句变得更加简洁
和方便。
以下是SQLHelper的主要知识点总结：
1. 数据库连接：SQLHelper可以通过提供连接字符串来连接到
数据库。
连接字符串包含数据库服务器的名称、数据库名称、用户名和密码等信息。
2. 执行SQL语句：SQLHelper可以执行各种SQL语句，包括
查询、插入、更新和删除等。
它可以执行单个SQL语句，也
可以执行多个SQL语句的批处理操作。
3. 参数化查询：SQLHelper支持参数化查询，可以通过参数来
动态设置SQL语句中的值，以避免SQL注入攻击，并提高查
询的性能。
4. 数据库事务：SQLHelper可以支持数据库事务操作。
事务是
一系列数据库操作的逻辑单元，可以保证数据库操作的原子性，一致性和隔离性。
5. 数据库连接池：SQLHelper可以使用连接池来提高数据库操
作的性能。
连接池维护了一组预先创建好的数据库连接，可以重复使用，避免了频繁创建和关闭连接的开销。
6. 异常处理：SQLHelper可以处理数据库操作中的异常。
它可
以捕获并处理数据库连接失败、SQL语法错误和执行异常等
异常情况。
总的来说，SQLHelper是一个简化数据库操作的工具类，它封装了数据库连接、SQL语句执行、参数化查询、事务管理、连接池和异常处理等功能，可以提高数据库操作的效率和可靠性。
C#，一份超简单的数据库帮助类，SqlHelp
C#，⼀份超简单的数据库帮助类，SqlHelp 简单，实⽤，留存。
1using System;2using System.Collections.Generic;3using System.Configuration;4using System.Data;5using System.Data.SqlClient;6using System.Linq;7using System.Text;8using System.Threading.Tasks;910namespace CarHailing.Base11 {12///<summary>13///数据库帮助类14///</summary>15public class SqlHelp16 {17///<summary>18///创建⼀个已打开的连接19///</summary>20///<returns></returns>21private static SqlConnection CreateConn()22 {23 SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["conn"].ConnectionString);24 conn.Open();25return conn;26 }2728///<summary>29///执⾏sql语句，返回受影响的⾏数30///</summary>31///<param name="sql"></param>32///<returns></returns>33public static int ExecuteNonQuery(string sql)34 {35return ExecuteNonQuery(sql, null);36 }3738///<summary>39///执⾏sql语句，返回受影响的⾏数40///</summary>41///<param name="sql"></param>42///<returns></returns>43public static int ExecuteNonQuery(string sql, SqlParameter[] ps)44 {45 SqlConnection conn = CreateConn();46 SqlCommand cmd = new SqlCommand(sql, conn);47try48 {49if (ps != null)50 {51 cmd.Parameters.AddRange(ps);52 }53return cmd.ExecuteNonQuery();54 }55catch (Exception ex)56 {57return0;58 }59finally60 {61 conn.Close();62 }63 }6465///<summary>66///执⾏sql语句,返回⼀个结果表67///</summary>68///<param name="sql"></param>69///<returns></returns>70public static DataTable ExecuteSelectDataTable(string sql)71 {72return ExecuteSelectDataTable(sql, null);73 }7475///<summary>76///执⾏sql语句,返回⼀个结果表77///</summary>78///<param name="sql"></param>79///<param name="ps"></param>80///<returns></returns>81public static DataTable ExecuteSelectDataTable(string sql, SqlParameter[] ps = null)82 {8384 SqlConnection conn = CreateConn();85 SqlCommand cmd = new SqlCommand(sql, conn);86try87 {88if (ps != null)89 {90 cmd.Parameters.AddRange(ps);91 }92//SqlDataAdapter sda = new SqlDataAdapter(cmd);93 SqlDataReader read = cmd.ExecuteReader();94 DataTable table = new DataTable();95 table.Load(read);96//DataSet ds = new DataSet();97//sda.Fill(ds);98return table;99 }100finally101 {102 conn.Close();103 }104 }105106///<summary>107///108///</summary>109///<param name="sql"></param>110///<returns></returns>decimal111public static DataTable ExecuteSelectPageDataTable(string sql, ref SqlParameter[] ps)112 {113 SqlConnection conn = CreateConn();114 SqlCommand cmd = new SqlCommand(sql, conn);115 mandType = CommandType.StoredProcedure;116try117 {118 cmd.Parameters.AddRange(ps);119 SqlDataAdapter sda = new SqlDataAdapter(cmd);120 DataSet ds = new DataSet();121 sda.Fill(ds);122return ds.Tables[0];123 }124catch (SqlException ex)125 {126throw ex;127 }128finally129 {130 conn.Close();131 }132 }133134//public static SqlDataReader ExecuteReader(string cmdText, CommandType cmdType, params SqlParameter[] cmdParms) 135//{136// SqlCommand cmd = new SqlCommand();137// SqlConnection conn = CreateConn();138139// try140// {141// ProCommand(cmd, conn, cmdText, cmdType, cmdParms);142// SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);143////cmd.Parameters.Clear();//放到这⾥，返回参数会被清空。
SQLHelp源代码
package com.gc.util;import java.io.IOException;import java.io.InputStream;import java.sql.*;import java.util.ArrayList;import java.util.Properties;import com.gc.model.SaveData;import er;public class SQLHelper {private static Connection ct=null;private static PreparedStatement ps=null;private static ResultSet rs=null;private static String driver="";private static String url="";private static String user="";private static String password="";private static Properties pp=null;private static InputStream fis=null;//读取配置文件，加载到内存static{try {pp=new Properties();fis=SQLHelper.class.getClassLoader().getResourceAsStream("dbinfo.properties ");pp.load(fis);//解析driver=pp.getProperty("driver");url=pp.getProperty("url");user=pp.getProperty("user");password=pp.getProperty("password");Class.forName(driver);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{if(fis!=null){try {fis.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}public static Connection getConnection(){try {ct=DriverManager.getConnection(url, user, password);} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}return ct;}/*//二次封装，返回的是一个 ArrayList<>集合，可以及时关闭rspublic static ArrayList<User> executeQuery2(Stringsql,String[]parameters){ArrayList<User> al=new ArrayList<User>();try {ct=getConnection();ps=ct.prepareStatement(sql);if(parameters!=null){for(int i=0;i<parameters.length;i++){ps.setString(i+1, parameters[i]);}}rs=ps.executeQuery();//开始封装while(rs.next()){User user =new User();user.setId(rs.getInt(1));user.setUsername(rs.getString(2));user.setPassword(rs.getString(3));user.setGrade(rs.getInt(4));user.setEmail(rs.getString(5));al.add(user);}} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{SQLHelper.close(SQLHelper.getRs(), SQLHelper.getPs(), SQLHelper.getCt());}return al;}*///二次封装，返回的是一个 ArrayList<>集合，可以及时关闭rspublic static ArrayList<SaveData> executeQuery2(String sql,String[]parameters){ArrayList<SaveData> al=new ArrayList<SaveData>();try {ct=getConnection();ps=ct.prepareStatement(sql);if(parameters!=null){for(int i=0;i<parameters.length;i++){ps.setString(i+1, parameters[i]);}}rs=ps.executeQuery();//开始封装int x=0;while(rs.next()){SaveData savedata =new SaveData();savedata.setDateTime(rs.getString(2));savedata.setMessage(rs.getString(3));al.add(savedata);System.out.println(al.get(x).getMessage());x+=1;}} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{SQLHelper.close(SQLHelper.getRs(), SQLHelper.getPs(), SQLHelper.getCt());}return al;}//写通用的查询方法无法及时关闭资源。
MySQL帮助类MySQLHelper
MySQL帮助类MySQLHelper///<summary>/// MySqlHelper操作类///</summary>public sealed partial class MySQLHelper{public static readonly string DBConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings[""].ToString();///<summary>///批量操作每批次记录数///</summary>public static int BatchSize = 2000;///<summary>///超时时间///</summary>public static int CommandTimeOut = 600;///<summary>///初始化MySqlHelper实例///</summary>///<param name="connectionString">数据库连接字符串</param>public MySQLHelper(string connectionString){this.ConnectionString = connectionString;}///<summary>///数据库连接字符串///</summary>public string ConnectionString { get; set; }#region实例⽅法#region ExecuteNonQuery///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public int ExecuteNonQuery(string commandText, params MySqlParameter[] parms){return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public int ExecuteNonQuery(CommandType commandType, string commandText, params MySqlParameter[] parms){return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);}#endregion ExecuteNonQuery#region ExecuteScalar///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<typeparam name="T">返回对象类型</typeparam>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public T ExecuteScalar<T>(string commandText, params MySqlParameter[] parms){return ExecuteScalar<T>(ConnectionString, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public object ExecuteScalar(string commandText, params MySqlParameter[] parms){return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public object ExecuteScalar(CommandType commandType, string commandText, params MySqlParameter[] parms){return ExecuteScalar(ConnectionString, commandType, commandText, parms);}#endregion ExecuteScalar#region ExecuteDataReader///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private MySqlDataReader ExecuteDataReader(string commandText, params MySqlParameter[] parms){return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private MySqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteDataReader(ConnectionString, commandType, commandText, parms);}#endregion#region ExecuteDataRow///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏</returns>public DataRow ExecuteDataRow(string commandText, params MySqlParameter[] parms){return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏</returns>public DataRow ExecuteDataRow(CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteDataRow(ConnectionString, commandType, commandText, parms);}#endregion ExecuteDataRow#region ExecuteDataTable///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public DataTable ExecuteDataTable(string commandText, params MySqlParameter[] parms){return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public DataTable ExecuteDataTable(CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];}#endregion ExecuteDataTable#region ExecuteDataSet///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public DataSet ExecuteDataSet(string commandText, params MySqlParameter[] parms){return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public DataSet ExecuteDataSet(CommandType commandType, string commandText, params MySqlParameter[] parms){return ExecuteDataSet(ConnectionString, commandType, commandText, parms);}#endregion ExecuteDataSet#region批量操作///<summary>///使⽤MySqlDataAdapter批量更新数据///</summary>///<param name="table">数据表</param>public void BatchUpdate(DataTable table){BatchUpdate(ConnectionString, table);}///<summary>///⼤批量数据插⼊,返回成功插⼊⾏数///</summary>///<param name="table">数据表</param>///<returns>返回成功插⼊⾏数</returns>public int BulkInsert(DataTable table){return BulkInsert(ConnectionString, table);}#endregion批量操作#endregion实例⽅法#region静态⽅法private static void PrepareCommand(MySqlCommand command, MySqlConnection connection, MySqlTransaction transaction, CommandType commandType {if (connection.State != ConnectionState.Open) connection.Open();command.Connection = connection;mandTimeout = CommandTimeOut;// 设置命令⽂本(存储过程名或SQL语句)mandText = commandText;// 分配事务if (transaction != null){command.Transaction = transaction;}// 设置命令类型.mandType = commandType;if (parms != null && parms.Length > 0){//预处理MySqlParameter参数数组，将为NULL的参数赋值为DBNull.Value;foreach (MySqlParameter parameter in parms){if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null)){parameter.Value = DBNull.Value;}}command.Parameters.AddRange(parms);}}#region ExecuteNonQuery///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(string connectionString, string commandText, params MySqlParameter[] parms){using (MySqlConnection connection = new MySqlConnection(connectionString)){return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);}}///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms){using (MySqlConnection connection = new MySqlConnection(connectionString)){return ExecuteNonQuery(connection, commandType, commandText, parms);}}///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteNonQuery(connection, null, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回影响的⾏数///</summary>///<param name="connection">数据库连接</param>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回影响的⾏数</returns>private static int ExecuteNonQuery(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, {MySqlCommand command = new MySqlCommand();PrepareCommand(command, connection, transaction, commandType, commandText, parms);int retval = command.ExecuteNonQuery();command.Parameters.Clear();return retval;}#endregion ExecuteNonQuery#region ExecuteScalar///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<typeparam name="T">返回对象类型</typeparam>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public static T ExecuteScalar<T>(string connectionString, string commandText, params MySqlParameter[] parms){object result = ExecuteScalar(connectionString, commandText, parms);if (result != null){return (T)Convert.ChangeType(result, typeof(T)); ;}return default(T);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public static object ExecuteScalar(string connectionString, string commandText, params MySqlParameter[] parms){using (MySqlConnection connection = new MySqlConnection(connectionString)){return ExecuteScalar(connection, CommandType.Text, commandText, parms);}}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms){using (MySqlConnection connection = new MySqlConnection(connectionString)){return ExecuteScalar(connection, commandType, commandText, parms);}}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public static object ExecuteScalar(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteScalar(connection, null, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>public static object ExecuteScalar(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏第⼀列///</summary>///<param name="connection">数据库连接</param>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀⾏第⼀列</returns>private static object ExecuteScalar(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText,{MySqlCommand command = new MySqlCommand();PrepareCommand(command, connection, transaction, commandType, commandText, parms);object retval = command.ExecuteScalar();command.Parameters.Clear();return retval;}#endregion ExecuteScalar#region ExecuteDataReader///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="connection">数据库连接</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private static MySqlDataReader ExecuteDataReader(string connectionString, string commandText, params MySqlParameter[] parms){MySqlConnection connection = new MySqlConnection(connectionString);return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private static MySqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] {MySqlConnection connection = new MySqlConnection(connectionString);return ExecuteDataReader(connection, null, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParam {return ExecuteDataReader(connection, null, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private static MySqlDataReader ExecuteDataReader(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParam {return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回只读数据集///</summary>///<param name="connection">数据库连接</param>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回只读数据集</returns>private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string{MySqlCommand command = new MySqlCommand();PrepareCommand(command, connection, transaction, commandType, commandText, parms);return command.ExecuteReader(CommandBehavior.CloseConnection);}#endregion#region ExecuteDataRow///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>,返回结果集中的第⼀⾏</returns>public static DataRow ExecuteDataRow(string connectionString, string commandText, params MySqlParameter[] parms){DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);return dt.Rows.Count > 0 ? dt.Rows[0] : null;}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>,返回结果集中的第⼀⾏</returns>public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms){DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);return dt.Rows.Count > 0 ? dt.Rows[0] : null;}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>,返回结果集中的第⼀⾏</returns>public static DataRow ExecuteDataRow(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms) {DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);return dt.Rows.Count > 0 ? dt.Rows[0] : null;}///<summary>///执⾏SQL语句,返回结果集中的第⼀⾏///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>,返回结果集中的第⼀⾏</returns>public static DataRow ExecuteDataRow(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms {DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);return dt.Rows.Count > 0 ? dt.Rows[0] : null;}#endregion ExecuteDataRow#region ExecuteDataTable///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public static DataTable ExecuteDataTable(string connectionString, string commandText, params MySqlParameter[] parms){return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];}///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms){return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];}///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public static DataTable ExecuteDataTable(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parm {return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];}///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集中的第⼀个数据表</returns>public static DataTable ExecuteDataTable(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parm {return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];}///<summary>///执⾏SQL语句,返回结果集中的第⼀个数据表///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="tableName">数据表名称</param>///<returns>返回结果集中的第⼀个数据表</returns>public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName){return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];}#endregion ExecuteDataTable#region ExecuteDataSet///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandText">SQL语句</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public static DataSet ExecuteDataSet(string connectionString, string commandText, params MySqlParameter[] parms){return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="connectionString">数据库连接字符串</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms){using (MySqlConnection connection = new MySqlConnection(connectionString)){return ExecuteDataSet(connection, commandType, commandText, parms);}}///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="connection">数据库连接</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public static DataSet ExecuteDataSet(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteDataSet(connection, null, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>public static DataSet ExecuteDataSet(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms) {return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);}///<summary>///执⾏SQL语句,返回结果集///</summary>///<param name="connection">数据库连接</param>///<param name="transaction">事务</param>///<param name="commandType">命令类型(存储过程,命令⽂本, 其它.)</param>///<param name="commandText">SQL语句或存储过程名称</param>///<param name="parms">查询参数</param>///<returns>返回结果集</returns>private static DataSet ExecuteDataSet(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, {MySqlCommand command = new MySqlCommand();PrepareCommand(command, connection, transaction, commandType, commandText, parms);MySqlDataAdapter adapter = new MySqlDataAdapter(command);DataSet ds = new DataSet();adapter.Fill(ds);。
Mysql命令帮助（使用help或者helpcontents）
Mysql命令帮助（使用help或者helpcontents）Mysql命令帮助(使用help或者help contents)进入到mysql客户端应用程序mysql，通过它可以管理数据库，访问数据库，执行SQL语句等等。
mysql -u root -p1. 获取帮助mysql>help或者/?2. 将在mysql>下输入的内容输出到文件中，使用mysql>tee filename或者\T filenamemysql会提示你已经logging to file 'filename'这样在mysql>下输入的命令及输出结果就会都保存到filename 文件中如果想取消挂载，输入notee或者\tmysql会提示outfile disabled在进入mysql之前，也可以通过选项--tee或者--no-tee挂载外部文件或者取消mysql -u root -p --tee outfile或者mysql -u root -p --no-tee3.mysql>tee mysql_help.txt将输出挂载到mysql_help.txt文件上输入mysql>help显示输出信息mysql> helpList of all MySQL commands:Note that all text commands must be first on line and end with ';'(\?) Synonym for `help'.help (\h) Display this help.clear (\c) Clear command.connect (\r) Reconnect to the server. Optional arguments are db and host.delimiter (\d) Set statement delimiter. NOTE: Takes the rest of the line as new delimiter.ego (\G) Send command to mysql server, display result vertically.go (\g) Send command to mysql server.tee (\T) Set outfile [to_outfile]. Append everything into given outfile.notee (\t) Don't write into outfile.print (\p) Print current command.prompt (\R) Change your mysql prompt.rehash (\#) Rebuild completion hash.source (\.) Execute an SQL script file. Takes a file name as an argument.status (\s) Get status information from the server.use (\u) Use another database. Takes database name as argument.charset (\C) Switch to another charset. Might be needed for processing binlog with multi-byte charsets. < type="text/javascript">warnings (\W) Show warnings after every statement.nowarning (\w) Don't show warnings after every statement.exit (\q) Exit mysql. Same as quit.quit (\q) Quit mysql.For server side help, type 'help contents'4. 常用命令示例a. mysql>?或者helpb. mysql> show databases \G*************************** 1. row *************************** Database: information_schema*************************** 2. row *************************** Database: broker*************************** 3. row *************************** Database: gene2p med*************************** 4. row *************************** Database: mysql*************************** 5. row *************************** Database: test5 rows in set (0.00 sec)c.mysql>tee [outfile] 不输入outfile，则使用上次挂载的文件mysql>notee 取消挂载d. mysql>status 显示状态信息e. mysql>use database_namef.定义一个文件sql_script，内容为sql语句，使用source执行文件中的sql script如sql_script文件中保存show databases;mysql>source sql_script会显示sql_script中show databases;执行的结果此外注意，获取server side的帮助可以使用help contents命令mysql>下输入help contents查询各种帮助。
sql server复制技术
SQL Server复制技术是一种用于在不同数据库之间复制数据的高效、可靠的技术。
通过SQL Server复制技术，用户可以在不同的数据库之间同步数据，实现数据的备份、数据共享或者数据分发等功能。
SQL Server复制技术具有多种不同的复制类型和配置选项，可以满足不同场景下的数据同步需求。
一、SQL Server复制技术的基本原理1. 发布者-订阅者模型SQL Server复制技术采用发布者-订阅者模型，其中包括发布者、分发者和订阅者三个角色。
发布者负责发布数据的变化，分发者负责将变化的数据分发到订阅者，订阅者接收到数据的变化并将其应用到自己的数据库中。
2. 数据复制的过程数据复制的过程主要包括数据的捕获、数据的传送和数据的应用。
当发布者的数据发生变化时，这些变化会被捕获并传送到分发者，分发者再将这些变化传送给订阅者，最终订阅者将这些变化应用到自己的数据库中。
二、SQL Server复制技术的应用场景1. 数据备份与灾难恢复SQL Server复制技术可以用于实现数据的备份与灾难恢复。
通过将数据同步到不同的数据库中，可以保证数据的安全性和可靠性，当一个数据库发生故障时，可以快速地切换到另一个数据库进行数据恢复。
2. 数据共享与数据分发SQL Server复制技术也可以用于实现数据的共享与分发。
通过将数据同步到不同的数据库中，可以实现不同部门或者不同业务系统之间的数据共享和数据分发，提高数据的利用率和共享效率。
3. 数据报告和数据分析SQL Server复制技术还可以用于实现数据报告和数据分析。
通过将生产数据库中的数据同步到报告数据库或者分析数据库中，可以保证数据报告和数据分析的准确性和及时性，提高数据分析的效率和准确度。
三、SQL Server复制技术的优点1. 灵活性高SQL Server复制技术提供了多种不同的复制类型和配置选项，可以满足不同场景下的数据同步需求，可以灵活地选择合适的复制方式和配置参数。
SqlHelp详解
if @@error <> 0 rollback transaction
commit transaction
GO
比较ASP回滚：
标题 在ASP中使用事务控制 julyclyde（原作）
关键字 ASP,事务,COM+
作者系2月份微软社区之星Microsoft China Community Star
{
try
{
string sql = "OA_Department_GetDepartment_Members";
string conn = ConfigurationSettings.AppSettings["strConnection"];
SqlParameter[] p =
{
SqlHelper.MakeInParam("@departmentID",SqlDbType.Int,4,departmentID)
微软提供的Data Access Application Block中的SQLHelper类中封装了最常用的数据操作，各个使用者调用他而写的代码也有很大区别。
对于一个返回DataSet的方法我原来是这样写的：
public DataSet GetDepartmentMemberList(int departmentID)
直接返回DataTable， 返回表集合基本不用，只返回一个table用于绑定。
string conn = ConfigurationSettings.AppSettings["strConnection"];
我写在SqlHelper.CONN_STRING_NON_DTC里面
中文的SqlHelper详解
中文的SqlHelper.cs类//这是在网上找的中文解释的SqlHelperusing System;using System.Configuration;using System.Data;using System.Data.SqlClient;using System.Collections;namespace com.DataAccess{///<summary>/// SqlHelper类提供很高的数据访问性能,///使用SqlClient类的通用定义.///</summary>public abstract class SqlHelper{//定义数据库连接串public static readonly string ConnectionStringLocalTransaction = Configurati onManager.ConnectionStrings["TestConnectionString"].ConnectionString;//public static readonly string ConnectionStringInventoryDistributedTransact ion = ConfigurationManager.ConnectionStrings["SQLConnString2"].ConnectionStri ng;//public static readonly string ConnectionStringOrderDistributedTransaction= ConfigurationManager.ConnectionStrings["SQLConnString3"].ConnectionString;//public static readonly string ConnectionStringProfile = ConfigurationManag er.ConnectionStrings["SQLProfileConnString"].ConnectionString;// 存贮Cache缓存的Hashtable集合private static Hashtable parmCache = Hashtable.Synchronized(new Hashtab le());///<summary>///使用连接字符串，执行一个SqlCommand命令（没有记录返回）///使用提供的参数集.///</summary>///<remarks>///示例:/// int result = ExecuteNonQuery(connString, CommandType.StoredProced ure, "PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="connectionString">一个有效的SqlConnection连接串</param>///<param name="commandType">命令类型CommandType(stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>受此命令影响的行数</returns>public static int ExecuteNonQuery(string connectionString, CommandType c mdType, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();using (SqlConnection conn = new SqlConnection(connectionString)){PrepareCommand(cmd, conn, null, cmdType, cmdText, commandPara meters);int val = cmd.ExecuteNonQuery();cmd.Parameters.Clear();return val;}}///<summary>///在一个存在的连接上执行数据库的命令操作///使用提供的参数集.///</summary>///<remarks>/// e.g.:/// int result = ExecuteNonQuery(connection, CommandType.StoredProced ure, "PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="conn">一个存在的数据库连接对象</param>///<param name="commandType">命令类型CommandType (stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>受此命令影响的行数</returns>public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();PrepareCommand(cmd, connection, null, cmdType, cmdText, commandP arameters);int val = cmd.ExecuteNonQuery();cmd.Parameters.Clear();return val;}///<summary>///在一个事务的连接上执行数据库的命令操作///使用提供的参数集.///</summary>///<remarks>/// e.g.:/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, " PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="trans">一个存在的事务</param>///<param name="commandType">命令类型CommandType (stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>受此命令影响的行数</returns>public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmd Type, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, com mandParameters);int val = cmd.ExecuteNonQuery();cmd.Parameters.Clear();return val;}///<summary>///在一个连接串上执行一个命令，返回一个SqlDataReader对象///使用提供的参数.///</summary>///<remarks>/// e.g.:/// SqlDataReader r = ExecuteReader(connString, CommandType.StoredPr ocedure, "PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="connectionString">一个有效的SqlConnection连接串</param>///<param name="commandType">命令类型CommandType(stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>一个结果集对象SqlDataReader</returns>public static SqlDataReader ExecuteReader(string connectionString, Comma ndType cmdType, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();SqlConnection conn = new SqlConnection(connectionString);// 如果不存在要查询的对象，则发生异常// 连接要关闭// CommandBehavior.CloseConnection在异常时不发生作用try{PrepareCommand(cmd, conn, null, cmdType, cmdText, commandPara meters);SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseCon nection);cmd.Parameters.Clear();return rdr;}catch{conn.Close();throw;}}///<summary>///在一个连接串上执行一个命令，返回表中第一行，第一列的值///使用提供的参数.///</summary>///<remarks>/// e.g.:/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure , "PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="connectionString">一个有效的SqlConnection连接串</param>///<param name="commandType">命令类型CommandType(stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>返回的对象，在使用时记得类型转换</returns>public static object ExecuteScalar(string connectionString, CommandType c mdType, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();using (SqlConnection connection = new SqlConnection(connectionString)){PrepareCommand(cmd, connection, null, cmdType, cmdText, comman dParameters);object val = cmd.ExecuteScalar();cmd.Parameters.Clear();return val;}}///<summary>///在一个连接上执行一个命令，返回表中第一行，第一列的值///使用提供的参数.///</summary>///<remarks>/// e.g.:/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure , "PublishOrders", new SqlParameter("@prodid", 24));///</remarks>///<param name="connectionString">一个有效的SqlConnection连接</param>///<param name="commandType">命令类型CommandType(stored procedure, text, etc.)</param>///<param name="commandText">存贮过程名称或是一个T-SQL语句串</param>///<param name="commandParameters">执行命令的参数集</param>///<returns>返回的对象，在使用时记得类型转换</returns>public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters){SqlCommand cmd = new SqlCommand();PrepareCommand(cmd, connection, null, cmdType, cmdText, commandP arameters);object val = cmd.ExecuteScalar();cmd.Parameters.Clear();return val;}///<summary>///在缓存中添加参数数组///</summary>///<param name="cacheKey">参数的Key</param>///<param name="cmdParms">参数数组</param>public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters){parmCache[cacheKey] = commandParameters;}///<summary>///提取缓存的参数数组///</summary>///<param name="cacheKey">查找缓存的key</param>///<returns>返回被缓存的参数数组</returns>public static SqlParameter[] GetCachedParameters(string cacheKey){SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];if (cachedParms == null)return null;SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];for (int i = 0, j = cachedParms.Length; i < j; i++)clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();return clonedParms;}///<summary>///提供一个SqlCommand对象的设置///</summary>///<param name="cmd">SqlCommand对象</param>///<param name="conn">SqlConnection 对象</param>///<param name="trans">SqlTransaction 对象</param>///<param name="cmdType">CommandType 如存贮过程，T-SQL</param> ///<param name="cmdText">存贮过程名或查询串</param>///<param name="cmdParms">命令中用到的参数集</param>private static void PrepareCommand(SqlCommand cmd, SqlConnection conn , SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms){if (conn.State != ConnectionState.Open)conn.Open();cmd.Connection = conn;mandText = cmdText;if (trans != null)cmd.Transaction = trans;mandType = cmdType;if (cmdParms != null){foreach (SqlParameter parm in cmdParms)cmd.Parameters.Add(parm);}}} }。
sqlHelp
using System.Web.UI.HtmlControls;
using System.Data.SqlClient; //导入访问SqlServer数据库的名称空间
/// <summary>
/// SqlHelper 的摘要说明
{
PrepareCommand(conn, cmd, null, nType, nText, paras); //调用后面的方法，后面具体说
SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection); //通过SQLCommand对象创建一个SqlDataReader对象
public SqlHelper()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
public static SqlDataReader ExcuteRead(string nText, CommandType nType, SqlParameter[] paras) {
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
return ds; //返回数据集对象
}
catch (SqlException ex) {
SQLserver数据库操作帮助类SqlHelper
SQLserver数据库操作帮助类SqlHelper 1 SqlHelper源码using System;using System.Data;using System.Xml;using System.Data.SqlClient;using System.Collections;namespace SQL.Access{/// <summary>/// SqlServer数据访问帮助类/// </summary>public sealed class SqlHelper{#region 私有构造函数和⽅法private SqlHelper() {}/// <summary>/// 将SqlParameter参数数组(参数值)分配给SqlCommand命令./// 这个⽅法将给任何⼀个参数分配DBNull.Value;/// 该操作将阻⽌默认值的使⽤./// </summary>/// <param name="command">命令名</param>/// <param name="commandParameters">SqlParameters数组</param>private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters){if( command == null ) throw new ArgumentNullException( "command" );if( commandParameters != null ){foreach (SqlParameter p in commandParameters){if( p != null ){// 检查未分配值的输出参数,将其分配以DBNull.Value.if ( ( p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input ) &&(p.Value == null)){p.Value = DBNull.Value;}command.Parameters.Add(p);}}}}/// <summary>/// 将DataRow类型的列值分配到SqlParameter参数数组./// </summary>/// <param name="commandParameters">要分配值的SqlParameter参数数组</param>/// <param name="dataRow">将要分配给存储过程参数的DataRow</param>private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow){if ((commandParameters == null) || (dataRow == null)){return;}int i = 0;// 设置参数值foreach(SqlParameter commandParameter in commandParameters){// 创建参数名称,如果不存在,只抛出⼀个异常.if( commandParameter.ParameterName == null ||commandParameter.ParameterName.Length <= 1 )throw new Exception(string.Format("请提供参数{0}⼀个有效的名称{1}.", i, commandParameter.ParameterName ) );// 从dataRow的表中获取为参数数组中数组名称的列的索引.// 如果存在和参数名称相同的列,则将列值赋给当前名称的参数.if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];i++;}}/// <summary>/// 将⼀个对象数组分配给SqlParameter参数数组./// </summary>/// <param name="commandParameters">要分配值的SqlParameter参数数组</param>/// <param name="parameterValues">将要分配给存储过程参数的对象数组</param>private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues){if ((commandParameters == null) || (parameterValues == null)){return;}// 确保对象数组个数与参数个数匹配,如果不匹配,抛出⼀个异常.if (commandParameters.Length != parameterValues.Length){throw new ArgumentException("参数值个数与参数不匹配.");}// 给参数赋值for (int i = 0, j = commandParameters.Length; i < j; i++){// If the current array value derives from IDbDataParameter, then assign its Value propertyif (parameterValues[i] is IDbDataParameter){IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i];if( paramInstance.Value == null ){commandParameters[i].Value = DBNull.Value;}else{commandParameters[i].Value = paramInstance.Value;}}else if (parameterValues[i] == null){commandParameters[i].Value = DBNull.Value;}else{commandParameters[i].Value = parameterValues[i];}}}/// <summary>/// 预处理⽤户提供的命令,数据库连接/事务/命令类型/参数/// </summary>/// <param name="command">要处理的SqlCommand</param>/// <param name="connection">数据库连接</param>/// <param name="transaction">⼀个有效的事务或者是null值</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本, 其它.)</param>/// <param name="commandText">存储过程名或都T-SQL命令⽂本</param>/// <param name="commandParameters">和命令相关联的SqlParameter参数数组,如果没有参数为'null'</param>/// <param name="mustCloseConnection"><c>true</c> 如果连接是打开的,则为true,其它情况下为false.</param>private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction,CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection ){if( command == null ) throw new ArgumentNullException( "command" );if( commandText == null || commandText.Length == 0 ) throw new ArgumentNullException( "commandText" );// If the provided connection is not open, we will open itif (connection.State != ConnectionState.Open){mustCloseConnection = true;connection.Open();}else{mustCloseConnection = false;}// 给命令分配⼀个数据库连接.command.Connection = connection;// 设置命令⽂本(存储过程名或SQL语句)mandText = 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;}// 设置命令类型.mandType = commandType;// 分配命令参数if (commandParameters != null){AttachParameters(command, commandParameters);}return;}#endregion 私有构造函数和⽅法结束#region ExecuteNonQuery命令/// <summary>/// 执⾏指定连接字符串,类型的SqlCommand./// </summary>/// <remarks>/// ⽰例:/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本, 其它.)</param>/// <param name="commandText">存储过程名称或SQL语句</param>/// <returns>返回命令影响的⾏数</returns>public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText){return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果./// </summary>/// <remarks>/// ⽰例:/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本, 其它.)</param>/// <param name="commandText">存储过程名称或SQL语句</param>/// <param name="commandParameters">SqlParameter参数数组</param>/// <returns>返回命令影响的⾏数</returns>public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();return ExecuteNonQuery(connection, commandType, commandText, commandParameters);}}/// <summary>/// 执⾏指定连接字符串的存储过程,将对象数组的值赋给存储过程参数,/// 此⽅法需要在参数缓存⽅法中探索参数并⽣成参数./// </summary>/// <remarks>/// 这个⽅法没有提供访问输出参数和返回值./// ⽰例:/// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串/param>/// <param name="spName">存储过程名称</param>/// <param name="parameterValues">分配到存储过程输⼊参数的对象数组</param>/// <returns>返回受影响的⾏数</returns>public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues){if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );// 如果存在参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组.SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);// 给存储过程参数赋值AssignParameterValues(commandParameters, parameterValues);return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);}else{// 没有参数情况下return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);}}/// <summary>/// 执⾏指定数据库连接对象的命令/// </summary>/// <remarks>/// ⽰例:/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令⽂本或其它.)</param>/// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText){return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏指定数据库连接对象的命令/// </summary>/// <remarks>/// ⽰例:/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令⽂本或其它.)</param>/// <param name="commandText">T存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if( connection == null ) throw new ArgumentNullException( "connection" );// 创建SqlCommand命令,并进⾏预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection );// Finally, execute the commandint retval = cmd.ExecuteNonQuery();// 清除参数,以便再次使⽤.cmd.Parameters.Clear();if( mustCloseConnection )connection.Close();return retval;}/// <summary>/// 执⾏指定数据库连接对象的命令,将对象数组的值赋给存储过程参数./// </summary>/// <remarks>/// 此⽅法不提供访问存储过程输出参数和返回值/// ⽰例:/// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输⼊参数的对象数组</param>/// <returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues){if( connection == null ) throw new ArgumentNullException( "connection" );if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );// 如果有参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);// 给存储过程分配参数值AssignParameterValues(commandParameters, parameterValues);return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);}}/// <summary>/// 执⾏带事务的SqlCommand./// </summary>/// <remarks>/// ⽰例.:/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");/// </remarks>/// <param name="transaction">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令⽂本或其它.)</param>/// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回影响的⾏数/returns>public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText){return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏带事务的SqlCommand(指定参数)./// </summary>/// <remarks>/// ⽰例:/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="transaction">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令⽂本或其它.)</param>/// <param name="commandText">存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回影响的⾏数</returns>public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if( transaction == null ) throw new ArgumentNullException( "transaction" );if( transaction != null && transaction.Connection == null )throw new ArgumentException( "The transaction was rollbacked or commited, please provide an open transaction.", "transaction" );// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection );// 执⾏int retval = cmd.ExecuteNonQuery();// 清除参数集,以便再次使⽤.cmd.Parameters.Clear();return retval;}/// <summary>/// 执⾏带事务的SqlCommand(指定参数值)./// </summary>/// <remarks>/// 此⽅法不提供访问存储过程输出参数和返回值/// ⽰例:/// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);/// </remarks>/// <param name="transaction">⼀个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输⼊参数的对象数组</param>/// <returns>返回受影响的⾏数</returns>public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues){if( transaction == null ) throw new ArgumentNullException( "transaction" );if( transaction != null && transaction.Connection == null )throw new ArgumentException( "The transaction was rollbacked or commited, please provide an open transaction.", "transaction" );if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );// 如果有参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);// 给存储过程参数赋值AssignParameterValues(commandParameters, parameterValues);// 调⽤重载⽅法return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);}else{// 没有参数值return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);}}#endregion ExecuteNonQuery⽅法结束#region ExecuteDataset⽅法/// <summary>/// 执⾏指定数据库连接字符串的命令,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText){return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏指定数据库连接字符串的命令,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamters参数数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );// 创建并打开数据库连接对象,操作完成释放对象.using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();// 调⽤指定数据库连接字符串重载⽅法.return ExecuteDataset(connection, commandType, commandText, commandParameters);}}/// <summary>/// 执⾏指定数据库连接字符串的命令,直接提供参数值,返回DataSet./// </summary>/// <remarks>/// 此⽅法不提供访问存储过程输出参数和返回值./// ⽰例:/// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);/// </remarks>/// <param name="connectionString">⼀个有效的数据库连接字符串</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输⼊参数的对象数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues){if( connectionString == null || connectionString.Length == 0 ) throw new ArgumentNullException( "connectionString" );if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中检索存储过程参数SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);}}/// <summary>/// 执⾏指定数据库连接对象的命令,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名或T-SQL语句</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText){return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏指定数据库连接对象的命令,指定存储过程参数,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters){if( connection == null ) throw new ArgumentNullException( "connection" );// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection );// 创建SqlDataAdapter和DataSet.using( SqlDataAdapter da = new SqlDataAdapter(cmd) ){DataSet ds = new DataSet();// 填充DataSet.da.Fill(ds);cmd.Parameters.Clear();if( mustCloseConnection )connection.Close();return ds;}}public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, int pageIndex, int pageSize, params SqlParameter[] commandParameters) {using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();if (connection == null) throw new ArgumentNullException("connection");// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);// 创建SqlDataAdapter和DataSet.using (SqlDataAdapter da = new SqlDataAdapter(cmd)){DataSet ds = new DataSet();// 填充DataSet.da.Fill(ds, (pageIndex - 1) * pageSize, pageSize, "pageTable");cmd.Parameters.Clear();if (mustCloseConnection)connection.Close();return ds;}}}//⾃⼰增加⽤与分页的public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, int pageIndex, int pageSize){using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();if (connection == null) throw new ArgumentNullException("connection");// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;SqlParameter[] commandParameters = null;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);// 创建SqlDataAdapter和DataSet.using (SqlDataAdapter da = new SqlDataAdapter(cmd)){DataSet ds = new DataSet();// 填充DataSet.da.Fill(ds, (pageIndex - 1) * pageSize, pageSize, "pageTable");cmd.Parameters.Clear();if (mustCloseConnection)connection.Close();return ds;}}}/// <summary>/// 执⾏指定数据库连接对象的命令,指定参数值,返回DataSet./// </summary>/// <remarks>/// 此⽅法不提供访问存储过程输⼊参数和返回值./// ⽰例.:/// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);/// </remarks>/// <param name="connection">⼀个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输⼊参数的对象数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues){if( connection == null ) throw new ArgumentNullException( "connection" );if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );if ((parameterValues != null) && (parameterValues.Length > 0)){// ⽐缓存中加载存储过程参数SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteDataset(connection, CommandType.StoredProcedure, spName);}}/// <summary>/// 执⾏指定事务的命令,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="transaction">事务</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名或T-SQL语句</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText){return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执⾏指定事务的命令,指定参数,返回DataSet./// </summary>/// <remarks>/// ⽰例:/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="transaction">事务</param>/// <param name="commandType">命令类型 (存储过程,命令⽂本或其它)</param>/// <param name="commandText">存储过程名或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters){if( transaction == null ) throw new ArgumentNullException( "transaction" );if( transaction != null && transaction.Connection == null ) throw new ArgumentException( "The transaction was rollbacked or commited, please provide an open transaction.", "transaction" ); // 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection );// 创建 DataAdapter & DataSetusing( SqlDataAdapter da = new SqlDataAdapter(cmd) ){DataSet ds = new DataSet();da.Fill(ds);cmd.Parameters.Clear();return ds;}}/// <summary>/// 执⾏指定事务的命令,指定参数值,返回DataSet./// </summary>/// <remarks>/// 此⽅法不提供访问存储过程输⼊参数和返回值./// ⽰例.:/// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);/// </remarks>/// <param name="transaction">事务</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输⼊参数的对象数组</param>/// <returns>返回⼀个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues){if( transaction == null ) throw new ArgumentNullException( "transaction" );if( transaction != null && transaction.Connection == null ) throw new ArgumentException( "The transaction was rollbacked or commited, please provide an open transaction.", "transaction" ); if( spName == null || spName.Length == 0 ) throw new ArgumentNullException( "spName" );if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);。
mssql dbhelper例子
mssql dbhelper例子MSSQL DBHelper是一个用于处理Microsoft SQL Server数据库的帮助类或工具类，它提供了一些常用的方法和功能，以简化与数据库的交互和操作。
以下是MSSQL DBHelper的含义、特点和作用的详细解释：1. 含义：MSSQL DBHelper是一个用于简化与Microsoft SQL Server数据库交互的工具类。
它封装了一些常用的数据库操作方法，使开发人员能够更轻松地进行数据库连接、数据查询、数据插入、更新和删除等操作。
2. 特点：- 数据库连接管理：MSSQL DBHelper提供了数据库连接管理的功能，可以在应用程序中方便地创建、关闭和释放数据库连接，避免了手动管理连接的繁琐过程。
- SQL语句执行：MSSQL DBHelper支持执行各种SQL语句，包括查询语句、插入语句、更新语句和删除语句等。
它可以根据传入的参数自动生成并执行相应的SQL语句，简化了编写和执行SQL语句的过程。
- 参数化查询：MSSQL DBHelper支持参数化查询，可以预编译SQL语句并使用参数来替换变量部分，提高了查询效率，并且能够有效防止SQL注入攻击。
- 事务处理：MSSQL DBHelper提供了事务处理的功能，可以在多个数据库操作之间创建事务，并对它们进行统一的提交或回滚，确保数据的完整性和一致性。
- 异常处理：MSSQL DBHelper具有良好的异常处理机制，可以捕获并处理数据库操作过程中可能出现的异常情况，提高了系统的稳定性和可靠性。
3. 作用：MSSQL DBHelper的主要作用是简化与Microsoft SQL Server数据库的交互和操作。
通过封装常用的数据库操作方法，它能够帮助开发人员提高开发效率，减少重复工作量，并且提供了良好的代码复用性。
使用MSSQL DBHelper可以快速实现与数据库的连接、查询、插入、更新、删除等操作，同时还能够提供良好的错误处理和事务管理功能，保证数据的完整性和一致性。
复制表sql语句3篇
复制表sql语句一、复制表sql语句的作用和优势复制表sql语句是指在数据库中创建一个新的表，这个新的表的结构和原有表的结构完全相同。
复制表sql语句的优势主要有以下几点：1. 保证数据的安全性：复制表sql语句对原有表的数据没有任何影响，所以不会导致数据的丢失和损坏，保证了数据的安全性。
2. 方便进行实验和测试：通过复制表sql语句，可以在不对原始数据表进行修改的情况下，进行数据的实验和测试，有效保证了数据的完整性和准确性。
3. 提高数据分析效率：复制表sql语句可以让数据表在不影响原有数据的情况下，进行多次查询和分析，有效提高了数据分析的效率。
4. 降低数据库管理员工作负担：通过复制表sql语句可以节约数据库管理员的工作时间和精力，避免人工操作出现错误和遗漏。
二、实例演示下面给出一个实例演示，用以说明如何复制表sql语句来创建新表。
1. 首先需要在 MySQL 数据库中创建一个数据表，如下所示：CREATE TABLE student(ID INT,NAME VARCHAR(20),AGE INT,SEX VARCHAR(5),ADDRESS VARCHAR(50),PRIMARY KEY (ID));2. 创建了 student 数据表之后，我们可以通过以下sql 语句进行表的复制操作：CREATE TABLE student_copy LIKE student;3. 通过执行以上 sql 语句，我们就可以复制一个新的student_copy 表，这个新表的结构和 student 表完全一致。
三、总结本文主要介绍了复制表sql语句的作用和优势，并通过一个实例演示，说明了如何通过复制表sql语句来创建新表。
在实际操作中，我们可以根据需要进行不同的查询操作，有效提高了数据分析和处理的效率，同时保证了数据的完整性和安全性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
using System;using System.Data;using System.Xml;using System.Data.SqlClient;using System.Collections;using System.Configuration;namespace BookDAL{/// <summary>/// SqlServer数据访问帮助类/// </summary>public sealed class SqlHelper{#region 私有构造函数和方法private SqlHelper() { }/// <summary>/// 将SqlParameter参数数组(参数值)分配给SqlCommand命令./// 这个方法将给任何一个参数分配DBNull.Value;/// 该操作将阻止默认值的使用./// </summary>/// <param name="command">命令名</param>/// <param name="commandParameters">SqlParameters数组</param>private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters){if (command == null) throw new ArgumentNullException("command");if (commandParameters != null){foreach (SqlParameter p in commandParameters){if (p != null){// 检查未分配值的输出参数,将其分配以DBNull.Value.if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) &&(p.Value == null)){p.Value = DBNull.Value;}command.Parameters.Add(p);}}}}/// <summary>/// 将DataRow类型的列值分配到SqlParameter参数数组./// </summary>/// <param name="commandParameters">要分配值的SqlParameter参数数组</param>/// <param name="dataRow">将要分配给存储过程参数的DataRow</param>private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow){if ((commandParameters == null) || (dataRow == null)){return;}int i = 0;// 设置参数值foreach (SqlParameter commandParameter in commandParameters){// 创建参数名称,如果不存在,只抛出一个异常.if (commandParameter.ParameterName == null ||commandParameter.ParameterName.Length <= 1)throw new Exception(string.Format("请提供参数{0}一个有效的名称{1}.", i, commandParameter.ParameterName));// 从dataRow的表中获取为参数数组中数组名称的列的索引.// 如果存在和参数名称相同的列,则将列值赋给当前名称的参数.if(dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)commandParameter.Value =dataRow[commandParameter.ParameterName.Substring(1)];i++;}}/// <summary>/// 将一个对象数组分配给SqlParameter参数数组./// </summary>/// <param name="commandParameters">要分配值的SqlParameter参数数组/// <param name="parameterValues">将要分配给存储过程参数的对象数组</param>private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues){if ((commandParameters == null) || (parameterValues == null)){return;}// 确保对象数组个数与参数个数匹配,如果不匹配,抛出一个异常.if (commandParameters.Length != parameterValues.Length){throw new ArgumentException("参数值个数与参数不匹配.");}// 给参数赋值for (int i = 0, j = commandParameters.Length; i < j; i++){// If the current array value derives from IDbDataParameter, then assign its Value propertyif (parameterValues[i] is IDbDataParameter){IDbDataParameter paramInstance =(IDbDataParameter)parameterValues[i];if (paramInstance.Value == null){commandParameters[i].Value = DBNull.Value;}else{commandParameters[i].Value = paramInstance.Value;}}else if (parameterValues[i] == null){commandParameters[i].Value = DBNull.Value;}else{commandParameters[i].Value = parameterValues[i];}}/// <summary>/// 预处理用户提供的命令,数据库连接/事务/命令类型/参数/// </summary>/// <param name="command">要处理的SqlCommand</param>/// <param name="connection">数据库连接</param>/// <param name="transaction">一个有效的事务或者是null值</param>/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param> /// <param name="commandText">存储过程名或都T-SQL命令文本</param>/// <param name="commandParameters">和命令相关联的SqlParameter参数数组,如果没有参数为'null'</param>/// <param name="mustCloseConnection"><c>true</c> 如果连接是打开的,则为true,其它情况下为false.</param>private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection) {if (command == null) throw new ArgumentNullException("command");if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");// If the provided connection is not open, we will open itif (connection.State != ConnectionState.Open){mustCloseConnection = true;connection.Open();}else{mustCloseConnection = false;}// 给命令分配一个数据库连接.command.Connection = connection;// 设置命令文本(存储过程名或SQL语句)mandText = 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;}// 设置命令类型.mandType = commandType;// 分配命令参数if (commandParameters != null){AttachParameters(command, commandParameters);}return;}#endregion 私有构造函数和方法结束#region 数据库连接/// <summary>/// 一个有效的数据库连接字符串/// </summary>/// <returns></returns>public static string GetConnSting(){return ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;}/// <summary>/// 一个有效的数据库连接对象/// </summary>/// <returns></returns>public static SqlConnection GetConnection(){SqlConnection Connection = new SqlConnection(SqlHelper.GetConnSting());return Connection;}#endregion#region ExecuteNonQuery命令/// <summary>/// 执行指定连接字符串,类型的SqlCommand./// </summary>/// <remarks>/// 示例:/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串</param>/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param> /// <param name="commandText">存储过程名称或SQL语句</param>/// <returns>返回命令影响的行数</returns>public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText){return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果./// </summary>/// <remarks>/// 示例:/// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串</param>/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param> /// <param name="commandText">存储过程名称或SQL语句</param>/// <param name="commandParameters">SqlParameter参数数组</param>/// <returns>返回命令影响的行数</returns>public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();return ExecuteNonQuery(connection, commandType, commandText, commandParameters);}}/// <summary>/// 执行指定连接字符串的存储过程,将对象数组的值赋给存储过程参数,/// 此方法需要在参数缓存方法中探索参数并生成参数./// </summary>/// <remarks>/// 这个方法没有提供访问输出参数和返回值./// 示例:/// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串/param>/// <param name="spName">存储过程名称</param>/// <param name="parameterValues">分配到存储过程输入参数的对象数组</param>/// <returns>返回受影响的行数</returns>public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues){if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");// 如果存在参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组.SqlParameter[] commandParameters =SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);// 给存储过程参数赋值AssignParameterValues(commandParameters, parameterValues);return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);}else{// 没有参数情况下return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);}}/// <summary>/// 执行指定数据库连接对象的命令/// </summary>/// <remarks>/// 示例:/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> /// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回影响的行数</returns>public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText){return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行指定数据库连接对象的命令/// </summary>/// <remarks>/// 示例:/// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> /// <param name="commandText">T存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回影响的行数</returns>public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if (connection == null) throw new ArgumentNullException("connection");// 创建SqlCommand命令,并进行预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);// Finally, execute the commandint retval = cmd.ExecuteNonQuery();// 清除参数,以便再次使用.cmd.Parameters.Clear();if (mustCloseConnection)connection.Close();return retval;}/// 执行指定数据库连接对象的命令,将对象数组的值赋给存储过程参数./// </summary>/// <remarks>/// 此方法不提供访问存储过程输出参数和返回值/// 示例:/// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);/// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输入参数的对象数组</param>/// <returns>返回影响的行数</returns>public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues){if (connection == null) throw new ArgumentNullException("connection");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");// 如果有参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);// 给存储过程分配参数值AssignParameterValues(commandParameters, parameterValues);return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);}}/// <summary>/// 执行带事务的SqlCommand./// </summary>/// <remarks>/// 示例.:/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");/// </remarks>/// <param name="transaction">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> /// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回影响的行数/returns>public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText){return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行带事务的SqlCommand(指定参数)./// </summary>/// <remarks>/// 示例:/// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="transaction">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它.)</param> /// <param name="commandText">存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回影响的行数</returns>public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if (transaction == null) throw new ArgumentNullException("transaction");if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);// 执行int retval = cmd.ExecuteNonQuery();// 清除参数集,以便再次使用.cmd.Parameters.Clear();return retval;}/// <summary>/// 执行带事务的SqlCommand(指定参数值)./// </summary>/// <remarks>/// 此方法不提供访问存储过程输出参数和返回值/// 示例:/// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);/// </remarks>/// <param name="transaction">一个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输入参数的对象数组</param>/// <returns>返回受影响的行数</returns>public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues){if (transaction == null) throw new ArgumentNullException("transaction");if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");// 如果有参数值if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()SqlParameter[] commandParameters =SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);// 给存储过程参数赋值AssignParameterValues(commandParameters, parameterValues);// 调用重载方法return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);}else{// 没有参数值return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);}}#endregion ExecuteNonQuery方法结束#region ExecuteDataset方法/// <summary>/// 执行指定数据库连接字符串的命令,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名称或T-SQL语句</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText){return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行指定数据库连接字符串的命令,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名称或T-SQL语句</param>/// <param name="commandParameters">SqlParamters参数数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");// 创建并打开数据库连接对象,操作完成释放对象.using (SqlConnection connection = new SqlConnection(connectionString)){connection.Open();// 调用指定数据库连接字符串重载方法.return ExecuteDataset(connection, commandType, commandText, commandParameters);}}/// <summary>/// 执行指定数据库连接字符串的命令,直接提供参数值,返回DataSet./// </summary>/// <remarks>/// 此方法不提供访问存储过程输出参数和返回值./// 示例:/// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);/// </remarks>/// <param name="connectionString">一个有效的数据库连接字符串</param> /// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输入参数的对象数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues){if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中检索存储过程参数SqlParameter[] commandParameters =SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);else{return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);}}/// <summary>/// 执行指定数据库连接对象的命令,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名或T-SQL语句</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText){return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)if (connection == null) throw new ArgumentNullException("connection");// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);// 创建SqlDataAdapter和DataSet.using (SqlDataAdapter da = new SqlDataAdapter(cmd)){DataSet ds = new DataSet();// 填充DataSet.da.Fill(ds);cmd.Parameters.Clear();if (mustCloseConnection)connection.Close();return ds;}}/// <summary>/// 执行指定数据库连接对象的命令,指定参数值,返回DataSet./// </summary>/// <remarks>/// 此方法不提供访问存储过程输入参数和返回值./// 示例.:/// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);/// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输入参数的对象数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues){if (connection == null) throw new ArgumentNullException("connection");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");if ((parameterValues != null) && (parameterValues.Length > 0)){// 比缓存中加载存储过程参数SqlParameter[] commandParameters =SqlHelperParameterCache.GetSpParameterSet(connection, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteDataset(connection, CommandType.StoredProcedure, spName);}}/// <summary>/// 执行指定事务的命令,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");/// </remarks>/// <param name="transaction">事务</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名或T-SQL语句</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText){return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);}/// <summary>/// 执行指定事务的命令,指定参数,返回DataSet./// </summary>/// <remarks>/// 示例:/// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));/// </remarks>/// <param name="transaction">事务</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名或T-SQL语句</param>/// <param name="commandParameters">SqlParamter参数数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters) {if (transaction == null) throw new ArgumentNullException("transaction");if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");// 预处理SqlCommand cmd = new SqlCommand();bool mustCloseConnection = false;PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);// 创建DataAdapter & DataSetusing (SqlDataAdapter da = new SqlDataAdapter(cmd)){DataSet ds = new DataSet();da.Fill(ds);cmd.Parameters.Clear();return ds;}}/// <summary>/// 执行指定事务的命令,指定参数值,返回DataSet./// </summary>/// <remarks>/// 此方法不提供访问存储过程输入参数和返回值./// 示例.:/// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);/// </remarks>/// <param name="transaction">事务</param>/// <param name="spName">存储过程名</param>/// <param name="parameterValues">分配给存储过程输入参数的对象数组</param>/// <returns>返回一个包含结果集的DataSet</returns>public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues){if (transaction == null) throw new ArgumentNullException("transaction");if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");if ((parameterValues != null) && (parameterValues.Length > 0)){// 从缓存中加载存储过程参数SqlParameter[] commandParameters =SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);// 给存储过程参数分配值AssignParameterValues(commandParameters, parameterValues);return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);}else{return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);}}#endregion ExecuteDataset数据集命令结束#region ExecuteReader 数据阅读器/// <summary>/// 枚举,标识数据库连接是由SqlHelper提供还是由调用者提供/// </summary>private enum SqlConnectionOwnership{/// <summary>由SqlHelper提供连接</summary>Internal,/// <summary>由调用者提供连接</summary>External}/// <summary>/// 执行指定数据库连接对象的数据阅读器./// </summary>/// <remarks>/// 如果是SqlHelper打开连接,当连接关闭DataReader也将关闭./// 如果是调用都打开连接,DataReader由调用都管理./// </remarks>/// <param name="connection">一个有效的数据库连接对象</param>/// <param name="transaction">一个有效的事务,或者为'null'</param>/// <param name="commandType">命令类型(存储过程,命令文本或其它)</param> /// <param name="commandText">存储过程名或T-SQL语句</param>/// <param name="commandParameters">SqlParameters参数数组,如果没有参数则为'null'</param>/// <param name="connectionOwnership">标识数据库连接对象是由调用者提供还是由SqlHelper提供</param>/// <returns>返回包含结果集的SqlDataReader</returns>private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership) {if (connection == null) throw new ArgumentNullException("connection");bool mustCloseConnection = false;// 创建命令SqlCommand cmd = new SqlCommand();try{PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);// 创建数据阅读器SqlDataReader dataReader;if (connectionOwnership == SqlConnectionOwnership.External){dataReader = cmd.ExecuteReader();}else{dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);}// 清除参数,以便再次使用..// HACK: There is a problem here, the output parameter values are fletched// when the reader is closed, so if the parameters are detached from the command// then the SqlReader can磘set its values.// When this happen, the parameters can磘be used again in other command.bool canClear = true;foreach (SqlParameter commandParameter in cmd.Parameters){。