BlogJava-都市淘沙者-文章分类-Oracle/Mysql/Postgres/

Mysql 查找当天记录语句

都市淘沙者 — Wed, 17 Aug 2011 03:51:00 GMT

有些函数一直未发现，知道经常才知道，愧疚啊

本季度的第一天，然后你可以把字符串再转换为日期。方法很多，包括同一个函数的别名（同义词）也很多。比如CURDATE(),CURRENT_DATE(), CURRENT_DATE, NOW 等都可以返回当天

mysql教程> select CURDATE(),ELT(QUARTER(CURDATE()),
    ->  year(CURDATE())*1000+0101,
    ->  year(CURDATE())*1000+0401,
    ->  year(CURDATE())*1000+0701,
    ->  year(CURDATE())*1000+1001) as firstDayofQ;
+------------+-------------+
| CURDATE()  | firstDayofQ |
+------------+-------------+
| 2009-05-19 | 2009401     |
+------------+-------------+
1 row in set (0.00 sec)

mysql>

用mysql语句获取本季度的第一天

本月的第一天，
date(
concat(year(curdate()),'-',month(curdate()),'-','1'))
本周的第一天
curdate()-
WEEKDAY(curdate())

用mysql语句获取本季度的第一天

date(
concat(year(curdate()),'-',
if(quarter(curdate())=1,1,if(quarter(curdate())=2,4,if(quarter(curdate())=3,7,10))

用mysql语句获取本季度的第一天：
优化：
date(
concat(year(curdate()),'-',elt(quarter(curdate()),1,4,7,10),'-',1))

本周的第一天
date_add(date('2009-5-29'),INTERVAL -weekday('2009-5-29') day)

mysql 获取当天发布文件内容sql语句

SELECT * FROM `p8_memberdata` where regdate BETWEEN (UNIX_TIMESTAMP(NOW())-86440) AND NOW()
SELECT * FROM `p8_memberdata` WHERE DATE_FORMAT(FROM_UNIXTIME(regdate),'%Y-%m-%d')= DATE_FORMAT(NOW(),'%Y-%m-%d') order by uid desc

某一天内某一帖的回复人数，排除同一个多次回复的情况

SELECT COUNT(DISTINCT author_id,subject_id,(DATE_FORMAT(`create_time` , '%Y-%m-%d'))) FROM COMMENT
WHERE subject_id IN (SELECT id FROM group_post WHERE group_id=5135203559277568 )

导出某个表里指定的记录，命令行模式下导出：

mysqldump -h 127.0.0.1 -uroot -p123456 sns groups -x --where " id IN (SELECT groupid FROM activity_group)" > a.sql

查找表中当日插进的记录

SELECT * FROM table_name WHERE DATEDIFF(create_time,NOW())=0

都市淘沙者 2011-08-17 11:51 发表评论

MYSQL 主从服务器配置工作原理

都市淘沙者 — Tue, 29 Mar 2011 06:30:00 GMT

一、        主从配置的原理:
Mysql的 Replication 是一个异步的复制过程，从一个 Mysql instace(我们称之为 Master)复制到另一个
Mysql instance(我们称之 Slave)。在 Master 与 Slave
之间的实现整个复制过程主要由三个线程来完成，其中两个线程(Sql线程和IO线程)在 Slave 端，另外一个线程(IO线程)在 Master
端。
要实现 MySQL 的 Replication ，首先必须打开 Master 端的Binary
Log(mysql-bin.xxxxxx)功能，否则无法实现。因为整个复制过程实际上就是Slave从Master端获取该日志然后再在自己身上完全
顺序的执行日志中所记录的各种操作。打开 MySQL 的 Binary Log 可以通过在启动 MySQL Server 的过程中使用
“—log-bin” 参数选项，或者在 my.cnf 配置文件中的 mysqld 参数组([mysqld]标识后的参数部分)增加
“log-bin” 参数项。
MySQL 复制的基本过程如下：
1. Slave 上面的IO线程连接上 Master，并请求从指定日志文件的指定位置(或者从最开始的日志)之后的日志内容;

2. Master 接收到来自 Slave 的 IO 线程的请求后，通过负责复制的 IO
线程根据请求信息读取指定日志指定位置之后的日志信息，返回给 Slave 端的 IO
线程。返回信息中除了日志所包含的信息之外，还包括本次返回的信息在 Master 端的 Binary Log 文件的名称以及在 Binary
Log 中的位置;
3. Slave 的 IO 线程接收到信息后，将接收到的日志内容依次写入到 Slave 端的Relay
Log文件(mysql-relay-bin.xxxxxx)的最末端，并将读取到的Master端的bin-log的文件名和位置记录到master-
info文件中，以便在下一次读取的时候能够清楚的高速Master“我需要从某个bin-log的哪个位置开始往后的日志内容，请发给我”

4. Slave 的 SQL 线程检测到 Relay Log 中新增加了内容后，会马上解析该 Log 文件中的内容成为在 Master
端真实执行时候的那些可执行的 Query 语句，并在自身执行这些 Query。这样，实际上就是在 Master 端和 Slave
端执行了同样的 Query，所以两端的数据是完全一样的。
二、        设置mysql主从配置的优点：
1、        解决web应用系统，数据库出现的性能瓶颈，采用数据库集群的方式来实现查询负载；一个系统中数据库的查询操作比更新操作要多得多，通过多台查询服务器将数据库的查询分担到不同的查询服务器上从而提高查询效率。
2、        Mysql数据库支持数据库的主从复制功能，使用主数据库进行数据的插入、删除与更新操作，而从数据库则专门用来进行数据查询操作，这样可以将更新操作和查询操作分担到不同的数据库上，从而提高了查询效率。
三、        主从数据库服务器的配置
1、        主数据库服务器的配置
（1）、修改mysql的配置文件（/etc/my.cnf）在配置文件中设置：
server-id       = 1   ###每一个数据库服务器都要制定一个唯一的server-id，通常主服务器制定为1。
log-bin=mysql-bin     ###mysql进行主从复制是通过二进制的日志文件来进行的，所以必须开启mysql的日志功能
（这个是/etc/my.cnf的默认配置，保持不变即可）
（2）、 GRANT REPLICATION SLAVE ON *.* TO ' replication'@'172.28.3.41' IDENTIFIED BY 'koncept';        #####给主数据库服务器授予一个可以进行复制的用户，172.28.3.41为从服务器的IP，这样从服务器就能有钱先来访问主数据库服务器
2、从数据库服务器的设置
修改数据库配置文件/etc/my.cnf，配置如下内容：
#server-id      = 1  ####必须把server-id      = 1注释掉，
server-id       = 2  ####设置从的ID号
master-host     =  172.28.3.43  #####设置主服务器的IP
master-user     =   replication  #####设置连接主服务器的用户名
master-password =   concept     #####设置连接主服务器的密码
replicate-do-db=imtest0  ######设置你要同步的数据库，可以设置多个
####就是我们前面建的用户名和密码，另外如果有端口号的变化还要配置端口
master-port     =  <port> 配置成你设置的端口就OK了！
3、分别重新启动主从服务器 #### 如果不重新启动主服务器在后面查看status的时候会出现问题！
4在从服务器上登录mysql，输入：show slave status\G  如果发现有：
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
就说明已经成功了，如果这两个选项不全是Yes，那就说明你钱面的某个配置错了，
我做的时候没有把主服务器重启，就出现  Slave_IO_Running: NO。重启后好了！
四、        监控服务器的状态
1、        监控主服务器的状态
可通过show master status来监控主服务器的状态，内容如下：
+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000003 |     1164 |              |                  |
+------------------+----------+--------------+------------------+
#####其中File表示日志文件记录，Position表示日志文件的位置，这个也是数据库执行复制操作的必须标识，后面两字段表示复制的数据库名和不复制的数据库名，也可以在配置文件中你进行配置。
2、        监控从服务器的状态
可以通过：show slave status\G来查看，另外如果从数据库在复制的过程中出现问题，可以通过命令reset slave从数据库服务器复制的线程，从数据库服务器的通常操作命令有：
start slave；  ####启动复制线程
stop slave；  ####停止复制线程
reset slave；  ####重置复制线程
change master to； ###动态改变到主服务器的配置

都市淘沙者 2011-03-29 14:30 发表评论

Mysql-5.5.3-m3 主从同步不支持master-host问题的解决办法[转]

都市淘沙者 — Tue, 29 Mar 2011 06:01:00 GMT

http://hi.baidu.com/adriannet/blog/item/c4e187ecc586b7c32e2e2100.html

环境：
OS:CentOS release 5.5 (Final) (64位)
2.6.18-194.el5 #1 SMP Fri Apr 2 14:58:14 EDT 2010 x86_64 x86_64 x86_64 GNU/Linux
Mysql:
mysql-5.5.3-m3.tar.gz
Master:192.168.0.100
Slave:192.168.0.200
大部分配置跟"MySQL主从同步、读写分离配置步骤、问题解决笔记[原创]"类似，但在从服务器上配置的时候，加的复制条件都不能启动数据库；不过据网上消息介绍，Mysql版本从5.1.7以后开始就不支持“master-host”类似的参数;
查看mysql_error.log中的报错信息如下；
110105 13:38:00 mysqld_safe mysqld from pid file /data0/mysql/3306/mysql.pid ended
110105 13:38:06 mysqld_safe Starting mysqld daemon with databases from /data0/mysql/3306/data
InnoDB: The InnoDB memory heap is disabled
InnoDB: Mutexes and rw_locks use GCC atomic builtins
110105 13:38:06 InnoDB: highest supported file format is Barracuda.
110105 13:38:06 InnoDB Plugin 1.0.6 started; log sequence number 44309
110105 13:38:06 [ERROR] /usr/local/webserver/mysql/libexec/mysqld: unknown variable 'master-host=192.168.7.202'
110105 13:38:06 [ERROR] Aborting

110105 13:38:06 InnoDB: Starting shutdown...
110105 13:38:08 InnoDB: Shutdown completed; log sequence number 44319
110105 13:38:08 [Note] /usr/local/webserver/mysql/libexec/mysqld: Shutdown complete
无奈之下，从数据库my.cnf修改为以下配置；（主数据库中注意ID为1，并加入要同步的库既可）
[client]
character-set-server = utf8
port = 3306
socket = /tmp/mysql.sock

[mysqld]
character-set-server = utf8
replicate-ignore-db = mysql
replicate-do-db = db
replicate-ignore-db = test
replicate-ignore-db = information_schema
user = mysql
port = 3306
socket = /tmp/mysql.sock
basedir = /usr/local/mysql
datadir = /home/mysql/data
log-error = /home/mysql/mysql_error.log
pid-file = /home/mysql/mysql.pid
open_files_limit = 10240
back_log = 600
max_connections = 5000
max_connect_errors = 6000
table_cache = 614
external-locking = FALSE
max_allowed_packet = 32M
sort_buffer_size = 1M
join_buffer_size = 1M
thread_cache_size = 300
#thread_concurrency = 8
query_cache_size = 512M
query_cache_limit = 2M
query_cache_min_res_unit = 2k
default-storage-engine = MyISAM
thread_stack = 192K
transaction_isolation = READ-COMMITTED
tmp_table_size = 246M
max_heap_table_size = 246M
long_query_time = 3
log-slave-updates
log-bin = /home/mysql/binlog/binlog
binlog_cache_size = 4M
binlog_format = MIXED
max_binlog_cache_size = 8M
max_binlog_size = 1G
relay-log-index = /home/mysql/relaylog/relaylog
relay-log-info-file = /home/mysql/relaylog/relaylog
relay-log = /home/mysql/relaylog/relaylog
expire_logs_days = 30
key_buffer_size = 256M
read_buffer_size = 1M
read_rnd_buffer_size = 16M
bulk_insert_buffer_size = 64M
myisam_sort_buffer_size = 128M
myisam_max_sort_file_size = 10G
myisam_repair_threads = 1
myisam_recover
interactive_timeout = 120
wait_timeout = 120
skip-name-resolve
#master-connect-retry = 10
slave-skip-errors = 1032,1062,126,1114,1146,1048,1396
#master-host = 192.168.1.2
#master-user = username
#master-password = password
#master-port = 3306
server-id = 2
innodb_additional_mem_pool_size = 16M
innodb_buffer_pool_size = 512M
innodb_data_file_path = ibdata1:256M:autoextend
innodb_file_io_threads = 4
innodb_thread_concurrency = 8
innodb_flush_log_at_trx_commit = 2
innodb_log_buffer_size = 16M
innodb_log_file_size = 128M
innodb_log_files_in_group = 3
innodb_max_dirty_pages_pct = 90
innodb_lock_wait_timeout = 120
innodb_file_per_table = 0

#log-slow-queries = /home/mysql/slow.log

#long_query_time = 10

[mysqldump]
quick
max_allowed_packet = 32M

此时启动完数据库后，在从库上执行如下命令；
change master to master_host='192.168.0.100', master_user='slave', master_password='******', master_log_file='mysql-bin.000010', master_log_pos=16860;
slave start;
执行:show slave status"G;时看到的如下状态；
mysql> show slave status"G;
*************************** 1. row ***************************
               Slave_IO_State: Connecting to master
                  Master_Host: 192.168.0.100
                  Master_User: slave
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: binlog.000010
          Read_Master_Log_Pos: 16860
               Relay_Log_File: relaylog.000014
                Relay_Log_Pos: 17003
        Relay_Master_Log_File: binlog.000010
             Slave_IO_Running: Connecting
            Slave_SQL_Running: Yes
              Replicate_Do_DB: db
          Replicate_Ignore_DB: mysql,test,information_schema
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 16860
              Relay_Log_Space: 17295
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: error reconnecting to master 'slave@192.168.0.100:3306' - retry-time: 60 retries: 86400
               Last_SQL_Error:
Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
1 row in set (0.00 sec)

ERROR:
No query specified

从上面的状态可以看到，此时还无法从主库同步；

然后登录192.168.0.100主数据库,允许从数据库同步相关数据；
grant replication slave on *.* to slave@192.168.0.200 identified by '******'
再次重启从数据库，登录进去查看状态时：
mysql> show slave status"G;
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 192.168.0.100
                  Master_User: datasync
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: binlog.000010
          Read_Master_Log_Pos: 16860
               Relay_Log_File: relaylog.000014
                Relay_Log_Pos: 17003
        Relay_Master_Log_File: binlog.000010
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB: db
          Replicate_Ignore_DB: mysql,test,information_schema
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 16860
              Relay_Log_Space: 17295
              Until_Condition: None
               Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
1 row in set (0.00 sec)

ERROR:
No query specified
到此操作完成。
注意：主、从的my.cnf配置主要是ID，别的都问题不大。

都市淘沙者 2011-03-29 14:01 发表评论

Mysql 实现split字符串分割

都市淘沙者 — Sat, 26 Feb 2011 13:28:00 GMT

--场景大致如下：有A B两表，A表中的某一字段bids存放着一个B表主键的数组如3,4,5 而这个时候要做关联查询的时候，理想情况应该可以这样做
select b.* from A a,B b where b.id in (a.bids.split(',')) 但是mysql并不支持这样做,也没有提供类似的做法，所以很糟糕。有一种变态的做法就是给bids做一下处理，就是
在bids的前后都加上逗号, 这样bids就变成,3,4,5, 这个时候利用模糊查询来做关联就可以达到目的了，做法如下：

select b.* from A a, B b where CONCAT(CONCAT(',',a.bids),',') LIKE CONCAT(CONCAT('%,',b.id),',%')

当b的id=3时候的查询相当于执行
select b.* from A a, B b where ',3,4,5,' LIKE '%,3,%'

----真实例子----
SELECT t.*
FROM tea_material_trade t ,tea_process_product p WHERE p.id =2 AND CONCAT(CONCAT(',',p.tradeids),',') LIKE CONCAT(CONCAT('%,',t.id),',%')

--值得注意的是，这样的效率恐怕比较低，小数据量应该没有问题，大数据量估计不能这么做

mysql像个蛋一样，连基本的函数都不提供，难怪被oracle买了。只有通过存储过程来搞，郁闷得不行。

DELIMITER $$

USE `teasys`$$

DROP PROCEDURE IF EXISTS `proc_split`$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `proc_split`(
    inputstring VARCHAR(1000),
    delim CHAR(1)
)
BEGIN
    DECLARE strlen INT;
    DECLARE last_index INT;
    DECLARE cur_index INT;
    DECLARE cur_char VARCHAR(200);
    DECLARE len INT;
    SET cur_index=1;
    SET last_index=0;
    SET strlen=LENGTH(inputstring);
    DROP TABLE IF EXISTS splittable;
    CREATE TEMPORARY TABLE splittable(
        id INT AUTO_INCREMENT,
        VALUE VARCHAR(20),
        PRIMARY KEY (`ID`),
        UNIQUE KEY `ID` (`ID`)
    ) ;
    WHILE(cur_index<=strlen) DO
    BEGIN
        IF SUBSTRING(inputstring FROM cur_index FOR 1)=delim OR cur_index=strlen THEN
            SET len=cur_index-last_index-1;
            IF cur_index=strlen THEN
               SET len=len+1;
            END IF;
            INSERT INTO splittable(`value`)VALUES(SUBSTRING(inputstring FROM (last_index+1) FOR len));
            SET last_index=cur_index;
        END IF;
        SET cur_index=cur_index+1;
    END;
    END WHILE;
END$$

DELIMITER ;

CALL proc_split('a,b,c',',');
SELECT * FROM splittable

都市淘沙者 2011-02-26 21:28 发表评论

Oracle 数据库常用命令

都市淘沙者 — Thu, 13 Jan 2011 03:43:00 GMT

　　1.查询数据库当前进程的连接数：

　　select count(*) from v$process;

　　2.查看数据库当前会话的连接数：

　　elect count(*) from v$session;

　　3.查看数据库的并发连接数：

　　select count(*) from v$session where status='ACTIVE';

　　4.查看当前数据库建立的会话情况：

　　select sid,serial#,username,program,machine,status from v$session;

　　5.查询数据库允许的最大连接数：

　　select value from v$parameter where name = 'processes';

　　或者命令：show parameter processes;

　　6.修改数据库允许的最大连接数：

　　alter system set processes = 300 scope = spfile;

　　(需要重启数据库才能实现连接数的修改)

　　重启数据库：

　　SQL>shutdown immediate;

　　SQL>startup;

　　查看当前有哪些用户正在使用数据：

　　SQL>select osuser,a.username,cpu_time/executions/1000000||'s',sql_fulltext,machine

　　SQL>from v$session a,v$sqlarea b

　　SQL>where a.sql_address = b.address

　　SQL>order by cpu_time/executions desc;

　　备注：UNIX 1个用户session对应一个操作系统process，而Windows体现在线程。

　　启动oracle

　　su - oracle

　　SQL>sqlplus system/pwd as sysdba //进入sql

　　SQL>startup //启动数据库

　　SQL>lsnrctl start //启动监听

　　sqlplus "/as sysdba"

　　SQL>shutdown immediate; //关闭数据库

　　SQL>startup mount;

　　SQL>alter database open;

都市淘沙者 2011-01-13 11:43 发表评论

NoSQL数据库笔谈（转）

都市淘沙者 — Sun, 15 Aug 2010 08:51:00 GMT

摘要: 原文地址： http://www.yankay.com/wp-content/uploads/2010/02/NoSql%20Database%20Note/ NoSQL数据库笔谈 /* default css */ table { font-size: 1em; line-height: inherit; border-collapse: collapse; } tr ... 阅读全文

都市淘沙者 2010-08-15 16:51 发表评论

Oracle触发器及sql使用技巧

都市淘沙者 — Fri, 29 Jan 2010 12:07:00 GMT

很久没有玩这些玩意了，顺记录下WJ兄编写的触发器，大致实现的功能就是：当用户网terminal表插入一条记录时候顺便网ftp_user表插入一条记录，而后者表中
需要用到terminal表中的部分字段内容比如terminalseril字段，其中:new.terminalseril表示就是terminal表中新插入的这条记录的terminalseril值。现在对关键字做一下说明 :NEW 和:OLD使用方法和意义，new 只出现在insert和update时，old只出现在update和delete时。在insert时new表示新插入的行数据，update时new表示要替换的新数据、old表示要被更改的原来的数据行，delete时old表示要被删除的数据。触发器类型大致分为：事前触发和事后触发，具体可以google更详细。

create or replace trigger tib_terminal_insertFtp before insert
on Terminal for each row
declare
    integrity_error  exception;
    errno            integer;
    errmsg           char(200);
begin
    insert into FTP_USER (userid, userpassword,homedirectory, enableflag, writepermission, idletime,

uploadrate,downloadrate,maxloginnumber,maxloginperip)
                    VALUES (:new.terminalseril, 'E10ADC3949BA59ABBE56E057F20F883E', concat('/usr/local/ftproot/',:new.terminalseril), 1, 1, 0, 20480, 20480, 5, 5);
--  Errors handling
exception
    when integrity_error then
       raise_application_error(errno, errmsg);
end;

注意，如果要对在不同表空间的其他表进行插入操作，则需要具备有足够的权限，否则触发器编译会不通过。

另外下面是一个常有的sql语句，就是从当期的某个表选择数据插入另外一个表的常用方式：

insert into ftp_user(userid,userpassword,homedirectory,enableflag,writepermission,idletime,uploadrate,downloadrate,maxloginnumber,maxloginperip)
select distinct t.seril,'E10ADC3949BA59ABBE56E057F20F883E',
'/usr/local/ftproot/'||t.seril,
1,1,0,20480,20480,0,0 from terminal t

即将terminal表中的部分数据内容插入ftp_user用户之中。

都市淘沙者 2010-01-29 20:07 发表评论

oracle 查询不重复多列sql写法【原创】

都市淘沙者 — Fri, 23 Oct 2009 02:08:00 GMT

Oracle中要求查询表customer 中 t.address , t.customer_name不重复的列：

通常想法是：
select distinct t.address , t.customer_name from customer t
然而这种写法在oracle是错误的。

因此有第二种想法：
select count(*) from ( select distinct t.address , t.customer_name from customer t)
这种写法是正确的，然而有没有更好的写法呢

突发奇想的第三种，充分利用了||的连接功能：
select count(distinct t.address ||t.customer_name) from customer t

这样不就ok了吧，其实不是的，看看下面这种情况就知道了
若第一条记录为：
address= testAddT ，customer_name=omcat
第二条记录
address= testAdd ，customer_name=Tomcat
这种情况t.address ||t.customer_name得出的值都是一样的，然而显然这两条记录是不同的，如何解决这种问题呢，就是加入特殊字符来解决，比如我们确定这两列字段中不会出现#这样的字符内容，好办，此时就可以写出如下完美的sql语句了
select count(distinct t.address ||'#'||t.customer_name) from customer t

最后说明：不同的数据库中的sql查询语法都可能都会有差别的所以要针对特定数据库而言，不过思想是可以借鉴的，因此重要的是理解灵活的解决问题思想

都市淘沙者 2009-10-23 10:08 发表评论

解决MYSQL ERROR 1045 (28000)问题

都市淘沙者 — Wed, 26 Aug 2009 01:01:00 GMT

解决MYSQL ERROR 1045 (28000): Access denied for user (using password: YES)问题

开场白：解决LINUX问题是一种乐趣，当然，能遇到问题就是上天赐的享受幸福的机会。
这次使用的是Mandriva2008spring。
因为要搞一个项目，所以需要安装MySql，以往安装MySql都是非常顺利的，尤其MySql提供的rmp包，只需双击下就可以搞定~但不知道什么时候，MYSQL ERROR 1045 (28000): Access denied for user (using password: YES)，这个拒绝访问问题变得非常广泛。
百度了一下，没有现成的解决方法，唯有找出其问题所在了。
解决问题思路：
第一步，先使用跳过受权表访问，命令如下：mysqld_safe --user=mysql --skip-grant-tables --skip-networking & （当然，在这之前，先停止mysql服务的运行）。
第二步，mysql -uroot mysql 登录mysql。
第三步，访问mysql数据库下的user表。在我的机器上，mysql> select * from user; 得到的，竟然是
Empty set (0.00 sec)。这说明了，我的mysql没有任何可以访问的用户。知道了这问题所在，解决起来就简单了。另外一种情况有可能也存在该用户但是权限
或密码方面设置有问题也有可能报上面的错误，因此最好的办法先删掉该记录再重新添加该用户的纪录。
第四步，mysql> INSERT INTO user(host, user, password, select_priv, insert_priv, update_priv) VALUES ('localhost', 'username', PASSWORD(‘yourpassword’), 'Y', 'Y','Y');
Query OK, 1 row affected, 3 warnings (0.00 sec)
返回成功，没问题。嘿嘿~~~就这么简单。
第五步，测试，再重启下mysql服务，正常登录，成功！！！

提示：mysql系统中的mysql数据库，存储的是系统数据，像这里的user表存储的是用户信息及其访问权限，还有其他，例如你要新建一个数据库mydb，这数据库有用户me管理的话，mysql数据库里面的db表就会存储相关信息

都市淘沙者 2009-08-26 09:01 发表评论

MySQL索引分析和优化

都市淘沙者 — Mon, 17 Aug 2009 14:32:00 GMT

摘要: http://www.51testing.com/html/23/666.html 索引用来快速地寻找那些具有特定值的记录，所有MySQL索引都以B-树的形式保存。如果没有索引，执行查询时MySQL必须从第一个记录开始扫描整个表的所有记录，直至找到符合要求的记录。表里面的记录数量越多，这个操作的代价就越高。如果作为搜索条件的列上已经创建了索引，MySQL无需扫描任何记... 阅读全文

都市淘沙者 2009-08-17 22:32 发表评论

in和exists的区别与SQL执行效率分析[zhuan]

都市淘沙者 — Sat, 04 Jul 2009 12:00:00 GMT

in和exists的区别与SQL执行效率分析

原文：http://www.cnblogs.com/diction/archive/2008/01/18/1043844.html
本文对in和exists的区别与SQL执行效率进行了全面整理分析……

最近很多论坛又开始讨论in和exists的区别与SQL执行效率的问题，
本文特整理一些in和exists的区别与SQL执行效率分析

SQL中in可以分为三类：

　　1、形如select * from t1 where f1 in ('a','b')，应该和以下两种比较效率

　　select * from t1 where f1='a' or f1='b'

　　或者 select * from t1 where f1 ='a' union all select * from t1 f1='b'

　　你可能指的不是这一类，这里不做讨论。

　　2、形如select * from t1 where f1 in (select f1 from t2 where t2.fx='x')，

　　其中子查询的where里的条件不受外层查询的影响，这类查询一般情况下，自动优化会转成exist语句，也就是效率和exist一样。

　　3、形如select * from t1 where f1 in (select f1 from t2 where t2.fx=t1.fx)，

　　其中子查询的where里的条件受外层查询的影响，这类查询的效率要看相关条件涉及的字段的索引情况和数据量多少，一般认为效率不如exists。

　　除了第一类in语句都是可以转化成exists 语句的SQL，一般编程习惯应该是用exists而不用in，而很少去考虑in和exists的执行效率.

in和exists的SQL执行效率分析

　　A，B两个表，

　　(1)当只显示一个表的数据如A，关系条件只一个如ID时，使用IN更快：

　　select * from A where id in (select id from B)

　　(2)当只显示一个表的数据如A，关系条件不只一个如ID，col1时，使用IN就不方便了，可以使用EXISTS：

　　select * from A

　　where exists (select 1 from B where id = A.id and col1 = A.col1)

　　(3)当只显示两个表的数据时，使用IN，EXISTS都不合适，要使用连接：

　　select * from A left join B on id = A.id

　　所以使用何种方式，要根据要求来定。

　　这是一般情况下做的测试：

　　这是偶的测试结果:

　　set statistics io on
　　select * from sysobjects where exists (select 1 from syscolumns where id=syscolumns.id)
　　select * from sysobjects where id in (select id from syscolumns )
　　set statistics io off

　(47 行受影响)

　　表'syscolpars'。扫描计数 1，逻辑读取 3 次，物理读取 0 次，预读 2 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　表'sysschobjs'。扫描计数 1，逻辑读取 3 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　(1 行受影响)

　　(44 行受影响)

　　表'syscolpars'。扫描计数 47，逻辑读取 97 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　表'sysschobjs'。扫描计数 1，逻辑读取 3 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　(1 行受影响)

　　set statistics io on
　　select * from syscolumns where exists (select 1 from sysobjects where id=syscolumns.id)
　　select * from syscolumns where id in (select id from sysobjects )
　　set statistics io off

　　(419 行受影响)

　　表'syscolpars'。扫描计数 1，逻辑读取 10 次，物理读取 0 次，预读 15 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　表'sysschobjs'。扫描计数 1，逻辑读取 3 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　(1 行受影响)

　　(419 行受影响)

　　表'syscolpars'。扫描计数 1，逻辑读取 10 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　表'sysschobjs'。扫描计数 1，逻辑读取 3 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

　　(1 行受影响)

　　测试结果(总体来讲exists比in的效率高):

　　效率:条件因素的索引是非常关键的

　　把syscolumns 作为条件:syscolumns 数据大于sysobjects

　　用in

　　扫描计数 47，逻辑读取 97 次，

　　用exists

　　扫描计数 1，逻辑读取 3 次

　　把sysobjects作为条件:sysobjects的数据少于syscolumns

　　exists比in多预读 15 次

　　对此我记得还做过如下测试：

　　表

　　test

　　结构

　　id int identity(1,1), --id主键\自增

　　sort int, --类别,每一千条数据为一个类别

　　sid int --分类id

　　插入600w条数据

　　如果要查询每个类别的最大sid 的话

select * from test a
　　where not exists(select 1 from test where sort = a.sort and sid > a.sid)

比

select * from test a
　　where sid in (select max(sid) from test where sort = a.sort)

的执行效率要高三倍以上。具体的执行时间忘记了。但是结果我记得很清楚。在此之前我一直推崇第二种写法，后来就改第一种了。

in和exists的sql执行效率分析,再简单举一个例子：

declare @t table(id int identity(1,1), v varchar(10))
insert @t select'a'
union all select'b'
union all select'c'
union all select'd'
union all select'e'
union all select'b'
union all select'c'
--a语句in的sql写法
select * from @t where v in (select v from @t group by v having count(*)>1)
--b语句exists的sql写法
select * from @t a where exists(select 1 from @t where id!=a.id and v=a.v)

两条语句功能都是找到表变量@t中,v含有重复值的记录.

　　第一条sql语句使用in,但子查询中与外部没有连系.

　　第二条sql语句使用exists,但子查询中与外部有连系.

　　大家看SQL查询计划,很清楚了.

　　selec v from @t group by v having count(*)> 1

　　这条Sql语句,它的执行不依赖于主查询主句(我也不知道怎么来描述in外面的和里面的,暂且这么叫吧,大家明白就行)

　　那么,SQL在查询时就会优化,即将它的结果集缓存起来

　　即缓存了

　　v

　　---

　　b

　　c

　　后续的操作,主查询在每处理一步时,相当于在处理 where v in('b','c') 当然,语句不会这么转化, 只是为了说明意思,也即主查询每处理一行(记为currentROW时,子查询不会再扫描表, 只会与缓存的结果进行匹配

　　而

　　select 1 from @t where id!=a.id and v=a.v

　　这一句,它的执行结果依赖于主查询中的每一行.

　　当处理主查询第一行时即 currentROW(id=1)时, 子查询再次被执行 select 1 from @t where id!=1 and v='a' 扫描全表,从第一行记 currentSubROW(id=1) 开始扫描,id相同,过滤,子查询行下移,currentSubROW(id=2)继续,id不同,但v值不匹配,子查询行继续下移...直到currentSubROW(id=7)没找到匹配的, 子查询处理结束,第一行currentROW(id=1)被过滤,主查询记录行下移

　　处理第二行时,currentROW(id=2), 子查询 select 1 from @t where id!=2 and v='b' ,第一行currentSubROW(id=1)v值不匹配,子查询下移,第二行,id相同过滤,第三行,...到第六行,id不同,v值匹配, 找到匹配结果,即返回,不再往下处理记录. 主查询下移.

　　处理第三行时，以此类推...

　　sql优化中，使用in和exist？主要是看你的筛选条件是在主查询上还是在子查询上。

　　通过分析，相信大家已经对in和exists的区别、in和exists的SQL执行效率有较清晰的了解。

都市淘沙者 2009-07-04 20:00 发表评论

unix 系统下定时备份oracle数据库dmp文件

都市淘沙者 — Fri, 24 Apr 2009 06:08:00 GMT

原文地址：http://bbs.chinaunix.net/viewthread.php?tid=806862&pid=10440039&page=1&extra=
前提：
1、需要知道的信息：
oracle 的system密码以及要备份数据库账户的账户名和密码
Sco unix 的root密码、oracle密码
2、会使用vi编辑文件、mkdir创建文件夹、chmod改变文件权限、su 切换用户、文件的执行
3、了解sco unix的用户、组、权限及crontab的用途、oracle的dmp文件生成
一、建立数据库dmp文件存放目录
#su - oracle
$cd /dbf
$mkdir dmpbak
$cd dmpbak
$mkdir zd
$mkdir cm
二、建立导出数据库dmp的文件
1、指定目录
#su - oracle
$cd bin
2、用vi编辑exp_t文件
$vi exp_t
exp_t内容：
ORACLE_HOME=/oracle
ORACLE_SID=ora7
ORACLE_TERM=ansi
export ORACLE_HOME ORACLE_SID ORACLE_TERM
MENU5PATH=$ORACLE_HOME/forms30/admin/resource
export MENU5PATH
ORATERMPATH=$ORACLE_HOME/forms30/admin/resource
export ORATERMPATH
NLS_LANG=American_America.ZHS16CGB231280
export NLS_LANG
ORA_NLS=/oracle/ocommon/nls/admin/data
export ORA_NLS
home1='/dbf/dmpbak'
dt1=`date "+%H%M"`
echo ' ' >'$home1/'new_record
file_name="$home1"/zd/zd"$dt1"
echo $file_name >>'$home1'/new_record
$ORACLE_HOME/bin/exp zd/zdzd file=$file_name.dmp owner=zd grants=y buffer=204800 rows=y indexes=y compress=y
file_name="$home1"/cm/cm"$dt1"
echo $file_name >>'$home1'/new_record
$ORACLE_HOME/bin/exp common/cmcm file=$file_name.dmp owner=common grants=y buffer=204800 rows=y indexes=y compress=y
file='/dbf/dmpbak/new_record'
backup_dir='/oracle/sec_back'
if [ -d $backup_dir ]
then
for i in `cat $file`
do
cp $i $backup_dir/
done
echo ' '>$file
fi
3、给exp_t权限
$chmod 755 exp_t
4、测试exp_t
$cd /oracle/bin
$exp_t
5、查看dmp文件是否生成
$cd /dbf/dmpbak/zd
$ls
例如：11点35生成的文件是：1135.dmp
如果生成dmp文件，证明exp_t可以使用
三、编辑crontab
#crontab -e
增加行：
35 * * * * su - oracle -c /oracle/bin/exp_t
意思是每天每个小时的35分备份一次dmp文件
第2天的数据会覆盖第一天的数据

以上为个人总结，已经经过试验，不足之处会进行改进，希望对大家有所帮助

都市淘沙者 2009-04-24 14:08 发表评论

使用 C-JDBC 给 Mysql 集群

都市淘沙者 — Tue, 26 Aug 2008 04:06:00 GMT

摘要: 原文：http://huaronghu.spaces.live.com/blog/cns!B9A68E1C1CA857AD!288.entry 使用 C-JDBC 给 Mysql 集群润名，Thursday Twentieth Of April 一、前言&nbs... 阅读全文

都市淘沙者 2008-08-26 12:06 发表评论

层次关系数据库表的设计

都市淘沙者 — Tue, 26 Aug 2008 03:29:00 GMT

数据层次的概念:

　　数据层次是表达数据的一种重要关系，在数据库的设计中，如：组织结构分解、工作任务分解、行政区划的分解等都是层次关系数据的典型实例。

　　表达层次关系的数据一般需要实现如下属性：

　　1.层次的最大级联层次数。如：中国－>湖南省->长沙市->雨花区，就是4层。

　　2.能反映同一层次之间的顺序关系。如：长沙市必须在衡阳市的前面，（因为其是省会）。

　　3.能获取任意层次的父节点级子节点（子节点集）。

　　4.直接获取任意层次的数据。比如：第三层市级别的数据。

　　5.能方便构造层次关系表达树。

　　6.层次结构及排序方式的改变不影响其其他数据的内部逻辑关系。

　　一般有三种方式来表现层次关系的数据：

　　1.建立多个数据库表：

　　如： COUNTRY: ID(主键) COUNTRY_NAME

　　PROVINCE: ID(主键) COUNTRY_ID（外键）,PROVINCE_NAME

　　CITY: ID(主键), PROVINCE_ID（外键）,CITY_NAME

　　此种方式比较简单，但设计的灵活性不够，数据处理起来比较麻烦。

　　2.采用表的自关联外键引用

　　如： DISTRICT_INFO: ID（主键）,PARENT_ID,（外键）DISTRICT_INFO

　　通过外键(PARENT_ID)的自身引用主键(ID)来确立层次关系。

　　优点：无限级别的层次关系，扩充性强。对于Oracle数据库来说，能简单通过 Start With,,,Connect By--语句来实现数据的查询。

　　缺点：不能明确看出层次关系，无法实现排序。

　　3.采用编码方式来实现层次

　　DISTRICT: ID,CODE,NAME 其中CODE的特点是上级编码是下级编码的前缀

　　优点：通过编码的内容能够很容易回去数据的层次关系。

　　缺点：使用Like方法或函数查询来实现子集的查找，效率较低，能实现层次关系的级数有限（受CODE的字段长度影响）。

　　优化方案：

　　集合2，3的优点，采用固定编码级次的长度的方法来设计表。

　　DISTRICT:ID,CODE,PARENT_ID,NAME

　　其中ID为主键，CODE:规定为4位一级。表现的数据如下：

ID,CODE                  PARENT_ID,      NAME
            1  0001                                  中国
            2  00010001                  1           湖南
            3  000100010001              2           衡阳
            4  000100010002              2           长沙
            5  0001000100020001           4          雨花

　　从数据中可以看出，PARENT_ID可以直观表达层次的上下级关系

　　而编码CODE可以直观表达层次关系与同一层次的顺序关系。

　　如果要将长沙排在衡阳的前面，需要对调其编码即可，而外部的引用关系由于通过ID实现，不会受其影响。

　　获取节点的父级别节点：

　　Select * From DISTRICT Where ID＝(Select PARENT_ID From DISTRICT Where ID=2)

　　获取节点的子级别节点列表：

　　Select * From DISTRICT Where PARENT_ID＝2

　　获取所有的子节点信息：

　　Select level, * From DISTRICT d Start With PARENT_ID＝2 Connect By d.PARENT_ID=Prior t.ID

　　或 --排序模式

　　Select * From DISTRICT d Where d.CODE Like '00010001%' Order By CODE

　　获取某一层次(N)的节点信息(实现排序，层次码长度固定的意义)：

　　Select * From DISTRICT Where LENGTH(CODE)=4*N And CODE Like '0001%' Order By CODE......

都市淘沙者 2008-08-26 11:29 发表评论

关于索引的知识 (zhuanTie)

都市淘沙者 — Tue, 26 Aug 2008 02:52:00 GMT

一、关于索引的知识

要写出运行效率高的sql，需要对索引的机制有一定了解，下面对索引的基本知识做一介绍。

1、索引的优点和局限
索引可以提高查询的效率，但会降低dml操作的效率。
所以建立索引时需要权衡。对于dml操作比较频繁的表，索引的个数不宜太多。

2、什么样的列需要建索引？
经常用于查询、排序和分组的列（即经常在where、order或group by子句中出现的列）。

3、主键索引和复合索引
对于一张表的主键，系统会自动为其建立索引。
如果一张表的几列经常同时作为查询条件，可为其建立复合索引。

4、建立索引的语句
create  index  i_staff  on  staff  (empno);
create  index  i_agent  on  agent  (empno, start_date);

5、删除索引的语句
drop  index  I_staff;
drop  index  I_agent;

6、查询索引的语句
法一：利用数据字典
表一：all_indexes  查看一张表有哪些索引以及索引状态是否有效
主要字段： index_name,  table_name,  status
例如：select index_name,  status
from  all_indexes
      where  table_name=’STAFF_INFO’;
   INDEX_NAME       STATUS
   ---------------------    -----------
   I_STAFF          VALID
         表二：all_ind_columns  查看一张表在哪些字段上建了索引
            主要字段： table_name,  index_name,  column_name,  column_position
例如： select  index_name,  column_name,  column_position
from  all_ind_columns
      where  table_name=’AGENT’
   INDEX_NAME       COLUMN_NAME    COLUMN_POSITON
   ---------------------    -----------------------    --------------------------
   I_AGENT          EMPNO             1
   I_AGENT          START_DATE       2
由此可见，agent表中有一个复合索引（empno, start_date ）
   法二：利用toad工具
toad用户界面比sql*plus友好，并且功能强大。你可以在toad编辑器中键入表名，按F4，便可见到这张表的表结构以及所有索引列等基本信息。

7、索引的一些特点
1): 不同值较多的列上可建立检索，不同值少的列上则不要建。比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就没必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度。
2): 如果在索引列上加表达式，则索引不能正常使用
例如：b1,c1分别是表b,c的索引列
select  *  from  b  where  b1/30< 1000 ;
select  *  from  c  where  to_char(c1,’YYYYMMDD HH24:MI:SS’) = ‘200203 14:01:01’;
以上都是不正确的写法
      3): where子句中如果使用in、or、like、!=，均会导致索引不能正常使用
         例如：select  *  from  b  where  b1=30  or  b1=40;
   4): 使用复合索引进行查询时必须使用前置列
      例如表a上有一个复合索引（c1,c2,c3）,则c1为其前置列
      如果用c1或c1+c2或c1+c2+c3为条件进行查询，则该复合索引可以发挥作用，反之，用c2或c3或c2+c3进行查询，则该索引不能起作用。

