Ms SQL Server 2005 seems to go one step further by announcing future deprecation for ntext, text and image types.

From Sql Server 2005 notes:

“ntext, text, and image data types will be removed in a future version of Microsoft SQL Server. Avoid using these data types in new development work, and plan to modify applications that currently use them. Use nvarchar(max), varchar(max), and varbinary(max) instead.”

When working with Hibernate it seems there is no dialect to handle Unicode integration properly. You have to get down and write a custom dialect that maps to the new data types.

/**

* Unicode support in SQL Server

*

* @author icocan

*/

public class UnicodeSQLServerDialect extends SQLServerDialect {



public UnicodeSQLServerDialect() {

super();



// Use Unicode Characters

registerColumnType(Types.VARCHAR, 255, "nvarchar($l)");

registerColumnType(Types.CHAR, "nchar(1)");

registerColumnType(Types.CLOB, "nvarchar(max)");



// Microsoft SQL Server 2000 supports bigint and bit

registerColumnType(Types.BIGINT, "bigint");

registerColumnType(Types.BIT, "bit");

}

}

publicclassSQLServerNativeDialectextendsSQLServerDialect{

     publicSQLServerNativeDialect(){

         super();

         registerColumnType(Types.VARCHAR,"nvarchar($l)");

         registerColumnType(Types.CLOB,"nvarchar(max)");

     }



    publicString getTypeName(int code,int length,int precision,int scale)throwsHibernateException{

        if(code !=2005){

            returnsuper.getTypeName(code, length, precision, scale);

        }else{

            return"ntext";

        }

    }

}

This class maps Hibernate's types to SQL types, so the class will map the nvarchar(max) SQL Data Type to Hibernate's CLOB data type.

The getTypeName method is used to return "ntext" when Hibernate asks about the data type with code 2005 (which looks like it's the nvarchar(max) data type).

Finally, you need to change your hibernate persistence dialect to this new SQLServerDialect class, which allows hibernate to translate data types into SQL data types.

varchar[(n)]  
  长度为   n   个字节的可变长度且非   Unicode   的字符数据。n   必须是一个介于   1   和   8,000   之间的数值。存储大小为输入数据的字节的实际长度，而不是   n   个字节。所输入的数据字符长度可以为零。varchar   在   SQL-92   中的同义词为   char   varying   或   character   varying。  
   
  nvarchar(n)  
  包含   n   个字符的可变长度   Unicode   字符数据。n   的值必须介于   1   与   4,000   之间。字节的存储大小是所输入字符个数的两倍。所输入的数据字符长度可以为零。nvarchar   在   SQL-92   中的同义词为   national   char   varying   和   national   character   varying。  

通俗一點就是varchar適合輸入英文和數字，nvarchar一般用做中文或其它語言的輸入，這樣到別的語系不會出現亂碼:))

--如果是临时表可以用(说明,如果用查找实表方法来打临时表会找不到.发布区别对代.)
if object_id('tempdb..##temp') is not null
   drop table ##temp

--判断存储过程是否存在
if exists(select 1 from sysobjects where id=object_id('所有者.存储过程名') and xtype='P')  
print '存在'  
else  
print '不存在'

