POI操作Excel

posted @ 2020-03-20 10:13 鸿雁 阅读(105) | 评论 (0) | 编辑 收藏

python操作文件存在的问题解决办法

posted @ 2019-05-14 23:04 鸿雁 阅读(153) | 评论 (0) | 编辑 收藏

Hadoop-2.4.1学习之QJM HA的自动故障转移

前面学习了使用命令hdfs haadmin -failover手动进行故障转移，在该模式下，即使现役NameNode已经失效，系统也不会自动从现役NameNode转移到待机NameNode，下面学习如何配置部署HA自动进行故障转移。自动故障转移为HDFS部署增加了两个新组件：ZooKeeper和ZKFailoverController（ZKFC）进程。ZooKeeper是维护少量协调数据，通知客户端这些数据的改变和监视客户端故障的高可用服务。HA的自动故障转移依赖于ZooKeeper的以下功能：

• 故障检测：集群中的每个NameNode在ZooKeeper中维护了一个持久会话，如果机器崩溃，ZooKeeper中的会话将终止，ZooKeeper通知另一个NameNode需要触发故障转移。
• 现役NameNode选择：ZooKeeper提供了一个简单的机制用于唯一的选择一个节点为active状态。如果目前现役NameNode崩溃，另一个节点可能从ZooKeeper获得特殊的排外锁以表明它应该成为现役NameNode。

       ZKFC是自动故障转移中的另一个新组件，是ZooKeeper的客户端，也监视和管理NameNode的状态。每个运行NameNode的主机也运行了一个ZKFC进程，ZKFC负责：

• 健康监测：ZKFC使用一个健康检查命令定期地ping与之在相同主机的NameNode，只要该NameNode及时地回复健康状态，ZKFC认为该节点是健康的。如果该节点崩溃，冻结或进入不健康状态，健康监测器标识该节点为非健康的。
• ZooKeeper会话管理：当本地NameNode是健康的，ZKFC保持一个在ZooKeeper中打开的会话。如果本地NameNode处于active状态，ZKFC也保持一个特殊的znode锁，该锁使用了ZooKeeper对短暂节点的支持，如果会话终止，锁节点将自动删除。
• 基于ZooKeeper的选择：如果本地NameNode是健康的，且ZKFC发现没有其它的节点当前持有znode锁，它将为自己获取该锁。如果成功，则它已经赢得了选择，并负责运行故障转移进程以使它的本地NameNode为active。故障转移进城与前面描述的手动故障转移相似，首先如果必要保护之前的现役NameNode，然后本地NameNode转换为active状态。

       在典型部署中，ZooKeeper守护进程运行在三个或者五个节点上，但由于ZooKeeper本身需要较少的资源，所以将ZooKeeper部署在与现役NameNode和待机NameNode相同的主机上，还可以将ZooKeeper部署到与YARN的ResourceManager相同的节点上。建议配置ZooKeeper将数据存储在与HDFS元数据不同的硬盘上以得到最好的性能和隔离性。在配置自动故障转移之前需要先停掉集群，目前在集群运行时还不可能将手动故障转移的安装转换为自动故障转移的安装。接下来看看如何配置HA的自动故障转移。首先在hdfs-site.xml中添加下面的参数，该参数的值默认为false：

       在core-site.xml文件中添加下面的参数，该参数的值为ZooKeeper服务器的地址，ZKFC将使用该地址。

       在HA或者HDFS联盟中，上面的两个参数还需要以NameServiceID为后缀，比如dfs.ha.automatic-failover.enabled.mycluster。除了上面的两个参数外，还有其它几个参数用于自动故障转移，比如ha.zookeeper.session-timeout.ms，但对于大多数安装来说都不是必须的。

       在添加了上述的配置参数后，下一步就是在ZooKeeper中初始化要求的状态，可以在任一NameNode中运行下面的命令实现该目的，该命令将在ZooKeeper中创建znode：

       在启用自动故障转移的集群中，start-dfs.sh脚本将在任何运行NameNode的主机上自动启动ZKFC守护进程，一旦ZKFC启动完毕，它们将自动选择一个NameNode为现役NameNode。如果手动管理集群中的服务，需要在每台运行NameNode的主机上手动启动ZKFC，命令为：

       如果正在运行一个安全的集群，可能想确保存储在ZooKeeper中的信息也是安全的，这将阻止恶意的客户端修改ZooKeeper中的元数据或者潜在地触发一个错误的故障转移。为了保护ZooKeeper中的信息，首先在core-site.xml中添加下面的参数：

       参数值中的@字符表示参数值保存在@后的硬盘文件中。第一个配置文件指定了ZooKeeper的认证列表，其格式与ZK CLI使用的相同，例如：digest:hdfs-zkfcs:mypassword，其中hdfs-zkfcs为ZooKeeper的用户名，mypassword为密码。其次使用下面的命令为该认证生成一个ZooKeeper访问控制列表：

       拷贝->之后的字符串并添加digest:前缀，然后粘贴到zk-acls.txt中，例如：digest:hdfs-zkfcs:vlUvLnd8MlacsE80rDuu6ONESbM=:rwcda。要想使ACLs生效，需要再次运行zkfc –formatZK。最后可能像下面这样在ZK CLI中验证ACLs：

       在安装完成自动故障转移后，或许需要测试一下。首先定位现役NameNode，可以通过访问NameNode的web页面来确定哪个NameNode是active状态的。一旦确定了处于active状态的NameNode，就需要在该节点上制造点故障，比如使用命令kill -9 <pid of NN>模拟JVM崩溃，或重启主机或拔掉网线来模拟不同的中断。一旦触发了自动故障转移，另一个NameNode应该自动在几秒钟内变为active状态。检测到故障并触发故障转移由参数ha.zookeeper.session-timeout.ms控制，该参数为与core-site.xml中，默认为5秒。如果测试不成功，可能是配置问题，检查ZKFC和NameNode进程的日志以进一步诊断问题，通常错误都是很明显的。

posted @ 2017-08-13 18:49 鸿雁 阅读(419) | 评论 (0) | 编辑 收藏

Yarn 调度器Scheduler详解

理想情况下，我们应用对Yarn资源的请求应该立刻得到满足，但现实情况资源往往是有限的，特别是在一个很繁忙的集群，一个应用资源的请求经常需要等待一段时间才能的到相应的资源。在Yarn中，负责给应用分配资源的就是Scheduler。其实调度本身就是一个难题，很难找到一个完美的策略可以解决所有的应用场景。为此，Yarn提供了多种调度器和可配置的策略供我们选择。

一、调度器的选择

在Yarn中有三种调度器可以选择：FIFO Scheduler ，Capacity Scheduler，FairS cheduler。

FIFO Scheduler把应用按提交的顺序排成一个队列，这是一个先进先出队列，在进行资源分配的时候，先给队列中最头上的应用进行分配资源，待最头上的应用需求满足后再给下一个分配，以此类推。

FIFO Scheduler是最简单也是最容易理解的调度器，也不需要任何配置，但它并不适用于共享集群。大的应用可能会占用所有集群资源，这就导致其它应用被阻塞。在共享集群中，更适合采用Capacity Scheduler或Fair Scheduler，这两个调度器都允许大任务和小任务在提交的同时获得一定的系统资源。

下面“Yarn调度器对比图”展示了这几个调度器的区别，从图中可以看出，在FIFO 调度器中，小任务会被大任务阻塞。

而对于Capacity调度器，有一个专门的队列用来运行小任务，但是为小任务专门设置一个队列会预先占用一定的集群资源，这就导致大任务的执行时间会落后于使用FIFO调度器时的时间。

在Fair调度器中，我们不需要预先占用一定的系统资源，Fair调度器会为所有运行的job动态的调整系统资源。如下图所示，当第一个大job提交时，只有这一个job在运行，此时它获得了所有集群资源；当第二个小任务提交后，Fair调度器会分配一半资源给这个小任务，让这两个任务公平的共享集群资源。

需要注意的是，在下图Fair调度器中，从第二个任务提交到获得资源会有一定的延迟，因为它需要等待第一个任务释放占用的Container。小任务执行完成之后也会释放自己占用的资源，大任务又获得了全部的系统资源。最终的效果就是Fair调度器即得到了高的资源利用率又能保证小任务及时完成。

Yarn调度器对比图: 

二、Capacity Scheduler（容器调度器）的配置

2.1 容器调度介绍

Capacity 调度器允许多个组织共享整个集群，每个组织可以获得集群的一部分计算能力。通过为每个组织分配专门的队列，然后再为每个队列分配一定的集群资源，这样整个集群就可以通过设置多个队列的方式给多个组织提供服务了。除此之外，队列内部又可以垂直划分，这样一个组织内部的多个成员就可以共享这个队列资源了，在一个队列内部，资源的调度是采用的是先进先出(FIFO)策略。

通过上面那幅图，我们已经知道一个job可能使用不了整个队列的资源。然而如果这个队列中运行多个job，如果这个队列的资源够用，那么就分配给这些job，如果这个队列的资源不够用了呢？其实Capacity调度器仍可能分配额外的资源给这个队列，这就是“弹性队列”(queue elasticity)的概念。

在正常的操作中，Capacity调度器不会强制释放Container，当一个队列资源不够用时，这个队列只能获得其它队列释放后的Container资源。当然，我们可以为队列设置一个最大资源使用量，以免这个队列过多的占用空闲资源，导致其它队列无法使用这些空闲资源，这就是”弹性队列”需要权衡的地方。

2.2 容器调度的配置

假设我们有如下层次的队列：

root ├── prod └── dev     ├── eng     └── science 

下面是一个简单的Capacity调度器的配置文件，文件名为capacity-scheduler.xml。在这个配置中，在root队列下面定义了两个子队列prod和dev，分别占40%和60%的容量。需要注意，一个队列的配置是通过属性yarn.sheduler.capacity.<queue-path>.<sub-property>指定的，<queue-path>代表的是队列的继承树，如root.prod队列，<sub-property>一般指capacity和maximum-capacity。

我们可以看到，dev队列又被分成了eng和science两个相同容量的子队列。dev的maximum-capacity属性被设置成了75%，所以即使prod队列完全空闲dev也不会占用全部集群资源，也就是说，prod队列仍有25%的可用资源用来应急。我们注意到，eng和science两个队列没有设置maximum-capacity属性，也就是说eng或science队列中的job可能会用到整个dev队列的所有资源（最多为集群的75%）。而类似的，prod由于没有设置maximum-capacity属性，它有可能会占用集群全部资源。

Capacity容器除了可以配置队列及其容量外，我们还可以配置一个用户或应用可以分配的最大资源数量、可以同时运行多少应用、队列的ACL认证等。

2.3 队列的设置

关于队列的设置，这取决于我们具体的应用。比如，在MapReduce中，我们可以通过mapreduce.job.queuename属性指定要用的队列。如果队列不存在，我们在提交任务时就会收到错误。如果我们没有定义任何队列，所有的应用将会放在一个default队列中。

注意：对于Capacity调度器，我们的队列名必须是队列树中的最后一部分，如果我们使用队列树则不会被识别。比如，在上面配置中，我们使用prod和eng作为队列名是可以的，但是如果我们用root.dev.eng或者dev.eng是无效的。

三、Fair Scheduler（公平调度器）的配置

3.1 公平调度

Fair调度器的设计目标是为所有的应用分配公平的资源（对公平的定义可以通过参数来设置）。在上面的“Yarn调度器对比图”展示了一个队列中两个应用的公平调度；当然，公平调度在也可以在多个队列间工作。举个例子，假设有两个用户A和B，他们分别拥有一个队列。当A启动一个job而B没有任务时，A会获得全部集群资源；当B启动一个job后，A的job会继续运行，不过一会儿之后两个任务会各自获得一半的集群资源。如果此时B再启动第二个job并且其它job还在运行，则它将会和B的第一个job共享B这个队列的资源，也就是B的两个job会用于四分之一的集群资源，而A的job仍然用于集群一半的资源，结果就是资源最终在两个用户之间平等的共享。过程如下图所示： 

3.2 启用Fair Scheduler

调度器的使用是通过yarn-site.xml配置文件中的yarn.resourcemanager.scheduler.class参数进行配置的，默认采用Capacity Scheduler调度器。如果我们要使用Fair调度器，需要在这个参数上配置FairScheduler类的全限定名： org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler。

3.3 队列的配置

Fair调度器的配置文件位于类路径下的fair-scheduler.xml文件中，这个路径可以通过yarn.scheduler.fair.allocation.file属性进行修改。若没有这个配置文件，Fair调度器采用的分配策略，这个策略和3.1节介绍的类似：调度器会在用户提交第一个应用时为其自动创建一个队列，队列的名字就是用户名，所有的应用都会被分配到相应的用户队列中。

我们可以在配置文件中配置每一个队列，并且可以像Capacity 调度器一样分层次配置队列。比如，参考capacity-scheduler.xml来配置fair-scheduler： 

队列的层次是通过嵌套<queue>元素实现的。所有的队列都是root队列的孩子，即使我们没有配到<root>元素里。在这个配置中，我们把dev队列有分成了eng和science两个队列。

Fair调度器中的队列有一个权重属性（这个权重就是对公平的定义），并把这个属性作为公平调度的依据。在这个例子中，当调度器分配集群40:60资源给prod和dev时便视作公平，eng和science队列没有定义权重，则会被平均分配。这里的权重并不是百分比，我们把上面的40和60分别替换成2和3，效果也是一样的。注意，对于在没有配置文件时按用户自动创建的队列，它们仍有权重并且权重值为1。

每个队列内部仍可以有不同的调度策略。队列的默认调度策略可以通过顶级元素<defaultQueueSchedulingPolicy>进行配置，如果没有配置，默认采用公平调度。

尽管是Fair调度器，其仍支持在队列级别进行FIFO调度。每个队列的调度策略可以被其内部的<schedulingPolicy> 元素覆盖，在上面这个例子中，prod队列就被指定采用FIFO进行调度，所以，对于提交到prod队列的任务就可以按照FIFO规则顺序的执行了。需要注意，prod和dev之间的调度仍然是公平调度，同样eng和science也是公平调度。

尽管上面的配置中没有展示，每个队列仍可配置最大、最小资源占用数和最大可运行的应用的数量。

3.4 队列的设置

Fair调度器采用了一套基于规则的系统来确定应用应该放到哪个队列。在上面的例子中，<queuePlacementPolicy> 元素定义了一个规则列表，其中的每个规则会被逐个尝试直到匹配成功。例如，上例第一个规则specified，则会把应用放到它指定的队列中，若这个应用没有指定队列名或队列名不存在，则说明不匹配这个规则，然后尝试下一个规则。primaryGroup规则会尝试把应用放在以用户所在的Unix组名命名的队列中，如果没有这个队列，不创建队列转而尝试下一个规则。当前面所有规则不满足时，则触发default规则，把应用放在dev.eng队列中。

当然，我们可以不配置queuePlacementPolicy规则，调度器则默认采用如下规则：

<queuePlacementPolicy> <rule name="specified" /> <rule name="user" /> </queuePlacementPolicy> 

上面规则可以归结成一句话，除非队列被准确的定义，否则会以用户名为队列名创建队列。

还有一个简单的配置策略可以使得所有的应用放入同一个队列（default），这样就可以让所有应用之间平等共享集群而不是在用户之间。这个配置的定义如下：

<queuePlacementPolicy> <rule name="default" /> </queuePlacementPolicy> 

实现上面功能我们还可以不使用配置文件，直接设置yarn.scheduler.fair.user-as-default-queue=false，这样应用便会被放入default 队列，而不是各个用户名队列。另外，我们还可以设置yarn.scheduler.fair.allow-undeclared-pools=false，这样用户就无法创建队列了。

3.5 抢占（Preemption）

当一个job提交到一个繁忙集群中的空队列时，job并不会马上执行，而是阻塞直到正在运行的job释放系统资源。为了使提交job的执行时间更具预测性（可以设置等待的超时时间），Fair调度器支持抢占。

抢占就是允许调度器杀掉占用超过其应占份额资源队列的containers，这些containers资源便可被分配到应该享有这些份额资源的队列中。需要注意抢占会降低集群的执行效率，因为被终止的containers需要被重新执行。

可以通过设置一个全局的参数yarn.scheduler.fair.preemption=true来启用抢占功能。此外，还有两个参数用来控制抢占的过期时间（这两个参数默认没有配置，需要至少配置一个来允许抢占Container）：

- minimum share preemption timeout - fair share preemption timeout 

如果队列在minimum share preemption timeout指定的时间内未获得最小的资源保障，调度器就会抢占containers。我们可以通过配置文件中的顶级元素<defaultMinSharePreemptionTimeout>为所有队列配置这个超时时间；我们还可以在<queue>元素内配置<minSharePreemptionTimeout>元素来为某个队列指定超时时间。

