篇一：SQL - Apply运算符用法
使用 APPLY
APPLY 运算符的左操作数和右操作数都是表表达式。这些操作数之间的主要区别是，right_table_source 可以使用表值函数，从 left_table_source 获取一个列作为函数的参数之一。left_table_source 可以包括表值函数，但不能以来自 right_table_source 的列作为参数。
APPLY 运算符通过以下方式工作，以便为 FROM 子句生成表源：
1. 对 left_table_source 的每行计算 right_table_source 的值来生成
行集。
right_table_source 中的值依赖于 left_table_source。
right_table_source 可以按以下方式近似表示：
TVF(left_table_source.row)，其中，TVF 是表值函数。
2. 通过执行 UNION ALL 操作，将计算 right_table_source 的值时为每
行生成的结果集与 left_table_source 组合起来。
APPLY 运算符的结果生成的列的列表是来自 left_table_source（与来自 right_table_source 的列的列表相组合）的一组列。
SQL Server 2008 联机丛书
使用 APPLY
值函数。表值函数作为右输入，外部表表达式作为左输入。通过对右输入求值来获得左输入每一行的计算结果，生成的行被组合起来作为最终输出。APPLY 运
返回外部表中通过表值函数生成结果集的行。OUTER APPLY 既返回生成结果集的行，也返回不生成结果集的行，其中表值函数生成的列中的值为 NULL。 例如，考虑下列表 Employees 和 Departments：
--Create Employees table and insert values.
CREATE TABLE Employees
(
empidintNOT NULL
,mgridintNULL
,empname varchar(25) NOT NULL
,salary money NOT NULL
CONSTRAINT PK_Employees PRIMARY KEY(empid)
);
GO
INSERT INTO Employees VALUES(1 , NULL, 'Nancy', $10000.00); INSERT INTO Employees VALUES(2 , 1, 'Andrew' , $5000.00); INSERT INTO Employees VALUES(3 , 1, 'Janet', $5000.00); INSERT INTO Employees VALUES(4 , 1, 'Margaret', $5000.00); INSERT INTO Employees VALUES(5 , 2, 'Steven' , $2500.00); INSERT INTO Employees VALUES(6 , 2, 'Michael' , $2500.00); INSERT INTO Employees VALUES(7 , 3, 'Robert' , $2500.00); INSERT INTO Employees VALUES(8 , 3, 'Laura', $2500.00); INSERT INTO Employees VALUES(9 , 3, 'Ann' , $2500.00); INSERT INTO Employees VALUES(10, 4, 'Ina' , $2500.00); INSERT INTO Employees VALUES(11, 7, 'David', $2000.00); INSERT INTO Employees VALUES(12, 7, 'Ron' , $2000.00); INSERT INTO Employees VALUES(13, 7, 'Dan' , $2000.00); INSERT INTO Employees VALUES(14, 11 , 'James', $1500.00); GO
--Create Departments table and insert values.
CREATE TABLE Departments
(
deptid INT NOT NULL PRIMARY KEY
,deptname VARCHAR(25) NOT NULL
,deptmgrid INT NULL REFERENCES Employees
);
GO
INSERT INTO Departments VALUES(1, 'HR', 2);
INSERT INTO Departments VALUES(2, 'Marketing', 7);
INSERT INTO Departments VALUES(3, 'Finance',8);
INSERT INTO Departments VALUES(4, 'R&D', 9);
INSERT INTO Departments VALUES(5, 'Training', 4);
INSERT INTO Departments VALUES(6, 'Gardening', NULL);
Departments 表中的多数部门都具有一个经理 ID，这些 ID 与 Employees 表中的雇员相对应。以下表值函数接受雇员 ID 作为参数，并返回该雇员和他/她的所有下属。
CREATE FUNCTION dbo.fn_getsubtree(@empid AS INT)
RETURNS @TREE TABLE
(
empidINT NOT NULL
,empname VARCHAR(25) NOT NULL
,mgridINT NULL
,lvl INT NOT NULL
)
AS
BEGIN
WITH Employees_Subtree(empid, empname, mgrid, lvl)
AS
(
-- Anchor Member (AM)
SELECT empid, empname, mgrid, 0
FROM Employees
WHERE empid = @empid
UNION all
-- Recursive Member (RM)
SELECT e.empid, e.empname, e.mgrid, es.lvl+1
FROM Employees AS e
JOIN Employees_Subtree AS es
ON e.mgrid = es.empid;
)
INSERT INTO @TREE
SELECT * FROM Employees_Subtree;
RETURN
END
GO
若要返回每个部门经理的各级下属，请使用以下查询。
SELECT D.deptid, D.deptname, D.deptmgrid
,ST.empid, ST.empname, ST.mgrid
FROM Departments AS D
CROSS APPLY fn_getsubtree(D.deptmgrid) AS ST;
下面是结果集：
deptiddeptnamedeptmgridempid empname mgrid lvl ----------- ---------- ----------- ----------- ---------- ----------- ---
1 HR2 2 Andrew 1 0 1 HR2 5 Steven 2 1 1 HR2 6 Michael 2 1 2 Marketing 7 7 Robert 3 0 2 Marketing 7 11 David7 1 2 Marketing 7 12 Ron 7 1 2 Marketing 7 13 Dan 7 1 2 Marketing 7 14 James11 2 3 Finance 8 8 Laura3 0 4 R&D 9 9 Ann 3 0 5 Training4 4 Margaret1 0 5 Training4 10 Ina 4 1 注意，Departments 表中每一行复制的次数与针对部门经理执行
fn_getsubtree 而返回的行数相同。
另外，结果中不显示 Gardening 部门。因为该部门没有经理，所以
fn_getsubtree 将针对该部门返回空集。通过使用 OUTER APPLY，Gardening 部门也将在结果集中显示，其 deptmgrid 字段以及由
fn_getsubtree 返回的字段中的值都为空值。
请参阅
其他资源
FROM (Transact-SQL)
篇二：R总apply函数族详解
语言 apply函数家族详解
apply {base}
通过对数组或者矩阵的一个维度使用函数生成值得列表或者数组、向量。
apply(X, MARGIN, FUN, ...)
X 阵列，包括矩阵
MARGIN 1表示矩阵行，2表示矩阵列，也可以是c(1,2)
例：
>xxx<-matrix(1:20,ncol=4)
>apply(xxx,1,mean)
[1] 8.5 9.5 10.5 11.5 12.5
>apply(xxx,2,mean)
[1] 3 8 13 18
>xxx
[,1] [,2] [,3] [,4]
[1,] 1 61116
[2,] 2 71217
[3,] 3 81318
[4,] 4 91419
[5,] 5101520
lapply {base}
通过对x的每一个元素运用函数，生成一个与元素个数相同的值列表
lapply(X, FUN, ...)
X表示一个向量或者表达式对象，其余对象将被通过as.list强制转换为list
例：
> x <- list(a = 1:10, beta = exp(-3:3), logic = c(TRUE,FALSE,FALSE,TRUE))
> x
$a
[1] 1 2 3 4 5 6 7 8 9 10
$beta
[1] 0.04978707 0.13533528 0.36787944 1.00000000 2.71828183 7.38905610
[7] 20.08553692
$logic
[1] TRUE FALSE FALSE TRUE
> lapply(x,mean)
$a
[1] 5.5
$beta
[1] 4.535125
$logic
[1] 0.5
sapply {base}
这是一个用户友好版本，是lapply函数的包装版。该函数返回值为向量、矩阵，如果simplify=”array”，且合适的情况下，将会通过simplify2array()函数转换为阵列。sapply(x, f, simplify=FALSE, USE.NAMES=FALSE)返回的值与lapply(x,f)是一致的。
sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE) 表示一个向量或者表达式对象，其余对象将被通过as.list强制转换为list
simplify 逻辑值或者字符串，如果可以，结果应该被简化为向量、矩阵或者高维数组。必须是命名的，不能是简写。默认值是TRUE，若合适将会返回一个向量或者矩阵。如果simplify=”array”，结果将返回一个阵列。
USE.NAMES 逻辑值，如果为TRUE，且x没有被命名，则对x进行命名。
例：
> sapply(k, paste,USE.NAMES=FALSE,1:5,sep="...")
[,1] [,2] [,3]
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,USE.NAMES=TRUE,1:5,sep="...")
a b c
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,USE.NAMES=TRUE,1:5,sep="...",simplyfy=TRUE)
a b c
[1,] "a...1...TRUE" "b...1...TRUE" "c...1...TRUE"
[2,] "a...2...TRUE" "b...2...TRUE" "c...2...TRUE"
[3,] "a...3...TRUE" "b...3...TRUE" "c...3...TRUE"
[4,] "a...4...TRUE" "b...4...TRUE" "c...4...TRUE"
[5,] "a...5...TRUE" "b...5...TRUE" "c...5...TRUE"
> sapply(k, paste,simplify=TRUE,USE.NAMES=TRUE,1:5,sep="...")
a b c
[1,] "a...1" "b...1" "c...1"
[2,] "a...2" "b...2" "c...2"
[3,] "a...3" "b...3" "c...3"
[4,] "a...4" "b...4" "c...4"
[5,] "a...5" "b...5" "c...5"
> sapply(k, paste,simplify=FALSE,USE.NAMES=TRUE,1:5,sep="...")
$a
[1] "a...1" "a...2" "a...3" "a...4" "a...5"
$b
[1] "b...1" "b...2" "b...3" "b...4" "b...5"
$c
[1] "c...1" "c...2" "c...3" "c...4" "c...5"
vapply {base}
vapply类似于sapply函数，但是它的返回值有预定义类型，所以它使用起来会更加安全，有的时候会更快
在vapply函数中总是会进行简化，vapply会检测FUN的所有值是否与FUN.VALUE兼容，以使他们具有相同的长度和类型。类型顺序：逻辑<</span>整型<</span>实数<</span>复数 vapply(X, FUN, FUN.VALUE, ..., USE.NAMES = TRUE)
X表示一个向量或者表达式对象，其余对象将被通过as.list强制转换为list
simplify 逻辑值或者字符串，如果可以，结果应该被简化为向量、矩阵或者高维数组。必须是命名的，不能是简写。默认值是TRUE，若合适将会返回一个向量或者矩阵。如果simplify=”array”，结果将返回一个阵列。
USE.NAMES 逻辑值，如果为TRUE，且x没有被命名，则对x进行命名。
FUN.VALUE一个通用型向量，FUN函数返回值得模板
例：
> x<-data.frame(a=rnorm(4,4,4),b=rnorm(4,5,3),c=rnorm(4,5,3))
> vapply(x,mean,c(c=0))
a b c
1.8329043 6.0442858 -0.1437202
> k<-function(x)
+ {
+ list(mean(x),sd(x))
+ }
> vapply(x,k,c(c=0))
错误于vapply(x, k, c(c = 0)) : 值的长度必需为1，
但FUN(X[[1]])结果的长度却是2
> vapply(x,k,c(c=0,b=0))
错误于vapply(x, k, c(c = 0, b = 0)) : 值的种类必需是'double'，
但FUN(X[[1]])结果的种类却是'list'
> vapply(x,k,c(list(c=0,b=0)))
a b c
c 1.832904 6.044286 -0.1437202
b 1.257834 1.940433 3.649194
tapply {base}
对不规则阵列使用向量，即对一组非空值按照一组确定因子进行相应计算
tapply(X, INDEX, FUN, ..., simplify = TRUE)
x 一个原子向量，典型的是一个向量
INDEX 因子列表，和x长度一样，元素将被通过as.factor强制转换为因子
simplify 若为FALSE，tapply将以列表形式返回阵列。若为TRUE，FUN则直接返回数值 例：
> height <- c(174, 165, 180, 171, 160)
> sex<-c("F","F","M","F","M")
> tapply(height, sex, mean)
F M
170170
eapply {base}
eapply函数通过对environment中命名值进行FUN计算后返回一个列表值，用户可以请求所有使用过的命名对象。
eapply(env, FUN, ..., all.names = FALSE, USE.NAMES = TRUE)
env 将被使用的环境
all.names 逻辑值，指示是否对所有值使用该函数
USE.NAMES 逻辑值，指示返回的列表结果是否包含命名
例：
> require(stats)
>
> env <- new.env(hash = FALSE) # so the order is fixed
> env$a <- 1:10
> env$beta <- exp(-3:3)
> env$logic <- c(TRUE, FALSE, FALSE, TRUE)
> # what have we there?
> utils::ls.str(env)
a : int [1:10] 1 2 3 4 5 6 7 8 9 10
beta : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
logic : logi [1:4] TRUE FALSE FALSE TRUE
>
> # compute the mean for each list element
> eapply(env, mean)
$logic
[1] 0.5
$beta
[1] 4.535125
$a
[1] 5.5
> unlist(eapply(env, mean, USE.NAMES = FALSE))
[1] 0.500000 4.535125 5.500000
>
> # median and quartiles for each element (making use of "..." passing): > eapply(env, quantile, probs = 1:3/4)
$logic
25% 50% 75%
0.0 0.5 1.0
$beta
25% 50% 75%
0.2516074 1.0000000 5.0536690
$a
25% 50% 75%
3.25 5.50 7.75
> eapply(env, quantile)
$logic
0% 25% 50% 75% 100%
0.0 0.0 0.5 1.0 1.0
$beta
0%25%50%75% 100%
0.04978707 0.25160736 1.00000000 5.05366896 20.08553692
$a
0%25%50%75% 100%
1.00 3.25 5.50 7.75 10.00
篇三：【刷机】第二讲：刷机基础知识--卡刷
第二讲：刷机基础知识--卡刷（CWM刷） 刷机有两种：线刷和卡刷。所谓的“线刷”就是在手机Download模式（俗称为“挖煤”）下用Odin刷机程序刷机。而“卡刷”就是在手机的Recovery模式下刷机。
卡刷（CWM刷）：用手机里安装的ClockworkMod程序来在Recovery模式下进行刷机。刷机包为单个签名的zip压缩包。在刷机包中有一个脚本，里面有一系列命令，规定好把不同的文件复制的手机的指定分区，从而达到刷机目的。通常认为，卡刷比较安全，只涉及单个刷机文件，适合于新手刷机。
由于CWM的优越，所以也是大部分的第三方rom自带的工程模式。
卡刷在下列情况下使用：
1)手机里已经安装了ClockworkMod程序
2)手机可以进入Recovery模式
3)当然，你的刷机包是zip卡刷包
卡刷可以用于下列刷机情况：
1)刷完整ROM
2)刷ROM的补丁或升级包
3)刷内核或基带
4)刷特殊内容
为叙述方便，以下把上述各种要刷的内容统称为“刷机包”。下面以刷2.3.4 XXJVP汉化版为例来描述刷机过程和步骤。刷机包文件名为“JVP2.3.4_SunnyOK_CN-2.zip”。
1. 把刷机包拷贝到手机SD卡
将手机用USB数据线连接电脑，在“设置”-“USB设置”里选“大容量存储”。连接成功后，将刷机包JVP2.3.4_SunnyOK_CN-2.zip拷贝到SD卡的根目录下。之后，从手机移除USB数据线。
如果手机有内卡（sdcard），直接把刷机包拷贝到内卡。当然，也可以使用SD卡。
2. 手机进入Recovery（恢复）模式
有多种方法进入Recovery模式：
1)关机，按“音量上+下”和“电源开关”，屏幕点亮后松开按键，进入“恢复”模式。
2)用ADB命令：
在计算机上安装ADB工具包（见附件ADB-Tools.rar） 手机开机，到“设置”-“应用程序”-“开发”选“USB调试” 将手机用USB数据线连接电脑
在DOS窗口打入：adb reboot recovery
进入Recovery（恢复）模式
取下USB数据线
3)有些ROM里已经提供进入Recovery的功能。例如Li大的ROM里提供了“重启工具”应用。还有的ROM在主题文件的“关机”菜单里加了Recovery的选项。还有的ROM在“高级设置”里有Recovery操作的选项。
4)其它进Recovery模式方法
====================刷机系统的按键功能==========================
音量键，控制进行上下选择
电源键，为确定
音量下+电源键，重启手机
音量上+电源键，关闭recovery界面的字符串显示
==========================
-reboot system now 重启系统 相关翻译==============================
-apply sdcard:update.zip 使用SD卡根目录的update.zip更新系统
-wipe data/factory reset 清空data分区并恢复出厂设置
-wipe cache partition 清空cache分区
-install zip from sdcard 从SD卡选择文件更新系统
-backup and restore 备份和恢复
-mounts and storage 挂载和存储
-advanced 高级
======================================================================
3. 刷机
1)进入Recovery模式后，你会看到下面界面：
用音量上下键选取“install zip from sdcard”。见红色方框。然后按电源键确认。
2)进入下一个界面：
用音量上下键选取“choose zip from sdcard”。见红色方框。然后按电源键确认。
3)进入下一个界面：
《你会使用apply吗》出自：百味书屋
链接地址：http://www.850500.com/news/92272.html
转载请保留,谢谢!