项目笔记二

@Transaction 注解（指需要开启事务管理，可以每个方法开一个事务）

任意一个类都是Class类（带有一个私有的构造函数）的实例对象，任何一个类都有一个隐含的静态成员变量class

Class c1=Foo.class

Class c2=foo.getClass()

Class c3=Class.forName("xxx.Foo")

Foo foo=(Foo)c1.newInstance()

new 创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类；动态加载类，则在运行时加载

反射就是在编译之后的操作

java中集合的泛型是为了防止错误输入，编译阶段检查，可以反射（操作字节码）绕过泛型

ArrayList<String> list = new ArrayList<String>();

list.add("hello");  // list.add(20);X

Class c1 = list.getClass();

Method m = c1.getMethod("add",Object.class);

m.invoke(list,100);

}

forward:仅是容器中控制器的转向，客户端不显示转向后的地址，一次请求

redirect:重定向，url可见，两次请求

java是编译型语言，javascript是解释型语言

equals比较两个对象内容是否相等，重写哈希，==比较两个变量地址

装箱：将基本数据类型用引用类型包起来，使具有对象特性

拆箱：将Integer这样的引用类型简化为基本数据类型。

struts是一个按MVC模式设计的WEB层框架，本质是一个大大的servlet（ActionServlet），再通过一个配置文件（struts-config.xml）将各个请求分配给不同的Action处理

hibernate：配置configuration对象，产生sessionfactoty，创建session对象，启动事务，完成curd操作，提交操作，关闭session

<beans.../>是spring配置文件的根元素

<bean.../>是<beans,,,/>的子元素，每一个<bean.../>定义一个bean，每个bean对应spring里的一个java实例

id：确定该bean的唯一标识

class：指定该bean的具体实现类，不能是接口，spring会直接使用new关键字创建该bean的实例，要提供类名（通过BeanFactory.getBean）

javabean：特殊的java类，get，set，默认的无参构造器

默认情况下，spring创建ApplicationContext容器时，spring会自动初始化容器中所有singleton实例，可通过给bean增加lazy-init="true"来禁止，让该bean只在第一次调用时才实例化<bean scope="singleton" lazy-init="true" />

<bean scope="prototype" />非单例每次请求该bean时都实例化

hibernate的session持有一个必选的一级缓存，save（）的每一个实例都将在session级别的缓存区进行判断缓存，可定义一个累加器，每加20个数据，调用session.flush();session.clear();

hibernate的sessionfactory持有一个可选的二级缓存

<property name="hibernate.cache.use_second_level_cache">true</property><property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

hashCode在运用哈希算法的集合中（HashSet、HashMap）的检索、修改发挥了很大的作用（引发内存泄露，修改了参与哈希计算的字段，delete时该删的没有删，却以为删了，或者资源没有释放）

通过哈希算法，将集合划分区域，计算该对象的hashcode，再放进对应的区域，下次检索直接去该区域，大大提升对象检索性能。

HashSet 无序不重复（计算hashcode，调用contains）

简化框架原理

InputStream ips = new FileInputStream("config.properties");Properties pros = new Properties();pros.load(ips);ips.close();String classname = pros.getProperty("classname");(Collection)Class.forName(classname).newInstance();

struts2:无入侵式设计，不依赖servletApi,strutsApi,提供拦截器，提供类型转换器，对指定方法进行校验，适用多种表现层技术，核心是过滤器StrutsPrepareAndExecuteFilter，每来一个请求，新开一个action实例，由包来管理action

建议用BufferReader包装FileReader,InPutStreamReader,包装成高效流。BufferInPutStream

每一个方法执行时，每个方法都会建立自己的内存栈，方法内定义的局部变量会逐个放入这个栈中，方法结束，栈内存也跟着销毁。比堆数据回收快

Person p = new Person();创建一个Persion实例，并赋给变量P（引用变量）引用变量里放的是地址（栈中）