与之类似，如果队列在fair share preemption timeout指定时间内未获得平等的资源的一半（这个比例可以配置），调度器则会进行抢占containers。这个超时时间可以通过顶级元素<defaultFairSharePreemptionTimeout>和元素级元素<fairSharePreemptionTimeout>分别配置所有队列和某个队列的超时时间。上面提到的比例可以通过<defaultFairSharePreemptionThreshold>(配置所有队列)和<fairSharePreemptionThreshold>(配置某个队列)进行配置，默认是0.5。

posted @ 2017-08-05 00:35 鸿雁 阅读(350) | 评论 (0) | 编辑 收藏

hive大数据倾斜总结

在做Shuffle阶段的优化过程中，遇到了数据倾斜的问题，造成了对一些情况下优化效果不明显。主要是因为在Job完成后的所得到的Counters是整个Job的总和，优化是基于这些Counters得出的平均值，而由于数据倾斜的原因造成map处理数据量的差异过大，使得这些平均值能代表的价值降低。Hive的执行是分阶段的，map处理数据量的差异取决于上一个stage的reduce输出，所以如何将数据均匀的分配到各个reduce中，就是解决数据倾斜的根本所在。规避错误来更好的运行比解决错误更高效。在查看了一些资料后，总结如下。

1数据倾斜的原因

1.1操作：

1.2原因：

1)、key分布不均匀

2)、业务数据本身的特性

3)、建表时考虑不周

4)、某些SQL语句本身就有数据倾斜

1.3表现：

任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成。因为其处理的数据量和其他reduce差异过大。

单一reduce的记录数与平均记录数差异过大，通常可能达到3倍甚至更多。 最长时长远大于平均时长。

2数据倾斜的解决方案

2.1参数调节：

hive.map.aggr=true

Map 端部分聚合，相当于Combiner

hive.groupby.skewindata=true

有数据倾斜的时候进行负载均衡，当选项设定为 true，生成的查询计划会有两个 MR Job。第一个 MR Job 中，Map 的输出结果集合会随机分布到 Reduce 中，每个 Reduce 做部分聚合操作，并输出结果，这样处理的结果是相同的 Group By Key 有可能被分发到不同的 Reduce 中，从而达到负载均衡的目的；第二个 MR Job 再根据预处理的数据结果按照 Group By Key 分布到 Reduce 中（这个过程可以保证相同的 Group By Key 被分布到同一个 Reduce 中），最后完成最终的聚合操作。

2.2 SQL语句调节：

如何Join：

关于驱动表的选取，选用join key分布最均匀的表作为驱动表

做好列裁剪和filter操作，以达到两表做join的时候，数据量相对变小的效果。

大小表Join：

使用map join让小的维度表（1000条以下的记录条数） 先进内存。在map端完成reduce.

大表Join大表：

把空值的key变成一个字符串加上随机数，把倾斜的数据分到不同的reduce上，由于null值关联不上，处理后并不影响最终结果。

count distinct大量相同特殊值

count distinct时，将值为空的情况单独处理，如果是计算count distinct，可以不用处理，直接过滤，在最后结果中加1。如果还有其他计算，需要进行group by，可以先将值为空的记录单独处理，再和其他计算结果进行union。

group by维度过小：

采用sum() group by的方式来替换count(distinct)完成计算。

特殊情况特殊处理：

在业务逻辑优化效果的不大情况下，有些时候是可以将倾斜的数据单独拿出来处理。最后union回去。

3典型的业务场景

3.1空值产生的数据倾斜

场景：如日志中，常会有信息丢失的问题，比如日志中的 user_id，如果取其中的 user_id 和 用户表中的user_id 关联，会碰到数据倾斜的问题。

解决方法1： user_id为空的不参与关联（红色字体为修改后）

select * from log a   join users b   on a.user_id is not null   and a.user_id = b.user_id union all select * from log a   where a.user_id is null;

解决方法2 ：赋与空值分新的key值

select *   from log a   left outer join users b   on case when a.user_id is null then concat(‘hive’,rand() ) else a.user_id end = b.user_id;

结论：方法2比方法1效率更好，不但io少了，而且作业数也少了。解决方法1中 log读取两次，jobs是2。解决方法2 job数是1 。这个优化适合无效 id (比如 -99 , ’’, null 等) 产生的倾斜问题。把空值的 key 变成一个字符串加上随机数，就能把倾斜的数据分到不同的reduce上 ,解决数据倾斜问题。

3.2不同数据类型关联产生数据倾斜

场景：用户表中user_id字段为int，log表中user_id字段既有string类型也有int类型。当按照user_id进行两个表的Join操作时，默认的Hash操作会按int型的id来进行分配，这样会导致所有string类型id的记录都分配到一个Reducer中。

解决方法：把数字类型转换成字符串类型

select * from users a   left outer join logs b   on a.usr_id = cast(b.user_id as string)

3.3小表不小不大，怎么用 map join 解决倾斜问题

使用 map join 解决小表(记录数少)关联大表的数据倾斜问题，这个方法使用的频率非常高，但如果小表很大，大到map join会出现bug或异常，这时就需要特别的处理。 以下例子:

select * from log a   left outer join users b   on a.user_id = b.user_id;

users 表有 600w+ 的记录，把 users 分发到所有的 map 上也是个不小的开销，而且 map join 不支持这么大的小表。如果用普通的 join，又会碰到数据倾斜的问题。

解决方法：

select /*+mapjoin(x)*/* from log a   
left outer join (     
select  /*+mapjoin(c)*/d.*  from ( 
select distinct user_id from log ) c  join users d       
on c.user_id = d.user_id     ) x   
on a.user_id = b.user_id;  

假如，log里user_id有上百万个，这就又回到原来map join问题。所幸，每日的会员uv不会太多，有交易的会员不会太多，有点击的会员不会太多，有佣金的会员不会太多等等。所以这个方法能解决很多场景下的数据倾斜问题。

4总结

使map的输出数据更均匀的分布到reduce中去，是我们的最终目标。由于Hash算法的局限性，按key Hash会或多或少的造成数据倾斜。大量经验表明数据倾斜的原因是人为的建表疏忽或业务逻辑可以规避的。在此给出较为通用的步骤：

1、采样log表，哪些user_id比较倾斜，得到一个结果表tmp1。由于对计算框架来说，所有的数据过来，他都是不知道数据分布情况的，所以采样是并不可少的。

2、数据的分布符合社会学统计规则，贫富不均。倾斜的key不会太多，就像一个社会的富人不多，奇特的人不多一样。所以tmp1记录数会很少。把tmp1和users做map join生成tmp2,把tmp2读到distribute file cache。这是一个map过程。

3、map读入users和log，假如记录来自log,则检查user_id是否在tmp2里，如果是，输出到本地文件a,否则生成<user_id,value>的key,value对，假如记录来自member,生成<user_id,value>的key,value对，进入reduce阶段。

4、最终把a文件，把Stage3 reduce阶段输出的文件合并起写到hdfs。

如果确认业务需要这样倾斜的逻辑，考虑以下的优化方案：

1、对于join，在判断小表不大于1G的情况下，使用map join

2、对于group by或distinct，设定 hive.groupby.skewindata=true

3、尽量使用上述的SQL语句调节进行优化

posted @ 2017-07-31 19:57 鸿雁 阅读(173) | 评论 (0) | 编辑 收藏

Hive性能调优

Hive背后的Mapper调优:
1,Mapper数过大,会产生大量小文件,由于Mapper是基于虚拟机的,过多的Mapper创建和初始化及关闭虚拟机都会消耗大量的硬件资源;
    Mapper数太小,并发度过小,Job执行时间过长,无法充分利用分布式硬件资源;
2,Mapper数据由什么决定呢?
    输入文件数目;
    输入文件的大小;
    配置参数;
 默认情况下:例如一个文件800M,BLock大小是128M,那么Mapper数目就是7个,6个Mapper处理的数据是 128M, 1个Mapper处理的数据是32M;再例如,一个目录下有三个文件分别大小问5M 10M 150M
 此时会产生4个Mapper,处理的数据分别是5M 10M 128M 22M;
  
 减少Mapper的个数,就要合并小文件,这种小文件有可能是直接来自于数据源的小文件,也可能是Reducer产生的小文件;
    set hive.input.format=org.apache.Hadoop.hive.ql.io.CombineHiveInputFormat;
    set hive.merge.mapFiles=true;
    set hive.merge.mapredFiles=true;
    set hive.merge.size.per.task=256000000
    set mapred.max.split.size=256000000
    set mapred.min.split.size.per.node=128000000
    
    
 增加Mapper的个数,一般是通过控制Hive SQL中上一个Job的Reducer个数来控制的,例如在Join操作的时候会把多个表分解为多个Job;


 set mapred.map.tasks=2;
 set hive.merge.mapFiles=true;
 set hive.merge.mapredFiles=true;
 set hive.merge.size.per.task=256000000

 例如我们有5个300M的文件;按照上面的配置会产生10个Mapper,5个Mapper处理的都是256M的数据,另外5个Mapper处理的都是44M的数据,问题是:大的Mapper会数据倾斜
如何解决,设置set mapred.map.tasks=6,此时根据MapRed的运行机制,会划分6个Mapper,每个Mapper的处理数据的大小是250M, min(1500M/6, 256M) =250M

Hive背后的Reducer调优:
1,Reducer数目过大的话,会产生很多小文件,每个Reducer都会产生一个文件,如果这些小文件是下一个JOB的输入,则会需要对小文件进行合并;同样启动 初始化和销毁Reducer的虚拟机也需要消耗大量的硬件;
  Reducer数据过小的话,Reduce的时间会比较长,也可能会出现数据倾斜;
2,如何控制Reducer的个数呢?
  set hive.exec.reducers.byte.per.reducer=1G
  set hive.exec.reducers.max=999
  Reducer个数=min(999, Reducer的数据输入总量/1G);

  set mapred.reduce.tasks = 10, 默认是1; 如果说当前的Reducer的结果很大,且被接下来多个Job使用其结果,我们该如何设置参数呢?一般都需要调大该参数;

  什么情况下只有一个Reducer?如果不进行Group by但却需要汇总,或者说Order by,当然如果最后Reducer的数据小于默认的1G的话,也会只有一个Reducer;

1,Hive在分布式运行的时候最害怕的是数据倾斜,这是由于分布式系统的特性决定的,因为分布式系统之所以很快是由于作业平均分配给了不同的节点,不同节点同心协力,从而达到更快处理完作业的目的;
顺便说明一下,处理数据倾斜的能力是hadoop和Spark工程师最核心的竞争力之一;

2,Hive中数据倾斜的原因:
    数据在分布式节点上分布不平衡;
    join时某些key可能特别大;
    groupBy的时候某个Key可能特别多;
    count(distinct)有可能出现数据倾斜,因为其内部首先会进行groupBy操作;


3,join,我们希望join时候key是分散,如果一个key的数据量特别大,有可能会出现数据倾斜和OOM,一个核心点是:小表join大表,在reduce阶段左侧的小表会加载进内存,减少OOM的风险;
4,大表join大表的情况:数据倾斜,例如null值,解决办法一般是要打散null值,例如说使用随机数等,如果数据倾斜比较严重,采用这种方式可以提升至少一倍的速度;
5,mapJoin:小表join(超)大表的时候,可以采用mapJoin的方式把小表全部加载到Mapper端的内存中/*+MAPJOIN(table_name)*/;
6,小表join(超)大表的时候,是否会自动进行mapJoin,想进行mapJoin,需要设置:set hive.auto.convert.join=true,Hive在进行join的时候会判断左表的大小来决定是否进行mapJoin:
    set hive.mapjoin.smalltable.filesize=128000000;
    set hive.mapjoin.cache.numrows=100000;
    上述参数可以根据实际的硬件机器的内存进行调整,对性能有至关重要的影响,因为没有了Shuffle;
  对于mapJoin我们能够使用Mapper端JVM中多大的内存呢?
    set hive.mapjoin.followby.gby.localtask.max.momery.usage = 0.8
    set hive.mapjoin.localtask.max.memory.uage=0.9
7,groupBy,我们可以设置在Mapper端进行部分聚合,最后在Reducer端进行全局聚合
    set hive.map.aggr=true;
    set hive.groupby.mapaggr.checkinterval=100000

    set hive.groupby.skewindata = true 内部会产生两个Job,第一个Job会通过自己的算法打散倾斜的Key并进行聚合操作且保留结果,第二个Job会完成全部的groupBy操作,会产生Mapper-Reducer-Reducer的结构

8, count(distinct),如果某个字段特别多,容易产生数据倾斜,解决思路:
    在查询语句中例如对null进行过滤,在结果中加1


9, 笛卡尔积:join时候没有on条件,或者on条件无效,这个时候会使用Reducer进行笛卡尔积的操作;

posted @ 2017-07-30 13:52 鸿雁 阅读(185) | 评论 (0) | 编辑 收藏

HIVE和HBASE区别

1. 两者分别是什么？  

 Apache Hive是一个构建在Hadoop基础设施之上的数据仓库。通过Hive可以使用HQL语言查询存放在HDFS上的数据。HQL是一种类SQL语言，这种语言最终被转化为Map/Reduce. 虽然Hive提供了SQL查询功能，但是Hive不能够进行交互查询--因为它只能够在Haoop上批量的执行Hadoop。

    Apache HBase是一种Key/Value系统，它运行在HDFS之上。和Hive不一样，Hbase的能够在它的数据库上实时运行，而不是运行MapReduce任务。Hive被分区为表格，表格又被进一步分割为列簇。列簇必须使用schema定义，列簇将某一类型列集合起来（列不要求schema定义）。例如，“message”列簇可能包含：“to”, ”from” “date”, “subject”, 和”body”. 每一个 key/value对在Hbase中被定义为一个cell，每一个key由row-key，列簇、列和时间戳。在Hbase中，行是key/value映射的集合，这个映射通过row-key来唯一标识。Hbase利用Hadoop的基础设施，可以利用通用的设备进行水平的扩展。

2. 两者的特点

  Hive帮助熟悉SQL的人运行MapReduce任务。因为它是JDBC兼容的，同时，它也能够和现存的SQL工具整合在一起。运行Hive查询会花费很长时间，因为它会默认遍历表中所有的数据。虽然有这样的缺点，一次遍历的数据量可以通过Hive的分区机制来控制。分区允许在数据集上运行过滤查询，这些数据集存储在不同的文件夹内，查询的时候只遍历指定文件夹（分区）中的数据。这种机制可以用来，例如，只处理在某一个时间范围内的文件，只要这些文件名中包括了时间格式。

    HBase通过存储key/value来工作。它支持四种主要的操作：增加或者更新行，查看一个范围内的cell，获取指定的行，删除指定的行、列或者是列的版本。版本信息用来获取历史数据（每一行的历史数据可以被删除，然后通过Hbase compactions就可以释放出空间）。虽然HBase包括表格，但是schema仅仅被表格和列簇所要求，列不需要schema。Hbase的表格包括增加/计数功能。

3. 限制

  Hive目前不支持更新操作。另外，由于hive在hadoop上运行批量操作，它需要花费很长的时间，通常是几分钟到几个小时才可以获取到查询的结果。Hive必须提供预先定义好的schema将文件和目录映射到列，并且Hive与ACID不兼容。

    HBase查询是通过特定的语言来编写的，这种语言需要重新学习。类SQL的功能可以通过Apache Phonenix实现，但这是以必须提供schema为代价的。另外，Hbase也并不是兼容所有的ACID特性，虽然它支持某些特性。最后但不是最重要的--为了运行Hbase，Zookeeper是必须的，zookeeper是一个用来进行分布式协调的服务，这些服务包括配置服务，维护元信息和命名空间服务。

4. 应用场景

    Hive适合用来对一段时间内的数据进行分析查询，例如，用来计算趋势或者网站的日志。Hive不应该用来进行实时的查询。因为它需要很长时间才可以返回结果。

    Hbase非常适合用来进行大数据的实时查询。Facebook用Hbase进行消息和实时的分析。它也可以用来统计Facebook的连接数。

5. 总结

    Hive和Hbase是两种基于Hadoop的不同技术--Hive是一种类SQL的引擎，并且运行MapReduce任务，Hbase是一种在Hadoop之上的NoSQL 的Key/vale数据库。当然，这两种工具是可以同时使用的。就像用Google来搜索，用FaceBook进行社交一样，Hive可以用来进行统计查询，HBase可以用来进行实时查询，数据也可以从Hive写到Hbase，设置再从Hbase写回Hive。

posted @ 2017-07-21 11:44 鸿雁 阅读(155) | 评论 (0) | 编辑 收藏

Hive分布式安装配置Hive+Mysql

