直播小精灵(收看国内外电视节目,国内付费数字节目)
1.0 简体中文绿色版
直播小精灵(收看国内外电视节目,国内付费数字节目)
软件介绍 Soft content
直播小精灵是一款免费的网络数字电视直播软件，可收看国内外电视节目，国内付费数字节目也可免费观看。支持多线路切换，保障观看更加流畅，部分频道支持回看，不放过精彩瞬间。
直播小精灵(收看国内外电视节目,国内付费数字节目) 下载地址[]
* 推荐下载+解压；软件通过+++扫描，问题软件请
从评论反馈
* 本站已不再更新破解相关，若大意发布了相关破解，告知!保证永不再收录!
4.37MB/多国语言[中文]/3星
6.86MB/简体中文/3星
314KB/简体中文/3星
10.70MB/简体中文/3星找一家情色网站,七色情
柔术五月天,香台性爱黄色片,了。
咪咪情色 bt,日本美女种子动态图,邪少全文阅读。张大叔麻烦您拿些砍
友情链接：PPS影音付费节目支付后仍然不能观看怎么办
PPS影音付费节目支付后仍然不能观看，可能原因：　　1)由于网络原因用户支付过程有一定延迟。　　2)未完成支付过程，直接关闭页面。解决办法：　　1)支付完成后请等待5-10分钟，刷新播放页面。　　2)用户没有完成整个支付过程，中途退出，请重新支付。　　3)拨打客服电话021-(周一至周五9:00-18:00)　　PPS影音(全称PPStream)是全球第一家集P2P直播点播于一身的网络电视软件，能够在线收看电影电视剧、体育直播、游戏竞技、动漫、综艺、新闻、财经资讯等。PPS影音完全免费，无需注册，下载即可使用。　　PPS影音创办于2005年，是全球最大的网络电视服务商。2005年6月，PPS在雷量、张洪禹两人的研发下，正式推出，立刻获得了惊人的肯定，9月徐伟峰加入，正式进入商业运营并着手成立公司，三位联合创始人从此成为互联网影音视频的领导者。PPS在创立的第一天就将自己定位成未来的互联网电视平台，并愿为此目标不懈的努力奋斗。　　PPS获得了2012年TVB所有电视剧集、综艺节目的独家版权。日，艾瑞ivotracker最新报告显示，2012年8月，PPS影音的覆盖人数突破1亿，占行业整体的1/3。日 PPS设爱频道事业部，高清和是2013战略重点。日，宣布3.7亿美元收购PPS视频业务。　　PPS影音一直致力于倾听、挖掘与满足中国网民的需求，秉承&用户体验至上&的理念，除播放器外，还提供影视百科、PPS看看、影视搜索等多样化的产品及服务。&PPS&已经成为了人们进行互联网影视的代名词。
软件分类导航
最热软件词条排行
热门软件专区排行(转)详解iOS应用程序内应用IAP/StoreKit付费、沙盒（SandBox）测试、创建测试账号流程_Hash表的建立及增删节查相关操作_ORCLE-Select 语句执行顺序以及怎么提高Oracle 基本查询效率__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
(转)详解iOS应用程序内应用IAP/StoreKit付费、沙盒（SandBox）测试、创建测试账号流程
Hash表的建立及增删节查相关操作
ORCLE-Select 语句执行顺序以及怎么提高Oracle 基本查询效率
(转)详解iOS应用程序内应用IAP/StoreKit付费、沙盒（SandBox）测试、创建测试账号流程
(转)详解iOS应用程序内使用IAP/StoreKit付费、沙盒（SandBox）测试、创建测试账号流程！
原创， 欢迎转载，转载请在明显处注明！ 谢谢。
原文地址：http://blog.csdn.net/xiaominghimi/article/details/6937097
终于在11月公司的游戏即将上线了，那么对于iOS游戏来说当今都是内置道具收费属于主流，那么我们的游戏也是内置收费，所以Himi这里分享给大家关于内置应用收费以及申请测试账号进行测试购买的经验；
在应用内嵌入付费代码这一快Himi可以直接将代码分享给大家，所以我们来说一些主要流程，毕竟没有接触过这一块的童鞋肯定相当头疼 =。
OK，步入整体，如果你想在iOS里内嵌收费，那么分为以下几步：
【提示：以下创建App部分内容，你不用非要等项目能打包了才开始做，可以随时并且随便的创建个测试项目即可，因为嵌入付费并不要求上传App的ipa包的！！】
第一步：你需要在iTunesConnect中创建个新的App，然后为这个App设置一些产品（付费道具）等；
OK，这里Himi稍微解释下，iTunesConnect是苹果提供的一个平台，主要提供AP发布和管理App的，最重要的功能是创建管理项目信息，项目付费产品（道具）管理、付费的测试账号、提交App等等，这里就简单介绍这么多，关于产品一词在此我们可以理解成游戏道具即可；在苹果看来所有付费都属于产品 =。 =千万不要纠结字眼哦～
OK，打开iTunesConnect网站：/WebObjects/iTunesConnect.woa (注意：企业级的用户必须使用公司主开发者账号登陆才可！)
成功登陆后的页面如下：
这里大概说下重要的一些项：
Contracts, Tax, and Banking
： 管理银行账号、联系人以及税等等；这里要根据提示完成对应的信息填写！一定要详细填写喔～
Manage Users ：管理用户的，比如主账号以及测试付费的（测试App）账号；
Manage Your Applictions：管理应用程序的，你所有发布的应用和每个应用的状态都在这里面；
下面我们新建一个App项目，大家放心，我们这里创建的是不会直接提交给App审核的，所以放心创建，只要控制好App的状态不要是待审核状态即可，不过即使你不小心将项目提交了，也没事，直接更改App状态即可了；
选择Manage Your Applictions选项，然后新建一个项目：【Add New App】，根据提示来填写吧，这里就不细致说明了～
创建好一个App之后，在点击Manage Your Applictions后的界面应该如下：
这里你将看到自己创建的App，点击你创建的App项目，这里Himi创建的项目名字叫”ProjectForBuyTest“，点击你的App进入如下界面：
(注意：这里的Bundle ID一定要跟你的项目中的info.plist中的Bundle ID保证一致！！！！）
这里可以管理你的项目的信息、状态、是否嵌入GameCenter等等选项，那么本章我们重点介绍如何使用IAp沙盒测试程序内付费，所以这里我们点击右上角的”Manage In-App Purchases“选项进入创建产品（游戏道具）界面如下：
上图中的下方看到Himi创建过的四个产品（道具）了，你可以点击”Create New“选项新建一个产品（付费道具），点击新建如下界面：
上图中Himi没有截图出所有的选项，这里大概介绍下，这个界面是选择你的消费道具的种类，种类说明如下：
类型选择有四种选择：
1.Consumable（消耗品）: 每次下载都需要付费；
2.Non-consumable（非消耗品）: 仅需付费一次；
3.Auto-Renewable Subscriptions：自动订阅；
4.Free Subscription：免费订阅
最下方是你沙盒测试的截图，暂且不管即可；
这里Himi选择Consumable选项，比如很多游戏都是购买金币啦这样子就可以选择这个；然后出现如下界面：
Reference Name： 付费产品（道具的）参考名称
Product ID（产品ID）: 你产品的唯一id。通常格式是 com.xx.yy，但它可以是任何形式，不要求以程序的App ID作为前缀。
Add Language: 添加产品名称与描述语言；
Price Tier：选择价格，这里你选择价格后，会出现如上图最下方的价格对照表
Screenshot（截屏）: 展示你产品的截屏。（这个直接无视，测试App务必要管这个的）
Product ID（产品ID）可以创建多个，比如我想游戏中分为0.99$ 、1.99$等道具那就创建对应多个产品ID！
我们填写好了”Reference Name“与”Product ID“以及”Price Tier“后，点击”Add Language“选项然后出现如下界面：
上图中的选项：
Language：语言
Displayed Name（显示名称）: 用户看到的产品名称。
Description（描述）: 对产品进行描述。
Ok，一路 Save保存回到”Manage In-App Purchases“界面中会看到我们新建的产品（道具）如下：
大家可以看到新建的产品（道具）ID：这里Himi创建的产品ID是com.himi.wahaha ，这里要记住这个产品ID哦～
第二步：申请测试账号，利用沙盒测试模拟AppStore购买道具流程！
回到itunesconnect主页中，选择“Manage Users”然后选择“Test User”，然后出现的界面如下图：
这里Himi已经创建了两个测试账号了，点击界面中的 “Add New User”进行创建即可；记住账号和密码哈，记不住就删掉重新建 娃哈哈～（切记：不能用于真正的AppStore中使用此账号，不仅不能用，而且一旦AppStore发现后果你懂得～）
第三步：在项目中申请购买产品代码以及监听；
这里关于购买的代码部分呢，我都有备注的，Himi这里就不详细讲解了，Himi只是在代码后介绍几点值得注意的地方：
这里Himi是新建的一个Cocos2d的项目，然后给出HelloWorldLayer.h以及HelloWorldLayer.m的全部代码，所有购买代码也全在里面也对应有Himi的注释！
HelloWorldLayer.h
view plain
#import "cocos2d.h"
#import &UIKit/UIKit.h&
#import &StoreKit/StoreKit.h&
IAP0p99=10,
}buyCoinsT
@interface HelloWorldLayer : CCLayer&SKProductsRequestDelegate,SKPaymentTransactionObserver&
+(CCScene *)
- (void) requestProUpgradeProductD
-(void)RequestProductD
-(bool)CanMakeP
-(void)buy:(int)
- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)
-(void) PurchasedTransaction: (SKPaymentTransaction *)
- (void) completeTransaction: (SKPaymentTransaction *)
- (void) failedTransaction: (SKPaymentTransaction *)
-(void) paymentQueueRestoreCompletedTransactionsFinished: (SKPaymentTransaction *)
-(void) paymentQueue:(SKPaymentQueue *) paymentQueue restoreCompletedTransactionsFailedWithError:(NSError *)
- (void) restoreTransaction: (SKPaymentTransaction *)
-(void)provideContent:(NSString *)
-(void)recordTransaction:(NSString *)
HelloWorldLayer.m
view plain
#import "HelloWorldLayer.h"
#define ProductID_IAP0p99 @"com.buytest.one"//$0.99
#define ProductID_IAP1p99 @"com.buytest.two" //$1.99
#define ProductID_IAP4p99 @"com.buytest.three" //$4.99
#define ProductID_IAP9p99 @"com.buytest.four" //$19.99
#define ProductID_IAP24p99 @"com.buytest.five" //$24.99
<span style="color: background-color
Hash表的建立及增删节查相关操作
Hash表的建立及增删改查相关操作1、什么是hash？
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
也许这么听大家肯定会对hash不知所云，晕晕乎乎。说实话，我也是这样。所以根据我自己的理解呢，hash就是把一段数据通过某种方法映射成另外一个值（相当于x映射为f(x)），也就是一个单向加密的过程。这个方法可以自己定义，也可以去网上找现成的，比如MD5的加密算法就用到了hash。
2、为什么要用hash？
当然是用来加密数据了~~~不错，不过这却不是我要说的。hash还可以用来干许多事比如说快速建立索引及查找。举个最现实的例子：QQ同时在线人数平均在几千万~近两亿（极端情况不考虑），每个用户都是一个User的类保存在腾讯的服务器上，存储这些数据也许可以用数组，也可以用链表，不过我们很快就会发现这种方法的缺陷。假如说这时，有一个用户上线了，腾讯的服务器必须先检测是否该QQ号是否已经登录了。若是，则向原来登录的客户机发送离线消息，然后再让新的用户上线；若不是，则直接让该用户上线。不管是哪种情况，都需要进行查找遍历。如果用数组或链表，那么都得从头开始排查，最差的情况是里头有多少元素就要排查多少次，这已经大大降低了查询效率，况且一个时刻上线下线的人数少说也得数以百计，并且之后还伴随着添加和删除过程（相对来说，数组是查询快，增删操作慢，而链表正好相反），那么这么看来，单纯的用数组或是链表是行不通的了。
那么我们应该怎么解决呢？用hash，当然！不过具体要怎么实行？首先我们建立一个模型：一个长度为n的数组，每一个数组元素存的是一段链表的头节点，链表长度为m（每个链表的m值相互无关），而链表的每个节点存储的则是一个User类的对象，这样无形中就形成了一个二维的数据存储结构，我们称之为数组加链表模型。假如有0~99这100个数需要存到这种模型中，我们可以让数组的第一个元素专门存储第一位为0的数（即一位数），链表长度为10，存储的数据分别为0、1、2、3、4、5、6、7、8、9；第二个元素存储第一位为1的数……以此类推，直到全部存进。现在我们要查找65，假设数组名为a，我们只需要找到a[6]，然后再循环查找链表的下一个节点，直到找到65，只需要5次。而用链表查找，则需要查找65次。当然如果用数组定义的话直接a[65]就能得到，但是如果需要在65与66之间再插入一个值就比较麻烦了，而上述数组加链表模型依然能轻松的解决这一问题。
现在我们回到QQ用户的问题，若是对于不同的用户能够尽可能的把他们分散到数组加链表模型的各处的话，查找和增删等操作就迎刃而解了，采取一种什么样的机制让他们分散呢？这就是hash方法了。我们知道每个用户的QQ号是唯一的，所以我们可以用该数值来进行hash运算。假如QQ同时在线人数为1亿，我们采取取模的hash算法，我们建立一个数组名为a，长度为100000的数组加链表模型，然后用QQ号的值对100000取模，比如说QQ号为，取模后为56789，那么我们就把他存入a[56789]的链表中。当然不止一个QQ号取模后结果为56789，对于这些QQ号，新来一个就把他加到链表的最后一个节点的后面并设置链表相邻元素间的指向关系。全部遍历一遍建立好了之后再找某个QQ号就可以先取模，然后到指定的数组链表上去找了，在这里最多只需要10000次即可找到（针对九位数的QQ）或确定不存在。
3、需要注意的方面：
首先是hash方法的确定，在这方面每个人有自己的想法，根据hash算法和初始容量然后初步确定数组长度n的大小，要使得数据尽量散列开来（所以hash函数一般翻译为“散列”嘛）。
其次就是随着用户的增多会导致链表的越来越长，当数组长度不变之后每个元素的链表长度却在一个劲地增加，长此以往，这个模型就会变得越来越像纯链表，也就慢慢偏向无效率了。所以在适时的时候，即链表长度和数组长度达到某一关系后我们就应该扩充数组长度了，当数组长度一变，取模的值也就变了，就是说原来的hash结果已经改变了，无法再适用到新的长度的数组上，所以我们需要对原来的每个元素重新hash一次，称之为rehash过程。可以想象，rehash的代价是巨大的，但是这也是必须的。
4、拓展方面：
其实既然有了数组加链表模型，那么我们可以继续设置数组加数组加链表模型，或者在前面套n个数组，但是前提条件是该用户类必须有n个字段值是唯一的，若QQ设置用户昵称也不能一样，那么我们在第二个数组里可以对用户昵称再进行hash一下，建立一个索引，然后加入链表中。
以下是简单实现的一个数组加链表模型：
import java.util.ArrayL
import java.util.L
import java.util.R
import java.util.S
public class HashTest {
public HashTest() {
Scanner sc = new Scanner(System.in);
int count = 0;
System.out.println("请输入需要添加的个数（值由系统随机生成）：");
count = sc.nextInt();
long start = System.currentTimeMillis();
MyThread th = new MyThread();
th.start();
int size = 2 * (int) Math.sqrt(count);
prime = Prime(size);
User DataArray[] = new User[size];
h: for (int i = 0; i & i++) {
System.out.println(i);
int value = random();
int addr = hash(value);
// 排查重复
User checkuser = new User();
checkuser = DataArray[addr];
} catch (ArrayIndexOutOfBoundsException aioobe) {
aioobe.printStackTrace();
System.out.println(DataArray.length);
while (checkuser != null) {
if (checkuser.getid() == value) {
checkuser = checkuser.getnext();
User u = new User(value);
DataArray = addto(addr, u, DataArray);
th.setflag(false);
System.out.println("共用了"
+ ((System.currentTimeMillis() - start) / 1000) + "秒");
System.out.println("添加成功。\t\n是否继续操作：\t\n1：继续\t0：退出");
int choose = new Scanner(System.in).nextInt();
while (choose != 0 && choose != 1) {
System.out.println("输入错误，请重新输入");
sc = new Scanner(System.in);
choose = sc.nextInt();
if (choose == 0) {
System.exit(0);
System.out
.println("请输入需要进行的操作：\t\n1：增加\t2：删除\t\n3：修改\t4：查询\t\n0：退出");
int result = new Scanner(System.in).nextInt();
while (result != 1 && result != 2 && result != 3 && result != 4
&& result != 0) {
System.out.println("输入错误，请重新输入");
sc = new Scanner(System.in);
result = sc.nextInt();
switch (result) {
add(DataArray);
del(DataArray);
Thread.sleep(2000);
query(DataArray);
} catch (Exception e) {
fix(DataArray);
Thread.sleep(2000);
query(DataArray);
} catch (Exception e) {
query(DataArray);
System.exit(0);
* 获取质数
* @param len
* @return 离len数值最近的最大的质数
int Prime(int len) {
int sqr = (int) Math.sqrt(len);
while (len & 2) {
for (int i = 2; i & i++) {
if (len % i == 0) {
if (i == sqr - 1) {
* 生成随机数
* @return 生成的随机数
int random() {
return new Random().nextInt() + ;
* 哈希算法
* @param value
* @param prime
计算数组长度所得的质数
* @return 哈希算法后的结果
int hash(int value) {
int sum = 0;
while (value / 10 != 0) {
sum += Math.pow(8, value % 10);
value /= 10;
return sum %
* 添加元素
* @param addr
数组的第几号元素
* @param u
加入的User对象
* @param Array
加至的数组
User[] addto(int addr, User u, User[] Array) {
if (addr & Array.length) {
throw new RuntimeException("地址超出数组长度，添加失败");
if (Array[addr] == null) {
Array[addr] =
User user = Array[addr];
// 链表节点数
int amount = 0;
while (user.getnext() != null) {
user = user.getnext();
user.setnext(u);
u.setlast(user);
if (amount & Array.length * 0.8) {
// 链表节点过多，扩展数组
System.out.println("链表节点过多，扩展数组");
Array = rehash(Array);
* 当数组需要扩张时的重新散列方法
* @param Array
User[] rehash(User[] Array) {
User[] reArray = new User[(int) (Array.length * 1.5 + 100)];
List&User& list = new ArrayList&User&();
prime = Prime(reArray.length);
for (int i = 0; i & Array. i++) {
for (User u = Array[i]; u != u = u.getnext()) {
list.add(u);
// 把原本的上下链关系全部断开
u.getlast().setnext(null);
u.setlast(null);
} catch (NullPointerException npe) {
System.out.println("空指针");
for (int i = 0; i & list.size(); i++) {
// 逐个添加
User u = list.get(i);
int addr = hash(u.getid());
addto(addr, u, reArray);
Array = reA
void add(User[] DataArray) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要添加的个数（值由系统随机生成）：");
int count = sc.nextInt();
long start = System.currentTimeMillis();
MyThread th = new MyThread();
th.start();
h: for (int i = 0; i & i++) {
int value = random();
int addr = hash(value);
User checkuser = DataArray[addr];
while (checkuser != null) {
if (checkuser.getid() == value) {
checkuser = checkuser.getnext();
User u = new User(value);
DataArray = addto(addr, u, DataArray);
th.setflag(false);
System.out.println("花费了"
+ ((System.currentTimeMillis() - start) / 1000)
+ "秒后增加成功，即将显示结果……");
Thread.sleep(2000);
} catch (Exception e) {
query(DataArray);
void del(User[] DataArray) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要删除的用户的id值：");
int id = sc.nextInt();
int addr = hash(id);
User u = DataArray[addr];
if (u != null) {
if (u.getid() == id) {
DataArray[addr] = u.getnext();
System.out.println("元素已成功删除，即将显示结果……");
while (u.getnext() != null) {
u = u.getnext();
if (u.getid() == id) {
if (u.getnext() == null) {
u.getlast().setnext(null);
System.out.println("元素已成功删除，即将显示结果……");
u.getlast().setnext(u.getnext());
u.getnext().setlast(u.getlast());
System.out.println("元素已成功删除，即将显示结果……");
System.out.println("未找到相应元素，即将显示结果……");
void fix(User[] DataArray) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入需要修改的用户的id值");
int id = sc.nextInt();
int addr = hash(id);
User u = DataArray[addr];
while (u != null) {
if (u.getid() == id) {
System.out.println("请设置其名字：");
Scanner scan = new Scanner(System.in);
String name = scan.next();
u.setname(name);
System.out.println("已成功更新数据，即将显示结果……");
u = u.getnext();
System.out.println("未找到相应元素，即将显示结果……");
void query(User[] DataArray) {
int all = 0;
int mount = DataArray.
System.out.println("共有" + mount + "个元素");
for (int i = 0; i & i++) {
int num = 1;
User u = DataArray[i];
if (u != null) {
while (u.getnext() != null) {
u = u.getnext();
System.out.println("第" + i + "个元素的链表中共有" + num + "个对象");
System.out.println("共有" + all + "个对象");
* @param args
public static void main(String[] args) {
// TODO Auto-generated method stub
new HashTest();
class User {
private User nextuser,
public User() {
public User(int id) {
public int getid() {
public void setnext(User u) {
this.nextuser =
public User getnext() {
public void setlast(User u) {
this.lastuser =
public User getlast() {
public void setname(String name) {
this.name =
public String getname() {
class MyThread extends Thread {
public boolean flag =
public void run() {
while (flag) {
System.out.println("正在添加中，请等待……");
Thread.sleep(5000);
} catch (Exception e) {
public void setflag(boolean flag) {
this.flag =
ORCLE-Select 语句执行顺序以及怎么提高Oracle 基本查询效率
ORCLE-Select 语句执行顺序以及如何提高Oracle 基本查询效率今天把这几天做的练习复习了一下，不知道自己写得代码执行的效率如何以及要如何提高，于是乎上网开始研究一些材料，现整理如下：
首先，要了解在Oracle中Sql语句运行的机制。以下是sql语句的执行步骤：
1）语法分析，分析语句的语法是否符合规范，衡量语句中各表达式的意义。
2）语义分析，检查语句中涉及的所有数据库对象是否存在，且用户有相应的权限。
3）视图转换，将涉及视图的查询语句转换为相应的对基表查询语句。
4）表达式转换， 将复杂的 SQL 表达式转换为较简单的等效连接表达式。
5）选择优化器，不同的优化器一般产生不同的“执行计划”
6）选择连接方式， ORACLE 有三种连接方式，对多表连接 ORACLE 可选择适当的连接方式。
7）选择连接顺序， 对多表连接 ORACLE 选择哪一对表先连接，选择这两表中哪个表做为源数据表。
8）选择数据的搜索路径，根据以上条件选择合适的数据搜索路径，如是选用全表搜索还是利用索引或是其他的方式。
9）运行“执行计划”。
这里不得不提的是Oracle共享原理：将执行过的SQL语句存放在内存的共享池(shared buffer pool)中，可以被所有的数据库用户共享当你执行一个SQL语句(有时被称为一个游标)时,如果它和之前的执行过的语句完全相同, Oracle就能很快获得已经被解析的语句以及最好的 执行路径. 这个功能大大地提高了SQL的执行性能并节省了内存的使用。
在了解了SQL语句的运行机制与Oracle共享原理后，我们可以知道SQL语句的书写方式对SQL语句的执行效率有很大的影响。那么下面我们了解一下SQL中Select语句中各个关键字执行的顺序。
SQL语言不同于其他编程语言的最明显特征是处理代码的顺序。在大多数据库语言中，代码按编码顺序被处理。但在SQL语句中，第一个被处理的子句是FROM，而不是第一出现的SELECT。SQL查询处理的步骤序号：(8) SELECT (9) DISTINCT (11) &TOP_specification& &select_list& (1) FROM &left_table& (3) &join_type& JOIN &right_table& (2) ON &join_condition& (4) WHERE &where_condition& (5) GROUP BY &group_by_list& (6) WITH {CUBE | ROLLUP} (7) HAVING &having_condition& (10) ORDER BY &order_by_list& 　　以上每个步骤都会产生一个虚拟表，该虚拟表被用作下一个步骤的输入。这些虚拟表对调用者(客户端应用程序或者外部查询)不可用。只有最后一步生成的表才会会给调用者。如果没有在查询中指定某一个子句，将跳过相应的步骤。　　逻辑查询处理阶段简介：　　1、 FROM：对FROM子句中的前两个表执行笛卡尔积(交叉联接)，生成虚拟表VT1。表名执行顺序是从后往前，所以数据较少的表尽量放后。　　2、 ON：对VT1应用ON筛选器，只有那些使为真才被插入到TV2。　　3、 OUTER (JOIN):如果指定了OUTER JOIN(相对于CROSS JOIN或INNER JOIN)，保留表中未找到匹配的行将作为外部行添加到VT2，生成TV3。如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表位置。　　4、 WHERE：对TV3应用WHERE筛选器，只有使为true的行才插入TV4。执行顺序为从前往后或者说从左到右。　　5、 GROUP BY：按GROUP BY子句中的列列表对TV4中的行进行分组，生成TV5。执行顺序从左往右分组。　　6、 CUTE|ROLLUP：把超组插入VT5，生成VT6。　　7、 HAVING：对VT6应用HAVING筛选器，只有使为true的组插入到VT7。Having语句很耗资源，尽量少用　　
8、 SELECT：处理SELECT列表，产生VT8。　　9、 DISTINCT：将重复的行从VT8中删除，产品VT9。　　10、ORDER BY：将VT9中的行按ORDER BY子句中的列列表顺序，生成一个游标(VC10)。执行顺序从左到右，是一个很耗资源的语句。
11、TOP：从VC10的开始处选择指定数量或比例的行，生成表TV11，并返回给调用者。
看到这里，应该是清楚了整个SQL语句整个执行的过程，那么我们就接下来进一步要坐得就是在实现功能同时有考虑性能的思想，努力提高SQL的执行效率。
第一、只返回需要的数据
返回数据到客户端至少需要数据库提取数据、网络传输数据、客户端接收数据以及客户端处理数据等环节，如果返回不需要的数据，就会增加服务器、网络和客户端的无效劳动，其害处是显而易见的，避免这类事件需要注意：
A、横向来看，
(1)不要写SELECT *的语句，而是选择你需要的字段。
(2)当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误。
B、纵向来看，
(1)合理写WHERE子句，不要写没有WHERE的SQL语句。
(2) SELECT TOP N * --没有WHERE条件的用此替代
第二、尽量少做重复的工作
A、控制同一语句的多次执行，特别是一些基础数据的多次执行是很多程序员很少注意的。
B、减少多次的数据转换，也许需要数据转换是设计的问题，但是减少次数是程序员可以做到的。
C、杜绝不必要的子查询和连接表，子查询在执行计划一般解释成外连接，多余的连接表带来额外的开销。
D、合并对同一表同一条件的多次UPDATE。
E、UPDATE操作不要拆成DELETE操作+INSERT操作的形式，虽然功能相同，但是性能差别是很大的。
第三、注意临时表和表变量的用法
在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，需要注意：
A、如果语句很复杂，连接太多，可以考虑用临时表和表变量分步完成。
B、如果需要多次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。
C、如果需要综合多个表的数据，形成一个结果，可以考虑用临时表和表变量分步汇总这多个表的数据。
D、其他情况下，应该控制临时表和表变量的使用。
E、关于临时表和表变量的选择，很多说法是表变量在内存，速度快，应该首选表变量，但是在实际使用中发现，(1)主要考虑需要放在临时表的数据量，在数据量较多的情况下，临时表的速度反而更快。(2)执行时间段与预计执行时间(多长)
F、关于临时表产生使用SELECT INTO和CREATE TABLE + INSERT INTO的选择，一般情况下，SELECT INTO会比CREATE TABLE + INSERT INTO的方法快很多，但是SELECT INTO会锁定TEMPDB的系统表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，在多用户并发环境下，容易阻塞其他进程，所以我的建议是，在并发系统中，尽量使用CREATE TABLE + INSERT INTO，而大数据量的单个语句使用中，使用SELECT INTO。
第四、注意子查询的用法
子查询是一个 SELECT 查询，它嵌套在 SELECT、INSERT、UPDATE、DELETE 语句或其它子查询中。任何允许使用表达式的地方都可以使用子查询，子查询可以使我们的编程灵活多样，可以用来实现一些特殊的功能。但是在性能上，往往一个不合适的子查询用法会形成一个性能瓶颈。如果子查询的条件中使用了其外层的表的字段，这种子查询就叫作相关子查询。相关子查询可以用IN、NOT IN、EXISTS、NOT EXISTS引入。 关于相关子查询，应该注意：(1)A、NOT IN、NOT EXISTS的相关子查询可以改用LEFT JOIN代替写法。比如：
SELECT PUB_NAME
FROM PUBLISHERS
WHERE PUB_ID NOT IN (SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以改写成：
SELECT A.PUB_NAME
FROM PUBLISHERS A LEFT JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID
WHERE B.PUB_ID IS NULL(2)SELECT TITLE
FROM TITLES
WHERE NOT EXISTS (SELECT TITLE_ID FROM SALES WHERE TITLE_ID = TITLES.TITLE_ID)
可以改写成：SELECT TITLE
FROM TITLES LEFT JOIN SALES ON SALES.TITLE_ID = TITLES.TITLE_ID
WHERE SALES.TITLE_ID IS NULL
B、 如果保证子查询没有重复 ，IN、EXISTS的相关子查询可以用INNER JOIN 代替。
比如：SELECT PUB_NAME
FROM PUBLISHERS
WHERE PUB_ID IN (SELECT PUB_ID FROM TITLES
WHERE TYPE = 'BUSINESS')
可以改写成：SELECT DISTINCT A.PUB_NAME
FROM PUBLISHERS A INNER JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID
C、 IN的相关子查询用EXISTS代替，比如SELECT PUB_NAME
FROM PUBLISHERS
WHERE PUB_ID IN (SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以用下面语句代替：SELECT PUB_NAME
FROM PUBLISHERS
WHERE EXISTS (SELECT 1 FROM TITLES WHERE TYPE = 'BUSINESS' AND PUB_ID= PUBLISHERS.PUB_ID) D、不要用COUNT(*)的子查询判断是否存在记录，最好用LEFT JOIN或者EXISTS，比如有人写这样的语句：SELECT JOB_DESC
WHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)=0
应该改成：SELECT JOBS.JOB_DESC
FROM JOBS LEFT JOIN EMPLOYEE ON EMPLOYEE.JOB_ID=JOBS.JOB_ID
WHERE EMPLOYEE.EMP_ID IS NULL
SELECT JOB_DESC FROM JOBS WHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)&&0
应该改成：SELECT JOB_DESC FROM JOBS
WHERE EXISTS (SELECT 1 FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)
第五、尽量使用索引,并注意对含索引列的运算
建立索引后，并不是每个查询都会使用索引，在使用索引的情况下，索引的使用效率也会有很大的差别。只要我们在查询语句中没有强制指定索引，索引的选择和使用方法是SQLSERVER的优化器自动作的选择，而它选择的根据是查询语句的条件以及相关表的统计信息，这就要求我们在写SQL语句的时候尽量使得优化器可以使用索引。为了使得优化器能高效使用索引，写语句的时候应该注意：A、不要对索引字段进行运算，而要想办法做变换，比如SELECT ID FROM T WHERE NUM/2=100应改为:SELECT ID FROM T WHERE NUM=100*2-------------------------------------------------------SELECT ID FROM T WHERE NUM/2=NUM1如果NUM有索引应改为:SELECT ID FROM T WHERE NUM=NUM1*2如果NUM1有索引则不应该改。--------------------------------发现过这样的语句：SELECT 年,月,金额 FROM 结余表 WHERE 100*年+月=应该改为：SELECT 年,月,金额 FROM 结余表 WHERE 年=2010 AND月=10B、 不要对索引字段进行格式转换日期字段的例子：WHERE CONVERT(VARCHAR(10), 日期字段,120)=''应该改为WHERE日期字段〉='' AND 日期字段&'' IS NULL
转换的例子：
WHERE ISNULL(字段,'')&&''应改为:WHERE字段&&'WHERE ISNULL(字段,'')=''不应修改WHERE ISNULL(字段,'F') ='T'应改为: WHERE字段='T'WHERE ISNULL(字段,'F')&&'T'不应修改C、 不要对索引字段使用函数WHERE LEFT(NAME, 3)='ABC' 或者WHERE SUBSTRING(NAME,1, 3)='ABC'应改为: WHERE NAME LIKE 'ABC%'日期查询的例子：WHERE DATEDIFF(DAY, 日期,'')=0应改为:WHERE 日期&='' AND 日期 &''WHERE DATEDIFF(DAY, 日期,'')&0应改为:WHERE 日期 &''WHERE DATEDIFF(DAY, 日期,'')&=0应改为:WHERE 日期 &''WHERE DATEDIFF(DAY, 日期,'')&0应改为:WHERE 日期&=''WHERE DATEDIFF(DAY, 日期,'')&=0应改为:WHERE 日期&=''D、不要对索引字段进行多字段连接比如：WHERE FAME+ '. '+LNAME='HAIWEI.YANG'应改为:WHERE FNAME='HAIWEI' AND LNAME='YANG'
第六、注意多表连接的连接条件的选择与表示
多表连接的连接条件对索引的选择有着重要的意义，所以我们在写连接条件条件的时候需要特别注意。
A、多表连接的时候，连接条件必须写全，宁可重复，不要缺漏。
B、连接条件尽量使用聚集索引
C、注意ON、WHERE和HAVING部分条件的区别： ON是最先执行， WHERE次之，HAVING最后，因为ON是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，WHERE也应该比 HAVING快点的，因为它过滤数据后才进行SUM，在两个表联接时才用ON的，所以在一个表的时候，就剩下WHERE跟HAVING比较了
1、考虑联接优先顺序：
2、INNER JOIN
3、LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
4、CROSS JOIN
其它注意和了解的地方有：
A、在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减少判断的次数
B、注意UNION和UNION ALL的区别。--允许重复数据用UNION ALL好
C、注意使用DISTINCT，在没有必要时不要用
D、TRUNCATE TABLE 与 DELETE 区别
E、减少访问数据库的次数
还有就是我们写存储过程，如果比较长的话，最后用标记符标开，因为这样可读性很好，即使语句写的不怎么样但是语句工整。如：
--startof 查询在职人数
正式机器上我们一般不能随便调试程序，但是很多时候程序在我们本机上没问题，但是进正式系统就有问题，但是我们又不能随便在正式机器上操作，那么怎么办呢?我们可以用回滚来调试我们的存储过程或者是sql语句，从而排错。
BEGIN TRAN
UPDATE a SET 字段='
作业存储过程可以加上下面这段，这样检查错误可以放在存储过程，如果执行错误回滚操作，但是如果程序里面已经有了事务回滚，那么存储过程就不要写事务了，这样会导致事务回滚嵌套降低执行效率，但是我们很多时候可以把检查放在存储过程里，这样有利于我们解读这个存储过程，和排错。
BEGIN TRANSACTION
--事务回滚开始
--检查报错
IF ( @@ERROR & 0 )
--回滚操作
ROLLBACK TRANSACTION
RAISERROR('删除工作报告错误', 16, 3)
--结束事务
COMMIT TRANSACTION
第七、有效使用Decode函数
使用Decode函数可以有效避免重复扫描相同数据或重复连接相同表。
以上就是这次的总结了，参考了很多文档，网络是个好平台，感谢大家的分享
原来引用地址：http://wfly2004./blog/static//
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：}