二. 书写sql注意事项：

1、避免给sql语句中引用的索引列添加表达式：
典型实例：
b1,c1分别是表b,c的索引列：
1） select  *  from  b  where  b1/30< 1000 ;
2） select  *  from  c  where to_char(c1,’YYYYMMDD HH24:MI:SS’) = ‘200203 14:01:01’;
替代方案：
1) select  *  from  b where  b1 < 30000;
2) select * from c  where c1 = to_date(‘20020301 14:01:01’, ‘YYYYMMDD HH24:MI:SS’);
注：在lbs中有两个重要字段，pol_info中的undwrt_date和prem_info中的payment_date，这两个日期是带时分秒的，所以经常有同事用to_char 来查询某一时间段的数据。
例如：select  count(*)  from  pol_info  where  to_char(undwrt_date,’YYYYMMDD’)=’20020416’;
   select  count(*)  from  prem_info  where  to_char(undwrt_date,’YYYYMM’)=’200203’;
替代方案：
select  count(*)  from  pol_info
where  undwrt_date>=to_date(’20020416’,’YYYYMMDD’)  and
         undwrt_date select  count(*)  from  prem_info
where  payment_date>=to_date(’20020301’,’YYYYMMDD’)  and
      payment_date
2、避免在where子句中使用in、or、like、!=
典型实例：
a1是a表上的索引列：
1) select  *  from  a
where  ( a1 = ‘0’ and ...)  or  (a1 = ‘1’ and ...);
2) select  count(*)  from  a  where  a1  in  (‘0’,’1’) ;
替代方案：
1） select  *  from  a  where  a1 = ‘0’  and ...
union
select  *  from  a  where  a1 = ‘1’  and ...
2) select  count(*)  from  a  where  a1 = ‘0’;
  select  count(*)  from  a  where a1 = ‘1’;