posted @ 2017-07-20 15:20 鸿雁 阅读(455) | 评论 (0) | 编辑 收藏

TCP/UDP区别以及UDP如何实现可靠传输

TCP和UDP是OSI模型中的运输层中的协议。TCP提供可靠的通信传输，而UDP则常被用于让广播和细节控制交给应用的通信传输。

UDP(User Datagram Protocol)

        UDP不提供复杂的控制机制，利用IP提供面向无连接的通信服务。并且它是将应用程序发来的数据在收到的那一刻，立刻按照原样发送到网络上的一种机制。

        即使是出现网络拥堵的情况下，UDP也无法进行流量控制等避免网络拥塞的行为。此外，传输途中如果出现了丢包，UDO也不负责重发。甚至当出现包的到达顺序乱掉时也没有纠正的功能。如果需要这些细节控制，那么不得不交给由采用UDO的应用程序去处理。换句话说，UDP将部分控制转移到应用程序去处理，自己却只提供作为传输层协议的最基本功能。UDP有点类似于用户说什么听什么的机制，但是需要用户充分考虑好上层协议类型并制作相应的应用程序。

TCP(Transmission Control Protocol)

        TCP充分实现爱呢了数据传输时各种控制功能，可以进行丢包的重发控制，还可以对次序乱掉的分包进行顺序控制。而这些在UDP中都没有。此外，TCP作为一种面向有连接的协议，只有在确认通信对端存在时才会发送数据，从而可以控制通信流量的浪费。

        TCP通过检验和、序列号、确认应答、重发控制、连接管理以及窗口控制等机制实现可靠性传输。此处不一一叙述。

TCP与UDP如何加以区分使用？

        TCP用于在传输层有必要实现可靠性传输的情况。由于它是面向有连接并具备顺序控制、重发控制等机制的。所以它可以为应用提供可靠传输。

        另一方面，UDP主要用于那些对高速传输和实时性有较高要求的通信或广播通信。举一个IP电话进行通话的例子。如果使用TCP，数据在传送途中如果丢失会被重发，但是这样无法流畅地传输通话人的声音，会导致无法进行正常交流。而采用UDP，它不会进行重发处理。从而也就不会有声音大幅度延迟到达的问题。即使有部分数据丢失，也只是影响某一小部分的通话。此外，在多播与广播通信中也使用UDP而不是UDP。RIP、DHCP等基于广播的协议也要依赖于UDP。

TCP与UDP区别总结：

1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接

6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

UDP如何实现可靠传输

由于在传输层UDP已经是不可靠的连接，那就要在应用层自己实现一些保障可靠传输的机制

简单来讲，要使用UDP来构建可靠的面向连接的数据传输，就要实现类似于TCP协议的

超时重传（定时器）

有序接受 （添加包序号）

应答确认 （Seq/Ack应答机制）

滑动窗口流量控制等机制 （滑动窗口协议）

等于说要在传输层的上一层（或者直接在应用层）实现TCP协议的可靠数据传输机制，比如使用UDP数据包+序列号，UDP数据包+时间戳等方法。

目前已经有一些实现UDP可靠传输的机制，比如

UDT（UDP-based Data Transfer Protocol）

posted @ 2017-07-19 22:25 鸿雁 阅读(454) | 评论 (0) | 编辑 收藏

一文读懂分布式数据库Hbase

一、

1、什么是Hbase。

是一个高可靠性、高性能、列存储、可伸缩、实时读写的分布式数据库系统。

适合于存储非结构化数据，基于列的而不是基于行的模式

如图：Hadoop生态中hbase与其他部分的关系。

2、关系数据库已经流行很多年，并且hadoop已经有了HDFS和MapReduce，为什么需要HBase?

1、模型概述

HBase中执行更新操作时，并不会删除数据旧的版本，而是生成一个新的版本，旧有的版本仍然保留（这是和HDFS只允许追加不允许修改的特性相关的）

2、数据坐标
HBase中需要根据行键、列族、列限定符和时间戳来确定一个单元格，因此，可以视为一个“四维坐标”，即[行键,列族, 列限定符,时间戳]

键	值
[“201505003”,“Info”,“email”, 1174184619081]	“xie@qq.com”
[“201505003”,“Info”,“email”, 1174184620720]	“you@163.com”

3、概念视图

4、物理视图

三、HBase实现原理

1、HBase的实现包括三个主要的功能组件：

（3）许多个Region服务器

主服务器Master负责管理和维护HBase表的分区信息，维护Region服务器列表，分配Region，负载均衡

Region服务器负责存储和维护分配给自己的Region，处理来自客户端的读写请求

客户端并不是直接从Master主服务器上读取数据，而是在获得Region的存储位置信息后，直接从Region服务器上读取数据

客户端并不依赖Master，而是通过Zookeeper来获得Region位置信息，大多数客户端甚至从来不和Master通信，这种设计方式使得Master负载很小

2、Region
开始只有一个Region，后来不断分裂

Region拆分操作非常快，接近瞬间，因为拆分之后的Region读取的仍然是原存储文件，直到“合并”过程把存储文件异步地写到独立的文件之后，才会读取新文件

同一个Region不会被分拆到多个Region服务器

每个Region服务器存储10-1000个Region

元数据表，又名.META.表，存储了Region和Region服务器的映射关系

当HBase表很大时， .META.表也会被分裂成多个Region

根数据表，又名-ROOT-表，记录所有元数据的具体位置

-ROOT-表只有唯一一个Region，名字是在程序中被写死的

Zookeeper文件记录了-ROOT-表的位置

客户端访问数据时的“三级寻址”

为了加速寻址，客户端会缓存位置信息，同时，需要解决缓存失效问题

寻址过程客户端只需要询问Zookeeper服务器，不需要连接Master服务器

3、HBase的三层结构中各层次的名称和作用

层次	名称	作用
第一层	Zookeper文件	记录了-ROOT-表的位置信息
第二层	-ROOT-表	记录了.META.表的Region位置信息 -ROOT-表只能有一个Region。通过-ROOT-表，就可以访问.META.表中的数据
第三层	.META.表	记录了用户数据表的Region位置信息，.META.表可以有多个Region，保存了HBase中所有用户数据表的Region位置信息

四、HBase运行机制
1、HBase系统架构