--判断视图是否存在
--SQL Server 2000
IF EXISTS (SELECT * FROM sysviews WHERE object_id = '[dbo].[视图名]'
--SQL Server 2005
IF EXISTS (SELECT * FROM sys.views WHERE object_id = '[dbo].[视图名]'

/*
sysObjects (
Name sysname,      --object 名称
id   int,          --object id
xtype char(2),     -- object 类型  
type char(2),     -- Object 类型（与xtype 似乎一模一样？ 有点郁闷…）
uid   smallint,     -- object 所有者的ID
...                --其他的字段不常用到。  
)

sysobjects的xtype 代表的对象类型。可以是下列对象类型中的一种：
C = CHECK 约束
D = 默认值或 DEFAULT 约束
F = FOREIGN KEY 约束
L = 日志
FN = 标量函数
IF = 内嵌表函数
P = 存储过程
PK = PRIMARY KEY 约束（类型是 K）
RF = 复制筛选存储过程
S = 系统表
TF = 表函数
TR = 触发器
U = 用户表
UQ = UNIQUE 约束（类型是 K）
V = 视图
X = 扩展存储过程

object_id和data_object_id都是表示数据库对象的唯一标志。

object_id是数据库对象的逻辑id，data_object_id是数据库对象的物理id。

如果一些object没有物理属性的话那它就不存在data_object_id，例如procedure,function,package,data type,db link,mv定义，view定义，临时表，分区表定义等等这些object都是没有对应着某个segment，因此它们的data_object_id 都为空。

当一个表建立的时候，他的object_id 和 data_object_id是相等的。当表move和truncate后data_object_id会发生变化。修改表结构不会更改。

select object_id,data_object_id from user_objects where object_name=’T';
OBJECT_ID DATA_OBJECT_ID
———- ————–
63053 63464

SELECT HEADER_FILE,HEADER_BLOCK,BLOCKS FROM DBA_SEGMENTS WHERE SEGMENT_NAME=’T’ AND OWNER=’TEST’;
HEADER_FILE HEADER_BLOCK BLOCKS
———– ———— ———-
4 467 8

*/

SELECT * FROM sysobjects WHERE xtype='U' AND id=OBJECT_ID('Booking')

Contents

• Introduction
• Installation
• _mysql
  • MySQL C API translation
  • MySQL C API function mapping
  • Some _mysql examples
• MySQLdb
  • Functions and attributes
  • Connection Objects
  • Cursor Objects
  • Some examples
• Using and extending
• Embedded Server

import _mysql

db=_mysql.connect()

db=_mysql.connect("localhost","joebob","moonpie","thangs")

db=_mysql.connect(host="localhost",user="joebob",

passwd="moonpie",db="thangs")

db=_mysql.connect(passwd="moonpie",db="thangs")

db=_mysql.connect(host="outhouse",port=3307,passwd="moonpie",db="thangs")

db=_mysql.connect(host="outhouse",db="thangs",read_default_file="~/.my.cnf")

db.query("""SELECT spam, eggs, sausage FROM breakfast

WHERE price < 5""")

r=db.store_result()

# ...or...

r=db.use_result()

>>> r.fetch_row()

(('3','2','0'),)

from MySQLdb.constants import FIELD_TYPE

my_conv = { FIELD_TYPE.LONG: int }

import MySQLdb

db=MySQLdb.connect(passwd="moonpie",db="thangs")

c=db.cursor()

max_price=5

c.execute("""SELECT spam, eggs, sausage FROM breakfast

WHERE price < %s""", (max_price,))

>>> c.fetchone()

(3L, 2L, 0L)

c.executemany(

"""INSERT INTO breakfast (name, spam, eggs, sausage, price)

VALUES (%s, %s, %s, %s, %s)""",

[

("Spam and Sausage Lover's Plate", 5, 1, 8, 7.95 ),

("Not So Much Spam Plate", 3, 2, 0, 3.95 ),

("Don't Wany ANY SPAM! Plate", 0, 4, 3, 5.95 )

] )

Embedded Server

Instead of connecting to a stand-alone server over the network, the embedded server support lets you run a full server right in your Python code or application server.

If you have built MySQLdb with embedded server support, there are two additional functions you will need to make use of:

server_init(args, groups)

Initialize embedded server. If this client is not linked against the embedded server library, this function does nothing.

args

sequence of command-line arguments

groups

sequence of groups to use in defaults files

server_end()

Shut down embedded server. If not using an embedded server, this does nothing.

See the MySQL documentation for more information on the embedded server.

　　1、下载MySQL 5.x 发行版 ，解压并安装映像中的两个安装包文件。

　　a. mysql-5.x-osx10.6_x86_64.pkg －mysql 5.x 标准版安装

　　b. MySQLStartupItem.pkg－mysql启动项目，可以上你的电脑在启动系统时自动运行mysql服务。它安装在/Library /StartupItems/MySQL/，如果你不想系统启动时运行mysql服务，请不要安装。如果你在安装后又不想使用，请删除/Library /StartupItems/MySQL/这个目录。

　　启动mysql：

　　2、如果你已经安装了MySQLStartupItem.pkg，重新启动电脑即可。

　　3、如果你有安装MySQLStartupItem.pkg或者不想启动电脑，运行：应用程序－实用程序－终端程序，在终端中输入命令：

　　sudo /Library/StartupItems/MySQL/MySQL start

　　然后输入你的系统管理员密码，如果没有设定密码就直接回车。

　　关闭mysql服务：

　　终端中输入命令：sudo /Library/StartupItems/MySQL/MySQL stop

　　然后输入你的系统管理员密码，如果没有设定密码就直接回车。

　　mysql root账户密码：

　　mysql root密码初始值是空。这样虽然没有问题。但很不安全。建议你更改root用户密码。注意：mysql root用户和系统中的root用户是不一样的。是完全两个不同的用户。

　　更改mysql root密码请在终端中输入命令：

　　/usr/local/mysql/bin/mysqladmin -u root password 新密码

　　同时你也可以随时使用这条命令更改你的密码。

　　4、下载x版mysql数据库管理工具

　　这是一个运行在mac os x系统中的mysql数据库管理软件，支持本地及远程数据库管理。并且还是免费的。这个程序的优点是完全CGI界面。并且密码是保存在本机上的。相对比较 安全。

<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<!--PropertyPlaceholderConfigurer类来读取xxx.properties配置文件信息,以key和value的形式-->
<property name="locations">
<list>
<value>
/WEB-INF/classes/config/pkm/environment/jdbc.properties
</value>
<value>
<!--多个xxx.properties文件-->
</value>
</list>
</property>
</bean>
<!--事实上是因为DriverManagerDataSource建立连接是只要有连接就新建一个connection,根本没有连接池的作用-->
<!--两种不同的DataSource-->
<!--单纯的DataSource-->
<bean id="pkmDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${pkm.jdbc.driverClassName}</value>
<!--${pkm.jdbc.driverClassName}是jdbc.properties文件 中的key-->
</property>
<property name="url">
<value>${pkm.jdbc.url}</value>
</property>
<property name="username">
<value>${pkm.jdbc.username}</value>
</property>
<property name="password">
<value>${pkm.jdbc.password}</value>
</property>
</bean>
<!--连接池-->
<bean id="pkmDataSource"
class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" lazy-init="false">
<property name="driverClassName" value="${pkm.jdbc.driverClassName}"/>
<property name="url" value="${pkm.jdbc.url}"/>
<property name="username" value="${pkm.jdbc.username}"/>
<property name="password" value="${pkm.jdbc.password}"/>
<property name="initialSize" value="5"/>
<property name="maxActive" value="10"/>
<property name="maxWait" value="60000"/>
<property name="poolPreparedStatements" value="true"/>
</bean>

<bean id="pkmDataSource"
class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="pkmDataSource"/>
</bean>
<!--
这样的话部署的时候，需要在容器中（tomcat,weblogic）配置JDBC Connection Pool(DBCP)连接池
-->

再举个简单的例子

with a as (select * from test)

select * from a;

其实就是把一大堆重复用到的SQL语句放在with as 里面，取一个别名，后面的查询就可以用它

这样对于大批量的SQL语句起到一个优化的作用，而且清楚明了

The SQL-99 “WITH clause” is very confusing at first because the SQL statement does not begin with the word SELECT. Instead, we use the “WITH clause” to start our SQL query, defining the aggregations, which can then be named in the main query as if they were “real” tables:

WITH
subquery_name
AS
(the aggregation SQL statement)
SELECT
(query naming subquery_name);

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

         private CustomerType type;

         @Enumerated(EnumType.STRING)

         public CustomerType getType() {

                   return type;

         }

         public void setType(CustomerType type) {

                   this.type = type;

         }

         public enum CustomerType {

                   COMPETITOR, INVESTOR, PARTNER, VENDER

         }

}

在实体中虽然标注成枚举类型，但当实体持久化后，表中所对应的值仍旧是基本的数据类型，以上代码创建表的SQL语句是：

CREATE TABLE customer (

         id int(20) NOT NULL auto_increment,

         name varchar(255),

         type varchar(255),

         PRIMARY KEY (id)

)

使用枚举类型后，在创建实体时便可以直接引用枚举类型，例如以下代码所示。

CustomerEO customer = new CustomerEO();

customer.setName("Janet2");

customer.setType(CustomerType.PARTNER);

entityManager.persist(customer);

在使用@Enumerated注释时，需要注意以下几个问题：

l         因为枚举类型的有名称和值两个属性，所以在持久化时可以选择持久化名称或是持久化值。通过EnumType来定义，它有两个值如下所示。

public enum EnumType {

ORDINAL,

STRING

}

ORDINAL表示持久化的为枚举类型的值，STRING表示持久化的为枚举类型的名称。默认为ORDINAL，持久化值。例如以上示例中标注的为STRING，这样持久化实体后，数据库中保存的是枚举类型的名称，如图所示。

若此时改成ORDINAL，代码如下：

         @Enumerated(EnumType.ORDINAL)

         public CustomerType getType() {

                   return type;

         }

则同样持久化的实体后，数据库保存的结果如图所示。

l         如何选择STRING和ORDINAL：

如果使用STRING保存，虽然从数据库中查询数据时非常直观，能够清楚的看出该类型代表意义，但这样也会带来其他的问题。若此时枚举类型的定义改变，例如上例中的枚举类型名称改为：

         public enum CustomerType {

                   CUST_COMPETITOR, INVESTOR, PARTNER, VENDER

         }

则此时数据库中保存的“COMPETITOR”的值将不能转化为枚举类型CustomerType中的“CUST_COMPETITOR”的值。但若使用ORDINAL则不会带来这种问题。所以建议使用ORDINAL类型来持久化枚举类型。

l         枚举类型的定义位置，实体外部VS实体内部。

上例中CustomerType枚举类型定义在CustomerEO实体内部，这是因为只有CustomerEO这个实体会使用CustomerType类型，其他的实体不会使用该类型。该类型与这个实体关系紧密联系。

但若此时多个实体公用一个枚举类型时，则可以将枚举类型单独定义，定义在实体的外部。有这样一个枚举类型BusinessLine，它定义在实体外部，代码如下：

public enum BusinessLine {

         REAL_ESTATE,FINANCE, NON_PROFIT

}

例如CustomerEO实体增加一个BusinessLine的枚举类型，代码如下所示。

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

         private BusinessLine businessLine;

         @Enumerated(EnumType.STRING)

         public BusinessLine getBusinessLine() {

                   return businessLine;

         }

         public void setBusinessLine(BusinessLine businessLine) {

                   this.businessLine = businessLine;

         }

}

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

 /*
  * 该类只能创建一个实例，其它对象能够调用其静态方法（也称为类方法）获得该唯一实例的引用。
  * DBConnectionManager类的建构函数是私有的，这是为了避免其它对象创建该类的实例.
  * DBConnectionManager类的客户程序可以调用getInstance()方法获得对该类唯一实例的引用。
  * 类的唯一实例在getInstance()方法第一次被调用期间创建，此后其引用就一直保存在静态变量
  * instance中。每次调用getInstance()都增加一个DBConnectionManager的客户程序计数。
  * 即，该计数代表引用DBConnectionManager唯一实例的客户程序总数，它将被用于控制连接池的
  * 关闭操作。 该类实例的初始化工作私有方法init()完成。其中 getResourceAsStream()方法
  * 用于定位并打开外部文件。外部文件的定位方法依赖于类装载器的实现。标准的本地类装载器查找操
  * 作总是开始于类文件所在路径，也能够搜索CLASSPATH中声明的路径。db.properties是一个属性
  * 文件，它包含定义连接池的键-值对。可供定义的公用属性如下：
  *   drivers 以空格分隔的JDBC驱动程序类列表""
  *   logfile 日志文件的绝对路径
  *  其它的属性和特定连接池相关，其属性名字前应加上连接池名字：
  *  < poolname>.url 数据库的 JDBC URL
  *  < poolname>.maxconn 允许建立的最大连接数，0表示没有限制
  *  < poolname>.user 用于该连接池的数据库帐号
  *  < poolname>.password 相应的密码""
  * 其中url属性是必需的，而其它属性则是可选的。数据库帐号和密码必须合法。用于Windows平台的
  * db.properties文件示例如下：
  *  drivers=com.microsoft.jdbc.sqlserver.SQLServerDriver
  *  logfile=D:""log.txt
  *  access.maxconn=20
  *  access.url=jdbc:microsoft:sqlserver://localhost:1433;databasename=web
  *  access.user=sa
  *  access.password=sa 
  * 注意在Windows路径中的反斜杠必须输入2个，这是由于属性文件中的反斜杠同时也是一个转义字符。
  * init()方法在创建属性对象并读取db.properties文件之后，就开始检查logfile属性。如果属
  * 性文件中没有指定日志文件，则默认为当前目录下的DBConnectionManager.log文件。如日志文
  * 件无法使用，则向System.err输出日志记录。装载和注册所有在drivers属性中指定的JDBC驱动
  * 程序loadDrivers()方法实现。该方法先用StringTokenizer将drivers属性值分割为对应于驱
  * 动程序名称的字符串，然后依次装载这些类并创建其实例，最后在DriverManager中注册该实例并把
  * 它加入到一个私有的向量drivers。向量drivers将用于关闭服务时从DriverManager取消所有
  * JDBC 驱动程序的注册。init()方法的最后一个任务是调用私有方法createPools()创建连接池对
  * 象。createPools()方法先创建所有属性名字的枚举对象（即Enumeration对象，该对象可以想象
  * 为一个元素系列，逐次调用其nextElement()方法将顺序返回各元素），然后在其中搜索名字以“.url”
  * 结尾的属性。对于每一个符合条件的属性，先提取其连接池名字部分，进而读取所有属于该连接池的属性，
  * 最后创建连接池对象并把它保存在实例变量pools中。散列表（Hashtable类 ）pools实现连接池名字
  * 到连接池对象之间的映射，此处以连接池名字为键，连接池对象为值。 为便于客户程序从指定连接池获
  * 得可用连接或将连接返回给连接池，类DBConnectionManager提供了方法getConnection()和
  * freeConnection()。所有这些方法都要求在参数中指定连接池名字，具体的连接获取或返回操作则调
  * 用对应的连接池对象完成。为实现连接池的安全关闭，DBConnectionManager提供了方法release()。
  * 在上面我们已经提到，所有DBConnectionManager的客户程序都应该调用静态方法getInstance()
  * 以获得该管理器的引用，此调用将增加客户程序计数。客户程序在关闭时调用release()可以递减该计数。
  * 当最后一个客户程序调用release()，递减后的引用计数为0，就可以调用各个连接池的release()方法
  * 关闭所有连接了。管理类release()方法最后的任务是撤销所有JDBC驱动程序的注册。
  */