final是修饰符，修饰的类不能继承，不能派生出子类，修饰的方法，不能被重载，修饰的变量使用中不能被修改，且声明是必须初始化

finally是异常处理时，用来做一些最后清理工作的代码块

finalize是垃圾回收器在回收对象前调用的一个方法，做一些必要的清理工作

sleep()是线程类的方法，它会导致线程暂停执行指定的时间，让出CPU给其他线程，但它不会释放对象锁，监控状态依然保持

wait()是Object类方法，如果针对一个对象调用wait()方法，会导致本线程放弃对象锁，进入阻塞，只有针对该对象发出notify()方法或notifyAll(),它才会重新获得竞争锁的机会（进入就绪）

ObjectOutPutStream oos = new ObjectOutPutStream (new FileOutPutStream("t.tmp"));oos.writeInt(123);oos.writeObject("Toay");oos.writeObject(new Date());oos.close();ObjectInPutStream ios = new ObjectInPutStream (new FileInPutStream("t.tmp"));int i = ios .readInt();String today = (String)ios .readObject();Date date = (Date)ios.readObject();ios.close();

spring有两个核心接口 BeanFactory 和 ApplicationContext ,其中ApplicationContext是BeanFactory的子接口

struts主要充当控制层，负责接收用户发送过来的请求，分派action，转发视图，action里去调用业务逻辑层封装好的功能

string主要用来协调各组件组件的依赖关系，是生成和管理Bean的工厂，而bean究竟是什么，在spring中，任何java对象、java组件都是bean，包括数据源、事务管理等

web.xml中配置listener，应用启动将会初始化spring容器

通过依赖注入，各组件之间不需要硬编码方式耦合在一起

悲观锁：每次操作数据库时都加锁

乐观锁：操作数据库时不加锁，通过增加一个版本字段，由数据库的版本来标识

项目经理：首先对系统做一个初步的规划，先明确客户端需求，明确服务器端需求，再进行系统的易用性分析、安全性、可维护性、可扩展性分析，再到具体的功能模块设计，该用什么设计模式，一个类有什么样的行为，类与类之间又有什么样的依赖关系，尽量做到统一面向接口编程、面向抽象编程。
类加载器：1、加载，加载class进内存中，为之创建一个class对象；2、连接，验证语法结构，并为静态成员分配内存；3、初始化

线程连接池：ExecutorService

new SingleThreadExecutor

new FixedThreadPoor(..);

new CacheThreadPoor();//智能判断回收线程

load()永远不会返回空，而是返回代理对象，实体类new出的一个实例，到真正用到的时候才向数据库发出sql语句

persist()内部还是save()，但区别是没开事务情况下，save()会向数据库插入数据，再回滚，persist()则根本不会插入数据库

控制反转IOC：控制权的转移，对象的创建、维护不再由应用程序本身创建，而是交由第三方容器spring来统一装配和管理

spring是一种轻量级、无入侵式的框架，大大降低了程序开发的复杂度，让程序员更好地养成面向接口编程的习惯。

依赖注入：通过大量引入java的反射机制，动态调用，避免硬编码的约束

二级缓存不适合用于数据量大，经常修改的数据，数据量大会引起内存资源紧张，降低性能

数组是一种效率最高的存储和随机访问对象引用序列的方式，数组是一个简单的线性序列，使得访问元素速度非常快速

通过数组、泛型，我们可以参加一个数组、泛型去持有某种具体类型，这意味着我们可以通过编译期检查，防止插入错误类型数据

new Timer().schedule(new TimerTask(){},3000)

事务隔离级别

读未提交     读已提交     可重复读     序列化

hibernate对jdbc做了封装，程序员可以使用面向对象思维来操作数据库。5个接口：session、sessionFaction、query、transaction、configuration

struts2：客户端发送请求--请求经过一系列过滤器--在ActionMapper中决定是否调用某Action--请求交给ActionProxy--找的configuration询问框架配置文件，找的目标Action类--创建一个ActionInvocation实例，中间会经过一些拦截器--做相应业务处理--返回视图

