亚洲欧洲日本在线观看,亚洲av成人无码久久精品,中文字幕在线观看亚洲

在python中獲取mac和ip地址

python 獲得本機MAC地址：
import uuid
     def get_mac_address():
     mac=uuid.UUID(int=uuid.getnode()).hex[-12:]
     return ":".join([mac[e:e+2] for e in range(0,11,2)])

python獲取IP的方法：使用socket

import socket
myname=socket.getfqdn(socket.gethostname( ))
    myaddr=socket.gethostbyname(myname)
    print(myname)
    print(myaddr)

posted @ 2017-05-15 23:26 鴻雁閱讀(250) | 評論 (0) | 編輯收藏

Spring—Quartz定時調度CronTrigger時間配置格式說明與實例

spring中使用Quartz時時間配置例子：

<bean id="realweatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="realweatherTask" />
</property>
<property name="cronExpression">
<value>0 10/30 * * * ?</value>
</property>
</bean>

<bean id="weatherTime" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="weatherTask" />
</property>
<property name="cronExpression">

<value>0 0,30 0-23 * * ?</value><!---表示每天從0-23時中每時的整點或半點執行任務->
</property>
</bean>

1、 CronTrigger時間格式配置說明

CronTrigger配置格式:

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

序號	說明	是否必填	允許填寫的值	允許的通配符
1	秒	是	0-59	, - * /
2	分	是	0-59	, - * /
3	小時	是	0-23	, - * /
4	日	是	1-31	, - * ? / L W
5	月	是	1-12 or JAN-DEC	, - * /
6	周	是	1-7 or SUN-SAT	, - * ? / L #
7	年	否	empty 或 1970-2099	, - * /

通配符說明:

* ：表示所有值. 例如:在分的字段上設置 "*",表示每一分鐘都會觸發。
? ：表示不指定值。使用的場景為不需要關心當前設置這個字段的值。例如:要在每月的10號觸發一個操作，但不關心是周幾，所以需要周位置的那個字段設置為"?" 具體設置為 0 0 0 10 * ?
- ：表示區間。例如在小時上設置 "10-12",表示 10,11,12點都會觸發。
, ：表示指定多個值，例如在周字段上設置 "MON,WED,FRI" 表示周一，周三和周五觸發
/ ：用于遞增觸發。如在秒上面設置"5/15" 表示從5秒開始，每增15秒觸發(5,20,35,50)。在月字段上設置'1/3'所示每月1號開始，每隔三天觸發一次。
L ：表示最后的意思。在日字段設置上，表示當月的最后一天(依據當前月份，如果是二月還會依據是否是潤年[leap]), 在周字段上表示星期六，相當于"7"或"SAT"。如果在"L"前加上數字，則表示該數據的最后一個。

例如在周字段上設置"6L"這樣的格式,則表示“本月最后一個星期五"

W ：表示離指定日期的最近那個工作日(周一至周五). 例如在日字段上設置"15W"，表示離每月15號最近的那個工作日觸發。如果15號正好是周六，則找最近的周五(14號)觸發, 如果15號是周未，則找最近的下周一(16號)觸發.如果15號正好在工作日(周一至周五)，則就在該天觸發。如果指定格式為 "1W",它則表示每月1號往后最近的工作日觸發。如果1號正是周六，則將在3號下周一觸發。(注，"W"前只能設置具體的數字,不允許區間"-").

'L'和 'W'可以一組合使用。如果在日字段上設置"LW",則表示在本月的最后一個工作日觸發

# ：序號(表示每月的第幾周星期幾)，例如在周字段上設置"6#3"表示在每月的第三個周星期六.注意如果指定"6#5",正好第五周沒有星期六，則不會觸發該配置(用在母親節和父親節再合適不過了)

周字段的設置，若使用英文字母是不區分大小寫的 MON 與mon相同.

常用示例:

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

0 0 12 * * ?           每天12點觸發
0 15 10 ? * *          每天10點15分觸發
0 15 10 * * ?          每天10點15分觸發
0 15 10 * * ? *        每天10點15分觸發
0 15 10 * * ? 2005     2005年每天10點15分觸發
0 * 14 * * ?           每天下午的 2點到2點59分每分觸發
0 0/5 14 * * ?         每天下午的 2點到2點59分(整點開始，每隔5分觸發)
0 0/5 14,18 * * ?        每天下午的 18點到18點59分(整點開始，每隔5分觸發)

0 0-5 14 * * ?            每天下午的 2點到2點05分每分觸發
0 10,44 14 ? 3 WED        3月分每周三下午的 2點10分和2點44分觸發
0 15 10 ? * MON-FRI       從周一到周五每天上午的10點15分觸發
0 15 10 15 * ?            每月15號上午10點15分觸發
0 15 10 L * ?             每月最后一天的10點15分觸發
0 15 10 ? * 6L            每月最后一周的星期五的10點15分觸發
0 15 10 ? * 6L 2002-2005  從2002年到2005年每月最后一周的星期五的10點15分觸發

0 15 10 ? * 6#3           每月的第三周的星期五開始觸發
0 0 12 1/5 * ?            每月的第一個中午開始每隔5天觸發一次
0 11 11 11 11 ?           每年的11月11號 11點11分觸發(光棍節)

spring中使用Quartz時時間配置例子：

posted @ 2017-04-29 12:01 鴻雁閱讀(318) | 評論 (0) | 編輯收藏

前端內容展示操作

1.有時表格內容太多，只顯示部分，其余部分已省略號表示，用css處理如下：

.template td{

word-break:keep-all;/* 不換行 */

white-space:nowrap;/* 不換行 */

overflow:hidden;/* 內容超出寬度時隱藏超出部分的內容 */

text-overflow:ellipsis;/* 當對象內文本溢出時顯示省略標記(...) ；需與overflow:hidden;一起使用。*/

}

template 是該表單所在的table class屬性。

posted @ 2016-03-09 11:36 鴻雁閱讀(221) | 評論 (0) | 編輯收藏

js 金額用逗號隔開數字格式化

代碼如下：

引用

function fmoney(s, n)
{
   n = n > 0 && n <= 20 ? n : 2;
   s = parseFloat((s + "").replace(/[^\d\.-]/g, "")).toFixed(n) + "";
   var l = s.split(".")[0].split("").reverse(),
   r = s.split(".")[1];
   t = "";
   for(i = 0; i < l.length; i ++ )
   {
      t += l[i] + ((i + 1) % 3 == 0 && (i + 1) != l.length ? "," : "");
   }
   return t.split("").reverse().join("") + "." + r;
}

調用：fmoney("12345.675910", 3)，返回12,345.676

還原函數：

引用

function rmoney(s)
{
   return parseFloat(s.replace(/[^\d\.-]/g, ""));
}

示例（可保存一下代碼為html文件，運行查看效果）：

引用