/**
 * 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
 * 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.
 */
public class DBConnectionManager {
 static private DBConnectionManager instance; // 唯一实例

 static private int clients;

 private Vector drivers = new Vector();

 private PrintWriter log;

 private Hashtable pools = new Hashtable();

 /**
  * 返回唯一实例.如果是第一次调用此方法,则创建实例
  * @return DBConnectionManager 唯一实例
  */
 static synchronized public DBConnectionManager getInstance() {
  if (instance == null) {
   instance = new DBConnectionManager();
  }
  clients++;
  return instance;
 }

 /**
  * 建构函数私有以防止其它对象创建本类实例
  */
 private DBConnectionManager() {
  init();
 }

 /**
  * * 将连接对象返回给由名字指定的连接池
  * @param name在属性文件中定义的连接池名字
  * @param con连接对象""""r
  */
 public void freeConnection(String name, Connection con) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   pool.freeConnection(con);
  }
 }

 /**
  * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数 053 * 限制,则创建并返回新连
  * @param name在属性文件中定义的连接池名字 056 *
  * @return Connection 可用连接或null 057
  */
 public Connection getConnection(String name) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   return pool.getConnection();
  }
  return null;
 }

 /**
  * 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
  * 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
  * @param name 连接池名字 071 *
  * @param time以毫秒计的等待时间""""r
  * @return Connection 可用连接或null
  */
 public Connection getConnection(String name, long time) {
  DBConnectionPool pool = (DBConnectionPool) pools.get(name);
  if (pool != null) {
   return pool.getConnection(time);
  }
  return null;
 }

 /**
  * 关闭所有连接,撤销驱动程序的注册""""r
  */
 public synchronized void release() {
  // 等待直到最后一个客户程序调用
  if (--clients != 0) {
   return;
  }

  Enumeration allPools = pools.elements();
  while (allPools.hasMoreElements()) {
   DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
   pool.release();
  }
  Enumeration allDrivers = drivers.elements();
  while (allDrivers.hasMoreElements()) {
   Driver driver = (Driver) allDrivers.nextElement();
   try {
    DriverManager.deregisterDriver(driver);
    log("撤销JDBC驱动程序 " + driver.getClass().getName() + "的注册");
   } catch (SQLException e) {
    log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());
   }
  }
 }

 /**
  * 根据指定属性创建连接池实例.
  * @param props 连接池属性 113
  */
 private void createPools(Properties props) {
  Enumeration propNames = props.propertyNames();
  while (propNames.hasMoreElements()) {
   String name = (String) propNames.nextElement();
   if (name.endsWith(".url")) {
    String poolName = name.substring(0, name.lastIndexOf("."));
    String url = props.getProperty(poolName + ".url");
    if (url == null) {
     log("没有为连接池" + poolName + "指定URL");
     continue;
    }
    String user = props.getProperty(poolName + ".user");
    String password = props.getProperty(poolName + ".password");
    String maxconn = props.getProperty(poolName + ".maxconn", "0");
    int max;
    try {
     max = Integer.valueOf(maxconn).intValue();
    } catch (NumberFormatException e) {
     log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName);
     max = 0;
    }
    DBConnectionPool pool = new DBConnectionPool(poolName, url,
      user, password, max);
    pools.put(poolName, pool);
    log("成功创建连接池" + poolName);
   }
  }
 }

 /**
  * 读取属性完成初始化
  */
 private void init() {
  InputStream is = getClass().getResourceAsStream("/db.properties");
  Properties dbProps = new Properties();
  try {
   dbProps.load(is);
  } catch (Exception e) {
   System.err.println("不能读取属性文件. "+"请确保db.properties在CLASSPATH指定的路径中");
   return;
  }
  String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
  try {
   log = new PrintWriter(new FileWriter(logFile, true), true);
  } catch (IOException e) {
   System.err.println("无法打开日志文件: " + logFile);
   log = new PrintWriter(System.err);
  }
  loadDrivers(dbProps);
  createPools(dbProps);
 }

 /**
  * 装载和注册所有JDBC驱动程序
  * @param props属性
  */
 private void loadDrivers(Properties props) {
  String driverClasses = props.getProperty("drivers");
  StringTokenizer st = new StringTokenizer(driverClasses);
  while (st.hasMoreElements()) {
   String driverClassName = st.nextToken().trim();
   try {
    Driver driver = (Driver) Class.forName(driverClassName).newInstance();
    DriverManager.registerDriver(driver);
    drivers.addElement(driver);
    log("成功注册JDBC驱动程序" + driverClassName);
   } catch (Exception e) {
    e.printStackTrace();
    log("无法注册JDBC驱动程序: " + driverClassName + ", 错误: " + e);
   }
  }
 }

 /**
  * 将文本信息写入日志文件
  */
 private void log(String msg) {
  log.println(new Date() + ": " + msg);
 }

 /**
  * 将文本信息与异常写入日志文件
  */
 private void log(Throwable e, String msg) {
  log.println(new Date() + ": " + msg);
  e.printStackTrace(log);
 }

 // ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // ///////////////////////////////////////////////////////////////////////////////////////////////////////
 /*
  * DBConnectionPool实现，它表示指向某个数据库的连接池。数据库由JDBC URL标识。一个JDBCURL由三部分组成：协议标识（总是jdbc），
  * 驱动程序标识（如odbc、idb、oracle等），数据库标识（其格式依赖于驱动程序）。例如，jdbc:odbc:demo，即是一个指向demo数据
  * 库的JDBCURL，而且访问该数据库要使用JDBC-ODBC驱动程序。每个连接池都有一个供客户程序使用的名字以及可选的用户帐号、密码、最
  * 大连接数限制。如果Web应用程序所支持的某些数据库操作可以被所有用户执行，而其它一些操作应由特别许可的用户执行，则可以为两类操作
  * 分别定义连接池，两个连接池使用相同的JDBC URL，但使用不同的帐号和密码。类DBConnectionPool的建构函数需要上述所有数据作为其
  * 参数。客户程序可以使用DBConnectionPool
  * 类提供的两个方法获取可用连接。两者的共同之处在于：如连接池中存在可用连接，则直接返回，否则创建新的连接并返回。如果没有可用连接
  * 且已有连接总数等于最大限制数，第一个方法将直接返回null，而第二个方法将等待直到有可用连接为止。所有的可用连接对象均登记在名为
  * freeConnections的向量（Vector）中。如果向量中有多于一个的连接，getConnection()总是选取第一个。同时，由于新的可用连接总
  * 是从尾部加入向量，从而使得数据库连接由于长时间闲置而被关闭的风险减低到最小程度。 第一个getConnection()在返回可用连接给客户
  * 程序之前，调用了isClosed()方法验证连接仍旧有效。如果该连接被关闭或触发异常，getConnection()递归地调用自己以尝试获取另外的
  * 可用连接。如果在向量freeConnections中不存在任何可用连接，getConnection()方法检查是否已经指定最大连接数限制。如已经指定，
  * 则检查当前连接数是否已经到达极限。此处maxConn为0表示没有限制。如果没有指定最大连接数限制或当前连接数小于该值，该方法尝试创建
  * 新的连接。如创建成功，则增加已使用连接的计数并返回，否则返回空值。创建新连接由newConnection()方法实现。
  * 创建过程与是否已经指定数据库帐号、密码有关。JDBC的DriverManager类提供多个getConnection()方法，这些方法要用到JDBC URL
  * 与其它一些参数，如用户帐号和密码等。DriverManager将使用指定的JDBC URL确定适合于目标数据库的驱动程序及建立连接。
  * 第二个getConnection()方法需要一个以毫秒为单位的时间参数，该参数表示客户程序能够等待的最长时间。建立连接的具体操
  * 作仍旧由第一个getConnection()方法实现。该方法执行时先将startTime初始化为当前时间。在while循环中尝试获得一个连接。如果失
  * 败，则以给定的时间值为参数调用wait()。wait()的返回可能是由于其它线程调用notify()或notifyAll()，也可能是由于预定时间已到。
  * 为找出wait()返回的真正原因，程序用当前时间减开始时间（startTime），如差值大于预定时间则返回空值，否则再次调用getConnection()。
  * 把空闲的连接登记到连接池由freeConnection()方法实现，它的参数为返回给连接池的连接对象。该对象被加入到freeConnections
  * 向量的末尾，然后减少已使用连接计数。调用notifyAll()是为了通知其它正在等待可用连接的线程。 许多Servlet引擎为实现安全关闭提供
  * 多种方法。数据库连接池需要知道该事件以保证所有连接能够正常关闭。DBConnectionManager类负协调整个关闭过程，但关闭连接池中所有连
  * 接的任务则由DBConnectionPool类负责。release()方法供DBConnectionManager调用。该方法遍历freeConnections向量并关闭所有连接，
  * 然后从向量中删除这些连接。
  */

 /**
  * 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最""""r
  */
 class DBConnectionPool {
  private int checkedOut;

  private Vector freeConnections = new Vector();

  private int maxConn;

  private String name;

  private String password;

  private String URL;

  private String user;

  /**
   * 创建新的连接池
   * @param name连接池名字
   * @param URL数据库的JDBC URL
   * @param user数据库帐号,或 null
   * @param password密码,或 null
   * @param maxConn此连接池允许建立的最大连接数
   */
  public DBConnectionPool(String name, String URL, String user,
    String password, int maxConn) {
   this.name = name;
   this.URL = URL;
   this.user = user;
   this.password = password;
   this.maxConn = maxConn;
  }

  /**
   * 将不再使用的连接返回给连接池
   * @param con客户程序释放的连接
   */
  public synchronized void freeConnection(Connection con) {
   // 将指定连接加入到向量末尾
   freeConnections.addElement(con);
   checkedOut--;
   notifyAll();
  }

  /**
   * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接 数限制,则创建新连接.
   * 如原来登记为可用的连接不再有效,则从向量删除之,
   * 然后递归调用自己以尝试新的可用连接.
   */
  public synchronized Connection getConnection() {
   Connection con = null;
   if (freeConnections.size() > 0) {// 获取向量中第一个可用连接
    con = (Connection) freeConnections.firstElement();
    freeConnections.removeElementAt(0);
    try {
     if (con.isClosed()) {
      log("从连接池" + name + "删除一个无效连接");
      // 递归调用自己,尝试再次获取可用连接
      con = getConnection();
     }
    } catch (SQLException e) {
     log("从连接池" + name + "删除一个无效连接");
     // 递归调用自己,尝试再次获取可用连接
     con = getConnection();
    }
   } else if (maxConn == 0 || checkedOut < maxConn) {
    con = newConnection();
   }
   if (con != null) {
    checkedOut++;
   }
   return con;
  }

  /**
   * 从连接池获取可用连接.可以指定客户程序能够等待的最长时间 参见前一个getConnection()方法.
   * @param timeout以毫秒计的等待时间限制
   */
  public synchronized Connection getConnection(long timeout) {
   long startTime = new Date().getTime();
   Connection con;
   while ((con = getConnection()) == null) {
    try {
     wait(timeout);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    if ((new Date().getTime() - startTime) >= timeout) {// wait()返回的原因是超时
     return null;
    }
   }
   return con;
  }

  /**
   * 关闭所有连接
   */
  public synchronized void release() {
   Enumeration allConnections = freeConnections.elements();
   while (allConnections.hasMoreElements()) {
    Connection con = (Connection) allConnections.nextElement();
    try {
     con.close();
     log("关闭连接池" + name + "中的一个连接");
    } catch (SQLException e) {
     log(e, "无法关闭连接池" + name + "中的连接");
     e.printStackTrace();
    }
   }
   freeConnections.removeAllElements();
  }

  /**
   * 创建新的连接
   */
  private Connection newConnection() {
   Connection con = null;
   try {
    if (user==null||"".equals(user)) {
     con = DriverManager.getConnection(URL);
    } else {
     con = DriverManager.getConnection(URL, user, password);
    }
    log("连接池" + name + "创建一个新的连接");
   } catch (SQLException e) {
    log(e, "无法创建下列URL的连接: " + URL);
    return null;
   }
   return con;
  }
 }

 /////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////
}