(1、客户端包含访问HBase的接口，同时在缓存中维护着已经访问过的Region位置信息，用来加快后续数据访问过程

(2、Zookeeper可以帮助选举出一个Master作为集群的总管，并保证在任何时刻总有唯一一个Master在运行，这就避免了Master的“单点失效”问题

（Zookeeper是一个很好的集群管理工具，被大量用于分布式计算，提供配置维护、域名服务、分布式同步、组服务等。）

(3. Master

主服务器Master主要负责表和Region的管理工作：

管理用户对表的增加、删除、修改、查询等操作

实现不同Region服务器之间的负载均衡

在Region分裂或合并后，负责重新调整Region的分布

对发生故障失效的Region服务器上的Region进行迁移

(4. Region服务器

Region服务器是HBase中最核心的模块，负责维护分配给自己的Region，并响应用户的读写请求

2、Region

(1、用户读写数据过程
用户写入数据时，被分配到相应Region服务器去执行

用户数据首先被写入到MemStore和Hlog中

只有当操作写入Hlog之后，commit()调用才会将其返回给客户端

当用户读取数据时，Region服务器会首先访问MemStore缓存，如果找不到，再去磁盘上面的StoreFile中寻找

(2、缓存的刷新

系统会周期性地把MemStore缓存里的内容刷写到磁盘的StoreFile文件中，清空缓存，并在Hlog里面写入一个标记、
每次刷写都生成一个新的StoreFile文件，因此，每个Store包含多个StoreFile文件

每个Region服务器都有一个自己的HLog文件，每次启动都检查该文件，确认最近一次执行缓存刷新操作之后是否发生新的写入操作；如果发现更新，则先写入MemStore，再刷写到StoreFile，最后删除旧的Hlog文件，开始为用户提供服务
(3、StroreFile的合并

每次刷写都生成一个新的StoreFile，数量太多，影响查找速度

调用Store.compact()把多个合并成一个

合并操作比较耗费资源，只有数量达到一个阈值才启动合并

3、Store工作原理

Store是Region服务器的核心

多个StoreFile合并成一个
触发分裂操作，1个父Region被分裂成两个子Region

单个StoreFile过大时，又

4、HLog工作原理

分布式环境必须要考虑系统出错。HBase采用HLog保证系统恢复

HBase系统为每个Region服务器配置了一个HLog文件，它是一种预写式日志（WriteAhead Log）

用户更新数据必须首先写入日志后，才能写入MemStore缓存，并且，直到MemStore缓存内容对应的日志已经写入磁盘，该缓存内容才能被刷写到磁盘

Zookeeper会实时监测每个Region服务器的状态，当某个Region服务器发生故障时，Zookeeper会通知Master

Master首先会处理该故障Region服务器上面遗留的HLog文件，这个遗留的HLog文件中包含了来自多个Region对象的日志记录

系统会根据每条日志记录所属的Region对象对HLog数据进行拆分，分别放到相应Region对象的目录下，然后，再将失效的Region重新分配到可用的Region服务器中，并把与该Region对象相关的HLog日志记录也发送给相应的Region服务器

Region服务器领取到分配给自己的Region对象以及与之相关的HLog日志记录以后，会重新做一遍日志记录中的各种操作，把日志记录中的数据写入到MemStore缓存中，然后，刷新到磁盘的StoreFile文件中，完成数据恢复

共用日志优点：提高对表的写操作性能；缺点：恢复时需要分拆日志

五、HBase性能
1、行键（RowKey）

行键是按照字典序存储，因此，设计行键时，要充分利用这个排序特点，将经常一起读取的数据存储到一块，将最近可能会被访问的数据放在一块。

举个例子：如果最近写入HBase表中的数据是最可能被访问的，可以考虑将时间戳作为行键的一部分，由于是字典序排序，所以可以使用Long.MAX_VALUE- timestamp作为行键，这样能保证新写入的数据在读取时可以被快速命中。

InMemory：创建表的时候，可以通过HColumnDescriptor.setInMemory(true)将表放到Region服务器的缓存中，保证在读取的时候被cache命中。

Max Version：创建表的时候，可以通过HColumnDescriptor.setMaxVersions(int maxVersions)设置表中数据的最大版本，如果只需要保存最新版本的数据，那么可以设置setMaxVersions(1)。

Time To Live创建表的时候，可以通过HColumnDescriptor.setTimeToLive(inttimeToLive)设置表中数据的存储生命期，过期数据将自动被删除，例如如果只需要存储最近两天的数据，那么可以设置setTimeToLive(2* 24 * 60 * 60)。

2、HBaseMaster默认基于Web的UI服务端口为60010，HBase region服务器默认基于Web的UI服务端口为60030.如果master运行在名为master.foo.com的主机中，mater的主页地址就是http://master.foo.com:60010，用户可以通过Web浏览器输入这个地址查看该页面

可以查看HBase集群的当前状态

3、NoSQL区别于关系型数据库的一点就是NoSQL不使用SQL作为查询语言，至于为何在NoSQL数据存储HBase上提供SQL接口

易使用，减少编码

4、HBase只有一个针对行健的索引

访问HBase表中的行，只有三种方式：

通过单个行健访问

通过一个行健的区间来访问

全表扫描

总结：

1、HBase数据库是BigTable的开源实现，和BigTable一样，支持大规模海量数据，分布式并发数据处理效率极高，易于扩展且支持动态伸缩，适用于廉价设备

2、HBase可以支持NativeJava API、HBaseShell、ThriftGateway、Hive等多种访问接口，可以根据具体应用场合选择相应访问方式

3、HBase实际上就是一个稀疏、多维、持久化存储的映射表，它采用行键、列键和时间戳进行索引，每个值都是未经解释的字符串。

4、HBase采用分区存储，一个大的表会被分拆许多个Region，这些Region会被分发到不同的服务器上实现分布式存储

5、HBase的系统架构包括客户端、Zookeeper服务器、Master主服务器、Region服务器。客户端包含访问HBase的接口；Zookeeper服务器负责提供稳定可靠的协同服务；Master主服务器主要负责表和Region的管理工作；Region服务器负责维护分配给自己的Region，并响应用户的读写请求

posted @ 2017-07-19 22:24 鸿雁 阅读(235) | 评论 (0) | 编辑 收藏

在python中获取mac和ip地址

posted @ 2017-05-15 23:26 鸿雁 阅读(241) | 评论 (0) | 编辑 收藏

Spring—Quartz定时调度CronTrigger时间配置格式说明与实例

spring中使用Quartz时 时间配置例子：

<!-- 定义调用对象和调用对象的方法 end   -->
<!-- 定义调用时间 begin -->
<bean id="realweatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="realweatherTask" />
</property>
<property name="cronExpression">
<value>0 10/30 * * * ?</value><!-- 表示每小时的10，40时执行任务 -->
</property>
</bean>
<!-- 定义调用时间 end   -->

<!-- 定义调用对象和调用对象的方法 end   -->
<!-- 定义调用时间 begin -->
<bean id="weatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="weatherTask" />
</property>
<property name="cronExpression">
<!--  <value>0 30 8,13 * * ?</value>  --><!-- 表示每天的8:30和13:30时执行任务 -->
<value>0 0,30 0-23 * * ?</value><!---表示每天从0-23时中每时的整点或半点执行任务->
</property>
</bean>

<!-- 定义调用时间 end   -->1、   CronTrigger时间格式配置说明

CronTrigger配置格式:

格式: [秒] [分] [小时] [日] [月] [周] [年]

通配符说明:

* ：表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。
? ：表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?
- ：表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
, ：表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发
/ ：用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。 在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。
L ：表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。

例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"

W ：表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").

'L'和 'W'可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发

# ：序号(表示每月的第几周星期几)，例如在周字段上设置"6#3"表示在每月的第三个周星期六.注意如果指定"6#5",正好第五周没有星期六，则不会触发该配置(用在母亲节和父亲节再合适不过了)

周字段的设置，若使用英文字母是不区分大小写的 MON 与mon相同.

常用示例:

格式: [秒] [分] [小时] [日] [月] [周] [年]

0 0 12 * * ?           每天12点触发 
0 15 10 ? * *          每天10点15分触发 
0 15 10 * * ?          每天10点15分触发  
0 15 10 * * ? *        每天10点15分触发  
0 15 10 * * ? 2005     2005年每天10点15分触发 
0 * 14 * * ?           每天下午的 2点到2点59分每分触发 
0 0/5 14 * * ?         每天下午的 2点到2点59分(整点开始，每隔5分触发)  
0 0/5 14,18 * * ?        每天下午的 18点到18点59分(整点开始，每隔5分触发)

0 0-5 14 * * ?            每天下午的 2点到2点05分每分触发 
0 10,44 14 ? 3 WED        3月分每周三下午的 2点10分和2点44分触发 
0 15 10 ? * MON-FRI       从周一到周五每天上午的10点15分触发 
0 15 10 15 * ?            每月15号上午10点15分触发 
0 15 10 L * ?             每月最后一天的10点15分触发 
0 15 10 ? * 6L            每月最后一周的星期五的10点15分触发 
0 15 10 ? * 6L 2002-2005  从2002年到2005年每月最后一周的星期五的10点15分触发

0 15 10 ? * 6#3           每月的第三周的星期五开始触发 
0 0 12 1/5 * ?            每月的第一个中午开始每隔5天触发一次 
0 11 11 11 11 ?           每年的11月11号 11点11分触发(光棍节)

spring中使用Quartz时 时间配置例子：

<!-- 定义调用对象和调用对象的方法 end   -->
<!-- 定义调用时间 begin -->
<bean id="realweatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="realweatherTask" />
</property>
<property name="cronExpression">
<value>0 10/30 * * * ?</value><!-- 表示每小时的10，40时执行任务 -->
</property>
</bean>
<!-- 定义调用时间 end   -->

<!-- 定义调用对象和调用对象的方法 end   -->
<!-- 定义调用时间 begin -->
<bean id="weatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="weatherTask" />
</property>
<property name="cronExpression">
<!--  <value>0 30 8,13 * * ?</value>  --><!-- 表示每天的8:30和13:30时执行任务 -->
<value>0 0,30 0-23 * * ?</value><!---表示每天从0-23时中每时的整点或半点执行任务->
</property>
</bean>
<!-- 定义调用时间 end   -->

posted @ 2017-04-29 12:01 鸿雁 阅读(308) | 评论 (0) | 编辑 收藏

前端内容展示操作

posted @ 2016-03-09 11:36 鸿雁 阅读(209) | 评论 (0) | 编辑 收藏

js 金额 用逗号 隔开数字格式化

posted @ 2015-09-27 10:23 鸿雁 阅读(232) | 评论 (0) | 编辑 收藏

BigDecimal用法详解

一、简介
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

二、构造器描述 
BigDecimal(int)       创建一个具有参数所指定整数值的对象。 
BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 
BigDecimal(long)    创建一个具有参数所指定长整数值的对象。 
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。

三、方法描述 
add(BigDecimal)        BigDecimal对象中的值相加，然后返回这个对象。 
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。 
multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回这个对象。 
divide(BigDecimal)     BigDecimal对象中的值相除，然后返回这个对象。 
toString()                将BigDecimal对象的数值转换成字符串。 
doubleValue()          将BigDecimal对象中的值以双精度数返回。 
floatValue()             将BigDecimal对象中的值以单精度数返回。 
longValue()             将BigDecimal对象中的值以长整数返回。 
intValue()               将BigDecimal对象中的值以整数返回。

四、格式化及例子
由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。

以利用BigDecimal对货币和百分比格式化为例。首先，创建BigDecimal对象，进行BigDecimal的算术运算后，分别建立对货币和百分比格式化的引用，最后利用BigDecimal对象作为format()方法的参数，输出其格式化的货币值和百分比。

public static void main(String[] args) {     
    NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用      
    NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用      
    percent.setMaximumFractionDigits(3); //百分比小数点最多3位           
    BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额     
    BigDecimal interestRate = new BigDecimal("0.008"); //利率        
    BigDecimal interest = loanAmount.multiply(interestRate); //相乘      
    System.out.println("贷款金额:\t" + currency.format(loanAmount));      
    System.out.println("利率:\t" + percent.format(interestRate));      
    System.out.println("利息:\t" + currency.format(interest));  }

运行结果如下：

贷款金额:    ￥15,000.48 
利率:    0.8% 
利息:    ￥120.00

五、BigDecimal比较
BigDecimal是通过使用compareTo(BigDecimal)来比较的，具体比较情况如下：

public static void main(String[] args) {     
    BigDecimal a = new BigDecimal("1");     
    BigDecimal b = new BigDecimal("2");     
    BigDecimal c = new BigDecimal("1");     
    int result1 = a.compareTo(b);     
    int result2 = a.compareTo(c);     
    int result3 = b.compareTo(a);     
    System.out.println(result1);     
    System.out.println(result2);     
    System.out.println(result3);      
}

打印结果是：-1、0、1，即左边比右边数大，返回1，相等返回0，比右边小返回-1。
注意不能使用equals方法来比较大小。

使用BigDecimal的坏处是性能比double和float差，在处理庞大，复杂的运算时尤为明显，因根据实际需求决定使用哪种类型。

posted @ 2015-08-22 12:56 鸿雁 阅读(373) | 评论 (0) | 编辑 收藏

oracle列转行

1.
概述
最近论坛很多人提的问题都与行列转换有关系，所以我对行列转换的相关知识做了一个总结，希望对大家有所帮助，同时有何错疏，恳请大家指出，我也是在写作过程中学习，算是一起和大家学习吧！
行列转换包括以下六种情况：
1)
列转行
2)
行转列
3)
多列转换成字符串
4)
多行转换成字符串
5)
字符串转换成多列
6)
字符串转换成多行
下面分别进行举例介绍。
首先声明一点，有些例子需要如下10g及以后才有的知识：
A.
掌握model子句
B.
正则表达式
C.
加强的层次查询
讨论的适用范围只包括8i,9i,10g及以后版本。
2.
列转行
CREATE TABLE t_col_row(
ID INT,
c1 VARCHAR2(10),
c2 VARCHAR2(10),
c3 VARCHAR2(10));
INSERT INTO t_col_row VALUES (1, 'v11', 'v21', 'v31');
INSERT INTO t_col_row VALUES (2, 'v12', 'v22', NULL);
INSERT INTO t_col_row VALUES (3, 'v13', NULL, 'v33');
INSERT INTO t_col_row VALUES (4, NULL, 'v24', 'v34');
INSERT INTO t_col_row VALUES (5, 'v15', NULL, NULL);
INSERT INTO t_col_row VALUES (6, NULL, NULL, 'v35');
INSERT INTO t_col_row VALUES (7, NULL, NULL, NULL);
COMMIT;
SELECT * FROM t_col_row;
2.1
UNION ALL
适用范围：8i,9i,10g及以后版本
SELECT id, 'c1' cn, c1 cv
FROM t_col_row
UNION ALL
SELECT id, 'c2' cn, c2 cv
FROM t_col_row
UNION ALL
SELECT id, 'c3' cn, c3 cv FROM t_col_row;
若空行不需要转换，只需加一个where条件，
WHERE COLUMN IS NOT NULL 即可。
2.2
MODEL
适用范围：10g及以后
SELECT id, cn, cv FROM t_col_row
MODEL
RETURN UPDATED ROWS
PARTITION BY (ID)
DIMENSION BY (0 AS n)
MEASURES ('xx' AS cn,'yyy' AS cv,c1,c2,c3)
RULES UPSERT ALL
(
cn[1] = 'c1',
cn[2] = 'c2',
cn[3] = 'c3',
cv[1] = c1[0],
cv[2] = c2[0],
cv[3] = c3[0]
)
ORDER BY ID,cn;
2.3
COLLECTION
适用范围：8i,9i,10g及以后版本
要创建一个对象和一个集合：
CREATE TYPE cv_pair AS OBJECT(cn VARCHAR2(10),cv VARCHAR2(10));
CREATE TYPE cv_varr AS VARRAY(8) OF cv_pair;
SELECT id, t.cn AS cn, t.cv AS cv
FROM t_col_row,
TABLE(cv_varr(cv_pair('c1', t_col_row.c1),
cv_pair('c2', t_col_row.c2),
cv_pair('c3', t_col_row.c3))) t
ORDER BY 1, 2;
3.
行转列
CREATE TABLE t_row_col AS
SELECT id, 'c1' cn, c1 cv
FROM t_col_row
UNION ALL
SELECT id, 'c2' cn, c2 cv
FROM t_col_row
UNION ALL
SELECT id, 'c3' cn, c3 cv FROM t_col_row;
SELECT * FROM t_row_col ORDER BY 1,2;
3.1
AGGREGATE FUNCTION
适用范围：8i,9i,10g及以后版本
SELECT id,
MAX(decode(cn, 'c1', cv, NULL)) AS c1,
MAX(decode(cn, 'c2', cv, NULL)) AS c2,
MAX(decode(cn, 'c3', cv, NULL)) AS c3
FROM t_row_col
GROUP BY id
ORDER BY 1;
MAX聚集函数也可以用sum、min、avg等其他聚集函数替代。
被指定的转置列只能有一列，但固定的列可以有多列，请看下面的例子：
SELECT mgr, deptno, empno, ename FROM emp ORDER BY 1, 2;
SELECT mgr,
deptno,
MAX(decode(empno, '7788', ename, NULL)) "7788",
MAX(decode(empno, '7902', ename, NULL)) "7902",
MAX(decode(empno, '7844', ename, NULL)) "7844",
MAX(decode(empno, '7521', ename, NULL)) "7521",
MAX(decode(empno, '7900', ename, NULL)) "7900",
MAX(decode(empno, '7499', ename, NULL)) "7499",
MAX(decode(empno, '7654', ename, NULL)) "7654"
FROM emp
WHERE mgr IN (7566, 7698)
AND deptno IN (20, 30)
GROUP BY mgr, deptno
ORDER BY 1, 2;
这里转置列为empno，固定列为mgr，deptno。
还有一种行转列的方式，就是相同组中的行值变为单个列值，但转置的行值不变为列名：
ID CN_1 CV_1 CN_2 CV_2 CN_3 CV_3
1 c1 v11 c2 v21 c3 v31
2 c1 v12 c2 v22 c3
3 c1 v13 c2 c3 v33
4 c1 c2 v24 c3 v34
5 c1 v15 c2 c3
6 c1 c2 c3 v35
7 c1 c2 c3
这种情况可以用分析函数实现：
SELECT id,
MAX(decode(rn, 1, cn, NULL)) cn_1,
MAX(decode(rn, 1, cv, NULL)) cv_1,
MAX(decode(rn, 2, cn, NULL)) cn_2,
MAX(decode(rn, 2, cv, NULL)) cv_2,
MAX(decode(rn, 3, cn, NULL)) cn_3,
MAX(decode(rn, 3, cv, NULL)) cv_3
FROM (SELECT id,
cn,
cv,
row_number() over(PARTITION BY id ORDER BY cn, cv) rn
FROM t_row_col)
GROUP BY ID;
3.2
PL/SQL
适用范围：8i,9i,10g及以后版本
这种对于行值不固定的情况可以使用。
下面是我写的一个包，包中
p_rows_column_real用于前述的第一种不限定列的转换；
p_rows_column用于前述的第二种不限定列的转换。
CREATE OR REPLACE PACKAGE pkg_dynamic_rows_column AS
TYPE refc IS REF CURSOR;
PROCEDURE p_print_sql(p_txt VARCHAR2);
FUNCTION f_split_str(p_str VARCHAR2, p_division VARCHAR2, p_seq INT)
RETURN VARCHAR2;
PROCEDURE p_rows_column(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_cols IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc);
PROCEDURE p_rows_column_real(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_col IN VARCHAR2,
p_pivot_val IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc);
END;
/
CREATE OR REPLACE PACKAGE BODY pkg_dynamic_rows_column AS
PROCEDURE p_print_sql(p_txt VARCHAR2) IS
v_len INT;
BEGIN
v_len := length(p_txt);
FOR i IN 1 .. v_len / 250 + 1 LOOP
dbms_output.put_line(substrb(p_txt, (i - 1) * 250 + 1, 250));
END LOOP;
END;
FUNCTION f_split_str(p_str VARCHAR2, p_division VARCHAR2, p_seq INT)
RETURN VARCHAR2 IS
v_first INT;
v_last INT;
BEGIN
IF p_seq < 1 THEN
RETURN NULL;
END IF;
IF p_seq = 1 THEN
IF instr(p_str, p_division, 1, p_seq) = 0 THEN
RETURN p_str;
ELSE
RETURN substr(p_str, 1, instr(p_str, p_division, 1) - 1);
END IF;
ELSE
v_first := instr(p_str, p_division, 1, p_seq - 1);
v_last := instr(p_str, p_division, 1, p_seq);
IF (v_last = 0) THEN
IF (v_first > 0) THEN
RETURN substr(p_str, v_first + 1);
ELSE
RETURN NULL;
END IF;
ELSE
RETURN substr(p_str, v_first + 1, v_last - v_first - 1);
END IF;
END IF;
END f_split_str;
PROCEDURE p_rows_column(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_cols IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc) IS
v_sql VARCHAR2(4000);
TYPE v_keep_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_keep v_keep_ind_by;
TYPE v_pivot_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_pivot v_pivot_ind_by;
v_keep_cnt INT;
v_pivot_cnt INT;
v_max_cols INT;
v_partition VARCHAR2(4000);
v_partition1 VARCHAR2(4000);
v_partition2 VARCHAR2(4000);
BEGIN
v_keep_cnt := length(p_keep_cols) - length(REPLACE(p_keep_cols, ',')) + 1;
v_pivot_cnt := length(p_pivot_cols) -
length(REPLACE(p_pivot_cols, ',')) + 1;
FOR i IN 1 .. v_keep_cnt LOOP
v_keep(i) := f_split_str(p_keep_cols, ',', i);
END LOOP;
FOR j IN 1 .. v_pivot_cnt LOOP
v_pivot(j) := f_split_str(p_pivot_cols, ',', j);
END LOOP;
v_sql := 'select max(count(*)) from ' || p_table || ' group by ';
FOR i IN 1 .. v_keep.LAST LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
v_sql := rtrim(v_sql, ',');
EXECUTE IMMEDIATE v_sql
INTO v_max_cols;
v_partition := 'select ';
FOR x IN 1 .. v_keep.COUNT LOOP
v_partition1 := v_partition1 || v_keep(x) || ',';
END LOOP;
FOR y IN 1 .. v_pivot.COUNT LOOP
v_partition2 := v_partition2 || v_pivot(y) || ',';
END LOOP;
v_partition1 := rtrim(v_partition1, ',');
v_partition2 := rtrim(v_partition2, ',');
v_partition := v_partition || v_partition1 || ',' || v_partition2 ||
', row_number() over (partition by ' || v_partition1 ||
' order by ' || v_partition2 || ') rn from ' || p_table;
v_partition := rtrim(v_partition, ',');
v_sql := 'select ';
FOR i IN 1 .. v_keep.COUNT LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
FOR i IN 1 .. v_max_cols LOOP
FOR j IN 1 .. v_pivot.COUNT LOOP
v_sql := v_sql || ' max(decode(rn,' || i || ',' || v_pivot(j) ||
',null))' || v_pivot(j) || '_' || i || ',';
END LOOP;
END LOOP;
IF p_where IS NOT NULL THEN
v_sql := rtrim(v_sql, ',') || ' from (' || v_partition || ' ' ||
p_where || ') group by ';
ELSE
v_sql := rtrim(v_sql, ',') || ' from (' || v_partition ||
') group by ';
END IF;
FOR i IN 1 .. v_keep.COUNT LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
v_sql := rtrim(v_sql, ',');
p_print_sql(v_sql);
OPEN p_refc FOR v_sql;
EXCEPTION
WHEN OTHERS THEN
OPEN p_refc FOR
SELECT 'x' FROM dual WHERE 0 = 1;
END;
PROCEDURE p_rows_column_real(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_col IN VARCHAR2,
p_pivot_val IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc) IS
v_sql VARCHAR2(4000);
TYPE v_keep_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_keep v_keep_ind_by;
TYPE v_pivot_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_pivot v_pivot_ind_by;
v_keep_cnt INT;
v_group_by VARCHAR2(2000);
BEGIN
v_keep_cnt := length(p_keep_cols) - length(REPLACE(p_keep_cols, ',')) + 1;
FOR i IN 1 .. v_keep_cnt LOOP
v_keep(i) := f_split_str(p_keep_cols, ',', i);
END LOOP;
v_sql := 'select ' || 'cast(' || p_pivot_col ||
' as varchar2(200)) as ' || p_pivot_col || ' from ' || p_table ||
' group by ' || p_pivot_col;
EXECUTE IMMEDIATE v_sql BULK COLLECT
INTO v_pivot;
FOR i IN 1 .. v_keep.COUNT LOOP
v_group_by := v_group_by || v_keep(i) || ',';
END LOOP;
v_group_by := rtrim(v_group_by, ',');
v_sql := 'select ' || v_group_by || ',';
FOR x IN 1 .. v_pivot.COUNT LOOP
v_sql := v_sql || ' max(decode(' || p_pivot_col || ',' || chr(39) ||
v_pivot(x) || chr(39) || ',' || p_pivot_val ||
',null)) as "' || v_pivot(x) || '",';
END LOOP;
v_sql := rtrim(v_sql, ',');
IF p_where IS NOT NULL THEN
v_sql := v_sql || ' from ' || p_table || p_where || ' group by ' ||
v_group_by;
ELSE
v_sql := v_sql || ' from ' || p_table || ' group by ' || v_group_by;
END IF;
p_print_sql(v_sql);
OPEN p_refc FOR v_sql;
EXCEPTION
WHEN OTHERS THEN
OPEN p_refc FOR
SELECT 'x' FROM dual WHERE 0 = 1;
END;
END;
/
4.
多列转换成字符串
CREATE TABLE t_col_str AS
SELECT * FROM t_col_row;
这个比较简单，用||或concat函数可以实现：
SELECT concat('a','b') FROM dual;
4.1
|| OR CONCAT
适用范围：8i,9i,10g及以后版本
SELECT * FROM t_col_str;
SELECT ID,c1||','||c2||','||c3 AS c123
FROM t_col_str;
5.
多行转换成字符串
CREATE TABLE t_row_str(
ID INT,
col VARCHAR2(10));
INSERT INTO t_row_str VALUES(1,'a');
INSERT INTO t_row_str VALUES(1,'b');
INSERT INTO t_row_str VALUES(1,'c');
INSERT INTO t_row_str VALUES(2,'a');
INSERT INTO t_row_str VALUES(2,'d');
INSERT INTO t_row_str VALUES(2,'e');
INSERT INTO t_row_str VALUES(3,'c');
COMMIT;
SELECT * FROM t_row_str;
5.1
MAX + DECODE
适用范围：8i,9i,10g及以后版本
SELECT id,
MAX(decode(rn, 1, col, NULL)) ||
MAX(decode(rn, 2, ',' || col, NULL)) ||
MAX(decode(rn, 3, ',' || col, NULL)) str
FROM (SELECT id,
col,
row_number() over(PARTITION BY id ORDER BY col) AS rn
FROM t_row_str) t
GROUP BY id
ORDER BY 1;
5.2
ROW_NUMBER + LEAD
适用范围：8i,9i,10g及以后版本
SELECT id, str
FROM (SELECT id,
row_number() over(PARTITION BY id ORDER BY col) AS rn,
col || lead(',' || col, 1) over(PARTITION BY id ORDER BY col) ||
lead(',' || col, 2) over(PARTITION BY id ORDER BY col) ||
lead(',' || col, 3) over(PARTITION BY id ORDER BY col) AS str
FROM t_row_str)
WHERE rn = 1
ORDER BY 1;
5.3
MODEL
适用范围：10g及以后版本
SELECT id, substr(str, 2) str FROM t_row_str
MODEL
RETURN UPDATED ROWS
PARTITION BY(ID)
DIMENSION BY(row_number() over(PARTITION BY ID ORDER BY col) AS rn)
MEASURES (CAST(col AS VARCHAR2(20)) AS str)
RULES UPSERT
ITERATE(3) UNTIL( presentv(str[iteration_number+2],1,0)=0)
(str[0] = str[0] || ',' || str[iteration_number+1])
ORDER BY 1;
5.4
SYS_CONNECT_BY_PATH
适用范围：8i,9i,10g及以后版本
SELECT t.id id, MAX(substr(sys_connect_by_path(t.col, ','), 2)) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM t_row_str) t
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id
GROUP BY t.id;
适用范围：10g及以后版本
SELECT t.id id, substr(sys_connect_by_path(t.col, ','), 2) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM t_row_str) t
WHERE connect_by_isleaf = 1
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id;
5.5
WMSYS.WM_CONCAT
适用范围：10g及以后版本
这个函数预定义按','分隔字符串，若要用其他符号分隔可以用，replace将','替换。
SELECT id, REPLACE(wmsys.wm_concat(col), ',', '/') str
FROM t_row_str
GROUP BY id;
6.
字符串转换成多列
其实际上就是一个字符串拆分的问题。
CREATE TABLE t_str_col AS
SELECT ID,c1||','||c2||','||c3 AS c123
FROM t_col_str;
SELECT * FROM t_str_col;
6.1
SUBSTR + INSTR
适用范围：8i,9i,10g及以后版本
SELECT id,
c123,
substr(c123, 1, instr(c123 || ',', ',', 1, 1) - 1) c1,
substr(c123,
instr(c123 || ',', ',', 1, 1) + 1,
instr(c123 || ',', ',', 1, 2) - instr(c123 || ',', ',', 1, 1) - 1) c2,
substr(c123,
instr(c123 || ',', ',', 1, 2) + 1,
instr(c123 || ',', ',', 1, 3) - instr(c123 || ',', ',', 1, 2) - 1) c3
FROM t_str_col
ORDER BY 1;
6.2
REGEXP_SUBSTR
适用范围：10g及以后版本
SELECT id,
c123,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 1), ',') AS c1,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 2), ',') AS c2,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 3), ',') AS c3
FROM t_str_col
ORDER BY 1;
7.
字符串转换成多行
CREATE TABLE t_str_row AS
SELECT id,
MAX(decode(rn, 1, col, NULL)) ||
MAX(decode(rn, 2, ',' || col, NULL)) ||
MAX(decode(rn, 3, ',' || col, NULL)) str
FROM (SELECT id,
col,
row_number() over(PARTITION BY id ORDER BY col) AS rn
FROM t_row_str) t
GROUP BY id
ORDER BY 1;
SELECT * FROM t_str_row;
7.1
UNION ALL
适用范围：8i,9i,10g及以后版本
SELECT id, 1 AS p, substr(str, 1, instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
UNION ALL
SELECT id,
2 AS p,
substr(str,
instr(str || ',', ',', 1, 1) + 1,
instr(str || ',', ',', 1, 2) - instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
UNION ALL
SELECT id,
3 AS p,
substr(str,
instr(str || ',', ',', 1, 1) + 1,
instr(str || ',', ',', 1, 2) - instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
ORDER BY 1, 2;
适用范围：10g及以后版本
SELECT id, 1 AS p, rtrim(regexp_substr(str||',', '.*?' || ',', 1, 1), ',') AS cv
FROM t_str_row
UNION ALL
SELECT id, 2 AS p, rtrim(regexp_substr(str||',', '.*?' || ',', 1, 2), ',') AS cv
FROM t_str_row
UNION ALL
SELECT id, 3 AS p, rtrim(regexp_substr(str||',', '.*?' || ',',1,3), ',') AS cv
FROM t_str_row
ORDER BY 1, 2;
7.2
VARRAY
适用范围：8i,9i,10g及以后版本
要创建一个可变数组：
CREATE OR REPLACE TYPE ins_seq_type IS VARRAY(8) OF NUMBER;
SELECT * FROM TABLE(ins_seq_type(1, 2, 3, 4, 5));
SELECT t.id,
c.column_value AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.column_value) + 1,
instr(t.ca, ',', 1, c.column_value + 1) -
(instr(t.ca, ',', 1, c.column_value) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t
INNER JOIN TABLE(ins_seq_type(1, 2, 3)) c ON c.column_value <=
t.cnt
ORDER BY 1, 2;
7.3
SEQUENCE SERIES
这类方法主要是要产生一个连续的整数列，产生连续整数列的方法有很多，主要有：
CONNECT BY,ROWNUM+all_objects,CUBE等。
适用范围：8i,9i,10g及以后版本
SELECT t.id,
c.lv AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.lv) + 1,
instr(t.ca, ',', 1, c.lv + 1) -
(instr(t.ca, ',', 1, c.lv) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT LEVEL lv FROM dual CONNECT BY LEVEL <= 5) c
WHERE c.lv <= t.cnt
ORDER BY 1, 2;
SELECT t.id,
c.rn AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.rn) + 1,
instr(t.ca, ',', 1, c.rn + 1) -
(instr(t.ca, ',', 1, c.rn) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT rownum rn FROM all_objects WHERE rownum <= 5) c
WHERE c.rn <= t.cnt
ORDER BY 1, 2;
SELECT t.id,
c.cb AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.cb) + 1,
instr(t.ca, ',', 1, c.cb + 1) -
(instr(t.ca, ',', 1, c.cb) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT rownum cb FROM (SELECT 1 FROM dual GROUP BY CUBE(1, 2))) c
WHERE c.cb <= t.cnt
ORDER BY 1, 2;
适用范围：10g及以后版本
SELECT t.id,
c.lv AS p,
rtrim(regexp_substr(t.str || ',', '.*?' || ',', 1, c.lv), ',') AS cv
FROM (SELECT id,
str,
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL)) AS cnt
FROM t_str_row) t
INNER JOIN (SELECT LEVEL lv FROM dual CONNECT BY LEVEL <= 5) c ON c.lv <= t.cnt
ORDER BY 1, 2;
7.4
HIERARCHICAL + DBMS_RANDOM
适用范围：10g及以后版本
SELECT id,
LEVEL AS p,
rtrim(regexp_substr(str || ',', '.*?' || ',', 1, LEVEL), ',') AS cv
FROM t_str_row
CONNECT BY id = PRIOR id
AND PRIOR dbms_random.VALUE IS NOT NULL
AND LEVEL <=
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL))
ORDER BY 1, 2;
7.5
HIERARCHICAL + CONNECT_BY_ROOT
适用范围：10g及以后版本
SELECT id,
LEVEL AS p,
rtrim(regexp_substr(str || ',', '.*?' || ',', 1, LEVEL), ',') AS cv
FROM t_str_row
CONNECT BY id = connect_by_root id
AND LEVEL <=
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL))
ORDER BY 1, 2;
7.6
MODEL
适用范围：10g及以后版本
SELECT id, p, cv FROM t_str_row
MODEL
RETURN UPDATED ROWS
PARTITION BY(ID)
DIMENSION BY( 0 AS p)
MEASURES( str||',' AS cv)
RULES UPSERT
(cv
[ FOR p
FROM 1 TO length(regexp_replace(cv[0],'[^'||','||']',null))

例子：
SELECT t.dutyname , substr(sys_connect_by_path(t.username, ','), 2) str
FROM (SELECT dutyname, username, row_number() over(PARTITION BY dutyname ORDER BY username) rn
FROM test) t
WHERE connect_by_isleaf = 1
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND dutyname = PRIOR dutyname;

posted @ 2015-07-27 23:52 鸿雁 阅读(251) | 评论 (0) | 编辑 收藏

Https通讯原理

posted @ 2014-06-13 16:16 鸿雁 阅读(221) | 评论 (0) | 编辑 收藏

8种Nosql数据库系统对比

posted @ 2014-05-23 11:19 鸿雁 阅读(314) | 评论 (0) | 编辑 收藏

Oracle 10g内存结构之共享池的相关知识及使用简介

SGA中的第三个组成部分是共享池。共享池是对sql ,pl/sql 程序进行语法分析、编译、执行的内存区域。共享池包括库缓冲区（library cache）、数据字典缓冲区（Data Directory Cache）用户全局区（User Global Area）。其中库缓冲区含有Sql 语句的分析码、执行计划；数据字典缓冲区含有从数据字典中得到的表、列定义、权限。用户全局区包含用户的MTS 会话信息。

共享池主要用于对SQL 、pl/sql 程序语句进行语法分析、编译、执行、所以，如果应用中药运行大量存储过程或包，则要增加共享池的尺寸。共享池的大小由参数SHARE_POOL_SIZE确定。要了解共享池大小，可以用以下方法：

方法一：

………  
Shared_Pool_size = 52428800 
….. 

方法二：

SQL> select name,value from v$parameter where name like ‘%size’; 

方法三：

SQL> show parameter share_pool_size 

共享池应计算存储过程、包等的成功率。

可以查询数据字典 v$rowcache 了解数据字典的成功与失败次数。

SQL> select sum(gets) “dictionary gets”,  
Sum(getmisses) “dictionary cache getmisses”  
From v$rowcache ; 

其中gets 表示读取某一类数据字典的成功次数，getsmisses 表示读取某一类数据字典的失败次数。此外还可以通过查询结果计算共享池中读取数据字典的成功率

SQL> select parameter, get, getmisses, getmisses/(getmisses+gets)*100 “miss ratio”,  
(1-    (sum(getmisses)/(sum(getmisses)+sum(gets)) ) ) *100 “hit ratio”  
From v$rowcache  
Where gets+getmisses<>0  
Group by parameter,gets,getmisses; 

查询数据字典 v$librarycache 可以计算共享池中库缓存的失败率，结果应该小于1%。

SQL>select sum(pins) “ total pins”, sum(reloads) “ total reloads”, sum(reloads)/sum(pins)*100 libarycache  from  v$librarycache; 

其中 total pins 表示驻留内存的次数， total reloads 表示重新加载到内存的次数，librarycache 表示失败率。

上面分析了系统全局区的三个组成部分-----数据缓冲区、日志缓冲区及共享池，如果要得到SGA的总大小，可以在SQL*Plus中使用show sga 命令。

SQL>show sga或查询数据字典

SQL> select * from v$sga;

如果要查询某个参数的大小，可以查询数据字典v_$sagstat,通过计算可以知道sga的使用空间与空闲空间的比。

SQL>col OBJECT_NAME format a20  
SQL> col 空闲空间百分比(%) format 90.99  
SQL> select name,  
Sgasize/1024/1024  “allocated(M)” ,  
Bytes/1024        “空闲空间(k)” ,  
Round(bytes/sagsize*100,2)  “空闲空间百分比(%)”  
From ( select sum(bytes) sgasize from sys.v_$sgastat) s ,sys.v_$sgastat f  
Where f.name=’free memory’ ;  

关于Oracle 10g内存结构之共享池的相关知识及使用方法就介绍到这里了，希望本次的介绍能够对您有所收获！

posted @ 2014-05-17 23:37 鸿雁 阅读(162) | 评论 (0) | 编辑 收藏

Oracle 10g内存结构之系统全局区简介

我们知道，内存结构是Oracle体系结构中最重要的部分之一。按照系统对内存使用方法的不同，可以分为系统全局区（SGA）、程序全局区（PGA）、排序区（Sort Area）、大池（Large Pool）、及java池（java Pool），本文我们先介绍一下Oracle 10g内存结构之系统全局区的内容，接下来我们就开始介绍这部分内容。

系统全局区（System Global Area）

它是一组为系统分配的内存共享结构，可以包含一个数据库实例的数据和控制信息。如果多个用户连接到一个实例，在实例的系统全局区中，数据可以被多个用户共享，所以又称共享全局区。系统全局区按其作用不同，可以分为数据缓冲区、日志缓冲区及共享池。

数据缓冲区：

数据缓冲区用于从磁盘读入的数据，供所有用户共享。

修改的数据、插入的数据存储在数据缓冲区中，修改完成或DBWR进程的其他条件引发时，数据被写入数据文件

数据缓冲区工作原理：

LRU （Least recently used）：最近最少使用原则的缩写，是一种数据缓冲区的一种管理机制，，只保留最近数据，不保留旧数据。

Dirty：表示脏数据，脏数据是修改后还没有写到数据文件的数据。

Oracle10g 的数据库内存的设置参数不再由DB_BLOCK_BUFFERS确定，而是由oracle的新参数DB_CACHE_SIZE 和DB_nK_CACHE_SIZE确定，不同的数据段可以使用不同的数据块。大表可以存储在大的数据块表空间中，小表可以存储在小的数据块表空间中，以优化i/o性能。对于系统表空间、临时表空间、及其它默认设置的表空间，可以使用标准的数据块DB_BLOCK_SIZE确定。

标准数据块DB_BLOCK_SIZE用于系统表空间及默认表空间，其他表空间可以使用非标准数据块BLOCKSIZE（创建表空间时使用），其值分别为 2k 4k 8k 16k 32k ，非标准数据块的数据缓冲区使用参数DB_Nk_CACHE_SIZE确定。

需要注意的是BLOCKSIZE不得用于标准块。如果设置了DB_BLOCK_SIZE=2048,则不得设置DB_2K_CACHE_SIZE，标准块必须使用参数DB_CACHE_SIZE 来设置。同时可以在线修改数据缓冲区参数：SQL> alter system set db_2k_cache_size = 10M ;如果要查询数据缓冲区大小，可以如下：SQL> show parameter db。

在创建不同数据块表空间时，要使用参数BLOCKSIZE指出数据块的大小，同时在参数文件中要使用DB_Nk_CACHE_SIZE 进行配置，与BLOCKSIZE的个数相对应，否则会出现错误。

设置动态内存时，可以将多个参数全部写入参数文件，格式如下：

# cache and i/o  
 DB_BLOCK_SIZE=4096 
 DB_CACHE_SIZE=20971520 
 DB_2K_CACHE_SIZE=8M 
 DB_8K_CACHE_SIZE=4M 
 …….. 

其中，参数 DB_CACHE_SIZE 只适用于系统表空间、临时表空间、及默认表空间，DB_2K_CACHE_SIZE  适合 BLOCKSIZE 为2K的表空间。8K 也是一样的道理。

数据缓冲区对数据库德存取速度又直接影响。一般的缓冲区命中率应该在90% 以上。例如，使用数据字典 v$sysstat 计算数据缓冲区命中率：

SQL> select a.value+b.value “logical_reads” , c.value “phys_reads”,  
      Round(100* ( ( a.value+b.value)- c.value) /  
      ( a.value+b.value ) ) “buffer hit radio “  
      From v$sysstat a, v$sysstat b,v$sysstat c  
      Where a.statistic#=38 and b.statistic#=39 and c.statistic#=40; 

下面是计算数据缓冲命中率的另一种方法：

SQL> select name, value  
      From v$sysstat  
      Where name in ( ‘session logical reads’,’physical reads’,physical reads direct’, ‘physical reads direct (lob)’); 

其中：Session logical reads 为读的总量。Physical reads为从数据文件读。Physical reads direct 为从缓冲区读（不含lobs）。Physical reads direct (lobs) 为从缓冲区读（含lobs）。Hit Ratio = 1- ( ( physical reads- physical reads direct – physical reads direct(lob) ) /session logical reads) = 95%。

日志缓冲区

日志缓冲区用来存储数据库的修改信息。日志信息首先在日志缓冲区中产生，当日志缓冲区的日志达到一定数量时，由日志写入进程LGWR将日志数据写入日志文件组，再经过切换，由归档进程ARCH将日志数据写入归档介质。

日志缓冲区大小由参数LOG_BUFFER确定，要查询日志缓冲区大小可以用以下方法：

方法一：参数文件中：

 ……  
 Processes = 150 
 Parallel_max_servers = 5 
Log_buffer = 32768 
…….. 

方法二：

SQL> select name,value from v$parameter where name like ‘%buffer’; 

方法三：

SQL> show parameter log_buffer 

对于日志缓冲区而言可以计算失败率，使用数据字典v$latch 计算日志缓冲区的失败率

SQL>select name,gets,misses,immediate_gets,immediate_misses,  
     Decode(gets,0,0,misses/gets*100) ratiol,  
     Decode (immediate_gets+immediate_misses,0,0,  
immediate_misses/(immediate_gets+immediate_misses)*100)   ratio2  
     from v$latch  
     where name in (‘redo allocation’, ‘redo copy’); 

其中

Gets 表示成功等待日志缓冲区的次数。

Immediate gets 表示成功立即得到日志缓冲区的次数。

Immediate misses 表示未成功立即得到日志缓冲区的次数。

等待表示日志在进入日志缓冲区时，因为日志缓冲区过小而没有空闲空间，所以日志缓冲区的失败可以表示日志缓冲区是否足够大，不够大时，用户的日志写将产生等待过程。日志缓冲区的失败率应该小于1%。

此外，可以查询用户进程等待日志缓冲区时的次数，通过数据字典v$sysstat 得到：

SQL> select name,value from v$sysstat  
      Where name = ‘ redo buffer allocation retries’ ; 

关于Oracle 10g内存结构之系统全局区的相关知识就介绍到这里了，希望本次的介绍能够对您有所收获！

posted @ 2014-05-17 23:31 鸿雁 阅读(191) | 评论 (0) | 编辑 收藏

Oracle数据库命中率优化原理解析

本文是关于Oracle数据库调试与优化方面的文章，主要介绍Oracle数据库中命中率相关的问题，包括不同的算法之间性能的比对。关于Oracle中各个命中率的计算以及相关的调优

1)Library Cache的命中率:计算公式:Library Cache Hit Ratio = sum(pinhits) / sum(pins)

通常在98%以上，否则，需要要考虑加大共享池，绑定变量，修改cursor_sharing等参数。

2)计算共享池内存使用率:

其中: &TSP_IN_M是你的总的共享池的SIZE(M)

共享池内存使用率，应该稳定在75%-90%间，太小浪费内存，太大则内存不足。

查询空闲的共享池内存:

3)db buffer cache命中率:计算公式:Hit ratio = 1 - [physical reads/(block gets + consistent gets)]

通常应在90%以上，否则，需要调整,加大DB_CACHE_SIZE

外一种计算命中率的方法(摘自ORACLE官方文档<<数据库性能优化>>):

命中率的计算公式为:

Hit Ratio = 1 - ((physical reads - physical reads direct - physical reads direct (lob)) / (db block gets + consistent gets - physical reads direct - physical reads direct (lob))

分别代入上一查询中的结果值,就得出了Buffer cache的命中率

4)数据缓冲区命中率：

这里命中率的计算应该是令 x = physical reads direct + physical reads direct (lob),命中率 =100 - ( physical reads - x) / (consistent gets + db block gets - x)*100,通常如果发现命中率低于90%,则应该调整应用可可以考虑是否增大数据缓冲区

5)共享池的命中率：

假如共享池的命中率低于95%,就要考虑调整应用(通常是没使用bind var )或者增加内存

6)计算在内存中排序的比率:

查询内存排序数 

查询磁盘排序数caculate sort in memory ratio 