然后做一次加法运算；或者直接用存储过程来实现；
小结：
对字段使用了 ‘in，or，like’ 做条件、对字段使用了不等号 ‘!=’，均会使索引失效；如果不产生大量重复值，可以考虑把子句拆开；拆开的子句中应该包含索引，或者使用union连结符代替。另一种方式是使用存储过程，它使SQL变得更加灵活和高效。

3、建立适当的索引
曾经接过开发的一个统计sql， select …  from  tablea  where  cola=…  and  …
运行效率非常慢，经查tablea数据量巨大，再查all_ind_columns，发现cola是tablea的一个复合索引中的一列，但不是前置列。象这种情况，就需要与开发商量，是否针对cola建一个索引。

4、 like和substr
对于‘like’和‘substr’，其效率并没有多大分别。但是，当所搜索的值不存在时，使用‘like’的速度明显大于‘substr’。
所以：select  *  from  a  where  substr(a1,1,4) = '5378'  可以用like替代
select  *  from  a  where  a1  like  ‘5378%’;

5、写where条件时，有索引字段的判断在前，其它字段的判断在后；如果where条件中用到复合索引，按照索引列在复合索引中出现的顺序来依次写where条件；

6、使用多表连接时，在from子句中，将记录数少的表放在后面，可提高执行效率；