在sqlserver2000，tomcat5.5验证通过

方法调用！

package com.xinnuo.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

1>将mysql安装文件(本人使用mysql5.0.51a-linux-i686-glibc23.tar.gz)解压到对应目录，在此为 /home/seal/mysql

2>进入源码目录编译安装

CODE:

#cd /home/seal/mysql
#./configure --prefix=/usr/local/mysql --with-charset=gbk  |注:配置Mysql安装路径并且支持中文
#make  |注:编译
#make install  |注:编译安装

3>替换/etc/my.cnf文件,进入源码包,执行命令

CODE:

#cd /home/seal/mysql
#cp support-files/my-medium.cnf /etc/my.cnf

4>建立MySQL使用者和群组:

CODE:

5>完成以上操作以后进行初始化数据库,进入已经安装好的mysql目录

CODE:

#cd /usr/local/mysql
#bin/mysql_install_db --user=mysql  |注:--user=mysql 初始化表并且规定用mysql用户
6>设置给mysql和root用户设定访问权限 我们先进入mysql目录

CODE:

#cd /usr/local/mysql
#chown -R root /usr/local/mysql   |注:设定root能访问/usr/local/mysq
#chown -R mysql /usr/local/mysql/var   |注:设定mysql用户能访问/usr/local/mysql/var
#chgrp -R mysql /usr/local/mysql    |注:设定mysql组能够访问/usr/local/mysq
7>启动mysql,进入已经安装好的目录

