用 jQuery 的都知道，jQuery 的 get 和 post 方法有三个参数：地址，数据 和回调函数，但我们知道地址也可以跟随数据的（形如：get_data.php?v1=1&v2=2），而且第二个参数可以省略，即第二个参数可 以直接写回调函数，那么数据写在地址后面和写在 data 参数里有什么区别呢？

刚刚做了几个实验，看看下面的代码就清楚了:
以下内容需要回复才能看到

jquery_data.php

echo "post: ";
print_r($_POST);
echo "get: ";
print_r($_GET);
?>

jquery_test.html

实验1：

$(function() {
// post 方法，两处都有数据
$.post('jquery_data.php?v1=1', {v2: 2}, function(data) {
$('

').append(data).appendTo('body');

});

});



返回结果：

post: Array

(

[v2] => 2

)

get: Array

(

[v1] => 1

)



实验2：



$(function()

{

// post 方法，数据在地址后面， 第二个参数为回调函数

$.post('jquery_data.php?v1=1', function(data)

{

$('<pre/>').append(data).appendTo('body');

});

});



返回结果，数据在 get 中：

post: Array

(

)

get: Array

(

[v1] => 1

)



实验3：



$(function()

{

// get 方法，用 data 参数传值

$.get('jquery_data.php', {v2: 2}, function(data)

{

$('<pre/>').append(data).appendTo('body');

});

});



返回结果，数据在 get 中：

post: Array

(

)

get: Array

(

[v2] => 2

)



实验4：



$(function()

{

// get 方法，两处都有数据

$.get('jquery_data.php?v1=1', {v2: 2}, function(data)

{

$('<pre/>').append(data).appendTo('body');

});

});



返回结果，两处数据被合并了，都在 get 中：

post: Array

(

)

get: Array

(

[v1] => 1

[v2] => 2

)



实验5：



$(function()

{

// get 方法，两处都有数据，且变量名相同

$.get('jquery_data.php?v2=1', {v2: 2}, function(data)

{

$('<pre/>').append(data).appendTo('body');

});

});



返回结果，数据在 get 中，且 data 参数中的数据覆盖了地址后面的数据：

post: Array

(

)

get: Array

(

[v2] => 2

)



通过这几个简单的小例子不难看出，地址后面的数据永远是以 get 形式传递的，无论使用的是 get 方法还是 post 方法；而 data 参数中的数据是根据方法决定传递方式的。



因此，为了避免混淆，建议大家尽量不要把数据写在地址后面，而是统一放在 data 参数中。



当然，如果你想在用 post 方法时，同时利用 get 传值，那么就可以把要以 get 方式传递的数据写在地址后面，把要以 post 方式传递的数据写在 data 参数中。



总之方法是死的，人是活的，怎么用还要看实际情况。子曾经曰过：实践是检验真理的唯一标准。没事做做实验，掌握知识更牢固。

JPA常用标记说明¶

Table¶

Table用来定义entity主表的name，catalog，schema等属性。
元数据属性说明：

• name: 表名
• catalog: 对应关系数据库中的catalog
• schema：对应关系数据库中的schema
• UniqueConstraints:定义一个UniqueConstraint数组，指定需要建唯一约束的列

     

@Entity

@Table(name="CUST")

public class Customer { ... }

SecondaryTable¶

一个entity class可以映射到多表，SecondaryTable用来定义单个从表的名字，主键名字等属性。
元数据属性说明：

• name: 表名
• catalog: 对应关系数据库中的catalog
• schema：对应关系数据库中的schema
• pkJoin: 定义一个PrimaryKeyJoinColumn数组，指定从表的主键列
• UniqueConstraints:定义一个UniqueConstraint数组，指定需要建唯一约束的列

下面的代码说明Customer类映射到两个表，主表名是CUSTOMER，从表名是CUST_DETAIL，从表的主键列和主表的主键列类型相同，列名为CUST_ID。

                 

@Entity

@Table(name="CUSTOMER")

@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"))

public class Customer { ... }

SecondaryTables¶

当一个entity class映射到一个主表和多个从表时，用SecondaryTables来定义各个从表的属性。
元数据属性说明：

• value： 定义一个SecondaryTable数组，指定每个从表的属性。

                 

@Table(name = "CUSTOMER")

@SecondaryTables( value = {

@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }),

@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) })