<SCRIPT>
function fmoney(s, n)
{
   n = n > 0 && n <= 20 ? n : 2;
   s = parseFloat((s + "").replace(/[^\d\.-]/g, "")).toFixed(n) + "";
   var l = s.split(".")[0].split("").reverse(),
   r = s.split(".")[1];
   t = "";
   for(i = 0; i < l.length; i ++ )
   {
      t += l[i] + ((i + 1) % 3 == 0 && (i + 1) != l.length ? "," : "");
   }
   return t.split("").reverse().join("") + "." + r;
}
function rmoney(s)
{
   return parseFloat(s.replace(/[^\d\.-]/g, ""));
}
function g(id)
{
   return document.getElementById(id);
}
window.onload = function()
{
   var num,
   txt = g("txt"),
   txt2 = g("txt2"),
   btn = g("btn"),
   btn2 = g("btn2"),
   span = g("span");
   btn.onclick = function()
   {
      num = parseInt(g("num").value);
      txt.value = fmoney(txt.value, num);
      txt2.value = fmoney(txt2.value, num);
   }
   ;
   btn2.onclick = function()
   {
      num = parseInt(g("num").value);
      span.innerHTML = "=" + fmoney(rmoney(txt.value) + rmoney(txt2.value), num);
   }
   ;
}
;
</SCRIPT>
小數點位數：
<select id="num">
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option value="5">5</option>
</select>
<input type="text" id="txt" value="12345.675910"> +
<input type="text" id="txt2" value="1223"> <span id="span"></span>
<br>
<input type="button" id="btn" value="格式化">
<input type="button" id="btn2" value="相加">

posted @ 2015-09-27 10:23 鴻雁閱讀(238) | 評論 (0) | 編輯收藏

BigDecimal用法詳解

一、簡介
Java在java.math包中提供的API類BigDecimal，用來對超過16位有效位的數進行精確的運算。雙精度浮點型變量double可以處理16位有效數。在實際應用中，需要對更大或者更小的數進行運算和處理。float和double只能用來做科學計算或者是工程計算，在商業計算中要用java.math.BigDecimal。BigDecimal所創建的是對象，我們不能使用傳統的+、-、*、/等算術運算符直接對其對象進行數學運算，而必須調用其相對應的方法。方法中的參數也必須是BigDecimal的對象。構造器是類的特殊方法，專門用來創建對象，特別是帶有參數的對象。

二、構造器描述
BigDecimal(int) 創建一個具有參數所指定整數值的對象。
BigDecimal(double) 創建一個具有參數所指定雙精度值的對象。
BigDecimal(long) 創建一個具有參數所指定長整數值的對象。
BigDecimal(String) 創建一個具有參數所指定以字符串表示的數值的對象。

三、方法描述
add(BigDecimal) BigDecimal對象中的值相加，然后返回這個對象。
subtract(BigDecimal) BigDecimal對象中的值相減，然后返回這個對象。
multiply(BigDecimal) BigDecimal對象中的值相乘，然后返回這個對象。
divide(BigDecimal) BigDecimal對象中的值相除，然后返回這個對象。
toString() 將BigDecimal對象的數值轉換成字符串。
doubleValue() 將BigDecimal對象中的值以雙精度數返回。
floatValue() 將BigDecimal對象中的值以單精度數返回。
longValue() 將BigDecimal對象中的值以長整數返回。
intValue() 將BigDecimal對象中的值以整數返回。

四、格式化及例子
由于NumberFormat類的format()方法可以使用BigDecimal對象作為其參數，可以利用BigDecimal對超出16位有效數字的貨幣值，百分值，以及一般數值進行格式化控制。

以利用BigDecimal對貨幣和百分比格式化為例。首先，創建BigDecimal對象，進行BigDecimal的算術運算后，分別建立對貨幣和百分比格式化的引用，最后利用BigDecimal對象作為format()方法的參數，輸出其格式化的貨幣值和百分比。

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

運行結果如下：

貸款金額:    ￥15,000.48 
利率:    0.8% 
利息:    ￥120.00

五、BigDecimal比較
BigDecimal是通過使用compareTo(BigDecimal)來比較的，具體比較情況如下：

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

打印結果是：-1、0、1，即左邊比右邊數大，返回1，相等返回0，比右邊小返回-1。
注意不能使用equals方法來比較大小。

使用BigDecimal的壞處是性能比double和float差，在處理龐大，復雜的運算時尤為明顯，因根據實際需求決定使用哪種類型。

posted @ 2015-08-22 12:56 鴻雁閱讀(389) | 評論 (0) | 編輯收藏

oracle列轉行

如果你只是尋求多行轉換成一列，比如把同一個id的某個字段col變成一行數據庫，把多個col用逗號鏈接起來。下面幾個SQL可以立竿見影。

《1》最簡短的方式，使用WMSYS.WM_CONCAT：

SELECT id, REPLACE(wmsys.wm_concat(col), ',', '/') str
FROM Table1
GROUP BY id;

《2》使用sys_connect_by_path：

SELECT t.id id, MAX(substr(sys_connect_by_path(t.col, ','), 2)) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM Table1) t
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id
GROUP BY t.id;

或者

SELECT t.id id, substr(sys_connect_by_path(t.col, ','), 2) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM Table1) t
WHERE connect_by_isleaf = 1
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id;

《3》使用MODEL：

SELECT id, substr(str, 2) str FROM Table1
MODEL
RETURN UPDATED ROWS
PARTITION BY(ID)
DIMENSION BY(row_number() over(PARTITION BY ID ORDER BY col) AS rn)
MEASURES (CAST(col AS VARCHAR2(20)) AS str)
RULES UPSERT
ITERATE(3) UNTIL( presentv(str[iteration_number+2],1,0)=0)
(str[0] = str[0] || ',' || str[iteration_number+1])
ORDER BY 1;

下面是原文：