CODE:

#cd /usr/local/mysql
#bin/mysqld_safe --user=mysql &

8>
修改mysql数据库超级用户root的缺省密码:
/usr/local/mysql/bin/mysqladmin -u root password 'mysql'

关闭mysql服务器
cd /usr/local/mysql/bin
./mysqladmin -u root -p    shutdown 

9>设定开机就启动mysql,进入源码目录下

# cd /home/seal/mysql
# cp support-files/mysql.server /etc/init.d/mysql

解决方法：
1。改表法。可能是你的帐号不允许从远程登陆，只能在localhost。这个时候只要在localhost的那台电脑，登入mysql后，更改 “mysql” 数据库里的 “user” 表里的 “host” 项，从“localhost”改称“%”

2. 授权法。例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。

如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作为密码

日期类型概述

SQL Server中的日期类型包括datetime和smalldatetime，仅能处理可以识别为1753年～9999年间的日期的值，没有单独的日期型或时间型。

1．datetime

datetime类型处理从1753年1月1日～9999年12月31日的日期和时间数据，精确度为百分之三秒。即：对于0.000～0.001、0.009的日期值，调整为0.000；对于0.002～0.004的日期值，调整为0.003；对于0.005～0.008的日期值，调整为0.007。

例如，下面的代码在输入时，其时间精确度为百分之一秒，但经数据库保存后再显示出来，其结果就已经做了处理。