ArrayList底层数据结构是数组，LinkedList底层数据结构是链表，HashMap底层数据结构是数组+链表，数组的每一项元素又是一个链表Map.Entry就是一个key-value对，它还持有指向下一个元素的引用，vector扩容是原来的2倍

同步collections.synchronizedArrayList

并发concurrent包，concurrentHashMap

HashMap继承自AbstractMap，实现Map默认初始容量是16，加载因子0.75，加载因子表明元素可以达到多满的一种尺度，衡量一个散列表的空间使用尺度，负载因子越大，散列表填装程度越高，但查找效率低

Hashtable继承自Dictionary,线程安全，使用了“fail-fast”，快速失败机制，在对并发集合hashtable进行迭代操作时，如果有其他线程对其进行结构性的修改时，迭代器会马上感知，并立即抛出异常，而不是等到迭代完成之后才告诉你出错了，不允许出现空的key或value，默认初始容量11，加载因子0.75

新建一个HashMap时，会初始化一个数组，数组的元素为Entry节点。Entry是HashMap的内部类，包含key、value、next、hashcode

int hash = hash(key.hashcode());

TCP/IP协议

网络接口层--网络层--传输层--应用层

eclipse中dropins文件夹可放插件。

float的div在ie6下margin会加倍，解决方案加display：inline

数据库三大范式

1、每个字段是不可再分的最小数据单位（每列保持原子性）

2、确保每列都和主键相关（有主键）

3、确保每列都和主键直接相关，而不是间接相关（避免冗余，能从其他表推断出来的字段就不要放在本表）

window：分区管理目录

Linux：分区加载于目录，通过根元素"/"，加载子文件目录下的分区

1、Iterator it = c1.iterator();

while(it.hashNext()){}

2、for(Iterator it = c1.iterator();it.hashNext();){}

用for比while效率高，遍历后，引用对象it已成垃圾

ExecutorService pool = Executors.newFieldThreadPool(2);

pool.submit(new MyRunnable());

pool.shutdown();

serversocket--socket

二维数组其实是一个一维数组，只是它的每一个元素又是一个一维数组，二维数组不允许高维度没分配空间就给低维空间分配空间。

memcache：分布式的、高效的键值对数据缓存系统，在dao层去持有一个memcacheClient实例，相对redis，不能持久化，格式简单，不支持list，array，客户端程序简单配置就可以实现分布集群，serverlist

memcached -d(以守护线程) -l 127.0.0.1 -p 11211 0-m(分配内存) -u root

cache：在我们的应用服务器与数据库之间开出一块内存，做一个缓存层

体现在1、查询时findfirstcache、findsecondcache、finddb

2、插入，如微信群，达到一定量是再刷入数据库

http协议：请求头（accept-encoding内容编码）、响应头（content-type正文的媒体类型）、状态码

redis：一种高效的键值对数据缓存系统，它支持存储字符串、list链表、set集合、支持add/remove,push/pop,各种交集、并集、差集操作

redis高效是因为数据缓存在内存中，而传统数据库时存在磁盘中。redis库直接管理键值对，关系型数据库通过表来管理数据跟维护表

127.0.0.1 6379

五种数据类型

string：set、get

list：lpush、lpop、rpush、rpop，双向链表，可从链头或链尾来添加或删除数据，即可作栈又可作队列

set：sadd、spop、sdiff（差集）、sunior（并集）、sinter（交集）

hash：只有hash是二维的，适于存储对象，hset、hdel、hkeys

redis支持主从复制master--salve

redis支持事务，开启事务（multi）、执行事务（exec）、取消事务（discard），事务有缺陷，出错了，之前的命令不会回滚

java中用jedis来操作redis，jedis.jar

Jedis jedis = new Jedis("localhost");

jedis.ping();

jedis.get("name");