public class Customer {}

UniqueConstraint¶

UniqueConstraint定义在Table或SecondaryTable元数据里，用来指定建表时需要建唯一约束的列。
元数据属性说明：

• columnNames:定义一个字符串数组，指定要建唯一约束的列名。

                 

@Entity

@Table(name="EMPLOYEE", uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})})

public class Employee { ... }

Column¶

Column元数据定义了映射到数据库的列的所有属性：列名，是否唯一，是否允许为空，是否允许更新等。
元数据属性说明：

• name:列名。
• unique: 是否唯一
• nullable: 是否允许为空
• insertable: 是否允许插入
• updatable: 是否允许更新
• columnDefinition: 定义建表时创建此列的DDL
• secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。

         

public class Person {

@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)

private String name;



@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")

private byte[] picture;



...

JoinColumn¶

如果在entity class的field上定义了关系（one2one或one2many等），我们通过JoinColumn来定义关系的属性。JoinColumn的大部分属性和Column类似。
元数据属性说明：

• name:列名。
• referencedColumnName:该列指向列的列名（建表时该列作为外键列指向关系另一端的指定列）
• unique: 是否唯一
• nullable: 是否允许为空
• insertable: 是否允许插入
• updatable: 是否允许更新
• columnDefinition: 定义建表时创建此列的DDL
• secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字。

下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建一个名为CUST_ID的列，该列作为外键指向Custom对应表中名为ID的列。

                 