7、避免使用not in
not  in 是效率极低的写法，尽量使用minus或外连接加以替代
典型实例：
1) select col1 from tab1 where col1 not in (select col1 from tab2);
2) select sum(col2) from tab1 where col1 not in (select col1 from tab2);
替代方案
select col1 from tab1 minus  select col1 from tab2;
select  sum(a.col2)  from  tab1 a, tab2  b
where a.col1=b.col2(+) and b.col1 is null;

8、多表查询时，如果其中一个表的记录数量明显大于其他表，则可以先对此表进行查询后，再与其他小表进行表连接。
典型实例：
select  a.plan_code,  b.dno,  c,tno,  sum(a.tot_modal_prem),
from  prem_info a,  dept_ref b,  plan_type c
where  substr(a.deptno,1,7) = substr(b.deptno,1,7)
and a.plan_code = c.plan_code
group by b.dno,  c.tno,  a.plan_code;
替代方案：
select  b.dno,  c.tno,  a.plan_code,  a.tot_amount
from  (select  plan_code,  deptno,  sum(tot_modal_prem)  tot_amount
from  prem_info
group  by  deptno,  plan_code) a
dept_ref  b,
plan_type  c
  where  substr(a.deptno,1,7) = substr(b.deptno,1,7)
   and  a.plan_code = c.plan_code
group  by  b.dno,  c.tno,  a.plan_code;
小结：
由于prem_info表的记录数远远大于dept_ref表和plan_type表中的记录数，所以首先从prem_info表中查询需要的记录，此时记录数已经被大量缩小，然后再和其他两个表连接，速度会得到很大改善！

9、查询数量较大时，使用表连接代替IN，EXISTS，NOT IN，NOT EXISTS等。
典型实例：
a、使用IN：
select sum(col2) from tab1 where col1 in (select col1 from tab2);
使用EXISTS:：
select sum(col2) from tab1 a
where exists ( select * from tab2 where col1=a.col1);
b、使用NOT IN：
select sum(col2) from tab1 where col1 not in (select col1 from tab2);
使用NOT EXISTS：
select sum(col2) from tab1 a
where not exists ( select * from tab2 where col1=a.col1);
      替代方案：
a、使用连接：
select sum(a.col2) from tab1 a,tab2 b where a.col1=b.col2;
b、使用外连接：
select sum(a.col2) from tab1 a,tab2 b
where a.col1=b.col2(+) and b.col1 is null;

都市淘沙者 2008-08-26 10:52 发表评论

mysql数据库中的索引与优化

都市淘沙者 — Tue, 03 Jun 2008 07:37:00 GMT

mysql数据库中的索引与优化、理解与用途……

这是一个面试的题目：mysql数据库中的索引有那些、有什么用？

就这个问题？在没有web、书籍、资料的情况下我真的不知到怎么作答！汗、当回到电脑前baidu\google，让我汗汗啊，看了这篇文章就该知道答案了……

============================================================================

本文主要讲述了如何加速动态网站的MySQL索引分析和优化。

一、什么是索引？

索引用来快速地寻找那些具有特定值的记录，所有MySQL索引都以B-树的形式保存。如果没有索引，执行查询时MySQL必须从第一个记录开始扫描整个表的所有记录，直至找到符合要求的记录。表里面的记录数量越多，这个操作的代价就越高。如果作为搜索条件的列上已经创建了索引，MySQL无需扫描任何记录即可迅速得到目标记录所在的位置。如果表有1000个记录，通过索引查找记录至少要比顺序扫描记录快100倍。

假设我们创建了一个名为people的表：

CREATE TABLE people ( peopleid SMALLINT NOT NULL,

name CHAR(50) NOT NULL );

然后，我们完全随机把1000个不同name值插入到people表。在数据文件中name列没有任何明确的次序。如果我们创建了name列的索引，MySQL将在索引中排序name列,对于索引中的每一项，MySQL在内部为它保存一个数据文件中实际记录所在位置的“指针”。因此，如果我们要查找name等于“Mike”记录的peopleid（SQL命令为“SELECT peopleid FROM people WHERE name='Mike';”），MySQL能够在name的索引中查找“Mike”值，然后直接转到数据文件中相应的行，准确地返回该行的peopleid（999）。在这个过程中，MySQL只需处理一个行就可以返回结果。如果没有“name”列的索引，MySQL要扫描数据文件中的所有记录，即1000个记录！显然，需要MySQL处理的记录数量越少，则它完成任务的速度就越快。

二、索引的类型

MySQL提供多种索引类型供选择：

普通索引 :

这是最基本的索引类型，而且它没有唯一性之类的限制。普通索引可以通过以下几种方式创建：

创建索引，例如CREATE INDEX <索引的名字> ON tablename (列的列表)；

修改表，例如ALTER TABLE tablename ADD INDEX [索引的名字] (列的列表)；

创建表的时候指定索引，例如CREATE TABLE tablename ( [...], INDEX [索引的名字] (列的列表) )；

唯一性索引:

这种索引和前面的“普通索引”基本相同，但有一个区别：索引列的所有值都只能出现一次，即必须唯一。唯一性索引可以用以下几种方式创建：

创建索引，例如CREATE UNIQUE INDEX <索引的名字> ON tablename (列的列表)；

修改表，例如ALTER TABLE tablename ADD UNIQUE [索引的名字] (列的列表)；

创建表的时候指定索引，例如CREATE TABLE tablename ( [...], UNIQUE [索引的名字] (列的列表) )；

主键 :

主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”。如果你曾经用过AUTO_INCREMENT类型的列，你可能已经熟悉主键之类的概念了。主键一般在创建表的时候指定，例如“CREATE TABLE tablename ( [...], PRIMARY KEY (列的列表) ); ”。但是，我们也可以通过修改表的方式加入主键，例如“ALTER TABLE tablename ADD PRIMARY KEY (列的列表); ”。每个表只能有一个主键。

全文索引:

MySQL从3.23.23版开始支持全文索引和全文检索。在MySQL中，全文索引的索引类型为FULLTEXT。全文索引可以在VARCHAR或者TEXT类型的列上创建。它可以通过CREATE TABLE命令创建，也可以通过ALTER TABLE或CREATE INDEX命令创建。对于大规模的数据集，通过ALTER TABLE（或者CREATE INDEX）命令创建全文索引要比把记录插入带有全文索引的空表更快。本文下面的讨论不再涉及全文索引，要了解更多信息，请参见MySQL documentation。

三、单列索引与多列索引

索引可以是单列索引，也可以是多列索引。下面我们通过具体的例子来说明这两种索引的区别。假设有这样一个people表：

CREATE TABLE people ( peopleid

SMALLINT NOT NULL AUTO_INCREMENT,

firstname CHAR(50) NOT NULL, lastname CHAR(50) NOT NULL,

age SMALLINT NOT NULL,

townid SMALLINT NOT NULL, PRIMARY KEY (peopleid) );

下面是我们插入到这个people表的数据：

这个数据片段中有四个名字为“Mikes”的人（其中两个姓Sullivans，两个姓McConnells），有两个年龄为17岁的人，还有一个名字与众不同的Joe Smith。

这个表的主要用途是根据指定的用户姓、名以及年龄返回相应的peopleid。例如，我们可能需要查找姓名为Mike Sullivan、年龄17岁用户的peopleid（SQL命令为SELECT peopleid FROM people WHERE firstname='Mike' AND lastname='Sullivan' AND age=17；）。由于我们不想让MySQL每次执行查询就去扫描整个表，这里需要考虑运用索引。

首先，我们可以考虑在单个列上创建索引，比如firstname、lastname或者age列。如果我们创建firstname列的索引（ALTER TABLE people ADD INDEX firstname (firstname)；），MySQL将通过这个索引迅速把搜索范围限制到那些firstname='Mike'的记录，然后再在这个“中间结果集”上进行其他条件的搜索：它首先排除那些lastname不等于“Sullivan”的记录，然后排除那些age不等于17的记录。当记录满足所有搜索条件之后，MySQL就返回最终的搜索结果。

由于建立了firstname列的索引，与执行表的完全扫描相比，MySQL的效率提高了很多，但我们要求MySQL扫描的记录数量仍旧远远超过了实际所需要的。虽然我们可以删除firstname列上的索引，再创建lastname或者age列的索引，但总地看来，不论在哪个列上创建索引搜索效率仍旧相似。

为了提高搜索效率，我们需要考虑运用多列索引。如果为firstname、lastname和age这三个列创建一个多列索引，MySQL只需一次检索就能够找出正确的结果！下面是创建这个多列索引的SQL命令：

ALTER TABLE people ADD INDEX fname_lname_age (firstname,lastname,age)；

由于索引文件以B-树格式保存，MySQL能够立即转到合适的firstname，然后再转到合适的lastname，最后转到合适的age。在没有扫描数据文件任何一个记录的情况下，MySQL就正确地找出了搜索的目标记录！

那么，如果在firstname、lastname、age这三个列上分别创建单列索引，效果是否和创建一个firstname、lastname、age的多列索引一样呢？答案是否定的，两者完全不同。当我们执行查询的时候，MySQL只能使用一个索引。如果你有三个单列的索引，MySQL会试图选择一个限制最严格的索引。但是，即使是限制最严格的单列索引，它的限制能力也肯定远远低于firstname、lastname、age这三个列上的多列索引。

四、最左前缀

多列索引还有另外一个优点，它通过称为最左前缀（Leftmost Prefixing）的概念体现出来。继续考虑前面的例子，现在我们有一个firstname、lastname、age列上的多列索引，我们称这个索引为fname_lname_age。当搜索条件是以下各种列的组合时，MySQL将使用fname_lname_age索引：

firstname，lastname，age

firstname，lastname

firstname

从另一方面理解，它相当于我们创建了(firstname，lastname，age)、(firstname，lastname)以及(firstname)这些列组合上的索引。下面这些查询都能够使用这个fname_lname_age索引：

SELECT peopleid FROM people

WHERE firstname='Mike' AND lastname='Sullivan' AND age='17';

SELECT peopleid FROM people WHERE firstname='Mike' AND lastname='Sullivan';

SELECT peopleid FROM people WHERE firstname='Mike';

The following queries cannot use the index at all:

SELECT peopleid FROM people WHERE lastname='Sullivan';

SELECT peopleid FROM people WHERE age='17';

SELECT peopleid FROM people WHERE lastname='Sullivan' AND age='17';

五、选择索引列

在性能优化过程中，选择在哪些列上创建索引是最重要的步骤之一。可以考虑使用索引的主要有两种类型的列：在WHERE子句中出现的列，在join子句中出现的列。请看下面这个查询：

SELECT age ## 不使用索引

FROM people WHERE firstname='Mike' ## 考虑使用索引

AND lastname='Sullivan' ## 考虑使用索引

这个查询与前面的查询略有不同，但仍属于简单查询。由于age是在SELECT部分被引用，MySQL不会用它来限制列选择操作。因此，对于这个查询来说，创建age列的索引没有什么必要。下面是一个更复杂的例子：

　

　

SELECT people.age, ##不使用索引

town.name ##不使用索引

FROM people LEFT JOIN town ON

people.townid=town.townid ##考虑使用索引

WHERE firstname='Mike' ##考虑使用索引

AND lastname='Sullivan' ##考虑使用索引

与前面的例子一样，由于firstname和lastname出现在WHERE子句中，因此这两个列仍旧有创建索引的必要。除此之外，由于town表的townid列出现在join子句中，因此我们需要考虑创建该列的索引。那么，我们是否可以简单地认为应该索引WHERE子句和join子句中出现的每一个列呢？差不多如此，但并不完全。我们还必须考虑到对列进行比较的操作符类型。MySQL只有对以下操作符才使用索引：<，<=，=，>，>=，BETWEEN，IN，以及某些时候的LIKE。可以在LIKE操作中使用索引的情形是指另一个操作数不是以通配符（%或者_）开头的情形。例如，“SELECT peopleid FROM people WHERE firstname LIKE 'Mich%';”这个查询将使用索引，但“SELECT peopleid FROM people WHERE firstname LIKE '%ike';”这个查询不会使用索引。

都市淘沙者 2008-06-03 15:37 发表评论

MySQL面试题

都市淘沙者 — Tue, 03 Jun 2008 07:35:00 GMT

MySQL面试题基础 http://www.interview.org.cn/?p=15

1、MySQL取得当前时间的函数是?，格式化日期的函数是
2、写出 SQL语句的格式 : 插入，更新，删除
表名User
Name Tel Content Date
张三 13333663366 大专毕业 2006-10-11
张三 13612312331 本科毕业 2006-10-15
张四 021-55665566 中专毕业 2006-10-15
(a) 有一新记录(小王 13254748547 高中毕业 2007-05-06)请用SQL语句新增至表中
(b) 请用sql语句把张三的时间更新成为当前系统时间
(c) 请写出删除名为张四的全部记录
3、请写出数据类型(int char varchar datetime text)的意思; 请问varchar和char有什么区别
4、MySQL自增类型(通常为表ID字段)必需将其设为(?)字段
5、以下请用PHPMYADMIN完成
(一)创建新闻发布系统，表名为message有如下字段

id 文章id
title 文章标题
content 文章内容
category_id 文章分类id
hits 点击量

(二)同样上述新闻发布系统：表comment记录用户回复内容，字段如下

comment_id 回复id
id 文章id，关联message表中的id
comment_content 回复内容
现通过查询数据库需要得到以下格式的文章标题列表,并按照回复数量排序，回复最高的排在最前面
文章id 文章标题点击量回复数量
用一个SQL语句完成上述查询，如果文章没有回复则回复数量显示为0

(三)上述内容管理系统，表category保存分类信息，字段如下

category_id int(4) not null auto_increment;
categroy_name varchar(40) not null;
用户输入文章时，通过选择下拉菜单选定文章分类
写出如何实现这个下拉菜单

都市淘沙者 2008-06-03 15:35 发表评论

ORACLE中LOB字段的使用和维护

都市淘沙者 — Fri, 11 Apr 2008 09:41:00 GMT