webservice是一种跨平台、跨语言的规范，主要用来解决不同平台、不同语言编写的应用之间接口互调的问题。

@webservice

public interface A{

public void say(String name);

}

@webservice(endpointinterface="xxx.A",serviceName="xxx.B")

public class B implements A{

@override

}

A a = new B();

EndPoint.publish("http://....",a);//发布服务

Nginx 反向代理服务器，web服务器，http处理

反向代理服务器作用在服务端

正向代理服务器作用在客户端，翻墙软件

nginx.conf

server 127.0.0.1 8080 weight=1;配置权重

server 127.0.0.1 8088 weight=2;

server{

listen 80;监听端口

springmvc基于dispatcherservlet的mvc框架，请求最先经过dispatcherservlet，再把请求转发给handlermapping，由handler去处理url，再返回视图和模型。handler又是基于两个注解@controller和@requestmapping

@Target（{ElementType.Method,ElementType.type}）元注解

@Retention(RetentionPolicy.Runtime)

public @interface xxx{

}

public interface Advice{//增强接口

void beforem(Method m);//前置增强方法

void afterm(Method m);//后置增强方法

}

//增强实现类

代理类{

private Advice advice;//增强对象

private Object target;//目标对象

public Object getProxy(){

Object proxy = Proxy.newProxyInstance(target.getClas().getClassLoader(),target.getClass().getInteraces(),new InvocationHandler(){

invoke(Object proxy,Method method,Object[] args){

advice.beforem(method);

Object o = method.invoke(target,args);

advice.afterm(method);

return o;

}

})

}

}

定义增强接口，作为功能切入，创建接口的实现，重写invocationhandler里的invoke方法，在invoke里去持有定义的增强实例，做代理

数据库连接池 datasource

LinkList<Connection> 增删速度快，用的时候从链头取，不用了放到链尾回收连接

对象池，维持一定数量的连接connection

DriverManager.getConnection(url,user,password);

hibernate优化：表字段尽可能少，关联可以多；不用一对一，用多对一，在一对多、多对一关系中，使用延迟加载；适当使用session.clear()去清理缓存或对象

jvm 

堆：线程共享区域，存放对象

栈：线程私有栈，存放局部变量，对象地址，指令地址

方法区：线程共享区域，存放虚拟机加载的类信息、常量、静态变量

本地方法张：本地方法执行

堆内存不够分配，无法扩展，线程调度深度超出限制，引发内存溢出

分三个代：年轻代、年老代、持久代

年轻代分一个Eden区，两个survivior区（大部分对象在Eden区中生成，Eden区满时复制到survivor区，survivor区满时再复制到另一个survivor区，若survivor区满，还存活的对象复制到年老区）

年轻代存放生命周期较短的对象

年老代存放生命周期较长的对象

持久代存放静态文件，类，方法等，如hibernate这种动态生成或调用较多类的应用，可以设置大一些的内存-XX:maxpermsize=...

分析堆快照，一般先用jmap生成堆快照文件，将文件拖进eclipse即可

Jmap-dump:format=b,file=c:\fl.bin  //  将堆内存信息输出代fl.bin里

-XX:HeapDumpPath=....

-XX:HeapDumpOnOutOfMemoryError     //  遭遇OOM时导出堆中的相关信息

cdn 内容分发网络

（用户与服务器之间增加cache缓存层，将用户请求引导到cache节点，而不是服务器源站点）

原则：位置最近，路由最短，负载最轻

申请腾讯云CDN，填写域名和网站所在IP，设置缓存期，js、jpg等图片的缓存时间可以设置长一点

MyISAM

InnoDB：对MyISAM的进一步更新，支持事务、外键约束、行级锁、索引等

alter table xxx engine = xxx

jvm 垃圾回收算法：引用计数器算法，实现简单，高效率，但不能解决循环引用问题

复制算法：内存分相等两块，复制后清理掉内存

标记-整理算法

分代收集：根据对象存活时间，分新生代和老年代（新生代用复制算法，老年代用标记-整理算法）

新生代内存设置过小，新生代GC频繁，消耗大，大对象直接进入旧生代，占据空间，诱发FullGC

survivor过小，对象从Eden区直接进入旧生代

survivor过大，Eden过小，增加GC频率

尽量让对象在新生代被回收

年轻代：年老代（1:3比较合理）

哈希算法：把任意长度的输入，变成固定长度的输出，用在快速查找、加密

Java给每一个对象都提供了一个内部锁，在方法的定义中加上关键字synchronized后，那么对象的锁将保护整个方法。synchronized实现原理就是Java为每一个对象都内置了一个锁。对于一个类的普通方法来说，synchronized锁住的是每一个new出来的对象的方法。对于一个静态方法而言，synchronized则成为了一个类锁，T只要有一个对象占用了线程锁，其他的所有对象方法都会阻塞，因为静态方法是类的所有对象都共享的。

select m* from table , 返回的ResultSet并没有查询出所有的数据，而是只查询了一部分数据放到ResultSet,数据“用完”它 会自动查询下一批数据，你可以用setFetchSize(int rows)方法设置一个建议值给ResultSet,告诉它每次从数据库Fetch多少条数据。但是一般不赞成这种做法，因为JDBC驱动会根据实际情况自动调整 Fetch的数量。另外性能也与网线的带宽有直接的关系。

悲观锁(Pessimistic Locking):       

 悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自 外部系统的事务处理）修改持保守态度，因此，

在整个数据处理过程中，将数据处于锁定状态。

悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能 真正保证数据访问的排他性，否则，即使在本系统
中实现了加锁机制，也无法保证外部系 统不会修改数据）。 
       一个典型的倚赖数据库的悲观锁调用： 
       select * from account where name=”Erica” for update
       这条 sql 语句锁定了 account 表中所有符合检索条件（ name=”Erica” ）的记录。
       本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。 
       Hibernate 的悲观锁，也是基于数据库的锁机制实现。 
       下面的代码实现了对查询记录的加锁：
       String hqlStr ="from TUser as user where user.name='Erica'";
        Query query = session.createQuery(hqlStr);
        query.setLockMode("user",LockMode.UPGRADE); // 加锁
       List userList = query.list();// 执行查询，获取数据
       query.setLockMode 对查询语句中，特定别名所对应的记录进行加锁（我们为 TUser 类指定了一个别名 “user” ），这里也就是对
      返回的所有 user 记录进行加锁。 
      观察运行期 Hibernate 生成的 SQL 语句： 
      select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id
      as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex
      from t_user tuser0_ where (tuser0_.name='Erica' ) for update
     这里 Hibernate 通过使用数据库的 for update 子句实现了悲观锁机制。 
      Hibernate 的加锁模式有： 
      Ø LockMode.NONE ： 无锁机制。 
      Ø LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动获取
      Ø LockMode.READ ： Hibernate 在读取记录的时候会自动获取。 
      以上这三种锁机制一般由 Hibernate 内部使用，如 Hibernate 为了保证 Update
      过程中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。 
      Ø LockMode.UPGRADE ：利用数据库的 for update 子句加锁。 
      Ø LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 for
      update nowait 子句实现加锁。 
      上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现： 
      Criteria.setLockMode
      Query.setLockMode
      Session.lock
      注意，只有在查询开始之前（也就是 Hiberate 生成 SQL 之前）设定加锁，才会 
      真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含 for update
      子句的 Select SQL 加载进来，所谓数据库加锁也就无从谈起。

select * from T1 where T1.a in (select T2.a from T2) ”     
这里的“in”后面括号里的语句搜索出来的字段的内容一定要相对应，一般来说，T1和T2这两个表的a字段表达的意义应该是一样的，否则这样查没什么
select * from T1 where exists(select 1 from T2 where T1.a=T2.a) ;     
T1数据量小而T2数据量非常大时，T1<<T2 时，1) 的查询效率高。