DECLARE @t TABLE(date char(21))

INSERT @t SELECT '1900-1-1 00:00:00.000'

...

INSERT @t SELECT '1900-1-1 00:00:00.009'

SELECT date,转换后的日期=CAST(date as datetime) FROM @t

/*--结果

date                     转换后的日期

---------------------------------- ----------------------------

1900-1-1 00:00:00.000    1900-01-01 00:00:00.000
...
1900-1-1 00:00:00.000    1900-01-01 00:00:00.010

datetime的存储长度为8字节，日期和时间各用4个字节存储，第一个4字节存储自1900年1月1日之前或之后的天数（以1900年1月1日为分界点，在1900年1月1日之前的日期的天数小于0，在1900年1月1日之后的日期的天数大于0）。另外一个4字节存储以午夜（00:00:00.000）后毫秒数所代表的每天的时间。

例如，下面的代码演示了datetime变量中，仅包含单纯的日期和单纯的时间时，日期存储的十六进制存储表示结果。

DECLARE @dt datetime

--单纯的日期

SET @dt='1900-1-2'

SELECT CAST(@dt as binary(8))

--结果: 0x0000000100000000

--单纯的时间

SET @dt='00:00:01'

SELECT CAST(@dt as binary(8))

--结果: 0x000000000000012C

2．smalldatetime

smalldatetime类型处理从1900年1月1日～2079年6月6 日的日期和时间数据，精确到分钟。29.998秒或更低的smalldatetime值向下舍入为最接近的分钟，29.999秒或更高的smalldatetime值向上舍入为最接近的分钟。

smalldatetime的存储长度为4字节，第一个2字节存储自1900年1月1日之后的天数。另外一个2字节存储午夜（00:00:00.000）后的分钟数。

例如，下面的代码演示了smalldatetime变量中，仅包含单纯的日期和单纯的时间时，日期存储的十六进制存储表示结果。

DECLARE @dt smalldatetime

--单纯的日期

SET @dt='1900-1-2'

SELECT CAST(@dt as binary(4))

--结果: 0x00010000

--单纯的时间

SET @dt='00:10'

SELECT CAST(@dt as binary(4))
--结果: 0x0000000A

日期处理函数

日期由年、月、日、时等多个部分组成，它的处理相对复杂，因此，SQL Server提供了大量的日期处理函数，用以完成各种日期数据的处理。掌握好这些函数，对完成数据库的各种日期处理非常必要，本节将介绍几个常用的日期处理函数。期增减函数可以对日期指定部分的值进行增减，并返回处理后的日期值，SQL Server提供的日期增减函数为DATEADD。

DATEADD的具体语法如下：DATEADD ( datepart , number, date )

其中包括以下参数。

¡ datepart：是规定应向日期的哪一部分返回新值的参数。表2-1列出了SQL Server支持的日期部分、缩写及含义。

                    DATEADD、DATEDIFF支持的日期部分、缩写及含义

¡ number：是用来增加datepart的值。正数表示增加，负数表示减少，如果指定的是非整数值，则忽略此值的小数部分，不做四舍五入处理。例如，DATEADD（Day,1.7,date），表示date增加1天。

¡ date：是返回datetime或smalldatetime值或日期格式字符串的表达式。

如果date是smalldatetime，则返回smalldatetime，否则返回datetime。date为smalldatetime，Datepart为Second（ss,s）或Millisecond（ms）时，返回值将根据日期增减的结果调整到分钟；date为datetime，Datepart为Millisecond（ms）时，返回值将根据日期增减的结果调整为百分之三秒。调整规则可以参考2.1节的相关说明。

date允许直接与number进行增减计算，即对于DATEADD（Day,number,date），等同于date+number。

 日期信息获取函数

日期信息获取函数用于获取日期指定部分的相关信息，常用的日期信息获取函数如表2-2所示。

                                      常用的日期信息获取函数

                  DATENAME、DATEPART支持的日期部分、缩写及含义

DATEPART（Week,date）返回的星期计算方式，是按照星期日为一周的第一天，这点与中国人的日期处理习惯不同，在使用时要注意这一点。DATENAME函数返回指定日期的指定日期部分的字符串，其返回的具体字符串值，与SET DATEFIRST及SET DATELANGUAGE选项的设置有关。使用DATEPART（Weekday,date）时，其返回的值与SET DATEFIRST选项的设置有关，具体的将在2.3节中说明。

 日期差值计算函数

日期差值计算函数用于计算两个给定日期指定部分的边界数，SQL Server提供的日期差值计算函数为DATEDIFF。

DATEDIFF的具体语法如下：

DATEDIFF ( datepart , startdate , enddate )

其中包括以下参数。

¡ datepart：规定了应在日期的哪一部分计算差额，其定义如表2-1所示。

¡ startdate：规定了计算的开始日期。

¡ enddate：规定了计算的终止日期。

返回类型：integer

计算的开始日期和终止日期，可以是日期或日期格式的字符串。计算的方法是从enddate减去startdate。如果startdate比enddate晚，返回负值。当结果超出整数值范围，DATEDIFF就产生错误。对于毫秒，最大数是24天20小时31分钟23.647秒。对于秒，最大数是68年。

计算跨分钟、秒和毫秒这些边界的方法，使得DATEDIFF给出的结果在全部数据类型中是一致的。结果是带正负号的整数值，其等于跨第一个和第二个日期间的datepart边界数。例如，在2005年1月4日和2005年2月11日之间的月份数是1。

 其他日期处理相关函数

其他常用的日期处理相关函数包括以下几个。

1．GETDATE

GETDATE按照datetime值返回当前系统日期和时间。

GETDATE的语法如下：

GETDATE()

返回类型：datetime

2．ISDATE

ISDATE确定输入的表达式是否有效日期。

在输入日期表达式时，日期都是以日期格式的字符串提供的，由于不同的区域有不同的日期格式，所以并不能保证输入的日期表达式能够被SQL Server识别，这种情况下，就需要用ISDATE来判断日期表达式能否正确地被SQL Server识别了。

ISDATE的语法如下：

ISDATE(expression)

返回类型：int

3．CONVERT

CONVERT将某种数据类型的表达式显式转换为另一种数据类型。

严格来说，CONVERT不属于日期处理函数，只是它被经常用于日期处理中，所以这里把它列入了其他日期处理函数，下面是CONVERT的用法描述（只重点说明在日期处理中的应用）。

CONVERT的具体语法如下：

CONVERT ( data_type [ ( length ) ] , expression [ , style ] )

其中包括以下参数。

¡ expression：是要转换数据类型的有效SQL Server表达式。

¡ data_type：是expression转换后的数据类型，length是对于有精度定义需要的data_type的精度定义，对于没有精度定义需要的data_type，该参数可以省略。

¡ style：定义数据类型转换时的格式，对于日期类型的转换，它的定义如表2-4所示。

表2-4                                      style在日期转换中的说明

当从smalldatetime转换为字符数据时，由于smalldatetimer只保存到分钟的数据，因此，对于包含秒或毫秒的样式，将在秒或毫秒的位置上显示零。当从datetime或smalldatetime值进行转换时，可以通过使用适当的char或varchar数据类型长度来截断不需要的日期部分。

返回类型：由参数data_type确定。

下面是利用CONVERT进行日期转换的简单示例：

/*== 字符转换为日期时,Style的使用 ==*/