此比率越大越好,太小整要考虑调整,加大PGA

7)PGA的命中率:

计算公式:BP x 100 / (BP + EBP)

BP: bytes processed

EBP: extra bytes read/written

或者从OEM的图形界面中查看

我们可以查看一个视图以获取Oracle的建议值:

在此例中:PGA至少要分配375M

我个人认为PGA命中率不应该低于50%

以下的SQL统计sql语句执行在三种模式的次数: optimal memory size, one-pass memory size, multi-pass memory size:

8)共享区字典缓存区命中率

计算公式：SUM(gets - getmisses - usage -fixed) / SUM(gets)

命中率应大于0.85

9)数据高速缓存区命中率

计算公式：1-(physical reads / (db block gets + consistent gets))

命中率应大于0.90最好

10)共享区库缓存区命中率

计算公式：SUM(pins - reloads) / SUM(pins)

命中率应大于0.99

11)检测回滚段的争用

SUM(waits)值应小于SUM(gets)值的1%

12)检测回滚段收缩次数

几个常用的检查语句

1. 查找排序最多的SQL:

2.查找磁盘读写最多的SQL:

3.查找工作量最大的SQL(实际上也是按磁盘读写来排序的):

4. 用下列SQL工具找出低效SQL:

5、根据sid查看对应连接正在运行的sql

***************Oracle 缓冲区命中率低的分析及解决办法******************

首先确定下面的查询结果:

1,缓冲区命中率的查询(是否低于90%):

2,使用率的查询(有无free状态的数据快.):

3,相关等待事件的查询(是否有相关等待事件)

4,当前大小(是否已经很大)

5,top等待事件分析(Db file scatered read的比率是否大)

6,db_cache_advice建议值(9i后的新特性,可以根据他更好的调整cache_size)

说明分析:

缓冲区命中率(低于90的命中率就算比较低的).

没有free不一定说明需要增加,还要结合当前cache_size的大小(我们是否还可以再增大,是否有需要增加硬件,增加开销),

空闲缓冲区等待说明进程找不到空闲缓冲区，并通过写出灰缓冲区，来加速数据库写入器生成空闲缓冲区，当DBWn将块写入磁盘后，灰数据缓冲区将被释放，以便重新使用.产生这种原因主要是:

1，DBWn可能跟不上写入灰缓冲区：i/0系统较慢，尽量将文件均匀的分布于所有设备，

2，缓冲区过小或过大。

3，可以增加db_writer_processes数量。

4,可能有很大的一个事物，或者连续的大事物

我们需要长期观察这个事件是否长期存在并数值一直在增大,如果一直在增大,则说明需要增大db_cache大小.或优化sql.

数据分散读等待,通常表现存在着与全表扫描相关的等待，逻辑读时，在内存中进行的全表扫描一般是零散地，而并非连续的被分散到缓冲区的各个部分，可能有索引丢失，或被仰制索引的存在。该等待时间在数据库会话等待多块io读取结束的时候产生，并把指定的块数离散的分布在数据缓冲区。这意味这全表扫描过多，或者io不足或争用，

存在这个事件,多数都是问题的,这说明大量的全部扫描而未采用索引.

db_cache_advice对我们调整db_cache_size大小有一定的帮助,但这只是一个参考，不一定很精确。

通过上面6种情况的综合分析,判断是否需要增加大cache_size. 或者把常用的(小)表放到keep区。

但多数的时候做这些不会解决质的问题,

而真正的问题主要是对sql语句的优化(如:是否存在大量的全表扫描等)

索引是在不需要改变程序的情况下,对数据库性能，sql语句提高的最实用的方法.

我在生产中遇到过类似的问题,200M的cache_size,命中率很低21%,但通过对sql语句的优化(添加索引,避免全表扫描),命中率增加到96%,程序运行时间由原来的2小时减少到不到10分钟.

这就提到了怎么定位高消耗的sql问题.全表扫描的问题,在这里不做细致的解说,这里只说明方法,我会在相关的章节专门介绍怎么使用这些工具

1,sql_trace跟踪session.用tkprof 分别输出磁盘读,逻辑读,运行时间长的sql进行优化.这些高消耗的sql一般都伴随着全表扫描.

2,statspack分析.在系统繁忙时期进行时间点的统计分析,产看TOP事件是否有Db file scatered read.并查看TOP sql语句是否存在问题等.

还要说一句：当然在硬件允许的情况下，尽量增大db_cache_size 减少磁盘读，但并不是越大越好，一定要根据自己的库数据量的程度来调节，因为大的db_cache_size同样会增大数据库管理的开销，当然可能开销并不会明显的影响数据库的性能，硬件价格也越来越低，这就需要我们具体问题具体分析了，在我看来物尽其用就最好了，尽量不要浪费，找到问题的本质。调优是一件很艺术的事。

***********************Oracle数据库缓冲区命中率*****************

1、查看Oracle数据库缓冲区命中率

2、Tags: oracle

数据库缓冲区命中率：

这里命中率的计算应该是

令x=physical reads direct + physical reads direct(lob)

命中率=100-(physical reads -x)/(consistent gets +db block gets -x)*100

通常如果发现命中率低于90%，则应该调整应用可以考虑是否增大数据加

共享池的命中率

如果共享池的命中率低于95%就要考虑调整应用(通常是没应用bind var)或者增加内存。

关于排序部分

如果我们发现sorts(disk)/(sorts(memory)+sorts(disk))的比例过高，则通常意味着sort_area_size部分内存教较小，可考虑调整相应的参数。

关于log_buffer

假如redo buffer allocation retries/redo entries的比例超过1%我们就可以考虑增加log_buffer.

posted @ 2014-05-16 21:14 鸿雁 阅读(248) | 评论 (0) | 编辑 收藏

深入理解Oracle Statistic统计信息

1.统计信息简介

统计信息主要是描述数据库中表，索引的大小，规模，数据分布状况等的一类信息。比如，表的行数，块数，平均每行的大小，索引的leaf blocks，索引字段的行数，不同值的大小等，都属于统计信息。CBO正是根据这些统计信息数据，计算出不同访问路径下，不同join 方式下，各种计划的成本，最后选择出成本最小的计划。

在CBO(基于代价的优化器模式)条件下，SQL语句的执行计划由统计信息来决定，若没有统计信息则会采取动态采样的方式决定执行计划！可以说统计信息关乎sql的执行计划是否正确，属于sql执行的指导思想，oracle的初始化参数statistics_level控制收集统计信息的级别，有三个参数值:

BASIC :收集基本的统计信息

TYPICAL：收集大部分统计信息(数据库的默认设置)

ALL：收集全部统计信息

Oracle 10g之后，Query Optimizer就已经将CBO作为默认优化器，并且Oracle官方不再支持RBO服务。但是，通过优化器参数optimizer_mode，我们可以控制Oracle优化器生成不同模式下的执行计划。

关于优化器的请参考：《SQL性能优化之optimizer_mode参数原理渗透解析》

2.如何收集统计信息

2.1 统计信息的内容：

1）Table statistics

Number of rows --行数量

Number of blocks --block数量

Average row length --平均行的长度.

2）Column statistics

Number of distinct values (NDV) in column --列中distinct的值

Number of nulls in column --列中null的值

Data distribution (histogram)  --数据分布

3）Index statistics

Number of leaf blocks --子节点的块数量

Levels --子节点数量

Clustering factor --集群因子

4）System statistics

I/O performance and utilization --IO性能和利用率

CPU performance and utilization --CPU的性能和利用率

2.2 收集统计信息

Oracle Statistic 的收集，可以使用analyze 命令，也可以使用DBMS_STATS 包来收集，Oracle 建议使用DBMS_STATS包来收集统计信息，因为DBMS_STATS包收集的更广，并且更准确。analyze 在以后的版本中可能会被移除。

DBMS_STATS常用的几个过程如下：

analyze 命令的语法如下：

2.3 统计信息的分类

Oracle 的Statistic 信息的收集分两种：自动收集和手工收集。

Oracle 的Automatic Statistics Gathering 是通过Scheduler 来实现收集和维护的。Job 名称是GATHER_STATS_JOB, 该Job收集数据库所有对象的2种统计信息：

（1）Missing statistics（统计信息缺失）

（2）Stale statistics（统计信息陈旧）

该Job 是在数据库创建的时候自动创建，并由Scheduler来管理。Scheduler 在maintenance windows open时运行gather job。 默认情况下，job 会在每天晚上10到早上6点和周末全天开启。该过程首先检测统计信息缺失和陈旧的对象。然后确定优先级，再开始进行统计信息。

Scheduler Job的stop_on_window_close 属性控制GATHER_STATS_JOB 是否继续。该属性默认值为True. 如果该值设置为False，那么GATHER_STATS_JOB 会中断， 而没有收集完的对象将在下次启动时继续收集。

Gather_stats_job 调用dbms_stats.gather_database_stats_job_proc过程来收集statistics 的信息。 该过程收集对象statistics的条件如下：

（1）对象的统计信息之前没有收集过。

（2）当对象有超过10%的rows 被修改，此时对象的统计信息也称为stale statistics。

但是对于高度变化的表在白天的活动期间被TRUNCATE/DROP并重建或者块加载超过本身总大小10%的对象；我们可以将这些表上的统计设置为NULL

可以通过以下SQL来查看：

为了决定是否对对象进行监控，Oracle 提供了一个参数STATISTICS_LEVEL。通过设置初始化参数STATISTIC_LEVEL 为TYPICAL 或ALL，就可以自动收集统计信息(默认值为TYPICAL，因此可以随即启用自动收集统计信息的功能)。STATISTIC_LEVEL 参数的值可以激活GATHER_STATS_JOB。

在10g中表监控默认是激活的，如果STATISTICS_LEVEL设置为basic，不仅不能监控表，而且将禁掉如下一些10g的新功能：

（1）ASH(Active Session History)

（2）ASSM(Automatic Shared Memory Management)

（3）AWR(Automatic Workload Repository)

（4）ADDM(Automatic Database Diagnostic Monitor)

当启动对象的监控后，从上次统计信息收集之后的的信息，如inserts，updates，deletes 等，这些改变的信息会记录到user_tab_modifications 视图。

当对象的数据发生改变之后， 经过几分钟的延时，这些信息写入到user_tab_modifications视图，然后dbms_stats.flush_database_monitoring_info过程就会发现这些信息，并讲这些信息保存在内存中。

当监控的对象被修改的部分超过10%时，gather_database_stats 或者gather_schema_stats 过程就会去收集这些stale statistics

3.统计信息的存储位置以及常用数据字典

3.1 统计信息常用数据字典

统计信息收集如下数据：

（1）表自身的分析： 包括表中的行数，数据块数，行长等信息。

（2）列的分析：包括列值的重复数，列上的空值，数据在列上的分布情况。

（3）索引的分析： 包括索引叶块的数量，索引的深度，索引的聚合因子等。

这些统计信息存放在以下的数据字典里：

3.2 表的统计信息

包含表行数，使用的块数，空的块数，块的使用率，行迁移和链接的数量，pctfree，pctused的数据，行的平均大小：

3.3索引列的统计信息

包含索引的深度（B-Tree的级别），索引叶级的块数量，集群因子（clustering_factor), 唯一值的个数。

3.4 列的统计信息

包含唯一的值个数，列最大小值，密度（选择率），数据分布（直方图信息），NUll值个数

在OCP 10g考试中会有个跟统计信息相关的考试题：

1. In your Oracle 10g database , you have scheduled a job to update the optimizer statistics at 05:00 pm

every Friday. The job has successfully completed. Which three pieces of information would you check to

confirm that the statistics have been collected? (Choose three.)

A. average row size

B. last analyzed date

C. size of table in bytes

D. size of table in database blocks

E. number of free blocks in the free list

F. number of extents present in the table

Answer: ABD

posted @ 2014-05-16 19:08 鸿雁 阅读(293) | 评论 (0) | 编辑 收藏

Oracle统计信息的收集、管理与清除

posted @ 2014-05-16 18:21 鸿雁 阅读(190) | 评论 (0) | 编辑 收藏

oracle sql日期相关

posted @ 2014-05-15 17:36 鸿雁 阅读(376) | 评论 (0) | 编辑 收藏

Oracle 数据库启动的不同状态

Oracle数据库启动分为三个步骤：

nomount，找到初始化文件pfile或者spfile，创建SGA并启动后台进程但不允许访问数据库。

mount，根据初始化文件找到控制文件（Control File），为某些DBA活动装载数据库但不允许用户访问数据库。

open，根据控制文件找到数据文件（Data File），重做日志文件（Redo File），使用户可以访问数据库。

关闭数据库的4个不同命令

shutdown normal(等于shutdown)

正常是关闭的缺省方式正常的数据库关闭在下列情况下进行

• 不允许新的连接

• 等待会话结束

• 等待事务结束

• 做一个检查点并关闭数据文件

• 下一次启动时将不要求实例恢复

shutdown transactional

事务处理关闭防止客户丢失工作事务处理数据库关闭在下列情况下进行

• 不允许新的连接

• 不等待会话结束

• 等待事务结束

• 做一个检查点并关闭数据文件

• 下一次启动将不要求实例恢复

shutdown immediate

立即关闭数据库在下列情况下进行

• 不允许新的连接

• 不等待会话结束

• 不等待事务结束

• 未结束的事务自动回滚（rollback）

• 做一个检查点并关闭数据文件

• 下一次启动将不要求例程恢复

shutdown abort

如果正常和立即关闭选项不起作用可以中止当前数据库例程中止例程可以在下列情况下进行