instr（）返回值是目标字符（串）在母字符里第一次出现的位置，故而是整数。
例如：
instr("efabcdefg","e")的结果当然是1
instr(2，"efabcdefg","e")的结果就是7
instr(5，"efabcdefg","a")的结果就是0
instr("efabcdefg","k")的结果也是0
instr是内置函数，他是会走索引的，性能好。

like不一定：like '%iii%'是不走索引的，like 'ik%'走索引。

hashmap,基于哈希表的对Map接口的一种非同步实现。通过研究源码可以知道hashmap也是基于哈希表即散列表的键值对存储集合，内部是通过定义一个命名为table的entry静态内部类数组，entry里面放的是key，value，指向下一个元素的next引用和index，所有，我们又可以知道，hashmap底层数据结构是基于数组和链表。这样的结构组合又决定了hashmap对元素的存取和遍历的特殊性（涉及哈希算法）。get跟set时，通过hashcode哈希算法，定位内存地址，移位和异或运算，得到的index更加均匀，也是让元素分布更均匀些。最大程度上优化性能，减少去遍历链表的时间，通过定义一个结构性改变次数变量modcount来实现迭代时快速失败原理。concurrenthashmap优于hashtable的对map接口的同步实现。concurrenthashmap实现分段锁，hashtable还是基于synchronized的同步块，synchronized执行时间过长的话造成效率低下。