public class Custom {

@OneToOne

@JoinColumn(name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true)

public Order getOrder() {

return order;

}

JoinColumns¶

如果在entity class的field上定义了关系（one2one或one2many等），并且关系存在多个JoinColumn，用JoinColumns定义多个JoinColumn的属性。
元数据属性说明：

• value: 定义JoinColumn数组，指定每个JoinColumn的属性。

下面的代码说明Custom和Order是一对一关系。在Order对应的映射表建两列，一列名为CUST_ID，该列作为外键指向Custom对应表中名为ID的列,另一列名为CUST_NAME，该列作为外键指向Custom对应表中名为NAME的列。

                 

public class Custom {

@OneToOne

@JoinColumns({

@JoinColumn(name="CUST_ID", referencedColumnName="ID"),

@JoinColumn(name="CUST_NAME", referencedColumnName="NAME")

})



public Order getOrder() {

return order;

}

Id¶

声 明当前field为映射表中的主键列。id值的获取方式有五种：TABLE, SEQUENCE, IDENTITY, AUTO, NONE。Oracle和DB2支持SEQUENCE，SQL Server和Sybase支持IDENTITY,mysql支持AUTO。所有的数据库都可以指定为AUTO，我们会根据不同数据库做转换。 NONE需要用户自己指定Id的值。元数据属性说明：

• generate():主键值的获取类型
• generator():TableGenerator的名字（当generate=GeneratorType.TABLE才需要指定该属性）

下面的代码声明Task的主键列id是自动增长的。(Oracle和DB2从默认的SEQUENCE取值，SQL Server和Sybase该列建成IDENTITY，mysql该列建成auto increment。)

                

@Entity

@Table(name = "OTASK")

public class Task {

@Id(generate = GeneratorType.AUTO)

public Integer getId() {

return id;

}

}

IdClass¶

当entity class使用复合主键时，需要定义一个类作为id class。id class必须符合以下要求:类必须声明为public，并提供一个声明为public的空构造函数。必须实现Serializable接，覆写 equals()和hashCode（）方法。entity class的所有id field在id class都要定义，且类型一样。
元数据属性说明：

• value: id class的类名

                 

public class EmployeePK implements java.io.Serializable{

String empName;

Integer empAge;

public EmployeePK(){}



public boolean equals(Object obj){ ......}

public int hashCode(){......}

}



@IdClass(value=com.acme.EmployeePK.class)

@Entity(access=FIELD)

public class Employee {

@Id String empName;

@Id Integer empAge;

}

MapKey¶

在一对多，多对多关系中，我们可以用Map来保存集合对象。默认用主键值做key，如果使用复合主键，则用id class的实例做key，如果指定了name属性，就用指定的field的值做key。
元数据属性说明：

• name: 用来做key的field名字

下面的代码说明Person和Book之间是一对多关系。Person的books字段是Map类型，用Book的isbn字段的值作为Map的key。

                 

@Table(name = "PERSON")

public class Person {

@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")

@MapKey(name = "isbn")

private Map books = new HashMap();

}

OrderBy¶

在一对多，多对多关系中，有时我们希望从数据库加载出来的集合对象是按一定方式排序的，这可以通过OrderBy来实现，默认是按对象的主键升序排列。
元数据属性说明：

• value: 字符串类型，指定排序方式。格式为"fieldName1 [ASC|DESC],fieldName2 [ASC|DESC],......",排序类型可以不指定，默认是ASC。

下面的代码说明Person和Book之间是一对多关系。集合books按照Book的isbn升序，name降序排列。

                

@Table(name = "MAPKEY_PERSON")

public class Person {

@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")

@OrderBy(name = "isbn ASC, name DESC")

private List books = new ArrayList();

}

PrimaryKeyJoinColumn¶

在三种情况下会用到PrimaryKeyJoinColumn。

• 继承。
• entity class映射到一个或多个从表。从表根据主表的主键列（列名为referencedColumnName值的列），建立一个类型一样的主键列，列名由name属性定义。
• one2one关系，关系维护端的主键作为外键指向关系被维护端的主键，不再新建一个外键列。

元数据属性说明：

• name:列名。
• referencedColumnName:该列引用列的列名
• columnDefinition: 定义建表时创建此列的DDL

下面的代码说明Customer映射到两个表，主表CUSTOMER,从表CUST_DETAIL，从表需要建立主键列CUST_ID，该列和主表的主键列id除了列名不同，其他定义一样。

             

@Entity

@Table(name="CUSTOMER")

@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"，referencedColumnName="id"))

public class Customer { 

@Id(generate = GeneratorType.AUTO)

public Integer getId() {

return id;

}

}

下面的代码说明Employee和EmployeeInfo是一对一关系，Employee的主键列id作为外键指向EmployeeInfo的主键列INFO_ID。

             

@Table(name = "Employee")

public class Employee {

@OneToOne

@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")

EmployeeInfo info;

}

PrimaryKeyJoinColumns¶

如果entity class使用了复合主键，指定单个PrimaryKeyJoinColumn不能满足要求时，可以用PrimaryKeyJoinColumns来定义多个PrimaryKeyJoinColumn。
元数据属性说明：

• value: 一个PrimaryKeyJoinColumn数组，包含所有PrimaryKeyJoinColumn。

下面的代码说明了Employee和EmployeeInfo是一对一关系。他们都使用复合主键，建表时需要在Employee表建立一个外键，从Employee的主键列id,name指向EmployeeInfo的主键列INFO_ID和INFO_NAME.

             

@Entity

@IdClass(EmpPK.class)

@Table(name = "EMPLOYEE")

public class Employee {

private int id;

private String name;



private String address;



@OneToOne(cascade = CascadeType.ALL)

@PrimaryKeyJoinColumns({

@PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"),

@PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")})

EmployeeInfo info;

}



@Entity

@IdClass(EmpPK.class)

@Table(name = "EMPLOYEE_INFO")

public class EmployeeInfo {



@Id

@Column(name = "INFO_ID")

private int id;



@Id

@Column(name = "INFO_NAME")

private String name;

}

Transient¶

Transient用来注释entity的属性，指定的这些属性不会被持久化，也不会为这些属性建表。

     

@Transient

private String name;

Version¶

Version指定实体类在乐观事务中的version属性。在实体类重新由EntityManager管理并且加入到乐观事务中时，保证完整性。每一个类只能有一个属性被指定为version，version属性应该映射到实体类的主表上。

下面的代码说明versionNum属性作为这个类的version，映射到数据库中主表的列名是OPTLOCK。

                 

@Version

@Column("OPTLOCK")

protected int getVersionNum() { return versionNum; }

Lob¶

Lob指定一个属性作为数据库支持的大对象类型在数据库中存储。使用LobType这个枚举来定义Lob是二进制类型还是字符类型。
LobType枚举类型说明：

• BLOB 二进制大对象，Byte[]或者Serializable的类型可以指定为BLOB。
• CLOB 字符型大对象，char[]、Character[]或String类型可以指定为CLOB。

元数据属性说明：

• fetch： 定义这个字段是lazy loaded还是eagerly fetched。数据类型是FetchType枚举，默认为LAZY,即lazy loaded.
• type： 定义这个字段在数据库中的JDBC数据类型。数据类型是LobType枚举，默认为BLOB。

下面的代码定义了一个BLOB类型的属性和一个CLOB类型的属性。

                 

@Lob

@Column(name="PHOTO" columnDefinition="BLOB NOT NULL")

protected JPEGImage picture;



@Lob(fetch=EAGER, type=CLOB)

@Column(name="REPORT")

protected String report;

JoinTable¶

JoinTable在many-to-many关系的所有者一边定义。如果没有定义JoinTable，使用JoinTable的默认值。
元数据属性说明：

• table:这个join table的Table定义。
• joinColumns:定义指向所有者主表的外键列，数据类型是JoinColumn数组。
• inverseJoinColumns:定义指向非所有者主表的外键列，数据类型是JoinColumn数组。

下面的代码定义了一个连接表CUST和PHONE的join table。join table的表名是CUST_PHONE，包含两个外键，一个外键是CUST_ID，指向表CUST的主键ID，另一个外键是PHONE_ID，指向表PHONE的主键ID。

                 

@JoinTable(

table=@Table(name=CUST_PHONE),

joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),

inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")

)

TableGenerator¶

TableGenerator定义一个主键值生成器，在Id这个元数据的generate＝TABLE时，generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。
生成器是为多个实体类提供连续的ID值的表，每一行为一个类提供ID值，ID值通常是整数。
元数据属性说明：

• name:生成器的唯一名字，可以被Id元数据使用。
• table:生成器用来存储id值的Table定义。
• pkColumnName:生成器表的主键名称。
• valueColumnName:生成器表的ID值的列名称。
• pkColumnValue:生成器表中的一行数据的主键值。
• initialValue:id值的初始值。
• allocationSize:id值的增量。

下面的代码定义了两个生成器empGen和addressGen，生成器的表是ID_GEN。

                 

@Entity

public class Employee {

...

@TableGenerator(

name="empGen",

table=@Table(name="ID_GEN"),

pkColumnName="GEN_KEY",

valueColumnName="GEN_VALUE",

pkColumnValue="EMP_ID",

allocationSize=1

)

@Id(generate=TABLE, generator="empGen")

public int id;

...

}



@Entity

public class Address {

...

@TableGenerator(

name="addressGen",

table=@Table(name="ID_GEN"),

pkColumnValue="ADDR_ID" 

)

@Id(generate=TABLE, generator="addressGen")

public int id;

...

}

SequenceGenerator¶

SequenceGenerator定义一个主键值生成器，在Id这个元数据的generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。生成器是数据库支持的sequence对象。
元数据属性说明：

• name:生成器的唯一名字，可以被Id元数据使用。
• sequenceName:数据库中，sequence对象的名称。如果不指定，会使用提供商指定的默认名称。
• initialValue:id值的初始值。
• allocationSize:id值的增量。

下面的代码定义了一个使用提供商默认名称的sequence生成器。

                 

@SequenceGenerator(name="EMP_SEQ", allocationSize=25) 

DiscriminatorColumn¶

DiscriminatorColumn定义在使用SINGLE_TABLE或JOINED继承策略的表中区别不继承层次的列。
元数据属性说明：

• name:column的名字。默认值为TYPE。
• columnDefinition:生成DDL的sql片断。
• length:String类型的column的长度，其他类型使用默认值10。

下面的代码定义了一个列名为DISC，长度为20的String类型的区别列。

                 

@Entity

@Table(name="CUST")

@Inheritance(strategy=SINGLE_TABLE, discriminatorType=STRING, discriminatorValue="CUSTOMER")

@DiscriminatorColumn(name="DISC", length=20)

public class Customer { ... }

web.xml的配置¶

在web.xml中添加

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

classpath:/applicationContext-resources.xml

classpath:/applicationContext-dao.xml

classpath:/applicationContext-service.xml

classpath*:/applicationContext.xml

/WEB-INF/applicationContext*.xml

/WEB-INF/security.xml

/WEB-INF/dealer-security.xml

</param-value>

</context-param>



<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<listener>

<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>

</listener>

<listener>

<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>

</listener>

事务的配置¶

<aop:config>

<aop:advisor id="managerTx" advice-ref="txAdvice" pointcut="execution(* *..service.*Manager.*(..))" order="0" />

</aop:config>



<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="find*" read-only="true"/>

<tx:method name="search*" read-only="true"/>

<tx:method name="get*" read-only="true"/>

<tx:method name="*"  rollback-for="Throwable"/>

</tx:attributes>

</tx:advice>

ApplicationContext.xml的配置（spring bean 的配置）¶

<!--ProductManager-START-->

<bean id="productManager" class="com.eryiju.service.product.impl.ProductManagerImpl">

<constructor-arg ref="productDao" />

<property name="brandDao" ref="brandDao"></property>

</bean>



<!--ProductManager-END-->

<bean id="productDao" class="com.eryiju.dao.product.impl.ProductDaoHibernate">

<property name="sessionFactory" ref="sessionFactory"></property>

</bean>



<bean id="brandDao" class="com.eryiju.dao.product.impl.BrandDaoHibernate">

<property name="sessionFactory" ref="sessionFactory"></property>

</bean>

常见问题¶

如何与hibernate整合¶

<!-- Hibernate SessionFactory -->

<bean id="sessionFactory" 

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<property name="dataSource" ref="dataSource" />

<property name="configLocation" value="classpath:hibernate.cfg.xml" />

<property name="hibernateProperties">

<value>

hibernate.dialect=${hibernate.dialect}

hibernate.query.substitutions=true 'Y', false 'N'

hibernate.cache.use_second_level_cache=true

hibernate.cache.use_query_cache=true

hibernate.cache.provider_class=com.eryiju.util.cache.EhCacheProvider

hibernate.show_sql=false

hibernate.connection.release_mode=after_statement

hibernate.cglib.use_reflection_optimizer=false

hibernate.search.default.directory_provider=org.hibernate.search.store.FSDirectoryProvider

hibernate.search.default.indexBase=/opt/dev/static/index

hibernate.jdbc.batch_size=50

hibernate.jdbc.fetch_size=50

</value>

<!-- Turn batching off for better error messages under PostgreSQL -->

</property>

</bean>

h2. (1)使用spring过滤器解决中文问题



在web.xml中添加：

<filter>

<filter-name>Spring character encoding filter</filter-name>

<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>GBK</param-value>

</init-param>

</filter>



<filter-mapping>

<filter-name>Spring character encoding filter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>



h2. (2)将applicationContext.xml分解成多个文件



applicationContext-common.xml

"dataSource" 

"sessionFactory" 

事务相关



applicationContext-dao.xml

UserDAO



applicationContext-biz.xml

UserManager



applicationContext-action.xml

Action



struts-config.xml中要作修改：

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

<set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext-*.xml" />

</plug-in>   

h2. Spring2.0中的注解实现事务管理



第一步:引入<tx:>命名空间 ,在spring的配置文件中修改, beans根元素里多了三行,如下

Xml代码



<?xml version="1.0" encoding="UTF-8"?>  

<beans  

xmlns="http://www.springframework.org/schema/beans"  

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

xmlns:tx="http://www.springframework.org/schema/tx"  

xsi:schemaLocation="http://www.springframework.org/schema/beans   

http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   

http://www.springframework.org/schema/tx   

http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"> 



第二步:在spring的配置文件中修改,将所有具有@Transactional 注解的bean自动配置为声明式事务支持

Java代码



<!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器 -->    

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  

<property name="dataSource">  

<ref local="dataSource"/>  

</property>  

</bean>     



<!-- 用注解来实现事务管理 -->  

<tx:annotation-driven transaction-manager="transactionManager"/>  



第三步: 在接口或类的声明处 ,写一个@Transactional. 要是只的接口上写, 接口的实现类就会继承下来.

接口的实现类的具体方法,还可以覆盖类声明处的设置.

Java代码



@Transactional

public class TestPOAOImpl extends POAOBase implements TestPOAO  

{     

@Transactional(isolation = Isolation.READ_COMMITTED)  

public void test1()  

{  

String sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解赵云',30)";  

execute(sql);  



sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解张飞',26)";  

execute(sql);  



int a = 9 / 0; //异常  



sql = "INSERT INTO sy_test (NAME,AGE) VALUES('注解关羽',33)";  

execute(sql);  

System.out.println("走完了");  

}  

//execute() 方法略...  

} 



注意的几点:



1 @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.

2 默认情况下,一个有事务方法, 遇到RuntiomeException 时会回滚 .  遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .

安装¶

sudo apt-get install mysql

命令行操作¶

登录¶

mysql -u用户名 -p密码 -h数据库地址(ip) 数据库名称

注意：尽量不要在-p后直接跟密码，否则其他人很容易通过查阅命令行历史记录（比如，history命令）看到你的密码。

SQL参考¶

MySQL参考¶

常见数据类型¶

integer(11) 11位字节的整数
tinyint(1)
bigint(20)
decimal(10,2) 小数
varchar(20) 最长为20位字节的可变字符串
char(20) 最长为20位字节的定长字符串(定长指的是存储空间定长)
text 文本,用于存大量不固定长度的文本信息
blob 二级制信息

常见函数¶

length(str) 字符串的长度
trim(str) 去掉字符串前后的空格
substring(str,1) 获取子串
convert(str using gbk) 将字符串转化为gbk编码
reverse(str) 倒序

增删改查¶

insert into product (sku,name) values ('123456','productname')

向表中添加sku=123456,name='productname' 的数据

update product set name='updated product name' where sku='123456'

将表product中的sku为'123456'的数据的name字段的值设置为'updated product name'

select sku,name from product where sku='123456'

从表product 中查询 sku为'123456'的数据

delete from product where sku='123456'

其他操作实例¶

多表查询¶

select p.sku,b.name from product p,brand b where p.brand_id=b.id and p.sku='123456'

子查询¶

select p.sku,p.name from product p where p.brand_id in (select id from brand where id=123)

左连接¶

select p.sku,p.name,b.name from product p left join brand b on p.brand_id=b.id

从一个表导入数据到另一个表¶

insert into product1 (sku,name,brand_id) (select sku,name,brand_id from product2)

查找不同的数据¶

select distinct p.sku from product p

查询时按照某个字段排序(asc升序，desc降序)¶

select * from product order by name desc

常见问题¶

如何创建表¶

CREATE TABLE  product (

`sku` char(6) NOT NULL COMMENT '商品的唯一标识\n',

`brand_id` int(11) default NULL,

`name` varchar(50) default NULL,

PRIMARY KEY  (`sku`),

CONSTRAINT `brand_fk_constraint` FOREIGN KEY (`brand_id`) REFERENCES `brand` (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8

如何创建外键¶

alter table product add CONSTRAINT `brand_fk_constraint` FOREIGN KEY (`brand_id`) REFERENCES `brand` (`id`)

如何修改表中的字段¶

alter table product modify name varchar(200)

如何向表中添加字段¶

alter table product add comment varchar(200)

如何删除表中字段¶

alter table product drop name

存储过程和触发器¶

h3.mysql创建表

drop table if exists news;

/*==========================*/
/* Table: 消息表 */
/*==========================*/
create table news
(
NewsId bigint(20) not null unsigned primary key auto_increment,
NewsContext varchar(50) not null,
NewsType varchar(50) not null,
UsersId int(11) not null
);
alter table news add constraint FK_Id foreign key (NewsId)
references users (UsersId);

资源¶

官方参考：http://dev.mysql.com/doc/