Browsed by
标签:Database

好烂啊有点差凑合看看还不错很精彩 (No Ratings Yet)
Loading...
118 views
为什么 MySQL 使用多线程,而 Oracle 和 PostgreSQL 使用多进程?

为什么 MySQL 使用多线程,而 Oracle 和 PostgreSQL 使用多进程?

 

诸如Oracle这种商业数据库,基本都支持多种Process Models, Oracle默认是多进程。

根据Understanding MySQL Internals所说, MySQL一开始是Solaris上的 :

Thus in May of 1996 MySQL version 1.0 was released to a limited group, followed by a public release in October 1996 of version 3.11.1. The initial public release provided only a binary distribution for Solaris. A month later, the source and the Linux binary were released.

这本书也提及了,为什么MySQL用多线程:

Just as a good rider becomes one with the horse, Monty(MySQL author) had become one with the computer. It pained him to see system resources wasted. He felt confident enough to be able to write virtually bug-free code, deal with the concurrency issues presented by threads, and even work with s small stack. What an exciting challenge! Needless to say, he chose threads.

Postgres的原因可以在The design of Postgres中找到:

However, this approach requires that a fairly complete special-purpose operating system be built. In contrast, the process-per-user model is simpler to implement but will not perform as well on most conventional operating systems. We decided after much soul searching to implement POSTGRES using a process-per-user model architecture because of our limited programming resources.

总而言之,最根本的原因,主要是当年操作系统对线程支持不给力,而MySQL是特例,因为开发者喜欢挑战(不过事实上,那个时候的线程支持已经基本完善了。MySQL后于Oracle和POSTGRES)

至于如果要了解不同model间的优劣,强烈推荐Anatomy of a Database System第二章Process Models.

ORACLE在windows上也是多线程。
传统的unix系统,早期没有提供多线程,只有多进程。linux是最近的版本才加入多线程支持,以前一直都是多进程。windows很早就支持多线程,本地应用大部分也是多线程。因此oracle在windows上一直都是多线程,在unix上才是多进程。多进程的好处是,一个进程崩溃不会影响其他进程,多线程的好处是不需要共享内存这样的手段来访问数据库缓冲区。
这里不从历史原因说仅仅从技术上讲多线程与多进程有什么什么好处,因为自己曾经把postgres从多进程改为多线程,中间历尽苦难。
多线程多进程在linux的差别并不是很大,但是在Windows的性能差别就比较大,实际上oralce在Windows的版本也是多线程的。
多进程好处就是相对来讲稳定性较好,一个进程挂掉,重新拉起来就好,但是一个线程crash会导致整个进程都crash的.
一般操作系统教科书里的线程和进程的概念只是抽象理论上的,在不同OS里的实现显然有很大区别。
Windows上线程库很方便很高效,强于posix thread,而process的创建代价就很昂贵;而且这是由MS自己设计实现的,直接以系统API方式提供。
Unix上process model更简单,而multithreading基本就是一个雷区,Unix上几十年来的主流开发语言C/C++根本就不支持thread(直到C++11),即使后来有了posix thread,在移植性上也是开发人员的噩梦。
所以,抛开具体的DB产品不说,multitasking在Windows上一般首选thread,而Unix上肯定是用fork了。这也是为什么mysql基于solaris却采用thread会被认为是挑战。

请看一篇论文,stonebraker的数据库体系结构~
多进程实现起来方便~
多线程资源利用率高~

最好的体系结构是进程池和线程池~

好烂啊有点差凑合看看还不错很精彩 (No Ratings Yet)
Loading...
298 views
oracle中 sql截取某个字符前面和后面的值

oracle中 sql截取某个字符前面和后面的值

直接看代码:

–创建测试表及数据
create table test
(name varchar2(10));

insert into test values (‘2-15’);
insert into test values (‘2-33’);
insert into test values (‘2-3′);
insert into test values (’12-8′);
insert into test values (’12-22′);
insert into test values (’12-3′);

–执行

select name,substr(name,1,instr(name,’-‘)-1) 前,

substr(name,instr(name,’-‘)+1,length(name)-instr(name,’-‘)) 后

from test

–结果
NAME 前 后
2-15 2 15
2-33 2 33
2-3 2 3

–end–

 

好烂啊有点差凑合看看还不错很精彩 (No Ratings Yet)
Loading...
312 views
Oracle-分区表案例