explain tbl_name等价于describe tbl_name等价于show columns from tbl_name
throw new IllegalArgumentException("非法数据异常");抛出非法数据异常.
throw new RuntimeException(e)抛出运行时异常,一般在catch块中执行，阻止程序继续运行
String valArray[] = null;
if (s == null) {
 throw new IllegalArgumentException();
}
基于最基本的IOC容器接口BeanFactory，定义了IOC容器的基本行为和其实现类的遵守规范，它只提供顶层的接口抽象，不关心具体的细节实现，而是由具体的IOC容器来对它做具体的实现如xmlBeanFactory,ClassPathXmlApplicationContext,
对于xmlBeanFactory,spring设计AbstractBeanFactory,DefaultListableBeanFactory这些抽象类为其提供模板服务。其中通过resource 接口来抽象bean定义数据，对Xml定义文件的解析通过委托给XmlBeanDefinitionReader来完成。

ClassPathResource res = new ClassPathResource("beans.xml");  DefaultListableBeanFactory factory = new DefaultListableBeanFactory();  XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);  reader.loadBeanDefinitions(res);

heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。 非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。
索引是通过二叉树的数据结构来描述的，我们可以这么理解聚簇索引：索引的叶节点就是数据节点。在聚集索引中，叶结点也即数据结点，所有数据行的存储顺序与索引的存储顺序一致。而非聚簇索引的叶节点仍然是索引节点，只不过有一个指针指向对应的数据块。聚簇索引中键值的逻辑顺序决定了表中相应行的物理顺序
B-Tree不同于Binary Tree（二叉树，最多有两个子树）
Dubbo是一个分布式服务框架，大规模服务化之前，应用可能只是通过RMI或Hessian等工具，简单的暴露和引用远程服务，通过配置服务的URL地址进行调用，通过F5等硬件进行负载均衡。
服务提供者暴露接口，服务消费者订阅请求。出现断电等异常停机时，注册中心能自动删除提供者信息。注册中心重启时，能自动恢复注册数据，以及订阅请求。
服务注册中心，动态的注册和发现服务，使服务的位置透明。实现软负载均衡，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
TCP长连接：Client与server完成一次读写之后，它们之间的连接并不会主动关闭，后续的读写操作会继续使用这个连接。长连接不可能无限期的拿着，会有一个超时时间connection:Keep-Alive,Keep-Alive: timeout=20，表示这个TCP通道可以保持20秒。另外还可能有max=XXX，表示这个长连接最多接收XXX次请求就断开。
i和g只是版本的代号，指oracle运用的技术
i代表Internet就是互联网技术
g代表grid就是网格技术
现在出的最新版是c就是cloud也就是云技术
Kettle数据的同步和抽取，Kettle中有两种脚本文件，transformation和job，transformation完成针对数据的基础转换，job则完成整个工作流的控制。
表空间：是一个或多个数据文件的集合，存放数据对象，主要是表
表分区：只是将表中的数据在物理上存放到多个表空间(物理文件上)，这样查询数据时，不至于每次都扫描整张表。每个分区有自己的名称，还可以选择自己的存储特性。
每一个分区都必须有一个VALUES LESS THEN子句，它指定了该分区中的上限值。所有分区，除了第一个，都会有一个隐式的下限值，这个值就是此分区的前一个分区的上限值。
分区键的任何值等于或者大于这个上限值的记录都会被加入到下一个高一些的分区中。
范围分区
PARTITION BY RANGE (ID) 
( 
    PARTITION PART1 VALUES LESS THAN (100000) TABLESPACE TS01, 
    PARTITION PART2 VALUES LESS THAN (200000) TABLESPACE TS02 
)
PARTITION BY RANGE (ORDER_DATE) 
(
  PARTITION ORD_ACT_PART01 VALUES LESS THAN (TO_DATE('01- MAY -2003','DD-MON-YYYY')) TABLESPACEORD_TS01,
  PARTITION ORD_ACT_PART02 VALUES LESS THAN (TO_DATE('01-JUN-2003','DD-MON-YYYY')) TABLESPACE ORD_TS02,
  PARTITION ORD_ACT_PART02 VALUES LESS THAN (TO_DATE('01-JUL-2003','DD-MON-YYYY')) TABLESPACE ORD_TS03
)
列表分区
PARTITION  BY  LIST (area) 
( 
    PARTITION  part1 VALUES ('guangdong','beijing') TABLESPACE  Part1_tb, 
    PARTITION  part2 VALUES ('shanghai','nanjing')  TABLESPACE  Part2_tb 
);