ORACLE中LOB字段的使用和维护
--------------------------------------------------------------------------------
摘要：本文通过实例介绍了在ORACLE数据库中通过DBMS_LOB包使用和维护LOB数据类型的基本方法。
关键词：ORACLE DBMS_LOB LOB 维护
中图分类号：TP31
1、引言
随着社会的发展，在现代信息系统的开发中，需要存储的已不仅仅是简单的文字信息，同时还包括一些图片和音像资料或者是超长的文本。比如开发一套旅游信息系统，每一个景点都有丰富的图片、音像资料和大量的文字介绍。这就要求后台数据库要有存储这些数据的能力。ORACLE公司在其Oracle8i中通过提供LOB字段实现了该功能。
为了便于读者的理解，我们先介绍一些基本的概念：
在ORACLE数据库中，LOB（Large Objects—大对象）是用来存储大量的二进制和文本数据的一种数据类型（一个LOB字段可存储可多达4GB的数据）。目前，它又分为两种类型：内部LOB和外部LOB。内部LOB将数据以字节流的形式存储在数据库的内部。因而，内部LOB的许多操作都可以参与事务，也可以像处理普通数据一样对其进行备份和恢复操作。Oracle8i支持三种类型的内部LOB：BLOB（二进制数据）、CLOB（单字节字符数据）、NCLOB（多字节国家字符数据）。其中CLOB和NCLOB类型适用于存储超长的文本数据，BLOB字段适用于存储大量的二进制数据，如图像、视频、音频等。目前，Oracle8i只支持一种外部LOB类型，即BFILE类型。在数据库内，该类型仅存储数据在操作系统中的位置信息，而数据的实体以外部文件的形式存在于操作系统的文件系统中。因而，该类型所表示的数据是只读的，不参与事务。该类型可帮助用户管理大量的由外部程序访问的文件。
为了方便下文的叙述，我们假定使用如下语句在数据库中创建了一张表。
CREATE TABLE view_sites_info
(
site_id NUMBER(3),
audio BLOB DEFAULT empty_blob(),
document CLOB DEFAULT empty_clob(),
video_file BFILE DEFAULT NULL,
constraint PK_TAB_view_sites_info primary key (site_id)
);
2、LOB的使用和维护
ORACL提供了多种使用和维护LOB的方式，如使用PL/SQL DBMS_LOB包、调用OCI（Oracle Call Interface）、使用Proc * C/C++、使用JDBC等。其中最为方便有效的是使用PL/SQL调用DBMS_LOB包，本文就将介绍该方法。
在Oracle中，存储在LOB中数据称为LOB的值，如使用Select 对某一LOB字段进行选择，则返回的不是LOB的值，而是该LOB字段的定位器（可以理解为指向LOB值的指针）。如执行如下的SQL语句：
DELCARE
AUDIO_INFO BLOB；
BENGIN
SELECT audio INTO AUDIO_INFO FROM view_sites_info
WHERE site_id=100;
END;
/
存储在AUDIO_INFO变量中的就是LOB定位器，而不是LOB的值。而要对某一LOB的值进行访问和维护操作，必需通过其定位器来进行。DBMS_LOB包中提供的所有函数和过程都以LOB定位器作为参数。
2.1内部LOB
DBMS_LOB包中主要提供了以下几个过程供用户对内部LOB字段进行维护。
APPEND（）将源LOB中的内容加到目的LOB中
COPY（）从源LOB中复制数据到目的LOB
ERASE（）删除LOB中全部或部分内容
TRIM（）将LOB值减少到指定的长度
WRITE（）向LOB 中写入数据
COMPARE（）比较两个同种数据类型的LOB的部分或全部值是否相同
GETLENGTH（）获取LOB的长度
READ（）从LOB中读出数据
下面我们以最为常用的读和写为例详细介绍这些过程的用法。
首先介绍一下写过程。该过程的语法为：
PROCEDURE WRITE (
lob_loc IN OUT BLOB,
amount IN BINARY_INTEGER,
offset IN INTEGER,
buffer IN RAW);
PROCEDURE WRITE (
lob_loc IN OUT CLOB CHARACTER SET ANY_CS,
amount IN BINARY_INTEGER,
offset IN INTEGER,
buffer IN VARCHAR2 CHARACTER SET lob_loc%CHARSET);
各参数的含义为：
lob_loc：要写入的LOB定位器
amount：写入LOB中的字节数
offset：指定开始操作的偏移量
buffer：指定写操作的缓冲区
下面的代码就是运用该过程向LOB字段写入数据的示例。
DECLARE
lobloc CLOB;
buffer VARCHAR2(2000);
amount NUMBER := 20;
offset NUMBER := 1;
BEGIN
--初始化要写入的数据
buffer := 'This is a writing example';
amount := length(buffer);
SELECT document INTO lobloc -- 获取定位器并锁定行
FROM view_sites_info
WHERE site_id = 100 FOR UPDATE;
dbms_lob.write(lobloc,amount,1,buffer);
COMMIT;
END;
/
需要特别指出的是：
I. 在调用写过程前一定要使用SELECT语句检索到定位器且用 FOR UPDATE 子句锁定行，否则不能更新LOB；
II. 写过程从offset指定的位置开始，向LOB中写入长度为amount的数据，原LOB中在这个范围内的任何数据都将被覆盖。
III. 缓冲区的最大容量为32767字节，因此在写入大量数据时需多次调用该过程。

下面再来介绍一下读过程：
该过程的语法为：
PROCEDURE READ (
lob_loc IN BLOB,
amount IN OUT BINARY_INTEGER,
offset IN INTEGER,
buffer OUT RAW);
PROCEDURE READ (
lob_loc IN CLOB CHARACTER SET ANY_CS,
amount IN OUT BINARY_INTEGER,
offset IN INTEGER,
buffer OUT VARCHAR2 CHARACTER SET lob_loc%CHARSET);
各参数的含义为：
lob_loc：要读取的LOB定位器
amount：要读取的字节数
offset：开始读取操作的偏移量
buffer：存储读操作结果的缓冲区
下面的代码演示了如何使用该过程读取LOB字段中的数据：
DECLARE
lobloc CLOB;
buffer VARCHAR2(2000);
amount NUMBER := 2;
offset NUMBER := 6;
BEGIN
SELECT document INTO lobloc --获取定位器
FROM lob_store
WHERE lob_id = 100;
dbms_lob.read(lobloc,amount,offset,buffer);--读取数据到缓冲区
dbms_output.put_line(buffer);--显示缓冲区中的数据
COMMIT;
END;
/

都市淘沙者 2008-04-11 17:41 发表评论

处理CLOB字段的动态PL/SQL (zhuan)

都市淘沙者 — Fri, 11 Apr 2008 03:40:00 GMT

动态PL/SQL,对CLOB字段操作可传递表名table_name，表的唯一标志字段名field_id，clob字段名field_name，记录号v_id，开始处理字符的位置v_pos，传入的字符串变量v_clob

修改CLOB的PL/SQL过程：updateclob

create or replace procedure updateclob(
     table_name     in varchar2,
     field_id        in varchar2,
     field_name     in varchar2,
     v_id           in number,
     v_pos          in number,
     v_clob         in varchar2)
is
     lobloc     clob;
     c_clob     varchar2(32767);
     amt         binary_integer;
     pos         binary_integer;
     query_str     varchar2(1000);
begin
   pos:=v_pos*32766+1;
   amt := length(v_clob);
   c_clob:=v_clob;
   query_str :='select '||field_name||' from '||table_name||' where '||field_id||'= :id for update ';
--initialize buffer with data to be inserted or updated
   EXECUTE IMMEDIATE query_str INTO lobloc USING v_id;
--from pos position, write 32766 varchar2 into lobloc
   dbms_lob.write(lobloc, amt, pos, c_clob);
   commit;
exception
   when others then
   rollback;
end;
/

用法说明：
在插入或修改以前，先把其它字段插入或修改，CLOB字段设置为空empty_clob()，
然后调用以上的过程插入大于2048到32766个字符。
如果需要插入大于32767个字符，编一个循环即可解决问题。

查询CLOB的PL/SQL函数：getclob

create or replace function getclob(
     table_name     in varchar2,
     field_id        in varchar2,
     field_name     in varchar2,
     v_id     in number,
     v_pos     in number) return varchar2
is
     lobloc     clob;
     buffer     varchar2(32767);
     amount     number := 2000;
     offset     number := 1;
     query_str     varchar2(1000);
begin
   query_str :='select '||field_name||' from '||table_name||' where '||field_id||'= :id ';
--initialize buffer with data to be found
   EXECUTE IMMEDIATE query_str INTO lobloc USING v_id;
   offset:=offset+(v_pos-1)*2000;
--read 2000 varchar2 from the buffer
   dbms_lob.read(lobloc,amount,offset,buffer);
       return buffer;
exception
    when no_data_found then
       return buffer;
end;
/

用法说明：

用select getclob(table_name,field_id,field_name,v_id,v_pos) as partstr from dual;
可以从CLOB字段中取2000个字符到partstr中，
编一个循环可以把partstr组合成dbms_lob.getlength(field_name)长度的目标字符串。

调用PL/SQL过程的方法:
    SQL*PLUS        SQL> EXEC 过程名[(参数)];
    Procedure Builder    PL/SQL>过程名[(参数)];
    JAVA        CALL { 过程名[(参数)] };
    PHP        BEGIN { 过程名[(参数)] } END;

都市淘沙者 2008-04-11 11:40 发表评论

Oracle常见日期处理

都市淘沙者 — Wed, 09 Jan 2008 05:34:00 GMT

TO_DATE格式
Day:
dd number 12
dy abbreviated fri
day spelled out friday
ddspth spelled out, ordinal twelfth
Month:
mm number 03
mon abbreviated mar
month spelled out march
Year:
yy two digits 98
yyyy four digits 1998

24小时格式下时间范围为： 0:00:00 - 23:59:59.
12小时格式下时间范围为： 1:00:00 - 12:59:59 .

1.
日期和字符转换函数用法（to_date,to_char）

2.
select to_char( to_date(222,'J'),'Jsp') from dual

显示Two Hundred Twenty-Two

3.
求某天是星期几
select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day') from dual;
星期一
select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day','NLS_DATE_LANGUAGE = American') from dual;
monday
设置日期语言
ALTER SESSION SET NLS_DATE_LANGUAGE='AMERICAN';
也可以这样
TO_DATE ('2002-08-26', 'YYYY-mm-dd', 'NLS_DATE_LANGUAGE = American')

4.
两个日期间的天数
select floor(sysdate - to_date('20020405','yyyymmdd')) from dual;

5. 时间为null的用法
select id, active_date from table1
UNION
select 1, TO_DATE(null) from dual;

注意要用TO_DATE(null)

6.
a_date between to_date('20011201','yyyymmdd') and to_date('20011231','yyyymmdd')
那么12月31号中午12点之后和12月1号的12点之前是不包含在这个范围之内的。
所以，当时间需要精确的时候，觉得to_char还是必要的
7. 日期格式冲突问题
输入的格式要看你安装的ORACLE字符集的类型, 比如: US7ASCII, date格式的类型就是: '01-Jan-01'
alter system set NLS_DATE_LANGUAGE = American
alter session set NLS_DATE_LANGUAGE = American
或者在to_date中写
select to_char(to_date('2002-08-26','yyyy-mm-dd'),'day','NLS_DATE_LANGUAGE = American') from dual;
注意我这只是举了NLS_DATE_LANGUAGE，当然还有很多，
可查看
select * from nls_session_parameters
select * from V$NLS_PARAMETERS