Oracle-分区表案例

Oracle-分区表案例

Oracle数据库开发了解分区表
分区就是将一个非常大的表或者索引物理地分解为多个较小的 可独立管理的部分.
分区表或索引在逻辑上是一个表或一个索引,但物理上是由多个物理分区组成的.
分区功能通过改善可管理性 性能 可用性,为各种应用系统带来了极大的好处.
分区功能的好处:
1.增强数据可用性:如果表的一个分区因故障或者维护而不能使用时,表的其余分区仍是可用的;
2.维护方便:独立管理多个分区,比维护单个大表要轻松;
3.均衡I/O:可以把不同分区映射到磁盘以平衡I/O,显著改善性能;
4.改善查询性能:对已分区对象的某些查询可以运行更快,因为搜索仅限于关心的分区;

分区表有哪些??
Oracle 11g 提供6种表分区方法:范围分区(range) 散列分区(hash) 列表分区(list)
符合分区 间隔分区 引用分区.


按表中某个列值的范围进行分区,根据该列的值决定将数据存储在哪个分区上.

创建范围分区需注意以下几点:
1.指明分区方法,分区列,和分区描述
2.每一个分区都有values less than子句
3.在最高分区中定义maxvalue,这个maxvalue值高区其他分区中的任何键值.
例:创建范围分区

create table range_orders
(order_id varchar2(10) constraint OR_PK primary key
,order_date date default sysdate
,qty integer
,payterms varchar2(10)
,book_id number(6)
)
partition by range (order_date)
(partition p1 values less than (to_date(‘20140331′,’yyyymmdd’)) tablespace user01,
partition p2 values less than (to_date(‘20140430′,’yyyymmdd’)) tablespace user02,
partition p3 values less than (to_date(‘20140531′,’yyyymmdd’)) tablespace user03
)
;

SQL> insert into range_orders values (‘10001’,to_date(‘20140321′,’yyyymmdd’),1,’payterm_1′,110345);
1 row inserted
SQL> insert into range_orders values (‘10002’,to_date(‘20140421′,’yyyymmdd’),1,’payterm_2′,110745);
1 row inserted
SQL> insert into range_orders values (‘10003’,to_date(‘20140521′,’yyyymmdd’),1,’payterm_3′,110945);
1 row inserted

SQL> commit;
Commit complete

SQL> select rowid,r.* from range_orders r;
ROWID ORDER_ID ORDER_DATE QTY PAYTERMS BOOK_ID
—————— ———- ———– —- ———- ——-
AAADwpAAGAAAACFAAA 10001 2014/3/21 1 payterm_1 110345
AAADwqAAHAAAACFAAA 10002 2014/4/21 1 payterm_2 110745
AAADwrAAIAAAACFAAA 10003 2014/5/21 1 payterm_3 110945

可以看到AAG,AAH,AAI 分别代表了三条数据的文件号是6,7,8
备注:这个地方可以看下http://blog.itpub.net/28929558/viewspace-1150766/ 了解rowid
验证下

SQL> select x.FILE#,x.NAME from v$datafile x;

FILE# NAME
———- —————————————-
1 D:\ORACLE\ORADATA\CRISS_DB\SYSTEM01.DBF
2 D:\ORACLE\ORADATA\CRISS_DB\SYSAUX01.DBF
3 D:\ORACLE\ORADATA\CRISS_DB\UNDOTBS01.DBF
4 D:\ORACLE\ORADATA\CRISS_DB\USERS01.DBF
5 D:\ORACLE\ORADATA\CRISS_DB\TEST01.DBF
6 D:\ORACLE\ORADATA\CRISS_DB\USER01.DBF
7 D:\ORACLE\ORADATA\CRISS_DB\USER02.DBF
8 D:\ORACLE\ORADATA\CRISS_DB\USER03.DBF

8 rows selected


散列分区指一个或多个列上应用一个散列函数,数根据该散列值存放在不同的分区中.
通过散列分区,可以将数据比较均匀地分布到各个分区中.

例:创建散列分区表

SQL> create table hash_orders

(order_id varchar2(10) constraint HOR_PK primary key
,order_date date default sysdate
,qty integer
,payterms varchar2(10)
,book_id number(6)
)
partition by hash(order_id)
( partition hash_p1 tablespace user01
,partition hash_p2 tablespace user02
);

 