• 不允许新的连接

• 不等待会话结束

• 不等待事务结束

• 不做检查点且没有关闭数据文件

• 下一次启动将要求实例恢复

启动数据库相关命令

startup（默认启动到open状态）

startup nomount

startup mount

alter database mount;

alter database open;

初始化文件

pfile，文本文件，可以手工编辑该文件

spfile，二进制文件，不能手工修改里面的参数，只能使用数据库命令进行修改，数据库启动默认使用spfile

查看初始化文件路径

show parameter spfile;

根据spfile创建pfile文件

create pfile from spfile;

create pfile='/u01/app/pfile.ora' fromspfile;

create spfile from pfile='/u01/app/pfile.ora';

查看控制文件的路径

select name from v$controlfile;

查看控制文件的内容，可以根据ctl.trc重建控制文件

alter database backup controlfile to trace as '/u01/app/ctl.trc';

查看数据文件的位置

select name from v$datafile;

查看重做日志文件的位置

select member from v$logfile;

数据库的密码文件

Windows，$ORACLE_HOME/database/PWDorcl.ora

Linux/Unix，$ORACLE_HOME/dbs/orapworcl

密码文件的作用是允许数据库的sysdba、sysoper用户通过口令来远登陆

查看数据库是否允许用户远程登陆数据库

show parameter remote_login_passwordfile;

如果remote_login_passwordfile为EXCLUSIVE则表示允许远程连接数据库

如果remote_login_passwordfile为NONE则表示不允许远程连接数据库

禁止用户远程登陆数据库（需要重启数据库生效）

alter system set remote_login_passwordfile=none scope=spfile;

表空间

select * from dba_tablespaces;

数据文件

select * from dba_data_files;

重做日志文件

select * from v$logfile;

重做日志文件的状态

STALE表示数据已经提交到数据库中，空白状态表示正在使用该文件

posted @ 2014-05-11 19:54 鸿雁 阅读(149) | 评论 (0) | 编辑 收藏

如何查看及解决最耗cpu的sql语句

posted @ 2014-05-11 19:44 鸿雁 阅读(209) | 评论 (0) | 编辑 收藏

Oracle 分区表的新增、修改、删除、合并。普通表转分区表方法

posted @ 2014-05-10 12:19 鸿雁 阅读(7798) | 评论 (0) | 编辑 收藏

Oracle分区表

1. 若分区表跨不同表空间，做导出、导入时目标数据库必须预建这些表空间。分表区各区所在表空间在做导入时目标数据库一定要预建这些表空间！这些表空间不一定是用户的默认表空间，只要存在即可。如果有一个不存在，就会报错！
2. 默认时，对分区表的许多表维护操作会使全局索引不可用，标记成UNUSABLE。 那么就必须重建整个全局索引或其全部分区。如果已被分区，Oracle 允许在用于维护操作的ALTER TABLE 语句中指定UPDATE GLOBAL INDEXES 来重载这个默认特性，指定这个子句也就告诉Oracle 当它执行维护操作的DDL 语句时更新全局索引，这提供了如下好处：
   1. 在操作基础表的同时更新全局索引这就不需要后来单独地重建全局索引；
   2. 因为没有被标记成UNUSABLE， 所以全局索引的可用性更高了，甚至正在执行分区的DDL 语句时仍然可用索引来访问表中的其他分区,避免了查询所有失效的全局索引的名字以便重建它们；

另外在指定UPDATE GLOBAL INDEXES 之前还要考虑如下性能因素:

1. 因为要更新事先被标记成UNUSABLE 的索引，所以分区的DDL 语句要执行更长时间，当然这要与先不更新索引而执行DDL 然后再重建索引所花的时间做个比较，一个适用的规则是如果分区的大小小于表的大小的5% ，则更新索引更快一点；
2. DROP TRUNCATE 和EXCHANGE 操作也不那么快了，同样这必须与先执行DDL 然后再重建所有全局索引所花的时间做个比较；
3. 要登记对索引的更新并产生重做记录和撤消记录，重建整个索引时可选择NOLOGGING；
4. 重建整个索引产生一个更有效的索引，因为这更利于使用空间，再者重建索引时允许修改存储选项；
5. 分区索引结构表不支持UPDATE GLOBAL INDEXES 子句。

将已存在数据的普通表转变为分区表，没有办法通过修改属性的方式直接转化为分区表，必须通过重建的方式进行转变，一般可以有三种方法，视不同场景使用：

CREATE TABLE T (ID NUMBER PRIMARY KEY, TIME DATE); 

INSERT INTO t
  SELECT Rownum, SYSDATE - Rownum FROM Dba_Objects WHERE Rownum <= 5000;
COMMIT;

CREATE TABLE T_NEW (ID, TIME) PARTITION BY RANGE (TIME) 
 (PARTITION P1 VALUES LESS THAN (TO_DATE('2000-1-1', 'YYYY-MM-DD')), 
 PARTITION P2 VALUES LESS THAN (TO_DATE('2002-1-1', 'YYYY-MM-DD')), 
 PARTITION P3 VALUES LESS THAN (TO_DATE('2005-1-1', 'YYYY-MM-DD')), 
 PARTITION P4 VALUES LESS THAN (MAXVALUE))
 AS SELECT ID, TIME FROM T; 

RENAME T TO T_OLD; 

RENAME T_NEW TO T; 

优点：方法简单易用，由于采用DDL语句，不会产生UNDO，且只产生少量REDO，效率相对较高，而且建表完成后数据已经在分布到各个分区中了。

不足：对于数据的一致性方面还需要额外的考虑。由于几乎没有办法通过手工锁定T表的方式保证一致性，在执行CREATE TABLE语句和RENAME T_NEW TO T语句直接的修改可能会丢失，如果要保证一致性，需要在执行完语句后对数据进行检查，而这个代价是比较大的。另外在执行两个RENAME语句之间执行的对T的访问会失败。

适用性：适用于修改不频繁的表，在闲时进行操作，表的数据量不宜太大。

Drop table t;
CREATE TABLE T (ID NUMBER PRIMARY KEY, TIME DATE); 
INSERT INTO t
  SELECT Rownum, SYSDATE - Rownum FROM Dba_Objects WHERE Rownum <= 5000;
COMMIT;

CREATE TABLE T_NEW (ID NUMBER PRIMARY KEY, TIME DATE) PARTITION BY RANGE (TIME) 
 (PARTITION P1 VALUES LESS THAN (TO_DATE('2005-9-1', 'YYYY-MM-DD')), 
 PARTITION P2 VALUES LESS THAN (MAXVALUE)); 

ALTER TABLE T_NEW EXCHANGE PARTITION P1 WITH TABLE T; 

RENAME T TO T_OLD; 

RENAME T_NEW TO T; 

优点：只是对数据字典中分区和表的定义进行了修改，没有数据的修改或复制，效率最高。如果对数据在分区中的分布没有进一步要求的话，实现比较简单。在执行完RENAME操作后，可以检查T_OLD中是否存在数据，如果存在的话，直接将这些数据插入到T中，可以保证对T插入的操作不会丢失。

不足：仍然存在一致性问题，交换分区之后RENAME T_NEW TO T之前，查询、更新和删除会出现错误或访问不到数据。如果要求数据分布到多个分区中，则需要进行分区的SPLIT操作，会增加操作的复杂度，效率也会降低。

适用性：适用于包含大数据量的表转到分区表中的一个分区的操作。应尽量在闲时进行操作。

Drop table t;
CREATE TABLE T (ID NUMBER PRIMARY KEY, TIME DATE); 
INSERT INTO T
 SELECT ROWNUM, SYSDATE - ROWNUM FROM DBA_OBJECTS WHERE ROWNUM <= 5000;
COMMIT;

EXEC DBMS_REDEFINITION.CAN_REDEF_TABLE(USER, 'T'); 

PL/SQL 过程已成功完成。 

CREATE TABLE T_NEW (ID NUMBER PRIMARY KEY, TIME DATE) PARTITION BY RANGE (TIME) 
 (PARTITION P1 VALUES LESS THAN (TO_DATE('2004-7-1', 'YYYY-MM-DD')), 
 PARTITION P2 VALUES LESS THAN (TO_DATE('2005-1-1', 'YYYY-MM-DD')), 
 PARTITION P3 VALUES LESS THAN (TO_DATE('2005-7-1', 'YYYY-MM-DD')), 
 PARTITION P4 VALUES LESS THAN (MAXVALUE)); 

表已创建。 

EXEC DBMS_REDEFINITION.START_REDEF_TABLE(USER, 'T', 'T_NEW'); 

PL/SQL 过程已成功完成。 

EXEC DBMS_REDEFINITION.FINISH_REDEF_TABLE(USER, 'T', 'T_NEW'); 

PL/SQL 过程已成功完成。 

优点：保证数据的一致性，在大部分时间内，表T都可以正常进行DML操作。只在切换的瞬间锁表，具有很高的可用性。这种方法具有很强的灵活性，对各种不同的需要都能满足。而且，可以在切换前进行相应的授权并建立各种约束，可以做到切换完成后不再需要任何额外的管理操作。

不足：实现上比上面两种略显复杂。

适用性：适用于各种情况。

这里只给出了在线重定义表的一个最简单的例子，详细的描述和例子可以参考下面两篇文章。

Oracle的在线重定义表功能：http://blog.itpub.net/post/468/12855

Oracle的在线重定义表功能（二）：http://blog.itpub.net/post/468/12962

第一种（表不是太大）：

--1.把原表改名：
rename xsb1 to xsb2;
--2.创建分区表：
CREATE TABLE xsb1
 PARTITION BY LIST (c_test) 
 (PARTITION xsb1_p1 VALUES (1),
 PARTITION xsb1_p2 VALUES (2),
 PARTITION xsb1_p0 VALUES (default))
 nologging AS SELECT * FROM xsb2;
--3.将原表上的触发器、主键、索引等应用到分区表上；
--4.删除原表：
drop table xsb2;

第二种(表很大)：

--1. 创建分区表：
CREATE TABLE x PARTITION BY LIST (c_test) [range ()]
 (PARTITION p0 VALUES [less than ](1) tablespace tbs1,
 PARTITION p2 VALUES (2) tablespace tbs1,
 PARTITION xsb1_p0 VALUES ([maxvalue]default))
 AS SELECT * FROM xsb2 [where 1=2];
--2. 交换分区 
alter table x exchange partition p0 with table bsvcbusrundatald ;
--3. 原表改名
alter table bsvcbusrundatald rename to x0;
--4. 新表改名
alter table x rename to bsvcbusrundatald ;
--5. 删除原表
drop table x0;
--6. 创建新表触发器和索引
create index ind_busrundata_lp on bsvcbusrundatald(。。。) local tablespace tbs_brd_ind ;

或者：

1. 规划原大表中数据分区的界限，原则上将原表中近期少量数据复制至另一表；

2. 暂停原大表中的相关触发器；

3. 删除原大表中近期数据；

4. 改名原大表名称；

5. 创建分区表；

6. 交换分区；

7. 重建相关索引及触发器（先删除之再重建）.

参考脚本：

select count(*) from t1 where recdate>sysdate-2;

create table x2 nologging as select * from t1 where recdate>trunc(sysdate-2);

alter triger trg_t1 disable;

delete t1 where recdate>sysdate-2;

commit;

rename t1 to x1;

create table t1 [nologging] partition by range(recdate)

(partition pbefore values less than (trunc(sysdate-2)),

partition pmax values less than (maxvalue))

as select * from x1 where 1=2;

alter table t1 exchange partition pbefore with table x1;

alter table t1 exchange partition pmax with table x2;

drop table x2;

--重建触发器

drop table x1;

1. 范围分区Range
2. 散列分区Hash
3. 列表分区List
4. 组合范围-散列分区Range-Hash
5. 组合范围-列表分区Range-List

可对索引和表分区。全局索引只能按范围分区，但可以将其定义在任何类型的分区或非分区表上。通常全局索引比局部索引需要更多的维护。

一般组建局部索引，以便反映其基础表的结构。它与基础表是等同分区的，即它与基础表在同样的列上分区，创建同样数量的分区或子分区，设置与基础表相对应的同样的分区边界。对局部索引而言，当维护活动影响分区时，会自动维护索引分区。这保证了索引与基础表之间的等同分区。

关于范围分区Range：

要想将行映射到基于列值范围的分区，就使用范围分区方法。当数据可以被划分成逻辑范围时如年度中的月份，这种类型的分区就有用了。当数据在整个范围中能被均等地划分时性能最好。如果靠范围的分区会由于不均等的划分而导致分区在大小上明显不同时，就需要考虑其他的分区方法。

关于散列分区Hash：

如果数据不那么容易进行范围分区，但为了性能和管理的原因又想分区时，就使用散列分区方法。散列分区提供了一种在指定数量的分区中均等地划分数据的方法。基于分区键的散列值将行映射到分区中。创建和使用散列分区会给你提供了一种很灵活的放置数据的方法，因为你可以通过在I/O 驱动器之间播撒(摘掉)这些均等定量的分区，来影响可用性和性能。

关于列表分区List：

当你需要明确地控制如何将行映射到分区时，就使用列表分区方法。可以在每个分区的描述中为该分区列指定一列离散值，这不同于范围分区，在那里一个范围与一个分区相关，这也不同于散列分区，在那里用户不能控制如何将行映射到分区。列表分区方法是特意为遵从离散值的模块化数据划分而设计的。范围分区或散列分区不那么容易做到这一点。进一步说列表分区可以非常自然地将无序的和不相关的数据集进行分组和组织到一起。

与范围分区和散列分区所不同，列表分区不支持多列分区。如果要将表按列分区，那么分区键就只能由表的一个单独的列组成，然而可以用范围分区或散列分区方法进行分区的所有的列,都可以用列表分区方法进行分区。

关于组合范围-散列分区：

范围和散列技术的组合，首先对表进行范围分区，然后用散列技术对每个范围分区再次分区。给定的范围分区的所有子分区加在一起表示数据的逻辑子集。

关于组合范围-列表分区：

范围和列表技术的组合，首先对表进行范围分区，然后用列表技术对每个范围分区再次分区。与组合范围-散列分区不同的是，每个子分区的所有内容表示数据的逻辑子集，由适当的范围和列表分区设置来描述。

注意：创建或更改分区表时可以指定行移动子句，即ENABLE ROW MOVEMENT 或者DISABLE ROW MOVEMENT ，当其键被更改时，该子句启用或停用将行迁移到一个新的分区。默认值为DISABLE ROW MOVEMENT。

如果表中预期的数据量较大，通常都需要考虑使用分区表，确定使用分区表后，还要确定什么类型的分区（range partition、hash partition、list partition等）、分区区间大小等。分区的创建最好与程序有某种默契，比如创建一个分区表，按自然月份定义分区的，但程序却在查询时默认的开始时间与结束时间是：当前日期-30至当前日期，比如当天是9.18号，那查询条件被产生为8.18-9.18，结果分区后并不没有大幅提高性能。为此将程序的查询日期做了调整，按自然月查询，系统的负载小了很多。

从Oracle8.0开始支持表分区（MSSQL2005开始支持表分区）。

Oracle9i 分区能够提高许多应用程序的可管理性、性能与可用性。分区可以将表、索引及索引编排表进一步划分，从而可以更精细地对这些数据库对象进行管理和访问。Oracle 提供了种类繁多的分区方案以满足所有的业务需要。另外，由于在 SQL 语句中是完全透明的，所以分区可以用于几乎所有的应用程序。

分区表允许将数据分成被称为分区甚至子分区的更小的更好管理的块。索引也可以这么分区。每个分区可以被单独管理，可以不依赖于其他分区而单独发挥作用，因此提供了一个更有利于可用性和性能的结构。

分区可以提高可管理性、性能与可用性，从而给各种各样的应用程序带来极大的好处。通常，分区可以使某些查询以及维护操作的性能大大提高。此外，分区还能够在很大程度上简化日常管理任务。分区还使数据库设计人员和管理员能够解决尖端应用程序带来的最难的问题。分区是建立上亿万字节数据系统或需要极高可用性系统的关键工具。

在多CPU配置环境下，如果打算使用并行执行，则分区提供了另一种并行的方法。通过给表或索引的不同分区分配不同的并行执行服务器，就可以并行执行对分区表和分区索引的操作。

表或索引的分区和子分区都共享相同的逻辑属性。例如表的所有分区或子分区共享相同的列和约束定义，一个索引的分区或子分区共享相同的索引选项。然而它们可以具有不同的物理属性如表空间。

尽管不需要将表或索引的每个分区或子分区放在不同的表空间，但这样做更好。将分区存储到不同的表空间能够：