8.
select count(*)
from ( select rownum-1 rnum
from all_objects
where rownum <= to_date('2002-02-28','yyyy-mm-dd') - to_date('2002-
02-01','yyyy-mm-dd')+1
)
where to_char( to_date('2002-02-01','yyyy-mm-dd')+rnum-1, 'D' )
not
in ( '1', '7' )

查找2002-02-28至2002-02-01间除星期一和七的天数
在前后分别调用DBMS_UTILITY.GET_TIME, 让后将结果相减(得到的是1/100秒, 而不是毫秒).

9.
select months_between(to_date('01-31-1999','MM-DD-YYYY'),
to_date('12-31-1998','MM-DD-YYYY')) "MONTHS" FROM DUAL;
1

select months_between(to_date('02-01-1999','MM-DD-YYYY'),
to_date('12-31-1998','MM-DD-YYYY')) "MONTHS" FROM DUAL;

1.03225806451613
10. Next_day的用法
Next_day(date, day)

Monday-Sunday, for format code DAY
Mon-Sun, for format code DY
1-7, for format code D

11
select to_char(sysdate,'hh:mi:ss') TIME from all_objects
注意：第一条记录的TIME 与最后一行是一样的
可以建立一个函数来处理这个问题
create or replace function sys_date return date is
begin
return sysdate;
end;

select to_char(sys_date,'hh:mi:ss') from all_objects;
12.
获得小时数

SELECT EXTRACT(HOUR FROM TIMESTAMP '2001-02-16 2:38:40') from offer
SQL> select sysdate ,to_char(sysdate,'hh') from dual;

SYSDATE TO_CHAR(SYSDATE,'HH')
-------------------- ---------------------
2003-10-13 19:35:21 07

SQL> select sysdate ,to_char(sysdate,'hh24') from dual;

SYSDATE TO_CHAR(SYSDATE,'HH24')
-------------------- -----------------------
2003-10-13 19:35:21 19

获取年月日与此类似
13.
年月日的处理
select older_date,
newer_date,
years,
months,
abs(
trunc(
newer_date-
add_months( older_date,years*12+months )
)
) days
from ( select
trunc(months_between( newer_date, older_date )/12) YEARS,
mod(trunc(months_between( newer_date, older_date )),
12 ) MONTHS,
newer_date,
older_date
from ( select hiredate older_date,
add_months(hiredate,rownum)+rownum newer_date
from emp )
)

14.
处理月份天数不定的办法
select to_char(add_months(last_day(sysdate) +1, -2), 'yyyymmdd'),last_day(sysdate) from dual

16.
找出今年的天数
select add_months(trunc(sysdate,'year'), 12) - trunc(sysdate,'year') from dual

闰年的处理方法
to_char( last_day( to_date('02' || :year,'mmyyyy') ), 'dd' )
如果是28就不是闰年

17.
yyyy与rrrr的区别
'YYYY99 TO_C
------- ----
yyyy 99 0099
rrrr 99 1999
yyyy 01 0001
rrrr 01 2001

18.不同时区的处理
select to_char( NEW_TIME( sysdate, 'GMT','EST'), 'dd/mm/yyyy hh:mi:ss') ,sysdate
from dual;

19.
5秒钟一个间隔
Select TO_DATE(FLOOR(TO_CHAR(sysdate,'SSSSS')/300) * 300,'SSSSS') ,TO_CHAR(sysdate,'SSSSS')
from dual

2002-11-1 9:55:00 35786
SSSSS表示5位秒数

20.
一年的第几天
select TO_CHAR(SYSDATE,'DDD'),sysdate from dual
310 2002-11-6 10:03:51

21.计算小时,分,秒,毫秒
select
Days,
A,
TRUNC(A*24) Hours,
TRUNC(A*24*60 - 60*TRUNC(A*24)) Minutes,
TRUNC(A*24*60*60 - 60*TRUNC(A*24*60)) Seconds,
TRUNC(A*24*60*60*100 - 100*TRUNC(A*24*60*60)) mSeconds
from
(
select
trunc(sysdate) Days,
sysdate - trunc(sysdate) A
from dual
)

select * from tabname
order by decode(mode,'FIFO',1,-1)*to_char(rq,'yyyymmddhh24miss');

//
floor((date2-date1) /365) 作为年
floor((date2-date1, 365) /30) 作为月
mod(mod(date2-date1, 365), 30)作为日.
23.next_day函数
next_day(sysdate,6)是从当前开始下一个星期五。后面的数字是从星期日开始算起。

都市淘沙者 2008-01-09 13:34 发表评论

oracle SQL性能优化(转)

都市淘沙者 — Wed, 02 Jan 2008 11:51:00 GMT

摘要: （1）选择最有效率的表名顺序(只在基于规则的优化器中有效)： ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选... 阅读全文

都市淘沙者 2008-01-02 19:51 发表评论

oracle复杂查询语句

都市淘沙者 — Wed, 02 Jan 2008 11:38:00 GMT

1.查询语句的使用
使用 select语句和子查询(subquery)可以从一个或多个表,视图,实体试图中返回数据.

1.1相关子查询
可以将子查询(as subquery)或in或exists当成where的一个条件的一部分,这样的查询称为子查询
.where中可以包含一个select语句的子查询
.where中可以包含in,exists语句
.最多可以嵌套16层
.层次过多会影响性能
[例]简单子查询实例
查询是否有的专家既以研究所的名义来申请基金项目,又以大学系为单位申请项目
(按规定只能以一个单位来申请)
SQL> create table univ_subject
2    (
3       name                 varchar2(12) not null,
4       per_id                number     not null,
5      dept_name       varchar2(20)
6    );
SQL> insert into univ_subject values('gaoqianjing',1001,'信息工程系');
SQL> insert into univ_subject values('wangbing',1002,'物理系');
SQL> insert into univ_subject values('liming',1003,'化学系');
===============
   SQL> create table colle_subject
2     (
3              colle_name    varchar2(20),
4              per_id              number
5     );
SQL> insert into colle_subject values('电子研究所',1001);
SQL> insert into colle_subject values('物理研究所',1005);
================
SQL> select name,per_id,dept_name from univ_subject where per_id in
2    (select per_id from colle_subject);

NAME            PER_ID   DEPT_NAME
------------          ---------     --------------------
gaoqianjing 1001      信息工程系

1.2外连接
[例]外连接实例
招生中所有学生的信息放在students表中,而部分有特长的学生在另一个表中stuent_skill中同样有该学生
的信息。现在要全部列出所有学生,如果某个学生在表student_skill中就有其特长信息,并显示特长信息,如果
某个学生没有特长就显示特长问空.
SQL> create table students
2    (
3       st_id    varchar2(20),
4       name varchar2(10),
5       age      number(2),
6       tol_score   number(3)
7    ) ;
SQL>   insert into students values('973231','wangbindu',22,501);
SQL>   insert into students values('973232','zhuzhijing',21,538);
SQL> insert into students values('973233','gaojing',21,576);
===================

SQL> create table student_skill
2   (
3      st_id varchar2(20),
4      skill    varchar2(20)
5 );
SQL> insert into student_skill values('973231','篮球');
SQL> insert into student_skill(st_id) values('973232');
SQL> insert into student_skill values('973233','足球');
===================

SQL> select a.* , b.skill from students a,student_skill b where a.st_id=b.st_id(+)
order by a.st_id;

ST_ID                NAME             AGE TOL_SCORE SKILL
-------------------- ---------- --------- --------- ------------------ --
973231               wangbindu         22       501        篮球
973232               zhuzhijing           21       538
973233               gaojing                21       576        足球

1.3自我连接
自我连接是在同一个表或视图内进行条件连接.
[例]自我连接实例
查询每个雇员的名字和该雇员的经理的名字:
SQL> select e1.ename||' work for '||e2.ename "Employees and their Managers"
2 from scott.emp e1,scott.emp e2 where e1.mgr=e2.empno;

Employees and their Managers
-------------------------------------------------
SMITH      work for   FORD
ALLEN     work for   BLAKE
WARD      work for   BLAKE
JONES     work for   KING
MARTIN   work for   BLAKE
BLAKE     work for   KING
CLARK     work for   KING
SCOTT      work for   JONES
TURNER work for   BLAKE
ADAMS     work for   SCOTT
JAMES      work for   BLAKE
FORD        work for   JONES
MILLER     work for   CLARK

1.4UNION , INTERSECT及 MINUS
UNION: 可以将两个以上的表的相类似的查询结果放在一起 (union all则表示返回所有的行)
具体语法:
select ...
union[all]
select...
==========

INTERSECT: 返回两个表中相同的信息
具体语法:
select ...
intersect
select...
==========

MINUS : 返回一个表中出现的信息
具体语法:
select ...
minus
select...
[例1]UNION操作实例
SQL> select st_id from students
2 union
3 select st_id from student_skill;

ST_ID
--------------------
973231
973232
973233

[例2]INTERSECT操作实例
列出有特长的学生的学号
SQL> select st_id from students
2 intersect
3 select st_id from student_skill;
ST_ID
--------------------
973231
973233

[例3]MINUS操作实例
列出没有特长学生的学号
select st_id from students
minus
select st_id from student_skill;
ST_ID
--------------------
973232

2.创建复杂的视图
许多应用系统有统计等功能,建议最好把这些复杂语句写成视图.下面是几个常用的视图.
2.1分组视图
[例1]简单的分组视图
SQL> create or replace view dept_tot as
2 select a.dname dept,sum(b.sal) total_sal from scott.dept a,scott.emp b
3 where a.deptno=b.deptno group by a.dname;

查看已建立。
SQL> select * from dept_tot;

DEPT                           TOTAL_SAL
--------------                     ---------
ACCOUNTING          8750
RESEARCH              10875
SALES                        9400

[例2]带复杂函数视图
SQL> create or replace view itemtot as
2 select persion,sum(amount) itemtot from ledger
3 where actiondate between
4 to_date('01-MAR-1901','dd-mon-yyyy') and
5 to_date('31-MAR-1901','dd-mon-yyyy')
6 and action in('bought','raid') group by persion;

2.2合计视图
[例]合计函数视图实例
SQL> create or replace view emp_no1 as
2 select deptno,sum(sal) 工资和,sum(comm) 总和
3 from scott.emp group by deptno;
SQL> select * from emp_no1;
DEPTNO    工资和      总和
--------- --------- ---------
       10      8750
       20     10875
       30      9400      2200

2.3组合视图
[例]带组合函数的视图
SQL> create or replace view byitem as
2 select l.persion persion.item, amount, 100*amount/item bypersion,100*amount/total bytotal
3 from ledgent l,itemtotal i,total where l.persion=i.persion where l.persion=i.persion
4 and actiondate between
5 to_date('01-MAR-1901','dd-mon-yyyy') and
6 to_date('31-MAR-1901','dd-mon-yyyy')
7 and action in('bought','raid') ;

3.家族树
语法:
select column from table_name start with column=value
connect by prior 父主键=子主键

3.1排除单一性和分枝
以ORACLE中的EMP表为例
[例]从顶到底列出各雇员的信息
SQL> select lpad(' ',4*(level-1))||ename name,empno,mgr from emp start with mgr is null
2 connect by prior empno=mgr;

NAME                                 EMPNO       MGR
---------                                  ---------           ---------
KING                                   7839
    JONES                           7566            7839
          SCOTT                     7788            7566
                ADAMS              7876            7788

3.2遍历至根
[例1]现在要从某个雇员开始向他的上级列出该雇员的层次结构
SQL> col ename for a30;
SQL> select lpad(' ',4*(level-1))||ename ename,mgr,empno from scott.emp
2 start with mgr=7788 connect by prior mgr=empno;
ENAME                                MGR     EMPNO
------------------------------         ---------    ---------
ADAMS                               7788      7876
    SCOTT                           7566       7788
        JONES                       7839       7566
            KING                                        7839

[例2]列出所有雇员的层次结构
SQL> select lpad(' ',4*(level-1))||ename ename,empno,mgr from scott.emp
2 start with mgr is not null
3 connect by empno=prior mgr;

ENAME                              EMPNO       MGR
------------------------------       ---------           ---------
SMITH                               7369          7902
    FORD                            7902         7566
        JONES                       7566        7839
            KING                    7839
ALLEN                               7499        7698
    BLAKE                           7698        7839
        KING                        7839
WARD                                7521        7698
    BLAKE                           7698        7839
        KING                        7839
JONES                               7566        7839
    KING                            7839
MARTIN                              7654        7698
    BLAKE                           7698         7839
        KING                        7839
BLAKE                               7698        7839
    KING                            7839
CLARK                               7782         7839
    KING                            7839
SCOTT                               7788         7566
    JONES                           7566        7839

都市淘沙者 2008-01-02 19:38 发表评论

单表级联查询优化

都市淘沙者 — Mon, 24 Dec 2007 03:35:00 GMT

优化前的糟糕语句
select t.userid ,
             (select count(*)  from snsjob.mxt_temp_lxw_voice_info m where  m.statename='广东'  and   m.userid=t.userid    ) totals,
             (select count(*)  from snsjob.mxt_temp_lxw_voice_info m where  m.statename='广东'  and    m.userid=t.userid and m.isvalid = 0   ) uncheck,
             (select count(*)  from snsjob.mxt_temp_lxw_voice_info n where  m.statename='广东'   and    n.userid=t.userid and  n.isvalid = 1  ) checkedpass
             from snsjob.mxt_temp_lxw_voice_info t
             group by t.userid order by checkedpass desc

优化后如下

select t.userid,
        count(*),
       sum(case when  isvalid = 0 then 1 else 0 end ),
       sum(case when  isvalid = 1 then 1 else 0 end ) checkedpass
  from snsjob.mxt_temp_lxw_voice_info t where statename='广东'
group by t.useridby checkedpass desc
order

速度快20倍以上，数据越多越明显

都市淘沙者 2007-12-24 11:35 发表评论

教你自动恢复MySQL数据库的日志文件

都市淘沙者 — Sat, 08 Dec 2007 03:15:00 GMT

如果MySQL服务器启用了二进制日志，你可以使用mysqlbinlog工具来恢复从指定的时间点开始 (例如，从你最后一次备份)直到现在或另一个指定的时间点的数据。“mysqlbinlog：用于处理二进制日志文件的实用工具”。

要想从二进制日志恢复数据，你需要知道当前二进制日志文件的路径和文件名。一般可以从选项文件(即my.cnf or my.ini，取决于你的系统)中找到路径。如果未包含在选项文件中，当服务器启动时，可以在命令行中以选项的形式给出。启用二进制日志的选项为--log-bin。要想确定当前的二进制日志文件的文件名，输入下面的MySQL语句：

SHOW BINLOG EVENTS \G

你还可以从命令行输入下面的内容：

mysql --user=root -pmy_pwd -e 'SHOW BINLOG EVENTS \G'

将密码my_pwd替换为服务器的root密码。

1. 指定恢复时间

对于MySQL 4.1.4，可以在mysqlbinlog语句中通过--start-date和--stop-date选项指定DATETIME格式的起止时间。举例说明，假设在今天上午10:00(今天是2006年4月20日)，执行SQL语句来删除一个大表。要想恢复表和数据，你可以恢复前晚上的备份，并输入：

mysqlbinlog --stop-date="2005-04-20 9:59:59" /var/log/mysql/bin.123456 \
| mysql -u root -pmypwd

该命令将恢复截止到在--stop-date选项中以DATETIME格式给出的日期和时间的所有数据。如果你没有检测到几个小时后输入的错误的SQL语句，可能你想要恢复后面发生的活动。根据这些，你可以用起使日期和时间再次运行mysqlbinlog：

mysqlbinlog --start-date="2005-04-20 10:01:00" /var/log/mysql/bin.123456 \
| mysql -u root -pmypwd \

在该行中，从上午10:01登录的SQL语句将运行。组合执行前夜的转储文件和mysqlbinlog的两行可以将所有数据恢复到上午10:00前一秒钟。你应检查日志以确保时间确切。下一节介绍如何实现。

2. 指定恢复位置

也可以不指定日期和时间，而使用mysqlbinlog的选项--start-position和--stop-position来指定日志位置。它们的作用与起止日选项相同，不同的是给出了从日志起的位置号。使用日志位置是更准确的恢复方法，特别是当由于破坏性SQL语句同时发生许多事务的时候。要想确定位置号，可以运行mysqlbinlog寻找执行了不期望的事务的时间范围，但应将结果重新指向文本文件以便进行检查。操作方法为：

mysqlbinlog --start-date="2005-04-20 9:55:00" --stop-date="2005-04-20 10:05:00" \
/var/log/mysql/bin.123456 > /tmp/mysql_restore.sql

该命令将在/tmp目录创建小的文本文件，将显示执行了错误的SQL语句时的SQL语句。你可以用文本编辑器打开该文件，寻找你不要想重复的语句。如果二进制日志中的位置号用于停止和继续恢复操作，应进行注释。用log_pos加一个数字来标记位置。使用位置号恢复了以前的备份文件后，你应从命令行输入下面内容：

mysqlbinlog --stop-position="368312" /var/log/mysql/bin.123456 \
| mysql -u root -pmypwd
mysqlbinlog --start-position="368315" /var/log/mysql/bin.123456 \
| mysql -u root -pmypwd \

上面的第1行将恢复到停止位置为止的所有事务。下一行将恢复从给定的起始位置直到二进制日志结束的所有事务。因为mysqlbinlog的输出包括每个SQL语句记录之前的SET TIMESTAMP语句，恢复的数据和相关MySQL日志将反应事务执行的原时间。

1、mysql 数据库没有增量备份的机制，当数据量太大的时候备份是一个很大的问题。还好 mysql 数据库提供了一种主从备份的机制，其实就是把主数据库的所有的数据同时写到备份数据库中。实现 mysql 数据库的热备份。

　　2、要想实现双机的热备首先要了解主从数据库服务器的版本的需求。要实现热备 mysql 的版本都要高于3.2，还有一个基本的原则就是作为从数据库的数据库版本可以高于主服务器数据库的版本，但是不可以低于主服务器的数据库版本。

　　3、设置主数据库服务器：

　　a. 首先查看主服务器的版本是否是支持热备的版本。然后查看 my.cnf(类 unix)或者 my.ini(windows)中 mysqld 配置块的配置有没有 log-bin (记录数据库更改日志)，因为 mysql 的复制机制是基于日志的复制机制，所以主服务器一定要支持更改日志才行。然后设置要写入日志的数据库或者不要写入日志的数据库。这样只有您感兴趣的数据库的更改才写入到数据库的日志中。

　　server-id=1 //数据库的 id 这个应该默认是1就不用改动

　　log-bin=log_name //日志文件的名称，这里可以制定日志到别的目录如果没有设置则默认主机名的一个日志名称

　　binlog-do-db=db_name //记录日志的数据库

　　binlog-ignore-db=db_name //不记录日志的数据库

　　以上的如果有多个数据库用","分割开，然后设置同步数据库的用户帐号

　　mysql> GRANT REPLICATION SLAVE ON *.*

　　-> TO 'repl'@'%.mydomain.com' IDENTIFIED BY 'slavepass';

　　4.0.2 以前的版本, 因为不支持 REPLICATION 要使用下面的语句来实现这个功能

　　mysql> GRANT FILE ON *.*

　　-> TO 'repl'@'%.mydomain.com' IDENTIFIED BY 'slavepass';

　　设置好主服务器的配置文件后重新启动数据库

　　b.锁定现有的数据库并备份现在的数据

　　锁定数据库

　　mysql> FLUSH TABLES WITH READ LOCK;

　　备份数据库有两种办法一种是直接进入到 mysql 的 data 目录然后打包你需要备份数据库的文件夹，第二种是使用 mysqldump 的方式来备份数据库但是要加上"--master-data " 这个参数，建议使用第一种方法来备份数据库

　　c.查看主服务器的状态

都市淘沙者 2007-12-08 11:15 发表评论

随机抽取前N条记录的问题(zhuant)

都市淘沙者 — Tue, 04 Dec 2007 13:30:00 GMT

[A]8i以上版本
select * from (select * from tablename order by sys_guid()) where rownum < N;
select * from (select * from tablename order by dbms_random.value) where rownum< N;
注：dbms_random包需要手工安装，位于$ORACLE_HOME/rdbms/admin/dbmsrand.sql
dbms_random.value(100,200)可以产生100到200范围的随机数

[Q]抽取从N行到M行的记录，如从20行到30行的记录
[A]select * from (select rownum id,t.* from table where ……
and rownum <= 30) where id > 20;

[Q]怎么样实现分组取前N条记录
[A]8i以上版本，利用分析函数
如获取每个部门薪水前三名的员工或每个班成绩前三名的学生。
Select * from
(select depno,ename,sal,row_number() over (partition by depno
order by sal desc) rn
from emp)
where rn<=3

[Q]如何取得一列中第N大的值？
[A]select * from
(select t.*,dense_rank() over (order by t2 desc) rank from t)
where rank = [$N]

实例：

1建立測試環境
2create table 表(學生名稱 varchar(10),學生性別 varchar(10),年齡 int,所屬班級 varchar(10),分數 int)
3insert 表 select '張三','男',18,'三年一班',85
4union all select '張四','男',18,'三年一班',90
5union all select '張五','男',18,'三年一班',84
6union all select '張六','男',18,'三年一班',75
7union all select '李三','男',18,'三年二班',96
8union all select '李四','男',18,'三年二班',82
9union all select '李五','男',18,'三年二班',86
10union all select '李六','男',18,'三年二班',74
11union all select '王一','男',18,'四年一班',85
12union all select '王二','男',18,'四年一班',86
13union all select '王三','男',18,'四年一班',84
14union all select '王四','男',18,'四年一班',75
15go
16select * from 表
17第一中方法
18select * from 表 a
19where 分數 in(
20 select top 3 分數 from 表 where 所屬班級=a.所屬班級
21 order by 分數 desc)
22
23

1第二中方法
2select * from 表 a
3where 學生名稱 in(
4    select top 3 學生名稱 from 表 where 所屬班級=a.所屬班級
5    order by 分數 desc)
6order by 所屬班級,分數 desc
7
8第三中方法
9select
10    a.*
11from
12    表 a
13where
14    a.學生名稱 in (select top 3 學生名稱 from 表 where 所屬班級=a.所屬班級 order by 分數 desc)
15order by
16    a.所屬班級,a.分數 desc

实例2：

1create table 成绩
2(
3id int identity,
4班级 varchar(20),
5姓名 varchar(20),
6分数 int
7)
8insert into 成绩(班级,姓名,分数)values('1','aa',89)
9insert into 成绩(班级,姓名,分数)values('1','bb',45)
10insert into 成绩(班级,姓名,分数)values('1','cc',65)
11insert into 成绩(班级,姓名,分数)values('1','dd',67)
12insert into 成绩(班级,姓名,分数)values('1','ff',23)
13insert into 成绩(班级,姓名,分数)values('1','aeea',76)
14insert into 成绩(班级,姓名,分数)values('1','sfdsad',26)
15
16insert into 成绩(班级,姓名,分数)values('2','afdsf',34)
17insert into 成绩(班级,姓名,分数)values('2','dsf',75)
18insert into 成绩(班级,姓名,分数)values('2','fdfdg',23)
19insert into 成绩(班级,姓名,分数)values('2','dfg',74)
20insert into 成绩(班级,姓名,分数)values('2','sdf',23)
21insert into 成绩(班级,姓名,分数)values('2','sdf',56)
22insert into 成绩(班级,姓名,分数)values('2','jhj',74)
23
24
25select * from 成绩 a where (select count(*) from 成绩 b where a.班级 = b.班级 and a.分数<= b.分数)<=3 order by 班级,分数 desc

1/*实例四：语句中的30,31,40,58表示不同类型的数据，如：新闻，音乐，小说等类型，查询语句的具体条件就是：
从4个不同模块中各取最新的前10条记录（不够10条则取全部数据）总共不超过40条记录来随机取4条，注意其中有可能4条都是同个类型，如果要限制每样都要有一条，则可以对限制条件做处理即可*/
2
3select id,module_id,title,msg,obj1,obj2,obj3,obj5,add_date from (
4                select * from mxt_msginfo a  where (
5                     select count(*) from mxt_msginfo b  where  a.module_id = b.module_id and a.add_date<= b.add_date )<=10 and a.module_id in (30,31,40,58)
6                     order by dbms_random.value
7            )  where rownum<5

都市淘沙者 2007-12-04 21:30 发表评论

Oracle中随机抽取N条记录

都市淘沙者 — Tue, 04 Dec 2007 09:22:00 GMT

工作中经常用到随机数，比如随机抽取奖券，随机抽取某地区的客户样本等。在Oracle中可以非常方便地实现这个功能。

方法1：使用SAMPLE()。

使用sample的语法是：

SAMPLE [ BLOCK ]
(sample_percent)
[ SEED (seed_value) ]

BLOCK: 表示使用随机块例举而不是随机行例举。

sample_percent是随机获取一张表中记录的百分比。比如值为10，那就是表中的随机的百分之10的记录。值必须大于等于.000001，小于100。

seed表示从哪条记录返回，类似于预先设定例举结果，因而每次返回的结果都是固定的。该值必须介于0和4294967295之间。

接下来举例说明：

SQL> create table zeeno as select * from dba_objects;
 
Table created.
SQL> select object_name from zeeno sample(10) where rownum=1;
OBJECT_NAME

-------------------------------------------------------------
UET$
SQL> /
OBJECT_NAME

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

ICOL$

上面的示例表示从表zeeno中随机抽取10%的记录，并从中选择一条记录。

如果使用seed，则返回固定的集。

1* select object_name from zeeno sample(10) seed(10) where rownum=1

SQL> /
 
OBJECT_NAME

---------------------------------------------------------------------
PROXY_ROLE_DATA$
SQL> /
OBJECT_NAME

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

PROXY_ROLE_DATA$

只所以建临时表是因为如下原因：

SQL> select object_name from dba_objects sample(10)where rownum=1;

select object_name from dba_objects sample(10)where rownum=1

*

ERROR at line 1:

ORA-01446: cannot select ROWID from, or sample, a view with DISTINCT, GROUP BY,

etc.

方法2：使用DBMS_RANDOM包。

DBMS_RANDOM有两种主要的使用方法，分别是DBMS_RANDOM.VALUE()和DBMS_RANDOM.RANDOM。

SQL> select dbms_random.value() from dual;
 
DBMS_RANDOM.VALUE()

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

.638206012
SQL> /
DBMS_RANDOM.VALUE()

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

.312828706
SQL> select dbms_random.value(1,10) from dual
DBMS_RANDOM.VALUE(1,10)

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

2.49371361
SQL> /

DBMS_RANDOM.VALUE(1,10) ----------------------- 1.6890498

有了随机数，抽取随机记录就是一件非常轻松的事情了：

SQL> select * from (select object_name from zeeno

2 order by dbms_random.random)

3 where rownum=1;
 
OBJECT_NAME

-------------------------------------------------
DBMS_JAVA_TEST
SQL> /
OBJECT_NAME

-------------------------------------------------
USER_SNAPSHOT_REFRESH_TIMES
SQL> select * from (select object_name from zeeno

1 order by ceil(dbms_random.value(1,3))

2 )

3* where rownum=1
OBJECT_NAME

----------------------------------------------------------
UNDO$
SQL> /
OBJECT_NAME

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

I_USER1

通常情况下我更喜欢使用SAMPLE，因为更加方便。

都市淘沙者 2007-12-04 17:22 发表评论

总结一下关于行列转置的实现方法（CSDN）

都市淘沙者 — Mon, 03 Dec 2007 09:06:00 GMT

1、固定列数的行列转换
如
student subject grade
--------- ---------- --------
student1 语文 80
student1 数学 70
student1 英语 60
student2 语文 90
student2 数学 80
student2 英语 100
……
转换为
语文数学英语
student1 80 70 60
student2 90 80 100
……
语句如下：select student,
sum(decode(subject,'语文', grade,null)) "语文",
sum(decode(subject,'数学', grade,null)) "数学",
sum(decode(subject,'英语', grade,null)) "英语"
from table
group by student;
　

2、不定列行列转换
如
c1 c2
--- -----------
1 我
1 是
1 谁
2 知
2 道
3 不
……
转换为
1 我是谁
2 知道
3 不

这一类型的转换可以借助于PL/SQL来完成，这里给一个例子
CREATE OR REPLACE FUNCTION get_c2(tmp_c1 NUMBER)
RETURN VARCHAR2
IS
Col_c2 VARCHAR2(4000);
BEGIN
FOR cur IN (SELECT c2 FROM t WHERE c1=tmp_c1) LOOP
Col_c2 := Col_c2||cur.c2;
END LOOP;
Col_c2 := rtrim(Col_c2,1);
RETURN Col_c2;
END;

select distinct c1 ,get_c2(c1) cc2 from table;

或者不用pl/sql，利用分析函数和 CONNECT_BY 实现：

SELECT c1, SUBSTR (MAX (SYS_CONNECT_BY_PATH (c2, ';')), 2) NAME
    FROM (SELECT c1, c2, rn, LEAD (rn) OVER (PARTITION BY c1 ORDER BY rn) rn1
            FROM (SELECT c1, c2, ROW_NUMBER () OVER (ORDER BY c2) rn
                    FROM t))
START WITH rn1 IS NULL
CONNECT BY rn1 = PRIOR rn
GROUP BY c1;

3、列数不固定（交叉表行列转置）
这种是比较麻烦的一种，需要借助pl/sql：

原始数据：
CLASS1     CALLDATE         CALLCOUNT
1          2005-08-08       40
1          2005-08-07       6
2          2005-08-08       77
3          2005-08-09       33
3          2005-08-08       9
3          2005-08-07       21

转置后：
CALLDATE     CallCount1 CallCount2 CallCount3
------------ ---------- ---------- ----------
2005-08-09   0          0          33
2005-08-08   40         77         9
2005-08-07 　6 　　　　　0          21

试验如下：
1）. 建立测试表和数据
CREATE TABLE t(
    class1 VARCHAR2(2 BYTE),
    calldate DATE,
    callcount INTEGER
);

INSERT INTO t(class1, calldate, callcount)
VALUES ('1', TO_DATE ('08/08/2005', 'MM/DD/YYYY'), 40);

INSERT INTO t(class1, calldate, callcount)
VALUES ('1', TO_DATE ('08/07/2005', 'MM/DD/YYYY'), 6);

INSERT INTO t(class1, calldate, callcount)
VALUES ('2', TO_DATE ('08/08/2005', 'MM/DD/YYYY'), 77);

INSERT INTO t(class1, calldate, callcount)
VALUES ('3', TO_DATE ('08/09/2005', 'MM/DD/YYYY'), 33);

INSERT INTO t(class1, calldate, callcount)
VALUES ('3', TO_DATE ('08/08/2005', 'MM/DD/YYYY'), 9);

INSERT INTO t(class1, calldate, callcount)
VALUES ('3', TO_DATE ('08/07/2005', 'MM/DD/YYYY'), 21);

COMMIT ;

2）. 建立ref cursor准备输出结果集
CREATE OR REPLACE PACKAGE pkg_getrecord
IS
    TYPE myrctype IS REF CURSOR;
END pkg_getrecord;
/

3）. 建立动态sql交叉表函数，输出结果集
CREATE OR REPLACE FUNCTION fn_rs
    RETURN pkg_getrecord.myrctype
IS
    s VARCHAR2 (4000);
    CURSOR c1 IS
    SELECT ',sum(case when Class1='
            || class1
            || ' then CallCount else 0 end)'
            || ' "CallCount'
            || class1
            || '"' c2
    FROM t
    GROUP BY class1;
    r1 c1%ROWTYPE;
    list_cursor pkg_getrecord.myrctype;
BEGIN
    s := 'select CallDate ';
    OPEN c1;
    LOOP
        FETCH c1 INTO r1;
        EXIT WHEN c1%NOTFOUND;
        s := s || r1.c2;
    END LOOP;
    CLOSE c1;
    s := s || ' from T group by CallDate order by CallDate desc ';
    OPEN list_cursor FOR s;
    RETURN list_cursor;
END fn_rs;
/

4）. 测试在sql plus下执行：
var results refcursor;
exec :results := fn_rs;
print results;
CALLDATE        CallCount1 CallCount2 CallCount3
--------------- ---------- ---------- ----------
2005-08-09      0          0          33
2005-08-08      40         77         9
2005-08-07      6          0          21

都市淘沙者 2007-12-03 17:06 发表评论

PL/SQL开发中动态SQL的使用方法(zhuan)

都市淘沙者 — Wed, 17 Oct 2007 00:57:00 GMT

一般的PL/SQL程序设计中，在DML和事务控制的语句中可以直接使用SQL，但是DDL语句及系统控制语句却不能在PL/SQL中直接使用，要想实现在PL/SQL中使用DDL语句及系统控制语句，可以通过使用动态SQL来实现。

　　首先我们应该了解什么是动态SQL，在Oracle数据库开发PL/SQL块中我们使用的SQL分为：静态SQL语句和动态SQL语句。所谓静态SQL指在PL/SQL块中使用的SQL语句在编译时是明确的，执行的是确定对象。而动态SQL是指在PL/SQL块编译时SQL语句是不确定的，如根据用户输入的参数的不同而执行不同的操作。编译程序对动态语句部分不进行处理，只是在程序运行时动态地创建语句、对语句进行语法分析并执行该语句。

　　Oracle中动态SQL可以通过本地动态SQL来执行，也可以通过DBMS_SQL包来执行。下面就这两种情况分别进行说明：

　　一、本地动态SQL
　　本地动态SQL是使用EXECUTE IMMEDIATE语句来实现的。

　　1、本地动态SQL执行DDL语句：
　　需求：根据用户输入的表名及字段名等参数动态建表。
create or replace procedure proc_test
　　(
　　table_name in varchar2, --表名
　　field1 in varchar2, --字段名
　　datatype1 in varchar2, --字段类型
　　field2 in varchar2, --字段名
　　datatype2 in varchar2 --字段类型
　　) as
　　str_sql varchar2(500);
　　begin
　　str_sql:=’create table ’||table_name||’(’||field1||’ ’||datatype1||’,’||field2||’ ’||datatype2||’)’;
　　execute immediate str_sql; --动态执行DDL语句
　　exception
　　when others then
　　null;
　　end ;
　　以上是编译通过的存储过程代码。下面执行存储过程动态建表。　　

SQL＞ execute proc_test(’dinya_test’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
　　PL/SQL procedure successfully completed
　　SQL＞ desc dinya_test;
　　Name Type Nullable Default Comments
　　---- ------------- -------- ------- --------
　　ID NUMBER(8)
　　NAME VARCHAR2(100) Y
　　SQL＞

　　到这里，就实现了我们的需求，使用本地动态SQL根据用户输入的表名及字段名、字段类型等参数来实现动态执行DDL语句。

　　2、本地动态SQL执行DML语句。
　　需求：将用户输入的值插入到上例中建好的dinya_test表中。　　
create or replace procedure proc_insert
　　(
　　id in number, --输入序号
　　name in varchar2 --输入姓名
　　) as
　　str_sql varchar2(500);
　　begin
　　str_sql:=’insert into dinya_test values(:1,:2)’;
　　execute immediate str_sql using id,name; --动态执行插入操作
　　exception
　　when others then
　　null;
　　end ;
　　执行存储过程，插入数据到测试表中。
　　SQL＞ execute proc_insert(1,’dinya’);
　　PL/SQL procedure successfully completed
　　SQL＞select * from dinya_test;
　　ID NAME
　　1 dinya
　　在上例中，本地动态SQL执行DML语句时使用了using子句，按顺序将输入的值绑定到变量，如果需要输出参数，可以在执行动态SQL的时候，使用RETURNING INTO 子句，如：　
declare
　　p_id number:=1;
　　v_count number;
　　begin
　　v_string:=’select count(*) from table_name a where a.id=:id’;
　　execute immediate v_string into v_count using p_id;
　　end ;
　　更多的关于动态SQL中关于返回值及为输出输入绑定变量执行参数模式的问题，请读者自行做测试。

　　二、使用DBMS_SQL包
　　使用DBMS_SQL包实现动态SQL的步骤如下：A、先将要执行的SQL语句或一个语句块放到一个字符串变量中。B、使用DBMS_SQL包的parse过程来分析该字符串。C、使用DBMS_SQL包的bind_variable过程来绑定变量。D、使用DBMS_SQL包的execute函数来执行语句。

　　1、使用DBMS_SQL包执行DDL语句
　　需求：使用DBMS_SQL包根据用户输入的表名、字段名及字段类型建表。
create or replace procedure proc_dbms_sql
　　(
　　table_name in varchar2, --表名
　　field_name1 in varchar2, --字段名
　　datatype1 in varchar2, --字段类型
　　field_name2 in varchar2, --字段名
　　datatype2 in varchar2 --字段类型
　　)as
　　v_cursor number; --定义光标
　　v_string varchar2(200); --定义字符串变量
　　v_row number; --行数
　　begin
　　v_cursor:=dbms_sql.open_cursor; --为处理打开光标
　　v_string:=’create table ’||table_name||’(’||field_name1||’ ’||datatype1||’,’||field_name2||’ ’||datatype2||’)’;
　　dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
　　v_row:=dbms_sql.execute(v_cursor); --执行语句
　　dbms_sql.close_cursor(v_cursor); --关闭光标
　　exception
　　when others then
　　dbms_sql.close_cursor(v_cursor); --关闭光标
　　raise;
　　end;

　　以上过程编译通过后，执行过程创建表结构：

SQL＞ execute proc_dbms_sql(’dinya_test2’,’id’,’number(8) not null’,’name’,’varchar2(100)’);
　　PL/SQL procedure successfully completed
　　SQL＞ desc dinya_test2;
　　Name Type Nullable Default Comments
　　---- ------------- -------- ------- --------
　　ID NUMBER(8)
　　NAME VARCHAR2(100) Y
　　SQL＞

　　2、使用DBMS_SQL包执行DML语句
　　需求：使用DBMS_SQL包根据用户输入的值更新表中相对应的记录。

　　查看表中已有记录：　

SQL＞select * from dinya_test2;
　　ID NAME
　　1 Oracle
　　2 CSDN
　　3 ERP
　　SQL＞

建存储过程，并编译通过：　　

create or replace procedure proc_dbms_sql_update
　　(
　　id number,
　　name varchar2
　　)as
　　v_cursor number; --定义光标
　　v_string varchar2(200); --字符串变量
　　v_row number; --行数
　　begin
　　v_cursor:=dbms_sql.open_cursor; --为处理打开光标
　　v_string:=’update dinya_test2 a set a.name=:p_name where a.id=:p_id’;
　　dbms_sql.parse(v_cursor,v_string,dbms_sql.native); --分析语句
　　dbms_sql.bind_variable(v_cursor,’:p_name’,name); --绑定变量
　　dbms_sql.bind_variable(v_cursor,’:p_id’,id); --绑定变量
　　v_row:=dbms_sql.execute(v_cursor); 　　　　　　　　　　　--执行动态SQL
　　dbms_sql.close_cursor(v_cursor); --关闭光标
　　exception
　　when others then
　　dbms_sql.close_cursor(v_cursor); --关闭光标
　　raise;
　　end;
　　执行过程，根据用户输入的参数更新表中的数据：　　

SQL＞ execute proc_dbms_sql_update(2,’csdn_dinya’);
　　PL/SQL procedure successfully completed
　　SQL＞select * from dinya_test2;
　　ID NAME
　　1 Oracle
　　2 csdn_dinya
　　3 ERP
　　SQL＞
　
　　执行过程后将第二条的name字段的数据更新为新值csdn_dinya。这样就完成了使用dbms_sql包来执行DML语句的功能。

　　使用DBMS_SQL中，如果要执行的动态语句不是查询语句，使用DBMS_SQL.Execute或DBMS_SQL.Variable_Value来执行，如果要执行动态语句是查询语句，则要使用DBMS_SQL.define_column定义输出变量，然后使用DBMS_SQL.Execute, DBMS_SQL.Fetch_Rows, DBMS_SQL.Column_Value及DBMS_SQL.Variable_Value来执行查询并得到结果。

　　总结说明：

　　在Oracle开发过程中，我们可以使用动态SQL来执行DDL语句、DML语句、事务控制语句及系统控制语句。但是需要注意的是，PL/SQL块中使用动态SQL执行DDL语句的时候与别的不同，在DDL中使用绑定变量是非法的(bind_variable(v_cursor,’:p_name’,name))，分析后不需要执行DBMS_SQL.Bind_Variable，直接将输入的变量加到字符串中即可。另外，DDL是在调用DBMS_SQL.PARSE时执行的，所以DBMS_SQL.EXECUTE也可以不用，即在上例中的v_row:=dbms_sql.execute(v_cursor)部分可以不要。

都市淘沙者 2007-10-17 08:57 发表评论

Oracle中取前几名的方法（转）

都市淘沙者 — Tue, 16 Oct 2007 08:28:00 GMT

与SQL SERVER相比,Oracle没有Top n 这样简单方便取前几名的方法.
       但也有相对应的方法可以实现，使用的是Oracle中的伪列：rownum.

       最简单的方法如下：

一：最简单的问题：直接取前几名
        SELECT A.* from Company_Expense A WHERE ROWNUM<=N
         (注意,在上句中我们没有指定按哪列进行排序,而具体rownum序号是依据哪一列，现在我都不确定。但可以明确一点的是，如果我们按主键进行排序，rownum号不会乱，但如果指定其它列的号，序号有可能会乱)

二：麻烦一点的：取后几名
        上面方法的一点变通,首先在内部以某列进行排列，在外面取
        select V.* from
(
select rownum,A.* from company_expense A
order by a.expenseid desc
)V where rownum<3

三：变态一点的：取前几名，但值相同的记录为同一名次
        比如：对班级学生成绩进行排名，第一名:100,共2名，第二名,98,共5名........如此类推，取出排名前十名的所有学生。
        基本思路是：先使用Distinct取得成绩的前十名,并使用rownum排序.这样可以得出第十名的值，然后取所有成绩大于等于第十名的所有学生信息。
        记录得到后,然后再与刚使用Distinct取得成绩为前十名，且有rownum序号的表Join,以成绩为条件。就可以得到正常的排名次序。
         相关代码请参考如下脚本：

select rownum, T.Row_Num, v.*
  from (select A.Name,
               A.Employee_Code,
               v.STATUS,
               To_Char(v.JOIN_DATE, 'yyyy-mm-dd') Join_Date,
               V.Unit_Name,
               p.line_description Line_Num,
               sum(a.last_result) Sum_result
          from QM_QUALITY_LEVEL_JUDGE   A,
               hr_lbr_employee_tl_tbl_v v,
               Qm_Product_Line          P
         Where a.employee_code = v.EMPLOYEE_CODE
           And A.LINE_NUM = P.Line_Num
           And To_Char(A.Index_Date, 'yyyy-mm-dd') >= '2006-05-01'
           And To_Char(A.Index_Date, 'yyyy-mm-dd') <= '2006-07-24'
           And A.Last_Result > 0
         group by A.Name,
                  A.Employee_Code,
                  V.STATUS,
                  V.JOIN_DATE,
                  V.Unit_Name,
                  A.Line_Num,
                  P.LINE_DESCRIPTION
         order by Sum_Result desc, employee_code desc) v   ---基本的信息
  left join (select rownum row_Num, v.*
               from (select distinct sum(a.last_result) Sum_result
                       from QM_QUALITY_LEVEL_JUDGE   A,
                            hr_lbr_employee_tl_tbl_v v,
                            Qm_Product_Line          P
                      Where a.employee_code = v.EMPLOYEE_CODE
                        And A.LINE_NUM = P.Line_Num
                        And To_Char(A.Index_Date, 'yyyy-mm-dd') >=
                            '2006-05-01'
                        And To_Char(A.Index_Date, 'yyyy-mm-dd') <=
                            '2006-07-24'
                        And A.Last_Result > 0
                      group by A.Name,
                               A.Employee_Code,
                               V.STATUS,
                               V.JOIN_DATE,
                               V.Unit_Name,
                               A.Line_Num,
                               P.LINE_DESCRIPTION
                      Order by Sum_Result Desc) v
              Where rownum <= 10) T On v.Sum_Result = T.Sum_Result  --得到正确的排名序号

-----以下条件是取得所有大于第十名成绩的记录
where V.sum_Result >=
       (select min(Sum_Result) Sum_Result
          from (select rownum row_Num, v.*
                  from (select distinct sum(a.last_result) Sum_result
                          from QM_QUALITY_LEVEL_JUDGE   A,
                               hr_lbr_employee_tl_tbl_v v,
                               Qm_Product_Line          P
                         Where a.employee_code = v.EMPLOYEE_CODE
                           And A.LINE_NUM = P.Line_Num
                           And To_Char(A.Index_Date, 'yyyy-mm-dd') >=
                               '2006-05-01'
                           And To_Char(A.Index_Date, 'yyyy-mm-dd') <=
                               '2006-07-24'
                           And A.Last_Result > 0
                         group by A.Name,
                                  A.Employee_Code,
                                  V.STATUS,
                                  V.JOIN_DATE,
                                  V.Unit_Name,
                                  A.Line_Num,
                                  P.LINE_DESCRIPTION
                         Order By Sum_Result Desc) v
                 Where rownum <= 10))

都市淘沙者 2007-10-16 16:28 发表评论

Oracle常用查询（转）

都市淘沙者 — Tue, 16 Oct 2007 08:23:00 GMT

最近有许多学员问了一些面试中的问题，总结起来看，一是关于怎样找出和去除重复数据，这在另一个帖子利已有详细介绍。二是关于找出某一列里最大或最小的前几个，或是大于或小于某一个值（最大值或平均值）的数据。针对这种情况，再此做一个介绍。

1：找出公司里收入最高的前三名员工：

SQL> select rownum, last_name, salary
2 from (select last_name, salary
3 from s_emp
4 order by salary desc)
5 where rownum<=3;

ROWNUM LAST_NAME SALARY
---------- ------------------------- ----------
1 Velasquez 4750
2 Ropeburn 2945
3 Nguyen 2897.5

注意：请大家分析一下一下语句为什么不对：

SQL> select rownum, last_name, salary
2 from s_emp
3 where rownum<=3
4 order by salary desc;

ROWNUM LAST_NAME SALARY
---------- ------------------------- ----------
1 Velasquez 4750
3 Nagayama 2660
2 Ngao 2000

注：在informix里的查询用：select first 10 * from table where .....

2：找出表中的某一行或某几行的数据：

（1）：找出表中第三行数据：
用以下方法是不行的，因为rownum后面至可以用<或<=号,不可以用=,>号和其它的比较符号。

SQL> select * from s_emp
2 where rownum=3;

no rows selected

SQL> select * from s_emp
2 where rownum between 3 and 5;

no rows selected

正确的方法如下：

SQL> l
1 select last_name, salary
2 from (select rownum a, b.*
3 from s_emp b)
4* where a=3
SQL> /

LAST_NAME SALARY
------------------------- ----------
Nagayama 2660

（2）：找出第三行到第五行之间的数据：
SQL> l
1 select last_name, salary
2 from (select rownum a, b.*
3 from s_emp b)
4* where a between 3 and 5
SQL> /

LAST_NAME SALARY
------------------------- ----------
Nagayama 2660
Quick-To-See 2755
Ropeburn 2945

3：找出那些工资高于他们所在部门的平均工资的员工。

（1）：第一种方法：
SQL> select last_name, dept_id, salary
2 from s_emp a
3 where salary>(select avg(salary)
4 from s_emp
5 where dept_id=a.dept_id);

LAST_NAME DEPT_ID SALARY
------------------------- ---------- ----------
Velasquez 50 4750
Urguhart 41 2280
Menchu 42 2375
Biri 43 2090
Catchpole 44 2470
Havel 45 2483.3
Nguyen 34 2897.5
Maduro 41 2660
Nozaki 42 2280
Schwartz 45 2090

10 rows selected.

（2）：第二种方法：
SQL> l
1 select a.last_name, a.salary, a.dept_id, b.avgsal
2 from s_emp a, (select dept_id, avg(salary) avgsal
3 from s_emp
4 group by dept_id) b
5 where a.dept_id=b.dept_id
6* and a.salary>b.avgsal
SQL> /

LAST_NAME SALARY DEPT_ID AVGSAL
------------------------- ---------- ---------- ----------
Velasquez 4750 50 3847.5
Urguhart 2280 41 2181.5
Menchu 2375 42 2055.16667
Biri 2090 43 1710
Catchpole 2470 44 1995
Havel 2483.3 45 2069.1
Nguyen 2897.5 34 2204
Maduro 2660 41 2181.5
Nozaki 2280 42 2055.16667
Schwartz 2090 45 2069.1

10 rows selected.

4：找出那些工资高于他们所在部门的manager的工资的员工。

SQL> l
1 select id, last_name, salary, manager_id
2 from s_emp a
3 where salary>(select salary
4 from s_emp
5* where id=a.manager_id)
SQL> /

ID LAST_NAME SALARY MANAGER_ID
---------- ------------------------- ---------- ----------
6 Urguhart 2280 2
7 Menchu 2375 2
8 Biri 2090 2
9 Catchpole 2470 2
10 Havel 2483.3 2
12 Giljum 2831 3
13 Sedeghi 2878.5 3
14 Nguyen 2897.5 3
15 Dumas 2755 3
16 Maduro 2660 6

10 rows selected.

附注：查询数据库有那些表：
informix: select * from systables;
Oracle:select * from user_all_tables;

都市淘沙者 2007-10-16 16:23 发表评论