Table created

SQL> insert into hash_orders select * from range_orders;

3 rows inserted

 

SQL> select rowid,h.* from hash_orders h;

ROWID ORDER_ID ORDER_DATE QTY PAYTERMS BOOK_ID
—————— ———- —————– ———- ——-
AAADyIAAGAAAACNAAA 10002 2014/4/21 1 payterm_2 110745
AAADyIAAGAAAACNAAB 10003 2014/5/21 1 payterm_3 110945
AAADyJAAHAAAACNAAA 10001 2014/3/21 1 payterm_1 110345

 

继续: http://blog.csdn.net/woshimyc/article/details/73289798

 

-end-

好烂啊有点差凑合看看还不错很精彩 (No Ratings Yet)
Loading...
285 views
Oracle的with..as的用法

Oracle的with..as的用法

Oracle with..as 的用法

— code = SQL —

–语法:

with tempName as (select ….)
select …

 

–例:现在要从1-19中得到11-14。一般的sql如下:
select * from
(
–模拟生一个20行的数据
SELECT LEVEL AS lv
FROM DUAL
CONNECT BY LEVEL ) tt
WHERE tt.lv > 10 AND tt.lv

 

–使用With as 的SQL为:
with TT as(
–模拟生一个20行的数据
SELECT LEVEL AS lv
FROM DUAL
CONNECT BY LEVEL )
select lv from TT
WHERE lv > 10 AND lv

/*With查询语句不是以select开始的,而是以“WITH”关键字开头
可认为在真正进行查询之前预先构造了一个临时表TT,之后便可多次使用它做进一步的分析和处理

WITH Clause方法的优点
增加了SQL的易读性,如果构造了多个子查询,结构会更清晰;更重要的是:“一次分析,多次使用”,
这也是为什么会提供性能的地方,达到了“少读”的目标。
第一种使用子查询的方法表被扫描了两次,而使用WITH Clause方法,表仅被扫描一次。
这样可以大大的提高数据分析和查询的效率。
另外,观察WITH Clause方法执行计划,其中“SYS_TEMP_XXXX”便是在运行过程中构造的中间统计结果临时表。*/

—–*************************在视图中使用WITH语句进行连接
CREATE OR REPLACE VIEW WITH_V AS
WITH DEPT_V AS (SELECT * FROM DEPT),
EMP_V AS (SELECT * FROM EMP)
SELECT D.DNAME,D.LOC,E.* FROM EMP_V E
LEFT JOIN DEPT_V D
ON D.DEPTNO = E.DEPTNO
—–*************************WITH语句的使用例子:
/*查询出部门的总薪水大于所有部门平均总薪水的部门。部门表s_dept,员工表s_emp。
分析:做这个查询,首先必须计算出所有部门的总薪水,然后计算出总薪水的平均薪水,
再筛选出部门的总薪水大于所有部门总薪水平均薪水的部门。那么第1 步with 查询查出所有部门的总薪水,
第2 步用with 从第1 步获得的结果表中查询出平均薪水,最后利用这两次 的with 查询比较总薪水大于平均薪水的结果,如下:
*/

WITH DEPT_COSTS AS –查询出部门的总工资WITH DEPT_COSTS AS –查询出部门的总工资 (SELECT D.DNAME, SUM(E.SAL) DEPT_TOTAL FROM DEPT D, EMP E WHERE E.DEPTNO = D.DEPTNO GROUP BY D.DNAME), AVE_COST AS –查询出部门的平均工资,在后一个WITH语句中可以引用前一个定义的WITH语句 (SELECT SUM(DEPT_TOTAL) / COUNT(*) AVG_SUM FROM DEPT_COSTS) SELECT—–************************* /*一、WITH AS的含义        WITH AS短语,也叫做子查询部分(subquery factoring),可以定义一个SQL片断,该SQL片断会被整个SQL语句所用到。 特别对于UNION ALL比较有用。因为UNION ALL的每个部分可能相同,但是如果每个部分都去执行一遍的话,则成本太高, 所以可以使用WITH AS短语,则只要执行一遍即可。如果WITH AS短语所定义的表名被调用两次以上,则优化器会自动将WITH AS 短语所获取的数据放入一个TEMP表里,如果只是被调用一次,则不会。而提示materialize则是强制将WITH AS短语里的数据放入 一个全局临时表里。很多查询通过这种方法都可以提高速度。
二、WITH AS的使用实例从A表中查询某个字段出来,如果没有从B表中查询,如果A,B表中都没有,则输出ERROR*/