1. 减少数据在多个分区中冲突的可能性
2. 可以单独备份和恢复每个分区
3. 控制分区与磁盘驱动器之间的映射对平衡I/O 负载是重要的
4. 改善可管理性可用性和性能

分区操作对现存的应用和运行在分区表上的标准DML 语句来说是透明的。但是可以通过在DML 中使用分区扩展表或索引的名字来对应用编程，使其利用分区的优点。

可以使用SQL*Loader、Import 和Export 工具来装载或卸载分区表中的数据。这些工具都是支持分区和子分区的。

使用分区技术，维护操作可集中于表的特定部分。例如，数据库管理员可以只对表的一部分做备份，而不必对整个表做备份。对整个数据库对象的维护操作，可以在每个分区的基础上进行，从而将维护工作分解成更容易管理的小块。

分区技术提高可管理性的一个典型用法是支持数据仓库中的‘滚动视窗’加载进程。假设数据库管理员每周向表中加载新数据。该表可以是范围分区，以便每个分区包含一周的数据。加载进程只是简单地添加新的分区。添加一个新分区的操作比修改整个表效率高很多，因为数据库管理员不需要修改任何其他分区。从分区后的表中去除数据也是一样。你只要用一个很简便快捷的数据字典操作删掉一个分区，而不必发出使用大量资源和调动所有要删除的数据的 ‘DELETE’ 命令。

由于减少了所检查或操作的数据数量，同时允许并行执行，Oracle9i 的分区功能提供了性能上的优势。这些性能包括：

1. 分区修整：分区修整是用分区技术提高性能的最简单最有价值的手段。分区修整常常能够将查询性能提高几个数量级。例如，假定应用程序中有包含定单历史记录的定单表，该表用周进行了分区。查询一周的定单只需访问该定单表的一个分区。如果该定单表包含两年的历史记录，这个查询只需要访问一个而不是一百零四个分区。该查询的执行速度因为分区修整而有可能快一百倍。分区修整能与所有其他 Oracle 性能特性协作。Oracle 公司将把分区修整技术与索引技术、连结技术和并行访问方法一起联合使用。
2. 分区智能联接：分区功能可以通过称为分区智能联接的技术提高多表联接的性能。当两个表要联接在一起，而且每个表都用联接关键字来分区时，就可以使用分区智能联接。分区智能联接将大型联接分解成较小的发生在各个分区间的联接，从而用较少的时间完成全部联接。这就给串行和并行的执行都能带来显著的性能改善。
3. 更新和删除的并行执行：分区功能能够无限地并行执行 UPDATE、DELETE 与 MERGE 语句。当访问分区或未分区的数据库对象时Oracle 将并行处理 SELECT 与 INSERT 语句。当不使用位图索引时，也可以对分区或未分区的数据库对象并行处理 UPDATE、DELETE 和 MERGE 语句。为了对有位图索引的对象并行处理那些操作，目标表必须先分区。这些 SQL 语句的并行执行可以大大提高性能，特别是提高 UPDATE 与 DELETE 或 MERGE 操作涉及大量数据时的性能。

分区的数据库对象具有分区独立性。该分区独立性特点可能是高可用性战略的一个重要部分，例如，如果分区表的分区不能用，但该表的所有其他分区仍然保持在线并可用。那么这个应用程序可以继续针对该分区表执行查询和事务处理，只要不是访问那个不可用的分区，数据库操作仍然能够成功运行。 数据库管理员可以指定各分区存放在不同的表空间里，从而让管理员独立于其它表分区针对每个分区进行备份与恢复操作。 还有，分区功能可以减少计划停机时间。性能由于分区功能得到了改善，使数据库管理员在相对较小的批处理窗口完成大型数据库对象的维护工作。

posted @ 2014-05-07 22:53 鸿雁 阅读(210) | 评论 (0) | 编辑 收藏

普通表转分区表和交换分区（oracle）

将普通表转换成分区表有4种方法：  

       1. Export/import method  

       2. Insert with a subquery method  

       3. Partition exchange method  

       4. DBMS_REDEFINITION           

    select * from t_user_info_test;  

    --方法一   

    drop table t_phone_test purge;  

create table t_phone_test(phone,part) nologging  partition by list(part)  

(  

partition p0 values('0'),  

partition p1 values('1'),  

partition p2 values('2'),  

partition p3 values('3'),  

partition p4 values('4'),  

partition p5 values('5'),  

partition p6 values('6'),  

partition p7 values('7'),  

partition p8 values('8'),  

partition p9 values('9')  

)   

as   

select user_mobile phone,substr(user_mobile,-1,1) part  

from t_user_info_test;  

select * from t_phone_test partition(p0);  

select * from t_phone_test where part='0';  

--方法二 交换分区   

     这种方法只是对数据字典中分区和表的定义进行了修改，没有数据的修改或复制，效率最高。适用于包含大数据量的表转到分区表中的一个分区的操作。尽量在闲时进行操作。  

交换分区的操作步骤如下：  

     1. 创建分区表，假设有2个分区，P1，P2.  

     2. 创建表A存放P1规则的数据。  

     3. 创建表B 存放P2规则的数据。  

     4. 用表A 和P1 分区交换。 把表A的数据放到到P1分区  

     5. 用表B 和p2 分区交换。 把表B的数据存放到P2分区。  

create table t_phone_test_0 nologging  

as   

select user_mobile phone,substr(user_mobile,-1,1) part  

from t_user_info_test where substr(user_mobile,-1,1)='0';  

select count(*) from t_phone_test where part='0';  

--4410   

select count(*) from t_user_info_test where substr(user_mobile,-1,1)='0';  

--4410   

alter table t_phone_test exchange partition p0 with table t_phone_test_0;  

delete from   t_phone_test_0;  

select count(*) from t_phone_test where part='0';  

select count(*) from t_phone_test_0;  

insert into t_phone_test(phone,part) values('15267046070','0');  

--p0一条数据，t_phone_test_0里4410条数据，交换之后p0是4410，t_phone_test_0是1，再执行一次数据又换回来了。   

insert into t_phone_test_0(phone,part) values('15267046070','1');  

alter table t_phone_test exchange partition p0 with table t_phone_test_0;  

delete from t_phone_test_0 where part='1';  

--合并分区   

----alter table tbname merge partitions/subpartitions pt1,pt2 into partition/subpartition pt3;   

alter table t_phone_test merge partitions p0,p1 into partition p0;  

select count(*) from t_phone_test where part='0';  

select count(*) from t_phone_test where part='1';  

select count(*)  from t_phone_test partition(p0);  

select count(*)  from t_phone_test partition(p1);  

 alter table t_phone_test  add partition p10 values(default);  

insert into t_phone_test(phone,part) values('15267046010','10');  

insert into t_phone_test(phone,part) values('15267046020','20');  

select * from   

--   

alter table t_phone_test drop partition p10;  

 alter table t_phone_test  add partition p10 values( '10');  

alter table t_phone_test exchange partition p10 with table t_phone_test_10;  

--ORA-14097: column type or size mismatch in ALTER TABLE EXCHANGE PARTITION   

alter table T_PHONE_TEST_10 modify PART VARCHAR2(2);  

alter table t_phone_test merge partitions p0,p10 into partition p0;  

--此时p0中有p0和p10的数据，但是p0的list不再是0而是0和10   

  partition P0 values ('10', '0')  

    tablespace APP_DATAN  

    pctfree 10  

    initrans 1  

    maxtrans 255  

    storage  

    (  

      initial 1M  

      next 1M  

      minextents 1  

      maxextents unlimited  

      pctincrease 0  

    ),  

alter table t_phone_test exchange partition p0 with table t_phone_test_10;     

alter table t_phone_test drop partition p0;  

alter table t_phone_test  add partition p0 values( '0');      

alter table t_phone_test exchange partition p0 with table t_phone_test_10;     

drop table t_phone_test_10 purge;  

create table t_phone_test_10 nologging  

as   

select user_mobile phone,substr(user_mobile,-2,2) part  

from t_user_info_test where substr(user_mobile,-2,2)='10';  

drop table t_phone_test_0 purge;  

create table t_phone_test_0 nologging   

as  

select  phone,substr(phone,-1,1) part  

from t_phone_test_10;  

alter table t_phone_test exchange partition p0 with table t_phone_test_0;  

select * from t_phone_test_10;  

select count(*)  from t_phone_test partition(p0);  

select count(*)  from t_phone_test partition(p10);  

select count(*) from t_phone_test_10;  

select count(*) from t_phone_test_0;  

select substr('123456',-1,1),substr('123456',-2,2),substr('123456',-3,2) from dual;  

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

1.创建分区表  

drop table t_phone_test purge;  

create table t_phone_test(phone,part) nologging  partition by list(part)  

(  

partition p0 values('0'),  

partition p1 values('1'),  

partition p2 values('2'),  

partition p3 values('3'),  

partition p4 values('4'),  

partition p5 values('5'),  

partition p6 values('6'),  

partition p7 values('7'),  

partition p8 values('8'),  

partition p9 values('9')  

)   

as   

select user_mobile phone,substr(user_mobile,-1,1) part  

from t_user_info_test;  

select count(*)  from t_phone_test partition(p0);--4410   

select count(*)  from t_phone_test partition(p10);  

select count(*) from t_phone_test_10;  

select count(*) from t_phone_test_0;  

2.创建基表  

drop table t_phone_test_10 purge;  

create table t_phone_test_10 nologging  

as  

select  phone,substr(phone,-2,2) part  

from t_phone_test where substr(phone,-2,2)='10';  

select count(*) from t_phone_test_10;--406   

--ORA-14097: column type or size mismatch in ALTER TABLE EXCHANGE PARTITION   

alter table T_PHONE_TEST_10 modify PART VARCHAR2(2);  

3.添加分区  

alter table t_phone_test  add partition p10 values( '10');      

select count(*)  from t_phone_test partition(p10);--0   

4.交换分区  

alter table t_phone_test exchange partition p10 with table t_phone_test_10;     

select count(*)  from t_phone_test partition(p10);--406   

5.合并分区  

alter table t_phone_test merge partitions p0,p10 into partition p0;  

select count(*)  from t_phone_test partition(p0);--4816   

--此时p0中有p0和p10的数据，但是p0的list不再是0而是0和10   

  partition P0 values ('10', '0')  

    tablespace APP_DATAN  

    pctfree 10  

    initrans 1  

    maxtrans 255  

    storage  

    (  

      initial 1M  

      next 1M  

      minextents 1  

      maxextents unlimited  

      pctincrease 0  

    ),  

6.交换分区  

alter table t_phone_test exchange partition p0 with table t_phone_test_10;    

select count(*)  from t_phone_test partition(p0);--0   

select count(*) from t_phone_test_10;--4816   

6.删除分区 和添加分区  

alter table t_phone_test  drop partition p0;  

alter table t_phone_test  add partition p0 values('0');  

7.筛选数据  

drop table t_phone_test_0 purge;  

create table t_phone_test_0 nologging  

as  

select  phone,substr(phone,-1,1) part  

from t_phone_test_10 where substr(phone,-1,1)='0';  

select count(*) from t_phone_test_0;--4816   

8.交换分区  

alter table t_phone_test exchange partition p0 with table t_phone_test_0;    

select count(*)  from t_phone_test partition(p0);--4816   
select count(*) from t_phone_test_0;--0  

posted @ 2014-05-07 22:31 鸿雁 阅读(312) | 评论 (0) | 编辑 收藏

Oracle全局索引和本地索引

posted @ 2014-05-06 17:29 鸿雁 阅读(225) | 评论 (0) | 编辑 收藏

解决ORA-12560: TNS: 协议适配器错误

posted @ 2014-05-05 10:46 鸿雁 阅读(165) | 评论 (0) | 编辑 收藏

Oracle优化全攻略一（Oracle SQL Hint）

posted @ 2014-05-04 21:21 鸿雁 阅读(210) | 评论 (0) | 编辑 收藏

Oracle 执行计划（Explain Plan） 说明

posted @ 2014-05-03 11:52 鸿雁 阅读(258) | 评论 (0) | 编辑 收藏

使用EXPLAIN PLAN获取SQL语句执行计划

posted @ 2014-05-03 11:44 鸿雁 阅读(159) | 评论 (0) | 编辑 收藏

执行计划的使用(EXPLAIN)

　　2.        Explain使用

　　Oracle RDBMS执行每一条SQL语句，都必须经过Oracle优化器的评估。所 以，了解优化器是如何选择（搜索）路径以及索引是如何被使用的，对优化SQL语句有很大的帮助。Explain可以用来迅速方便地查出对于给定SQL语句中的查询数据是如何得到的即搜索路径（我们通常称为Access Path）。从而使我们选择最优的查询方式达到最大的优化效果。

　　2.1.        安装

　　要使用执行计划首先需要执行相应的脚本。

　　使用Explain工具需要创建Explain_plan表，这必须先进入相关应用表、视图和索引的所有者的帐户内。Oracle的介质中包含有执行此项工作的SQL源程序，例如：

　　ORA_RDBMS： XPLAINPL.SQL （VMS）

　　$ORACLE_HOME/rdbms/admin/utlxplan.sql （UNIX）

　　该脚本后会生成一个表这个程序会创建一个名为plan_table的表，表结构如下：

　　我们简单的介绍一下主要的字段含义：

字段名              字段类型            含义
STATEMENT_ID    VARCHAR2(30)        explain PLAN 语句中所指定的最优STATEMENT_ID 参数值, 如果在EXPLAN PLAN语句中没有使用SET STATEMENT_ID，那么此值会被设为NULL。
REMARKS         VARCHAR2(80)        与被解释规划的各步骤相关联的注释最长可达80 字节
OPERATION       VARCHAR2(30)        各步骤所执行内部操作的名称在某条语句所产生的第一行中该列的可能取值如下DELETE STATEMENT INSERT STATEMENT SELECT STATEMENT UPDATE STATEMENT
OPTIONS         VARCHAR2(30)        对OPERATION 列中所描述操作的变种
OBJECT_NODE     VARCHAR2(128)       用于访问对象的数据库链接database link 的名称对于使用并行执行的本地查询该列能够描述操作中输出的次序
OBJECT_OWNER    VARCHAR2(30)        对于包含有表或索引的架构schema 给出其所有者的名称
OBJECT_NAME     VARCHAR2(30)        表或索引的名称
OBJECT_INSTANCE  INTEGER            根据对象出现在原始original 语句中的次序所给出的相应次序编号就原始的语句文本而论其处理顺序为自左至右自外向内景象扩张view
OBJECT_TYPE     VARCHAR2(30)        用于提供对象描述性信息的修饰符例如索引的NON-UNIQUE
OPTIMIZER       VARCHAR2(255)       当前优化程序的模式
ID              INTEGER             分配给执行规划各步骤的编号
PARENT_ID       INTEGER             对ID 步骤的输出进行操作的下一个执行步骤的ID
POSITION        INTEGER             对于具有相同PARENT_ID 的步骤其相应的处理次序
COST            INTEGER             根据优化程序的基于开销的方法所估计出的操作开销值对于使用基于规则方法的语句该列为空该列值没有特定的测量单位它只是一个用于比较执行规划开销大小的权重值
CARDINALITY     INTEGER             根据基于开销的方法对操作所访问行数的估计值
BYTES           INTEGER             根据基于开销的方法对操作所访问字节的估计

　　2.2.        使用

　　2.2.1.        常规使用

　　常规使用语法：

explain PLAN [ SET STATEMENT_ID [=] < string literal > ]
[ INTO < table_name > ]
FOR < sql_statement >
其中：
STATEMENT_ID是一个唯一的字符串，把当前执行计划与存储在同一PLAN表中的其它执行计划区别开来。
TABLE_NAME是plan表名，它结构如前所示，你可以任意设定这个名称。
SQL_STATEMENT是真正的SQL语句。
如：
SQL> explain plan set statement_id='test1' for
  2     SELECT a.soctermbegin,
  3            a.soctermend,
  4            a.dealserialno,
  5            a.levydataid,
  6            a.dealtotal,
  7            e.categoryitemcode,
  8            row_number() over(PARTITION BY a.levydataid ORDER BY 1) AS theRow
  9       FROM tb_soc_packdealdata   a,
10            tb_Lvy_TaxDataBillMap c,
11            Tb_lvy_BillData       d,
12            tb_soc_levydetaildata e
13      WHERE a.levydataid = c.datafrompointer(+)
14        AND c.billdataid = d.billdataid(+)
15        AND a.levydataid = e.levydataid
16        AND a.packdealstatuscode = '10'
17        AND (a.datastatus <> '9' OR a.datastatus is NULL)
18        AND (d.billstatus IS NULL OR
19            (d.billstatus <> '2' AND d.billstatus <> '8'))
20        AND a.Insurcode = '6010952'
21  ;
Explained