nvl(num, 0) AS num
sum(decode(id, 1, money/100, 0)) as money
table1 a left join table2 b on a.id = b.id
left join table3 c on a.name = c.name
to_date('2012-12-12','yyyy-mm-dd')
select id,name ,count(1) from table group by id,name
with a as (select '张三,李四'|| ',' name from dual) , 
     b as (select regexp_substr(name,'[^,]+',1,rownum) name from a connect by rownum <= length(regexp_replace(name,'[^,]+')))
case when id='1' and name='2' then '12' else 
     case when id='2' and name='1' then '21' else 
          case when id='1' and name='0'  then '10' else 
          '00' 
          end 
      end 
end
('1,2,3' IS NULL OR t1.changetype IN ('1','2','3')) and  instr(',' || replace(name1,';',',') || ',',',' || name2 || ',') > 0
decode(sign(sum(decode(id, 1, money/100, 0))), 1, sum(decode(id, 1, money/100, 0)), 0)
decode(sign(sum(decode(id, 2, money/100, 0))), -1, sum(decode(id, 1, money/100, 0)), 0)

CREATE OR REPLACE PROCEDURE PROC_1(OUTPUT_NUM OUT NUMBER)  AUTHID CURRENT_USER AS
  v_sql1 varchar2(8000);
  v_sql2 varchar2(8000);
  v_sql3 varchar2(500);
  v_sql4 varchar2(8000);
  v_day DATE := TRUNC(
      sysdate,
      'dd') - 1
BEGIN
  for i in (select null
              from table
             where table_name = upper('TABLE_TEMP1')) loop
    execute immediate 'drop table TABLE_TEMP1';
  end loop;
COMMIT;
EXCEPTION
WHEN OTHERS THEN
COMMIT;
END