1.
概述
最近論壇很多人提的問題都與行列轉換有關系，所以我對行列轉換的相關知識做了一個總結，希望對大家有所幫助，同時有何錯疏，懇請大家指出，我也是在寫作過程中學習，算是一起和大家學習吧！
行列轉換包括以下六種情況：
1)
列轉行
2)
行轉列
3)
多列轉換成字符串
4)
多行轉換成字符串
5)
字符串轉換成多列
6)
字符串轉換成多行
下面分別進行舉例介紹。
首先聲明一點，有些例子需要如下10g及以后才有的知識：
A.
掌握model子句
B.
正則表達式
C.
加強的層次查詢
討論的適用范圍只包括8i,9i,10g及以后版本。
2.
列轉行
CREATE TABLE t_col_row(
ID INT,
c1 VARCHAR2(10),
c2 VARCHAR2(10),
c3 VARCHAR2(10));
INSERT INTO t_col_row VALUES (1, 'v11', 'v21', 'v31');
INSERT INTO t_col_row VALUES (2, 'v12', 'v22', NULL);
INSERT INTO t_col_row VALUES (3, 'v13', NULL, 'v33');
INSERT INTO t_col_row VALUES (4, NULL, 'v24', 'v34');
INSERT INTO t_col_row VALUES (5, 'v15', NULL, NULL);
INSERT INTO t_col_row VALUES (6, NULL, NULL, 'v35');
INSERT INTO t_col_row VALUES (7, NULL, NULL, NULL);
COMMIT;
SELECT * FROM t_col_row;
2.1
UNION ALL
適用范圍：8i,9i,10g及以后版本
SELECT id, 'c1' cn, c1 cv
FROM t_col_row
UNION ALL
SELECT id, 'c2' cn, c2 cv
FROM t_col_row
UNION ALL
SELECT id, 'c3' cn, c3 cv FROM t_col_row;
若空行不需要轉換，只需加一個where條件，
WHERE COLUMN IS NOT NULL 即可。
2.2
MODEL
適用范圍：10g及以后
SELECT id, cn, cv FROM t_col_row
MODEL
RETURN UPDATED ROWS
PARTITION BY (ID)
DIMENSION BY (0 AS n)
MEASURES ('xx' AS cn,'yyy' AS cv,c1,c2,c3)
RULES UPSERT ALL
(
cn[1] = 'c1',
cn[2] = 'c2',
cn[3] = 'c3',
cv[1] = c1[0],
cv[2] = c2[0],
cv[3] = c3[0]
)
ORDER BY ID,cn;
2.3
COLLECTION
適用范圍：8i,9i,10g及以后版本
要創建一個對象和一個集合：
CREATE TYPE cv_pair AS OBJECT(cn VARCHAR2(10),cv VARCHAR2(10));
CREATE TYPE cv_varr AS VARRAY(8) OF cv_pair;
SELECT id, t.cn AS cn, t.cv AS cv
FROM t_col_row,
TABLE(cv_varr(cv_pair('c1', t_col_row.c1),
cv_pair('c2', t_col_row.c2),
cv_pair('c3', t_col_row.c3))) t
ORDER BY 1, 2;
3.
行轉列
CREATE TABLE t_row_col AS
SELECT id, 'c1' cn, c1 cv
FROM t_col_row
UNION ALL
SELECT id, 'c2' cn, c2 cv
FROM t_col_row
UNION ALL
SELECT id, 'c3' cn, c3 cv FROM t_col_row;
SELECT * FROM t_row_col ORDER BY 1,2;
3.1
AGGREGATE FUNCTION
適用范圍：8i,9i,10g及以后版本
SELECT id,
MAX(decode(cn, 'c1', cv, NULL)) AS c1,
MAX(decode(cn, 'c2', cv, NULL)) AS c2,
MAX(decode(cn, 'c3', cv, NULL)) AS c3
FROM t_row_col
GROUP BY id
ORDER BY 1;
MAX聚集函數也可以用sum、min、avg等其他聚集函數替代。
被指定的轉置列只能有一列，但固定的列可以有多列，請看下面的例子：
SELECT mgr, deptno, empno, ename FROM emp ORDER BY 1, 2;
SELECT mgr,
deptno,
MAX(decode(empno, '7788', ename, NULL)) "7788",
MAX(decode(empno, '7902', ename, NULL)) "7902",
MAX(decode(empno, '7844', ename, NULL)) "7844",
MAX(decode(empno, '7521', ename, NULL)) "7521",
MAX(decode(empno, '7900', ename, NULL)) "7900",
MAX(decode(empno, '7499', ename, NULL)) "7499",
MAX(decode(empno, '7654', ename, NULL)) "7654"
FROM emp
WHERE mgr IN (7566, 7698)
AND deptno IN (20, 30)
GROUP BY mgr, deptno
ORDER BY 1, 2;
這里轉置列為empno，固定列為mgr，deptno。
還有一種行轉列的方式，就是相同組中的行值變為單個列值，但轉置的行值不變為列名：
ID CN_1 CV_1 CN_2 CV_2 CN_3 CV_3
1 c1 v11 c2 v21 c3 v31
2 c1 v12 c2 v22 c3
3 c1 v13 c2 c3 v33
4 c1 c2 v24 c3 v34
5 c1 v15 c2 c3
6 c1 c2 c3 v35
7 c1 c2 c3
這種情況可以用分析函數實現：
SELECT id,
MAX(decode(rn, 1, cn, NULL)) cn_1,
MAX(decode(rn, 1, cv, NULL)) cv_1,
MAX(decode(rn, 2, cn, NULL)) cn_2,
MAX(decode(rn, 2, cv, NULL)) cv_2,
MAX(decode(rn, 3, cn, NULL)) cn_3,
MAX(decode(rn, 3, cv, NULL)) cv_3
FROM (SELECT id,
cn,
cv,
row_number() over(PARTITION BY id ORDER BY cn, cv) rn
FROM t_row_col)
GROUP BY ID;
3.2
PL/SQL
適用范圍：8i,9i,10g及以后版本
這種對于行值不固定的情況可以使用。
下面是我寫的一個包，包中
p_rows_column_real用于前述的第一種不限定列的轉換；
p_rows_column用于前述的第二種不限定列的轉換。
CREATE OR REPLACE PACKAGE pkg_dynamic_rows_column AS
TYPE refc IS REF CURSOR;
PROCEDURE p_print_sql(p_txt VARCHAR2);
FUNCTION f_split_str(p_str VARCHAR2, p_division VARCHAR2, p_seq INT)
RETURN VARCHAR2;
PROCEDURE p_rows_column(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_cols IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc);
PROCEDURE p_rows_column_real(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_col IN VARCHAR2,
p_pivot_val IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc);
END;
/
CREATE OR REPLACE PACKAGE BODY pkg_dynamic_rows_column AS
PROCEDURE p_print_sql(p_txt VARCHAR2) IS
v_len INT;
BEGIN
v_len := length(p_txt);
FOR i IN 1 .. v_len / 250 + 1 LOOP
dbms_output.put_line(substrb(p_txt, (i - 1) * 250 + 1, 250));
END LOOP;
END;
FUNCTION f_split_str(p_str VARCHAR2, p_division VARCHAR2, p_seq INT)
RETURN VARCHAR2 IS
v_first INT;
v_last INT;
BEGIN
IF p_seq < 1 THEN
RETURN NULL;
END IF;
IF p_seq = 1 THEN
IF instr(p_str, p_division, 1, p_seq) = 0 THEN
RETURN p_str;
ELSE
RETURN substr(p_str, 1, instr(p_str, p_division, 1) - 1);
END IF;
ELSE
v_first := instr(p_str, p_division, 1, p_seq - 1);
v_last := instr(p_str, p_division, 1, p_seq);
IF (v_last = 0) THEN
IF (v_first > 0) THEN
RETURN substr(p_str, v_first + 1);
ELSE
RETURN NULL;
END IF;
ELSE
RETURN substr(p_str, v_first + 1, v_last - v_first - 1);
END IF;
END IF;
END f_split_str;
PROCEDURE p_rows_column(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_cols IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc) IS
v_sql VARCHAR2(4000);
TYPE v_keep_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_keep v_keep_ind_by;
TYPE v_pivot_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_pivot v_pivot_ind_by;
v_keep_cnt INT;
v_pivot_cnt INT;
v_max_cols INT;
v_partition VARCHAR2(4000);
v_partition1 VARCHAR2(4000);
v_partition2 VARCHAR2(4000);
BEGIN
v_keep_cnt := length(p_keep_cols) - length(REPLACE(p_keep_cols, ',')) + 1;
v_pivot_cnt := length(p_pivot_cols) -
length(REPLACE(p_pivot_cols, ',')) + 1;
FOR i IN 1 .. v_keep_cnt LOOP
v_keep(i) := f_split_str(p_keep_cols, ',', i);
END LOOP;
FOR j IN 1 .. v_pivot_cnt LOOP
v_pivot(j) := f_split_str(p_pivot_cols, ',', j);
END LOOP;
v_sql := 'select max(count(*)) from ' || p_table || ' group by ';
FOR i IN 1 .. v_keep.LAST LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
v_sql := rtrim(v_sql, ',');
EXECUTE IMMEDIATE v_sql
INTO v_max_cols;
v_partition := 'select ';
FOR x IN 1 .. v_keep.COUNT LOOP
v_partition1 := v_partition1 || v_keep(x) || ',';
END LOOP;
FOR y IN 1 .. v_pivot.COUNT LOOP
v_partition2 := v_partition2 || v_pivot(y) || ',';
END LOOP;
v_partition1 := rtrim(v_partition1, ',');
v_partition2 := rtrim(v_partition2, ',');
v_partition := v_partition || v_partition1 || ',' || v_partition2 ||
', row_number() over (partition by ' || v_partition1 ||
' order by ' || v_partition2 || ') rn from ' || p_table;
v_partition := rtrim(v_partition, ',');
v_sql := 'select ';
FOR i IN 1 .. v_keep.COUNT LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
FOR i IN 1 .. v_max_cols LOOP
FOR j IN 1 .. v_pivot.COUNT LOOP
v_sql := v_sql || ' max(decode(rn,' || i || ',' || v_pivot(j) ||
',null))' || v_pivot(j) || '_' || i || ',';
END LOOP;
END LOOP;
IF p_where IS NOT NULL THEN
v_sql := rtrim(v_sql, ',') || ' from (' || v_partition || ' ' ||
p_where || ') group by ';
ELSE
v_sql := rtrim(v_sql, ',') || ' from (' || v_partition ||
') group by ';
END IF;
FOR i IN 1 .. v_keep.COUNT LOOP
v_sql := v_sql || v_keep(i) || ',';
END LOOP;
v_sql := rtrim(v_sql, ',');
p_print_sql(v_sql);
OPEN p_refc FOR v_sql;
EXCEPTION
WHEN OTHERS THEN
OPEN p_refc FOR
SELECT 'x' FROM dual WHERE 0 = 1;
END;
PROCEDURE p_rows_column_real(p_table IN VARCHAR2,
p_keep_cols IN VARCHAR2,
p_pivot_col IN VARCHAR2,
p_pivot_val IN VARCHAR2,
p_where IN VARCHAR2 DEFAULT NULL,
p_refc IN OUT refc) IS
v_sql VARCHAR2(4000);
TYPE v_keep_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_keep v_keep_ind_by;
TYPE v_pivot_ind_by IS TABLE OF VARCHAR2(4000) INDEX BY BINARY_INTEGER;
v_pivot v_pivot_ind_by;
v_keep_cnt INT;
v_group_by VARCHAR2(2000);
BEGIN
v_keep_cnt := length(p_keep_cols) - length(REPLACE(p_keep_cols, ',')) + 1;
FOR i IN 1 .. v_keep_cnt LOOP
v_keep(i) := f_split_str(p_keep_cols, ',', i);
END LOOP;
v_sql := 'select ' || 'cast(' || p_pivot_col ||
' as varchar2(200)) as ' || p_pivot_col || ' from ' || p_table ||
' group by ' || p_pivot_col;
EXECUTE IMMEDIATE v_sql BULK COLLECT
INTO v_pivot;
FOR i IN 1 .. v_keep.COUNT LOOP
v_group_by := v_group_by || v_keep(i) || ',';
END LOOP;
v_group_by := rtrim(v_group_by, ',');
v_sql := 'select ' || v_group_by || ',';
FOR x IN 1 .. v_pivot.COUNT LOOP
v_sql := v_sql || ' max(decode(' || p_pivot_col || ',' || chr(39) ||
v_pivot(x) || chr(39) || ',' || p_pivot_val ||
',null)) as "' || v_pivot(x) || '",';
END LOOP;
v_sql := rtrim(v_sql, ',');
IF p_where IS NOT NULL THEN
v_sql := v_sql || ' from ' || p_table || p_where || ' group by ' ||
v_group_by;
ELSE
v_sql := v_sql || ' from ' || p_table || ' group by ' || v_group_by;
END IF;
p_print_sql(v_sql);
OPEN p_refc FOR v_sql;
EXCEPTION
WHEN OTHERS THEN
OPEN p_refc FOR
SELECT 'x' FROM dual WHERE 0 = 1;
END;
END;
/
4.
多列轉換成字符串
CREATE TABLE t_col_str AS
SELECT * FROM t_col_row;
這個比較簡單，用||或concat函數可以實現：
SELECT concat('a','b') FROM dual;
4.1
|| OR CONCAT
適用范圍：8i,9i,10g及以后版本
SELECT * FROM t_col_str;
SELECT ID,c1||','||c2||','||c3 AS c123
FROM t_col_str;
5.
多行轉換成字符串
CREATE TABLE t_row_str(
ID INT,
col VARCHAR2(10));
INSERT INTO t_row_str VALUES(1,'a');
INSERT INTO t_row_str VALUES(1,'b');
INSERT INTO t_row_str VALUES(1,'c');
INSERT INTO t_row_str VALUES(2,'a');
INSERT INTO t_row_str VALUES(2,'d');
INSERT INTO t_row_str VALUES(2,'e');
INSERT INTO t_row_str VALUES(3,'c');
COMMIT;
SELECT * FROM t_row_str;
5.1
MAX + DECODE
適用范圍：8i,9i,10g及以后版本
SELECT id,
MAX(decode(rn, 1, col, NULL)) ||
MAX(decode(rn, 2, ',' || col, NULL)) ||
MAX(decode(rn, 3, ',' || col, NULL)) str
FROM (SELECT id,
col,
row_number() over(PARTITION BY id ORDER BY col) AS rn
FROM t_row_str) t
GROUP BY id
ORDER BY 1;
5.2
ROW_NUMBER + LEAD
適用范圍：8i,9i,10g及以后版本
SELECT id, str
FROM (SELECT id,
row_number() over(PARTITION BY id ORDER BY col) AS rn,
col || lead(',' || col, 1) over(PARTITION BY id ORDER BY col) ||
lead(',' || col, 2) over(PARTITION BY id ORDER BY col) ||
lead(',' || col, 3) over(PARTITION BY id ORDER BY col) AS str
FROM t_row_str)
WHERE rn = 1
ORDER BY 1;
5.3
MODEL
適用范圍：10g及以后版本
SELECT id, substr(str, 2) str FROM t_row_str
MODEL
RETURN UPDATED ROWS
PARTITION BY(ID)
DIMENSION BY(row_number() over(PARTITION BY ID ORDER BY col) AS rn)
MEASURES (CAST(col AS VARCHAR2(20)) AS str)
RULES UPSERT
ITERATE(3) UNTIL( presentv(str[iteration_number+2],1,0)=0)
(str[0] = str[0] || ',' || str[iteration_number+1])
ORDER BY 1;
5.4
SYS_CONNECT_BY_PATH
適用范圍：8i,9i,10g及以后版本
SELECT t.id id, MAX(substr(sys_connect_by_path(t.col, ','), 2)) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM t_row_str) t
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id
GROUP BY t.id;
適用范圍：10g及以后版本
SELECT t.id id, substr(sys_connect_by_path(t.col, ','), 2) str
FROM (SELECT id, col, row_number() over(PARTITION BY id ORDER BY col) rn
FROM t_row_str) t
WHERE connect_by_isleaf = 1
START WITH rn = 1
CONNECT BY rn = PRIOR rn + 1
AND id = PRIOR id;
5.5
WMSYS.WM_CONCAT
適用范圍：10g及以后版本
這個函數預定義按','分隔字符串，若要用其他符號分隔可以用，replace將','替換。
SELECT id, REPLACE(wmsys.wm_concat(col), ',', '/') str
FROM t_row_str
GROUP BY id;
6.
字符串轉換成多列
其實際上就是一個字符串拆分的問題。
CREATE TABLE t_str_col AS
SELECT ID,c1||','||c2||','||c3 AS c123
FROM t_col_str;
SELECT * FROM t_str_col;
6.1
SUBSTR + INSTR
適用范圍：8i,9i,10g及以后版本
SELECT id,
c123,
substr(c123, 1, instr(c123 || ',', ',', 1, 1) - 1) c1,
substr(c123,
instr(c123 || ',', ',', 1, 1) + 1,
instr(c123 || ',', ',', 1, 2) - instr(c123 || ',', ',', 1, 1) - 1) c2,
substr(c123,
instr(c123 || ',', ',', 1, 2) + 1,
instr(c123 || ',', ',', 1, 3) - instr(c123 || ',', ',', 1, 2) - 1) c3
FROM t_str_col
ORDER BY 1;
6.2
REGEXP_SUBSTR
適用范圍：10g及以后版本
SELECT id,
c123,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 1), ',') AS c1,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 2), ',') AS c2,
rtrim(regexp_substr(c123 || ',', '.*?' || ',', 1, 3), ',') AS c3
FROM t_str_col
ORDER BY 1;
7.
字符串轉換成多行
CREATE TABLE t_str_row AS
SELECT id,
MAX(decode(rn, 1, col, NULL)) ||
MAX(decode(rn, 2, ',' || col, NULL)) ||
MAX(decode(rn, 3, ',' || col, NULL)) str
FROM (SELECT id,
col,
row_number() over(PARTITION BY id ORDER BY col) AS rn
FROM t_row_str) t
GROUP BY id
ORDER BY 1;
SELECT * FROM t_str_row;
7.1
UNION ALL
適用范圍：8i,9i,10g及以后版本
SELECT id, 1 AS p, substr(str, 1, instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
UNION ALL
SELECT id,
2 AS p,
substr(str,
instr(str || ',', ',', 1, 1) + 1,
instr(str || ',', ',', 1, 2) - instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
UNION ALL
SELECT id,
3 AS p,
substr(str,
instr(str || ',', ',', 1, 1) + 1,
instr(str || ',', ',', 1, 2) - instr(str || ',', ',', 1, 1) - 1) AS cv
FROM t_str_row
ORDER BY 1, 2;
適用范圍：10g及以后版本
SELECT id, 1 AS p, rtrim(regexp_substr(str||',', '.*?' || ',', 1, 1), ',') AS cv
FROM t_str_row
UNION ALL
SELECT id, 2 AS p, rtrim(regexp_substr(str||',', '.*?' || ',', 1, 2), ',') AS cv
FROM t_str_row
UNION ALL
SELECT id, 3 AS p, rtrim(regexp_substr(str||',', '.*?' || ',',1,3), ',') AS cv
FROM t_str_row
ORDER BY 1, 2;
7.2
VARRAY
適用范圍：8i,9i,10g及以后版本
要創建一個可變數組：
CREATE OR REPLACE TYPE ins_seq_type IS VARRAY(8) OF NUMBER;
SELECT * FROM TABLE(ins_seq_type(1, 2, 3, 4, 5));
SELECT t.id,
c.column_value AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.column_value) + 1,
instr(t.ca, ',', 1, c.column_value + 1) -
(instr(t.ca, ',', 1, c.column_value) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t
INNER JOIN TABLE(ins_seq_type(1, 2, 3)) c ON c.column_value <=
t.cnt
ORDER BY 1, 2;
7.3
SEQUENCE SERIES
這類方法主要是要產生一個連續的整數列，產生連續整數列的方法有很多，主要有：
CONNECT BY,ROWNUM+all_objects,CUBE等。
適用范圍：8i,9i,10g及以后版本
SELECT t.id,
c.lv AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.lv) + 1,
instr(t.ca, ',', 1, c.lv + 1) -
(instr(t.ca, ',', 1, c.lv) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT LEVEL lv FROM dual CONNECT BY LEVEL <= 5) c
WHERE c.lv <= t.cnt
ORDER BY 1, 2;
SELECT t.id,
c.rn AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.rn) + 1,
instr(t.ca, ',', 1, c.rn + 1) -
(instr(t.ca, ',', 1, c.rn) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT rownum rn FROM all_objects WHERE rownum <= 5) c
WHERE c.rn <= t.cnt
ORDER BY 1, 2;
SELECT t.id,
c.cb AS p,
substr(t.ca,
instr(t.ca, ',', 1, c.cb) + 1,
instr(t.ca, ',', 1, c.cb + 1) -
(instr(t.ca, ',', 1, c.cb) + 1)) AS cv
FROM (SELECT id,
',' || str || ',' AS ca,
length(str || ',') - nvl(length(REPLACE(str, ',')), 0) AS cnt
FROM t_str_row) t,
(SELECT rownum cb FROM (SELECT 1 FROM dual GROUP BY CUBE(1, 2))) c
WHERE c.cb <= t.cnt
ORDER BY 1, 2;
適用范圍：10g及以后版本
SELECT t.id,
c.lv AS p,
rtrim(regexp_substr(t.str || ',', '.*?' || ',', 1, c.lv), ',') AS cv
FROM (SELECT id,
str,
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL)) AS cnt
FROM t_str_row) t
INNER JOIN (SELECT LEVEL lv FROM dual CONNECT BY LEVEL <= 5) c ON c.lv <= t.cnt
ORDER BY 1, 2;
7.4
HIERARCHICAL + DBMS_RANDOM
適用范圍：10g及以后版本
SELECT id,
LEVEL AS p,
rtrim(regexp_substr(str || ',', '.*?' || ',', 1, LEVEL), ',') AS cv
FROM t_str_row
CONNECT BY id = PRIOR id
AND PRIOR dbms_random.VALUE IS NOT NULL
AND LEVEL <=
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL))
ORDER BY 1, 2;
7.5
HIERARCHICAL + CONNECT_BY_ROOT
適用范圍：10g及以后版本
SELECT id,
LEVEL AS p,
rtrim(regexp_substr(str || ',', '.*?' || ',', 1, LEVEL), ',') AS cv
FROM t_str_row
CONNECT BY id = connect_by_root id
AND LEVEL <=
length(regexp_replace(str || ',', '[^' || ',' || ']', NULL))
ORDER BY 1, 2;
7.6
MODEL
適用范圍：10g及以后版本
SELECT id, p, cv FROM t_str_row
MODEL
RETURN UPDATED ROWS
PARTITION BY(ID)
DIMENSION BY( 0 AS p)
MEASURES( str||',' AS cv)
RULES UPSERT
(cv
[ FOR p
FROM 1 TO length(regexp_replace(cv[0],'[^'||','||']',null))

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

posted @ 2015-07-27 23:52 鴻雁閱讀(259) | 評論 (0) | 編輯收藏

Https通訊原理

Https是什么? Https是基于安全目的的Http通道，其安全基礎由SSL層來保證。最初由netscape公司研發，主要提供了通訊雙方的身份認證和加密通信方法。現在廣泛應用于互聯網上安全敏感通訊。 Https與Http主要區別協議基礎不同：Https在Http下加入了SSL層，通訊方式不同：Https在數據通信之前需要客戶端、服務器進行握手(身份認證)，建立連接后，傳輸數據經過加密，通信端口443。 Http傳輸數據不加密，明文，通信端口80。 SSL協議基礎 SSL協議位于TCP/IP協議與各種應用層協議之間，本身又分為兩層： SSL記錄協議(SSL Record Protocol)：建立在可靠傳輸層協議(TCP)之上，為上層協議提供數據封裝、壓縮、加密等基本功能。 SSL握手協議(SSL Handshake Procotol)：在SSL記錄協議之上，用于實際數據傳輸前，通訊雙方進行身份認證、協商加密算法、交換加密密鑰等。 SSL協議通信過程 (1) 瀏覽器發送一個連接請求給服務器;服務器將自己的證書(包含服務器公鑰S_PuKey)、對稱加密算法種類及其他相關信息返回客戶端; (2) 客戶端瀏覽器檢查服務器傳送到CA證書是否由自己信賴的CA中心簽發。若是，執行4步;否則，給客戶一個警告信息：詢問是否繼續訪問。 (3) 客戶端瀏覽器比較證書里的信息，如證書有效期、服務器域名和公鑰S_PK，與服務器傳回的信息是否一致，如果一致，則瀏覽器完成對服務器的身份認證。 (4) 服務器要求客戶端發送客戶端證書(包含客戶端公鑰C_PuKey)、支持的對稱加密方案及其他相關信息。收到后，服務器進行相同的身份認證，若沒有通過驗證，則拒絕連接; (5) 服務器根據客戶端瀏覽器發送到密碼種類，選擇一種加密程度最高的方案，用客戶端公鑰C_PuKey加密后通知到瀏覽器; (6) 客戶端通過私鑰C_PrKey解密后，得知服務器選擇的加密方案，并選擇一個通話密鑰key，接著用服務器公鑰S_PuKey加密后發送給服務器; (7) 服務器接收到的瀏覽器傳送到消息，用私鑰S_PrKey解密，獲得通話密鑰key。 (8) 接下來的數據傳輸都使用該對稱密鑰key進行加密。上面所述的是雙向認證 SSL 協議的具體通訊過程，服務器和用戶雙方必須都有證書。由此可見，SSL協議是通過非對稱密鑰機制保證雙方身份認證，并完成建立連接，在實際數據通信時通過對稱密鑰機制保障數據安全性

posted @ 2014-06-13 16:16 鴻雁閱讀(227) | 評論 (0) | 編輯收藏

8種Nosql數據庫系統對比

1. CouchDB
•所用語言： Erlang
•特點：DB一致性，易于使用
•使用許可： Apache
•協議： HTTP/REST
•雙向數據復制，
•持續進行或臨時處理，
•處理時帶沖突檢查，
•因此，采用的是master-master復制（見編注2）
•MVCC – 寫操作不阻塞讀操作
•可保存文件之前的版本
•Crash-only（可靠的）設計
•需要不時地進行數據壓縮
•視圖：嵌入式映射/減少
•格式化視圖：列表顯示
•支持進行服務器端文檔驗證
•支持認證
•根據變化實時更新
•支持附件處理
•因此， CouchApps（獨立的 js應用程序）
•需要 jQuery程序庫
最佳應用場景：適用于數據變化較少，執行預定義查詢，進行數據統計的應用程序。適用于需要提供數據版本支持的應用程序。例如： CRM、CMS系統。
master-master復制對于多站點部署是非常有用的。（編注2：master-master復制：是一種數據庫同步方法，允許數據在一組計算機之間共享數據，
并且可以通過小組中任意成員在組內進行數據更新。）

2. Redis
•所用語言：C/C++
•特點：運行異常快
•使用許可： BSD
•協議：類 Telnet
•有硬盤存儲支持的內存數據庫，
•但自2.0版本以后可以將數據交換到硬盤（注意， 2.4以后版本不支持該特性！）
•Master-slave復制（見編注3）
•雖然采用簡單數據或以鍵值索引的哈希表，但也支持復雜操作，例如 ZREVRANGEBYSCORE。
•INCR & co （適合計算極限值或統計數據）
•支持 sets（同時也支持 union/diff/inter）
•支持列表（同時也支持隊列；阻塞式 pop操作）
•支持哈希表（帶有多個域的對象）
•支持排序 sets（高得分表，適用于范圍查詢）
•Redis支持事務 •支持將數據設置成過期數據（類似快速緩沖區設計）
•Pub/Sub允許用戶實現消息機制
最佳應用場景：適用于數據變化快且數據庫大小可遇見（適合內存容量）的應用程序。例如：股票價格、數據分析、實時數據搜集、實時通訊。
（編注3：Master-slave復制：如果同一時刻只有一臺服務器處理所有的復制請求，這被稱為 Master-slave復制，通常應用在需要提供高可用性的服務器集群。）

3. MongoDB
•所用語言：C++
•特點：保留了SQL一些友好的特性（查詢，索引）。
•使用許可： AGPL（發起者： Apache）
•協議： Custom, binary（ BSON）
•Master/slave復制（支持自動錯誤恢復，使用 sets 復制）
•內建分片機制
•支持 javascript表達式查詢
•可在服務器端執行任意的 javascript函數
•update-in-place支持比CouchDB更好
•在數據存儲時采用內存到文件映射
•對性能的關注超過對功能的要求
•建議最好打開日志功能（參數 –journal）
•在32位操作系統上，數據庫大小限制在約2.5Gb
•空數據庫大約占 192Mb
•采用 GridFS存儲大數據或元數據（不是真正的文件系統）
最佳應用場景：適用于需要動態查詢支持；需要使用索引而不是 map/reduce功能；需要對大數據庫有性能要求；需要使用 CouchDB但因為數據改變太頻繁而占滿內存的應用程序。例如：你本打算采用 MySQL或 PostgreSQL，但因為它們本身自帶的預定義欄讓你望而卻步。

4. Riak
•所用語言：Erlang和C，以及一些Javascript
•特點：具備容錯能力
•使用許可： Apache
•協議： HTTP/REST或者 custom binary
•可調節的分發及復制(N, R, W)
•用 JavaScript or Erlang在操作前或操作后進行驗證和安全支持。
•使用JavaScript或Erlang進行 Map/reduce
•連接及連接遍歷：可作為圖形數據庫使用
•索引：輸入元數據進行搜索（1.0版本即將支持）
•大數據對象支持（ Luwak）
•提供“開源”和“企業”兩個版本
•全文本搜索，索引，通過 Riak搜索服務器查詢（ beta版）
•支持Masterless多站點復制及商業許可的 SNMP監控
最佳應用場景：適用于想使用類似 Cassandra（類似Dynamo）數據庫但無法處理 bloat及復雜性的情況。適用于你打算做多站點復制，但又需要對單個站點的擴展性，可用性及出錯處理有要求的情況。例如：銷售數據搜集，工廠控制系統；對宕機時間有嚴格要求；可以作為易于更新的 web服務器使用。

5. Membase
•所用語言： Erlang和C
•特點：兼容 Memcache，但同時兼具持久化和支持集群
•使用許可： Apache 2.0
•協議：分布式緩存及擴展
•非常快速（200k+/秒），通過鍵值索引數據
•可持久化存儲到硬盤
•所有節點都是唯一的（ master-master復制）
•在內存中同樣支持類似分布式緩存的緩存單元
•寫數據時通過去除重復數據來減少 IO
•提供非常好的集群管理 web界面
•更新軟件時軟無需停止數據庫服務
•支持連接池和多路復用的連接代理
最佳應用場景：適用于需要低延遲數據訪問，高并發支持以及高可用性的應用程序例如：低延遲數據訪問比如以廣告為目標的應用，高并發的 web 應用比如網絡游戲（例如 Zynga）

6. Neo4j
•所用語言： Java
•特點：基于關系的圖形數據庫
•使用許可： GPL，其中一些特性使用 AGPL/商業許可
•協議： HTTP/REST（或嵌入在 Java中）
•可獨立使用或嵌入到 Java應用程序
•圖形的節點和邊都可以帶有元數據
•很好的自帶web管理功能
•使用多種算法支持路徑搜索
•使用鍵值和關系進行索引
•為讀操作進行優化
•支持事務（用 Java api）
•使用 Gremlin圖形遍歷語言
•支持 Groovy腳本
•支持在線備份，高級監控及高可靠性支持使用 AGPL/商業許可最佳應用場景：適用于圖形一類數據。這是 Neo4j與其他nosql數據庫的最顯著區別例如：社會關系，公共交通網絡，地圖及網絡拓譜

7. Cassandra
•所用語言： Java
•特點：對大型表格和 Dynamo支持得最好
•使用許可： Apache
•協議： Custom, binary (節約型)
•可調節的分發及復制(N, R, W)
•支持以某個范圍的鍵值通過列查詢
•類似大表格的功能：列，某個特性的列集合
•寫操作比讀操作更快
•基于 Apache分布式平臺盡可能地 Map/reduce
•我承認對 Cassandra有偏見，一部分是因為它本身的臃腫和復雜性，也因為 Java的問題（配置，出現異常，等等）
最佳應用場景：當使用寫操作多過讀操作（記錄日志）如果每個系統組建都必須用 Java編寫（沒有人因為選用 Apache的軟件被解雇）例如：銀行業，金融業（雖然對于金融交易不是必須的，但這些產業對數據庫的要求會比它們更大）寫比讀更快，所以一個自然的特性就是實時數據分析

8. HBase （配合 ghshephard使用）
•所用語言： Java
•特點：支持數十億行X上百萬列
•使用許可： Apache
•協議：HTTP/REST （支持 Thrift，見編注4）
•在 BigTable之后建模
•采用分布式架構 Map/reduce
•對實時查詢進行優化
•高性能 Thrift網關
•通過在server端掃描及過濾實現對查詢操作預判
•支持 XML, Protobuf, 和binary的HTTP
•Cascading, hive, and pig source and sink modules
•基于 Jruby（ JIRB）的shell
•對配置改變和較小的升級都會重新回滾
•不會出現單點故障
•堪比MySQL的隨機訪問性能最佳應用場景：適用于偏好BigTable:)并且需要對大數據進行隨機、實時訪問的場合。例如： Facebook消息數據庫（更多通用的用例即將出現）

posted @ 2014-05-23 11:19 鴻雁閱讀(323) | 評論 (0) | 編輯收藏

Oracle 10g內存結構之共享池的相關知識及使用簡介

SGA中的第三個組成部分是共享池。共享池是對sql ,pl/sql 程序進行語法分析、編譯、執行的內存區域。共享池包括庫緩沖區（library cache）、數據字典緩沖區（Data Directory Cache）用戶全局區（User Global Area）。其中庫緩沖區含有Sql 語句的分析碼、執行計劃；數據字典緩沖區含有從數據字典中得到的表、列定義、權限。用戶全局區包含用戶的MTS 會話信息。

共享池主要用于對SQL 、pl/sql 程序語句進行語法分析、編譯、執行、所以，如果應用中藥運行大量存儲過程或包，則要增加共享池的尺寸。共享池的大小由參數SHARE_POOL_SIZE確定。要了解共享池大小，可以用以下方法：

方法一：

………  
Shared_Pool_size = 52428800 
…..

方法二：

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

方法三：

SQL> show parameter share_pool_size

共享池應計算存儲過程、包等的成功率。

可以查詢數據字典 v$rowcache 了解數據字典的成功與失敗次數。

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

其中gets 表示讀取某一類數據字典的成功次數，getsmisses 表示讀取某一類數據字典的失敗次數。此外還可以通過查詢結果計算共享池中讀取數據字典的成功率

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

查詢數據字典 v$librarycache 可以計算共享池中庫緩存的失敗率，結果應該小于1%。

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

其中 total pins 表示駐留內存的次數， total reloads 表示重新加載到內存的次數，librarycache 表示失敗率。

上面分析了系統全局區的三個組成部分-----數據緩沖區、日志緩沖區及共享池，如果要得到SGA的總大小，可以在SQL*Plus中使用show sga 命令。

SQL>show sga或查詢數據字典

SQL> select * from v$sga;

如果要查詢某個參數的大小，可以查詢數據字典v_$sagstat,通過計算可以知道sga的使用空間與空閑空間的比。

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

關于Oracle 10g內存結構之共享池的相關知識及使用方法就介紹到這里了，希望本次的介紹能夠對您有所收獲！

posted @ 2014-05-17 23:37 鴻雁閱讀(168) | 評論 (0) | 編輯收藏

Oracle 10g內存結構之系統全局區簡介

我們知道，內存結構是Oracle體系結構中最重要的部分之一。按照系統對內存使用方法的不同，可以分為系統全局區（SGA）、程序全局區（PGA）、排序區（Sort Area）、大池（Large Pool）、及java池（java Pool），本文我們先介紹一下Oracle 10g內存結構之系統全局區的內容，接下來我們就開始介紹這部分內容。

系統全局區（System Global Area）

它是一組為系統分配的內存共享結構，可以包含一個數據庫實例的數據和控制信息。如果多個用戶連接到一個實例，在實例的系統全局區中，數據可以被多個用戶共享，所以又稱共享全局區。系統全局區按其作用不同，可以分為數據緩沖區、日志緩沖區及共享池。

數據緩沖區：

數據緩沖區用于從磁盤讀入的數據，供所有用戶共享。

修改的數據、插入的數據存儲在數據緩沖區中，修改完成或DBWR進程的其他條件引發時，數據被寫入數據文件

數據緩沖區工作原理：

LRU （Least recently used）：最近最少使用原則的縮寫，是一種數據緩沖區的一種管理機制，，只保留最近數據，不保留舊數據。

Dirty：表示臟數據，臟數據是修改后還沒有寫到數據文件的數據。

Oracle10g 的數據庫內存的設置參數不再由DB_BLOCK_BUFFERS確定，而是由oracle的新參數DB_CACHE_SIZE 和DB_nK_CACHE_SIZE確定，不同的數據段可以使用不同的數據塊。大表可以存儲在大的數據塊表空間中，小表可以存儲在小的數據塊表空間中，以優化i/o性能。對于系統表空間、臨時表空間、及其它默認設置的表空間，可以使用標準的數據塊DB_BLOCK_SIZE確定。

標準數據塊DB_BLOCK_SIZE用于系統表空間及默認表空間，其他表空間可以使用非標準數據塊BLOCKSIZE（創建表空間時使用），其值分別為 2k 4k 8k 16k 32k ，非標準數據塊的數據緩沖區使用參數DB_Nk_CACHE_SIZE確定。

需要注意的是BLOCKSIZE不得用于標準塊。如果設置了DB_BLOCK_SIZE=2048,則不得設置DB_2K_CACHE_SIZE，標準塊必須使用參數DB_CACHE_SIZE 來設置。同時可以在線修改數據緩沖區參數：SQL> alter system set db_2k_cache_size = 10M ;如果要查詢數據緩沖區大小，可以如下：SQL> show parameter db。

在創建不同數據塊表空間時，要使用參數BLOCKSIZE指出數據塊的大小，同時在參數文件中要使用DB_Nk_CACHE_SIZE 進行配置，與BLOCKSIZE的個數相對應，否則會出現錯誤。

設置動態內存時，可以將多個參數全部寫入參數文件，格式如下：

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

其中，參數 DB_CACHE_SIZE 只適用于系統表空間、臨時表空間、及默認表空間，DB_2K_CACHE_SIZE 適合 BLOCKSIZE 為2K的表空間。8K 也是一樣的道理。

數據緩沖區對數據庫德存取速度又直接影響。一般的緩沖區命中率應該在90% 以上。例如，使用數據字典 v$sysstat 計算數據緩沖區命中率：

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

下面是計算數據緩沖命中率的另一種方法：

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

其中：Session logical reads 為讀的總量。Physical reads為從數據文件讀。Physical reads direct 為從緩沖區讀（不含lobs）。Physical reads direct (lobs) 為從緩沖區讀（含lobs）。Hit Ratio = 1- ( ( physical reads- physical reads direct – physical reads direct(lob) ) /session logical reads) = 95%。

日志緩沖區

日志緩沖區用來存儲數據庫的修改信息。日志信息首先在日志緩沖區中產生，當日志緩沖區的日志達到一定數量時，由日志寫入進程LGWR將日志數據寫入日志文件組，再經過切換，由歸檔進程ARCH將日志數據寫入歸檔介質。

日志緩沖區大小由參數LOG_BUFFER確定，要查詢日志緩沖區大小可以用以下方法：

方法一：參數文件中：

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

方法二：

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

方法三：

SQL> show parameter log_buffer

對于日志緩沖區而言可以計算失敗率，使用數據字典v$latch 計算日志緩沖區的失敗率

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

其中

Gets 表示成功等待日志緩沖區的次數。

Immediate gets 表示成功立即得到日志緩沖區的次數。

Immediate misses 表示未成功立即得到日志緩沖區的次數。

等待表示日志在進入日志緩沖區時，因為日志緩沖區過小而沒有空閑空間，所以日志緩沖區的失敗可以表示日志緩沖區是否足夠大，不夠大時，用戶的日志寫將產生等待過程。日志緩沖區的失敗率應該小于1%。

此外，可以查詢用戶進程等待日志緩沖區時的次數，通過數據字典v$sysstat 得到：

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

關于Oracle 10g內存結構之系統全局區的相關知識就介紹到這里了，希望本次的介紹能夠對您有所收獲！

posted @ 2014-05-17 23:31 鴻雁閱讀(200) | 評論 (0) | 編輯收藏

僅列出標題

The important thing in life is to have a great aim , and the determination

導航

留言簿(7)

隨筆分類

隨筆檔案

文章檔案

相冊

閱讀排行榜

評論排行榜

常用鏈接

統計

IT技術鏈接

保險相關

友情鏈接

基金知識

生活相關

最新評論