with sql1 as
(select to_char(id) myid from a),
sql2 as
(select to_char(id) myid from b where not exists
(select * from sql1 where rownum > 5))
select * from sql1
union all
select * from sql2
union all
select ‘error’ from dual
where not exists (select * from sql1 where rownum > 5) and not exists
(select * from sql2 where rownum > 2);

–code–

 

–end–

好烂啊有点差凑合看看还不错很精彩 (No Ratings Yet)
Loading...
718 views
MySQL行级锁、表级锁、页级锁详细介绍

MySQL行级锁、表级锁、页级锁详细介绍

MySQL行级锁、表级锁、页级锁详细介绍

1、如果对读的响应度要求非常高,比如证券交易系统,那么适合用乐观锁,因为悲观锁会阻塞读

2、如果读远多于写,那么也适合用乐观锁,因为用悲观锁会导致大量读被少量的写阻塞

3、如果写操作频繁并且冲突比例很高,那么适合用悲观写独占锁

由于InnoDB 预设是Row-Level Lock,所以 只有「明确」的指定主键,MySQL 才会执行Row lock (只锁住被选取的数据) ,否则MySQL 将会执行Table Lock (将整个数据表单给锁住)。

举个例子:

假设有个表单products ,里面有id 跟name 二个栏位,id 是主键。

例1: (明确指定主键,并且有此数据,row lock)

SELECT * FROM products WHERE id=’3′ FOR UPDATE;

例2: (明确指定主键,若查无此数据,无lock)

SELECT * FROM products WHERE id=’-1′ FOR UPDATE;

例2: (无主键,table lock)

SELECT * FROM products WHERE name=’Mouse’ FOR UPDATE;

例3: (主键不明确,table lock)

SELECT * FROM products WHERE id’3′ FOR UPDATE;

例4: (主键不明确,table lock)

SELECT * FROM products WHERE id LIKE ‘3’ FOR UPDATE;

注1: FOR UPDATE 仅适用于InnoDB,且必须在事务区块(BEGIN/COMMIT)中才能生效。

注2: 要测试锁定的状况,可以利用MySQL 的Command Mode ,开二个视窗来做测试。

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

页级:引擎 BDB。

表级:引擎 MyISAM , 理解为锁住整个表,可以同时读,写不行

行级:引擎 INNODB , 单独的一行记录加锁

表级,直接锁定整张表,在你锁定期间,其它进程无法对该表进行写操作。如果你是写锁,则其它进程则读也不允许

行级,,仅对指定的记录进行加锁,这样其它进程还是可以对同一个表中的其它记录进行操作。

页级,表级锁速度快,但冲突多,行级冲突少,但速度慢。所以取了折衷的页级,一次锁定相邻的一组记录。

MySQL 5.1支持对MyISAM和MEMORY表进行表级锁定,对BDB表进行页级锁定,对InnoDB表进行行级锁定。

对WRITE,MySQL使用的表锁定方法原理如下:

如果在表上没有锁,在它上面放一个写锁。

否则,把锁定请求放在写锁定队列中。

对READ,MySQL使用的锁定方法原理如下:

如果在表上没有写锁定,把一个读锁定放在它上面

否则,把锁请求放在读锁定队列中。

InnoDB使用行锁定,BDB使用页锁定。对于这两种存储引擎,都可能存在死锁。这是因为,在SQL语句处理期间,InnoDB自动获得行锁定和BDB获得页锁定,而不是在事务启动时获得。

行级锁定的优点:

·         当在许多线程中访问不同的行时只存在少量锁定冲突。

·         回滚时只有少量的更改。

·         可以长时间锁定单一的行。

行级锁定的缺点:

·         比页级或表级锁定占用更多的内存。

·         当在表的大部分中使用时,比页级或表级锁定速度慢,因为你必须获取更多的锁。

·         如果你在大部分数据上经常进行GROUP BY操作或者必须经常扫描整个表,比其它锁定明显慢很多。

·         用高级别锁定,通过支持不同的类型锁定,你也可以很容易地调节应用程序,因为其锁成本小于行级锁定。

-end-

跳至工具栏