--1. Style=101时,表示日期字符串为:mm/dd/yyyy格式

SELECT CONVERT(datetime,'11/1/2003',101)

--结果:2003-11-01 00:00:00.000

--2. Style=101时,表示日期字符串为:dd/mm/yyyy格式

SELECT CONVERT(datetime,'11/1/2003',103)

--结果:2003-01-11 00:00:00.000 

/*== 日期转换为字符串 ==*/

DECLARE @dt datetime

SET @dt='2003-1-11'

--1. Style=101时,表示将日期转换为:mm/dd/yyyy 格式

SELECT CONVERT(varchar,@dt,101)

--结果:01/11/2003

--2. Style=103时,表示将日期转换为:dd/mm/yyyy 格式

SELECT CONVERT(varchar,@dt,103)

--结果:11/01/2003

 /*== 这是很多人经常犯的错误,对非日期型转换使用日期的style样式 ==*/

SELECT CONVERT(varchar,'2003-1-11',101)

数据库结构的脚本:
if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[TempA]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[TempA]
GO

CREATE TABLE [dbo].[TempA] (
 [id] [int] IDENTITY (1, 1) NOT NULL ,
 [PositionName] [varchar] (256) COLLATE Chinese_PRC_CI_AS NULL ,
 [EnglishPositionName] [varchar] (256) COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY]
GO

ALTER TABLE [dbo].[TempA] ADD
 CONSTRAINT [PK_TempA] PRIMARY KEY  CLUSTERED
 (
  [id]
 )  ON [PRIMARY]
GO

TempA表中有三个字段,id唯一且为主键,自动增长; PositionName,EnglishPositionName中有重复的记录,比如:
id      PositionName        EnglishPositionName
20     其他                           Others
21     质量工程师               QC Engineer
22     其他                           Others
.......
100  质量工程师               QC Engineer
需要剔除重复的"其他","质量工程师"等记录。

采用的SQL语句：
Delete from TempA where id not in (
        select max(t1.id) from TempA t1 group by
         t1.PositionName,t1.EnglishPositionName)

说明：
(1)需要剔除那几个用于判断重复的字段，则将它们放在group by语句之后。
(2)max(t1.id) 也可以改成：min(t1.id)