28/28, 223«‹25262728›»

[原]网络试衣间幻想曲---纸上谈兵

2008-5-14 22:08:09 软件 抢沙发(0)

由于KingFo曾经初出茅庐第一家公司就有打算做此方面的尝试，但由于本人知识浅薄加上对衣服的理解程度薄弱，所以也就做了半年后离开了，但随着时间的流逝，在脑中呈献的想法堆积的越来越多，故特别为此想法公布于众，在接下来的日子里，我会逐渐尝试任何可能的问题，不过由于目前工作的关系，故仅能浅尝辄止。

Ok，本着本域名取名来自X 加上Intend，本意是超级打算，X就是超级的意思，而Intend是指有此意图，但不一定要做，但是可以让想法共享的网络平台，目前一直希望更多的人能够加入这个队伍中来，但由于本人和本博客系统都有所缺陷，故还望各位一起来加入这个队伍。

本人对外邮箱是 oicuicu@gmail.com,希望收到路过此地，同时希望一起分享自己超级想法的伙伴和我取得联系。

 

嗯，切入正题。

 

首先，目标运行程序是Actionscript3/mxml下搭建的页面级程序，由于目前环境的种种限制，最好的方式是采用2D建制。目前7face，taobao，等多家企业/公司都已经在尝试这方面的内容了。

而2D建制最大的问题就是衣服的和人体对象的贴合程度，以及受众的接受程度。

首先关于贴合程度，如果有CAD数据那自然再好不过，可是由于CAD数据来自衣服制造商，以及目前国内大多数小规模的衣服生产厂商受环境限制基本手工绘制于布料上活着纸张上，所以是非常难以活的的数据。

另外，多数衣服的来自网络商家，故为了适用性达到最广和表现力达到最优本人所想到的方法是如下：

模型制定：
         制作和真人1：1的橡胶充气娃娃
数据采集：
         制作背景比例尺
                类似大多数电影中能看到的囚犯拍照后面的那个标度尺
               拥有标准光圈范围(含各种相机和通用相机)
         制作真人标准云台，(正\两侧\背)
基础库建设：
         标准人体3D数据(1)
                默认以上述娃娃为准
         标准UV展开图网格(2)
                方便人们将数据
         标准人体4面或6面状态图(3)
工具建设：
         绘制和上传系统
              一般用高效的C/C++编写，用来让客户将自行采集的数据编辑和上传 
             使用以上（1）和（2） ，并导存为2D以上（3）
         展示系统
              由swf文件网络中展示
              或专业版下载，让用户条件期望体型，并以3D拟真效果展示

主要构建思想：
        尽量让目前还不能高效3D运算的AS程序尽可能的去分析数据和展示2D的东西
        如果用户真想编辑，务必让用户使用绘制和上传工具
        其他虚拟真实的内容尽量采用小软件的形式

分支思想：
       如果非要让as程序在线进行操作，则需要在损失一定的真实度，让用户针对已拍摄好的对象进行类似PS的操作。

其他智能化研究：
      如研究胖矮高瘦等因素与标准体型间的关系，并建立模型
      研究身体动作与衣服间的连带关系等等
      这些。。。。囧。。。。。好高深，不过不是不可能吧~~~反正尽量让这些方放到非swf中编辑。毕竟如果作为商家不会嫌弃花费5-10分钟整理一个模型的，再说，如果协议统一，就连模型数据都可以成为商品，或者简易的外包项目咯~~（1件2块钱？）
  
OK~ 纸上谈兵就到这吧，部分数据待进行中，如果路过的您有此类相通的想法，或者更好的建议，请及时联系我哦，哈哈

困了，音乐。。。。。。。

阅读更多...
My-X-Intend, Adobe-Front-End-Technology, Experience

SQLite B+树实现代码

2008-5-13 2:10:49 开发者 抢沙发(0)

 from: http://www.sqlite.com.cn/MySqlite/6/373.Html

C++代码
  1. /* btrees.h */    
  2. /*   
  3. * 平衡多路树的一种重要方案。   
  4. * 在 1970 年由 R. Bayer 和 E. McCreight 发明。   
  5. */    
  6. #define M 1    
  7. /* B 树的阶，即非根节点中键的最小数目。   
  8. * 有些人把阶定义为非根节点中子树的最大数目。   
  9. */    
  10. typedef int typekey;    
  11. typedef struct btnode { /* B-Tree 节点 */    
  12. int d; /* 节点中键的数目 */    
  13. typekey k[2*M]; /* 键 */    
  14. char *v[2*M]; /* 值 */    
  15. struct btnode *p[2*M+1]; /* 指向子树的指针 */    
  16. } node, *btree;    
  17. /*   
  18. * 每个键的左子树中的所有的键都小于这个键，   
  19. * 每个键的右子树中的所有的键都大于等于这个键。   
  20. * 叶子节点中的每个键都没有子树。   
  21. */    
  22.   
  23. /* 当 M 等于 1 时也称为 2-3 树   
  24. * +----+----+   
  25. * | k0 | k1 |   
  26. * +-+----+----+---   
  27. * | p0 | p1 | p2 |   
  28. * +----+----+----+   
  29. */    
  30. extern int btree_disp; /* 查找时找到的键在节点中的位置 */    
  31. extern char * InsValue; /* 与要插的键相对应的值 */    
  32.   
  33. extern btree search(typekey, btree);    
  34. extern btree insert(typekey,btree);    
  35. extern btree delete(typekey,btree);    
  36. extern int height(btree);    
  37. extern int count(btree);    
  38. extern double payload(btree);    
  39. extern btree deltree(btree);    
  40. /* end of btrees.h */    
  41.   
  42. /*******************************************************/  
C++代码
  1. /*******************************************************/    
  2.   
  3. /* btrees.c */    
  4. #include    
  5. #include    
  6. #include "btrees.h"    
  7.   
  8. btree search(typekey, btree);    
  9. btree insert(typekey,btree);    
  10. btree delete(typekey,btree);    
  11. int height(btree);    
  12. int count(btree);    
  13. double payload(btree);    
  14. btree deltree(btree);    
  15.   
  16. static void InternalInsert(typekey, btree);    
  17. static void InsInNode(btree, int);    
  18. static void SplitNode(btree, int);    
  19. static btree NewRoot(btree);    
  20.   
  21. static void InternalDelete(typekey, btree);    
  22. static void JoinNode(btree, int);    
  23. static void MoveLeftNode(btree t, int);    
  24. static void MoveRightNode(btree t, int);    
  25. static void DelFromNode(btree t, int);    
  26. static btree FreeRoot(btree);    
  27.   
  28. static btree delall(btree);    
  29. static void Error(int,typekey);    
  30.   
  31. int btree_disp; /* 查找时找到的键在节点中的位置 */    
  32. char * InsValue = NULL; /* 与要插的键相对应的值 */    
  33. static int flag; /* 节点增减标志 */    
  34. static int btree_level = 0; /* 多路树的高度 */    
  35. static int btree_count = 0; /* 多路树的键总数 */    
  36. static int node_sum = 0; /* 多路树的节点总数 */    
  37. static int level; /* 当前访问的节点所处的高度 */    
  38. static btree NewTree; /* 在节点分割的时候指向新建的节点 */    
  39. static typekey InsKey; /* 要插入的键 */    
  40.   
  41. btree search(typekey key, btree t)    
  42. {    
  43. int i,j,m;    
  44. level=btree_level-1;    
  45. while (level >= 0){    
  46. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  47. if (key == t->k){    
  48. btree_disp = i;    
  49. return t;    
  50. }    
  51. if (key > t->k) /* i == t->d-1 时有可能出现 */    
  52. i++;    
  53. t = t->p;    
  54. level--;    
  55. }    
  56. return NULL;    
  57. }    
  58.   
  59. btree insert(typekey key, btree t)    
  60. {    
  61. level=btree_level;    
  62. InternalInsert(key, t);    
  63. if (flag == 1) /* 根节点满之后，它被分割成两个半满节点 */    
  64. t=NewRoot(t); /* 树的高度增加 */    
  65. return t;    
  66. }    
  67.   
  68. void InternalInsert(typekey key, btree t)    
  69. {    
  70. int i,j,m;    
  71.   
  72. level--;    
  73. if (level < 0){ /* 到达了树的底部: 指出要做的插入 */    
  74. NewTree = NULL; /* 这个键没有对应的子树 */    
  75. InsKey = key; /* 导致底层的叶子节点增加键值+空子树对 */    
  76. btree_count++;    
  77. flag = 1; /* 指示上层节点把返回的键插入其中 */    
  78. return;    
  79. }    
  80. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  81. if (key == t->k) {    
  82. Error(1,key); /* 键已经在树中 */    
  83. flag = 0;    
  84. return;    
  85. }    
  86. if (key > t->k) /* i == t->d-1 时有可能出现 */    
  87. i++;    
  88. InternalInsert(key, t->p);    
  89.   
  90. if (flag == 0)    
  91. return;    
  92. /* 有新键要插入到当前节点中 */    
  93. if (t->d < 2*M) {/* 当前节点未满 */    
  94. InsInNode(t, i); /* 把键值+子树对插入当前节点中 */    
  95. flag = 0; /* 指示上层节点没有需要插入的键值+子树，插入过程结束 */    
  96. }    
  97. else /* 当前节点已满，则分割这个页面并把键值+子树对插入当前节点中 */    
  98. SplitNode(t, i); /* 继续指示上层节点把返回的键值+子树插入其中 */    
  99. }    
  100.   
  101. /*   
  102. * 把一个键和对应的右子树插入一个节点中   
  103. */    
  104. void InsInNode(btree t, int d)    
  105. {    
  106. int i;    
  107. /* 把所有大于要插入的键值的键和对应的右子树右移 */    
  108. for(i = t->d; i > d; i--){    
  109. t->k = t->k[i-1];    
  110. t->v = t->v[i-1];    
  111. t->p[i+1] = t->p;    
  112. }    
  113. /* 插入键和右子树 */    
  114. t->k = InsKey;    
  115. t->p[i+1] = NewTree;    
  116. t->v = InsValue;    
  117. t->d++;    
  118. }    
  119. /*   
  120. * 前件是要插入一个键和对应的右子树，并且本节点已经满   
  121. * 导致分割这个节点，插入键和对应的右子树，   
  122. * 并向上层返回一个要插入键和对应的右子树   
  123. */    
  124. void SplitNode(btree t, int d)    
  125. {    
  126. int i,j;    
  127. btree temp;    
  128. typekey temp_k;    
  129. char *temp_v;    
  130. /* 建立新节点 */    
  131. temp = (btree)malloc(sizeof(node));    
  132. /*   
  133. * +---+--------+-----+-----+--------+-----+   
  134. * | 0 | ...... | M | M+1 | ...... |2*M-1|   
  135. * +---+--------+-----+-----+--------+-----+   
  136. * |<- M+1 ->|<- M-1 ->|   
  137. */    
  138. if (d > M) { /* 要插入当前节点的右半部分 */    
  139. /* 把从 2*M-1 到 M+1 的 M-1 个键值+子树对转移到新节点中,   
  140. * 并且为要插入的键值+子树空出位置 */    
  141. for(i=2*M-1,j=M-1; i>=d; i--,j--) {    
  142. temp->k[j] = t->k;    
  143. temp->v[j] = t->v;    
  144. temp->p[j+1] = t->p[i+1];    
  145. }    
  146. for(i=d-1,j=d-M-2; j>=0; i--,j--) {    
  147. temp->k[j] = t->k;    
  148. temp->v[j] = t->v;    
  149. temp->p[j+1] = t->p[i+1];    
  150. }    
  151. /* 把节点的最右子树转移成新节点的最左子树 */    
  152. temp->p[0] = t->p[M+1];    
  153. /* 在新节点中插入键和右子树 */    
  154. temp->k[d-M-1] = InsKey;    
  155. temp->p[d-M] = NewTree;    
  156. temp->v[d-M-1] = InsValue;    
  157. /* 设置要插入上层节点的键和值 */    
  158. InsKey = t->k[M];    
  159. InsValue = t->v[M];    
  160.   
  161. }    
  162. else { /* d <= M */    
  163. /* 把从 2*M-1 到 M 的 M 个键值+子树对转移到新节点中 */    
  164. for(i=2*M-1,j=M-1; j>=0; i--,j--) {    
  165. temp->k[j] = t->k;    
  166. temp->v[j] = t->v;    
  167. temp->p[j+1] = t->p[i+1];    
  168. }    
  169. if (d == M) /* 要插入当前节点的正中间 */    
  170. /* 把要插入的子树作为新节点的最左子树 */    
  171. temp->p[0] = NewTree;    
  172. /* 直接把要插入的键和值返回给上层节点 */    
  173. else { /* (d /* 把节点当前的最右子树转移成新节点的最左子树 */    
  174. temp->p[0] = t->p[M];    
  175. /* 保存要插入上层节点的键和值 */    
  176. temp_k = t->k[M-1];    
  177. temp_v = t->v[M-1];    
  178. /* 把所有大于要插入的键值的键和对应的右子树右移 */    
  179. for(i=M-1; i>d; i--) {    
  180. t->k = t->k[i-1];    
  181. t->v = t->v[i-1];    
  182. t->p[i+1] = t->p;    
  183. }    
  184. /* 在节点中插入键和右子树 */    
  185. t->k[d] = InsKey;    
  186. t->p[d+1] = NewTree;    
  187. t->v[d] = InsValue;    
  188. /* 设置要插入上层节点的键和值 */    
  189. InsKey = temp_k;    
  190. InsValue = temp_v;    
  191. }    
  192. }    
  193. t->d =M;    
  194. temp->d = M;    
  195. NewTree = temp;    
  196. node_sum++;    
  197. }    
  198.   
  199. btree delete(typekey key, btree t)    
  200. {    
  201. level=btree_level;    
  202. InternalDelete(key, t);    
  203. if (t->d == 0)    
  204. /* 根节点的子节点合并导致根节点键的数目随之减少，   
  205. * 当根节点中没有键的时候，只有它的最左子树可能非空 */    
  206. t=FreeRoot(t);    
  207. return t;    
  208. }    
  209.   
  210. void InternalDelete(typekey key, btree t)    
  211. {    
  212. int i,j,m;    
  213. btree l,r;    
  214. int lvl;    
  215.   
  216. level--;    
  217. if (level < 0) {    
  218. Error(0,key); /* 在整个树中未找到要删除的键 */    
  219. flag = 0;    
  220. return;    
  221. }    
  222. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  223. if (key == t->k) { /* 找到要删除的键 */    
  224. if (t->v != NULL)    
  225. free(t->v); /* 释放这个节点包含的值 */    
  226. if (level == 0) { /* 有子树为空则这个键位于叶子节点 */    
  227. DelFromNode(t,i);    
  228. btree_count--;    
  229. flag = 1;    
  230. /* 指示上层节点本子树的键数量减少 */    
  231. return;    
  232. } else { /* 这个键位于非叶节点 */    
  233. lvl = level-1;    
  234. /* 找到前驱节点 */    
  235. r = t->p;    
  236. while (lvl > 0) {    
  237. r = r->p[r->d];    
  238. lvl--;    
  239. }    
  240. t->k=r->k[r->d-1];    
  241. t->v=r->v[r->d-1];    
  242. r->v[r->d-1]=NULL;    
  243. key = r->k[r->d-1];    
  244. }    
  245. }    
  246. else if (key > t->k) /* i == t->d-1 时有可能出现 */    
  247. i++;    
  248. InternalDelete(key,t->p);    
  249. /* 调整平衡 */    
  250. if (flag == 0)    
  251. return;    
  252. if (t->p->d < M) {    
  253. if (i == t->d) /* 在最右子树中发生了删除 */    
  254. i--; /* 调整最右键的左右子树平衡 */    
  255. l = t->p;    
  256. r = t->p[i+1];    
  257. if (r->d > M)    
  258. MoveLeftNode(t,i);    
  259. else if(l->d > M)    
  260. MoveRightNode(t,i);    
  261. else {    
  262. JoinNode(t,i);    
  263. /* 继续指示上层节点本子树的键数量减少 */    
  264. return;    
  265. }    
  266. flag = 0;    
  267. /* 指示上层节点本子树的键数量没有减少，删除过程结束 */    
  268. }    
  269. }    
  270.   
  271. /*   
  272. * 合并一个节点的某个键对应的两个子树   
  273. */    
  274. void JoinNode(btree t, int d)    
  275. {    
  276. btree l,r;    
  277. int i,j;    
  278. l = t->p[d];    
  279. r = t->p[d+1];    
  280.   
  281. /* 把这个键下移到它的左子树 */    
  282. l->k[l->d] = t->k[d];    
  283. l->v[l->d] = t->v[d];    
  284. /* 把右子树中的所有键值和子树转移到左子树 */    
  285. for (j=r->d-1,i=l->d+r->d; j >= 0 ; j--,i--) {    
  286. l->k = r->k[j];    
  287. l->v = r->v[j];    
  288. l->p = r->p[j];    
  289. }    
  290. l->p[l->d+r->d+1] = r->p[r->d];    
  291. l->d += r->d+1;    
  292. /* 释放右子树的节点 */    
  293. free(r);    
  294. /* 把这个键右边的键和对应的右子树左移 */    
  295. for (i=d; i < t->d-1; i++) {    
  296. t->k = t->k[i+1];    
  297. t->v = t->v[i+1];    
  298. t->p[i+1] = t->p[i+2];    
  299. }    
  300. t->d--;    
  301. node_sum--;    
  302. }    
  303. /*   
  304. * 从一个键的右子树向左子树转移一些键，使两个子树平衡   
  305. */    
  306. void MoveLeftNode(btree t, int d)    
  307. {    
  308. btree l,r;    
  309. int m; /* 应转移的键的数目 */    
  310. int i,j;    
  311. l = t->p[d];    
  312. r = t->p[d+1];    
  313. m = (r->d - l->d)/2;    
  314.   
  315. /* 把这个键下移到它的左子树 */    
  316. l->k[l->d] = t->k[d];    
  317. l->v[l->d] = t->v[d];    
  318. /* 把右子树的最左子树转移成左子树的最右子树   
  319. * 从右子树向左子树移动 m-1 个键+子树对 */    
  320. for (j=m-2,i=l->d+m-1; j >= 0; j--,i--) {    
  321. l->k = r->k[j];    
  322. l->v = r->v[j];    
  323. l->p = r->p[j];    
  324. }    
  325. l->p[l->d+m] = r->p[m-1];    
  326. /* 把右子树的最左键提升到这个键的位置上 */    
  327. t->k[d] = r->k[m-1];    
  328. t->v[d] = r->v[m-1];    
  329. /* 把右子树中的所有键值和子树左移 m 个位置 */    
  330. r->p[0] = r->p[m];    
  331. for (i=0; id-m; i++) {    
  332. r->k = r->k[i+m];    
  333. r->v = r->v[i+m];    
  334. r->p = r->p[i+m];    
  335. }    
  336. r->p[r->d-m] = r->p[r->d];    
  337. l->d+=m;    
  338. r->d-=m;    
  339. }    
  340. /*   
  341. * 从一个键的左子树向右子树转移一些键，使两个子树平衡   
  342. */    
  343. void MoveRightNode(btree t, int d)    
  344. {    
  345. btree l,r;    
  346. int m; /* 应转移的键的数目 */    
  347. int i,j;    
  348. l = t->p[d];    
  349. r = t->p[d+1];    
  350.   
  351. m = (l->d - r->d)/2;    
  352. /* 把右子树中的所有键值和子树右移 m 个位置 */    
  353. r->p[r->d+m]=r->p[r->d];    
  354. for (i=r->d-1; i>=0; i--) {    
  355. r->k[i+m] = r->k;    
  356. r->v[i+m] = r->v;    
  357. r->p[i+m] = r->p;    
  358. }    
  359. /* 把这个键下移到它的右子树 */    
  360. r->k[m-1] = t->k[d];    
  361. r->v[m-1] = t->v[d];    
  362. /* 把左子树的最右子树转移成右子树的最左子树 */    
  363. r->p[m-1] = l->p[l->d];    
  364. /* 从左子树向右子树移动 m-1 个键+子树对 */    
  365. for (i=l->d-1,j=m-2; j>=0; j--,i--) {    
  366. r->k[j] = l->k;    
  367. r->v[j] = l->v;    
  368. r->p[j] = l->p;    
  369. }    
  370. /* 把左子树的最右键提升到这个键的位置上 */    
  371. t->k[d] = l->k;    
  372. t->v[d] = l->v;    
  373. l->d-=m;    
  374. r->d+=m;    
  375. }    
  376. /*   
  377. * 把一个键和对应的右子树从一个节点中删除   
  378. */    
  379. void DelFromNode(btree t, int d)    
  380. {    
  381. int i;    
  382. /* 把所有大于要删除的键值的键左移 */    
  383. for(i=d; i < t->d-1; i++) {    
  384. t->k = t->k[i+1];    
  385. t->v = t->v[i+1];    
  386. }    
  387. t->d--;    
  388. }    
  389. /*   
  390. * 建立有两个子树和一个键的根节点   
  391. */    
  392. btree NewRoot(btree t)    
  393. {    
  394. btree temp;    
  395. temp = (btree)malloc(sizeof(node));    
  396. temp->d = 1;    
  397. temp->p[0] = t;    
  398. temp->p[1] = NewTree;    
  399. temp->k[0] = InsKey;    
  400. temp->v[0] = InsValue;    
  401. btree_level++;    
  402. node_sum++;    
  403. return(temp);    
  404. }    
  405. /*   
  406. * 释放根节点，并返回它的最左子树   
  407. */    
  408. btree FreeRoot(btree t)    
  409. {    
  410. btree temp;    
  411. temp = t->p[0];    
  412. free(t);    
  413. btree_level--;    
  414. node_sum--;    
  415. return temp;    
  416. }    
  417.   
  418. void Error(int f,typekey key)    
  419. {    
  420. if (f)    
  421. printf("Btrees error: Insert %d! ",key);    
  422. else    
  423. printf("Btrees error: delete %d! ",key);    
  424. }    
  425.   
  426. int height(btree t)    
  427. {    
  428. return btree_level;    
  429. }    
  430.   
  431. int count(btree t)    
  432. {    
  433. return btree_count;    
  434. }    
  435. double payload(btree t)    
  436. {    
  437. if (node_sum==0)    
  438. return 1;    
  439. return (double)btree_count/(node_sum*(2*M));    
  440. }    
  441. btree deltree (btree t)    
  442. {    
  443. level=btree_level;    
  444. btree_level = 0;    
  445. return delall(t);    
  446.   
  447. }    
  448. btree delall(btree t)    
  449. {    
  450. int i;    
  451. level--;    
  452. if (level >= 0) {    
  453. for (i=0; i < t->d; i++)    
  454. if (t->v != NULL)    
  455. free(t->v);    
  456. if (level > 0)    
  457. for (i=0; i<= t->d ; i++)    
  458. t->p=delall(t->p);    
  459. free(t);    
  460. }    
  461. return NULL;    
  462. }    
  463.   
  464. /* end of btrees.c */   
阅读更多...
Sql, code

B+ 树的组织结构

2008-5-13 1:59:22 软件 抢沙发(0)

  

、B+树索引的总体结构
①B+树索引是一个多级索引，但是其结构不同于多级顺序索引；
②B+树索引采用平衡树结构，即每个叶结点到根的路径长度都相同；
③每个非叶结点有到n个子女，n对特定的树是固定的；
④B+树的所有结点结构都相同，它最多包含n-1个搜索码值K1、K2、…、Kn-1，以及n个指针P1、P2、…、Pn，每个结点中的搜索码值按次序存放，即如果i<j，那么Ki<Kj，如图8-3-1所示。
图8-3-1：B+树的结点结构 
2、B+树索引的叶结点
①指针Pi(i=1,2,…,n-1)指向具有搜索码值Ki的一个文件记录或一个指针（存储）桶，桶中的每个指针指向具有搜索码值Ki的一个文件记录。指针桶只在文件不按搜索码顺序物理存储时才使用。指针Pn具有特殊的作用；
②每个叶结点最多可有n-1个搜索码值，最少也要有个搜索码值。各个叶结点中搜索码值的范围互不相交。要使B+树索引成为稠密索引，数据文件中的各搜索码值都必须出现在某个叶结点中且只能出现一次；
③由于各叶结点按照所含的搜索码值有一个线性顺序，所以就可以利用各个叶结点的指针Pn将叶结点按搜索码顺序链接在一起。这种排序能够高效地对文件进行顺序处理，而B+树索引的其他结构能够高效地对文件进行随机处理，如图8-3-2所示。
图8-3-2：B+树索引的叶结点结构示例 
3、B+树索引的非叶结点
①B+树索引的非叶结点形成叶结点上的一个多级（稀疏）索引；
②非叶结点的结构和叶结点的结构相同，即含有能够存储n-1个搜索码值和n个指针的存储单元的数据结构。只不过非叶结点中的所有指针都指向树中的结点；
③如果一个非叶结点有m个指针，则≤m≤n。若m<n，则非叶结点中指针Pm之后的所有空闲空间作为预留空间，与叶结点的区别在于结点的最后一个指针Pm和Pn的位置与指向不同，如图8-3-3所示；
图8-3-3：B+树索引的非叶结点结构 
④在一个含有m个指针的非叶结点中，指针Pi(i=2,…,m-1)指向一棵子树，该子树的所有结点的搜索码值大于等于Ki-1而小于Ki。指针Pm指向子树中所含搜索码值大于等于Km-1的那一部分，而指针P1指向子树中所含搜索码值小于K1的那一部分，如图8-3-4所示。
图8-3-4：B+树索引的非叶结点中指针Pi的指向
4、B+树索引的根结点
①根结点的结构也与叶结点相同；
②根结点包含的指针数可以小于。但是，除非整棵树只有一个结点，否则根结点必须至少包含两个指针。图8-3-5给出一个B+树结构的示意图。
图8-3-5：account关系的B+树索引结构 

 

来源：http://www.sqlite.com.cn/MySqlite/6/373.Html 

阅读更多...
Sql

SQLite的SQL语法---select

2008-5-13 1:57:03 开发者 抢沙发(0)

SELECT

sql-statement ::= SELECT [ALL | DISTINCT] result [FROM table-list]
[WHERE expr]
[GROUP BY expr-list]
[HAVING expr]
[compound-op select]*
[ORDER BY sort-expr-list]
[LIMIT integer [( OFFSET | , ) integer]]
result ::= result-column [, result-column]*
result-column ::= * | table-name . * | expr [ [AS] string ]
table-list ::= table [join-op table join-args]*
table ::= table-name [AS alias] |
( select ) [AS alias]
join-op ::= , | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN
join-args ::= [ON expr] [USING ( id-list )]
sort-expr-list ::= expr [sort-order] [, expr [sort-order]]*
sort-order ::= [ COLLATE collation-name ] [ ASC | DESC ]
compound_op ::= UNION | UNION ALL | INTERSECT | EXCEPT
阅读更多...
Sql

SQLite测试报告

2008-5-13 1:44:20 开发者 抢沙发(0)

来自官方旧数据

内容为转贴:

数据库速度比较

附注：这篇文档是一篇旧文档。它把老版的SQLite的速度和老版的MySQL和 PostgreSQL的速度进行了对比。读者被热诚地邀请贡献更先进的速度对比在SQLite Wiki.

这里的数字非常老，几乎没什么意义。在更新之前仍使用这篇文档只是为了证明SQLite不是停滞不前的。

执行程序总结

一系列的测试程序已经被运行去测量SQLite 2.7.6，PostgreSQL 7.1.3，和 MySQL 3.23.41 的相对性能。以下是根据实验得出的一些总结：

  • SQLite 2.7.6 是非常快的，有时可以比安装在RedHat 7.2 上的预置的PostgreSQL 7.1.3 快10倍甚至20倍。

  • SQLite 2.7.6 总是很快， 有时比MySQL 3.23.41 快2倍多。

  • SQLite 执行CREATE INDEX or DROP TABLE时不像其它数据库那样快。但这不是什么问题，因为这些是很少运用的操作。

  • 如果你把 multiple 操作聚集到一个单独的事物项，SQLite可以更快些。

但以下几点是值得注意的：

  • 这些测试程序不是在测量多用户使用时数据库的性能，也不是在测量包含multiple的最优化复杂查询。

  • 这些测试是在一个相对小的数据库里完成的（大约14兆字节）。 它们没有测试数据库引擎的大小对程序运行速度的影响有多大。

测试环境

测试所用的平台是一个具有1GB内存的1.6GHz Athlon和一个IDE驱动硬盘。操作系统是具有一个stock内核的RedHat Linux 7.2 。

使用的PostgreSQL 和MySQL服务器被RedHat 7.2 中的默认程序所传送。（PostgreSQL 7.1.3 版和MySQL3.23.41版）所使用的引擎自始至终没有被调整过。需要特别注意的是，RedHat 7.2 中默认的MYSQL配置不支持处理事物项，这一点使MYSQL的速度大大增加。但SQLite还是有能力完成大部分的测试的。

我被告知，RedHat 7.3 中预设的PostgreSQL配置是非常落后的（它必须在具有 8MB RAM 的机器上工作）。 and that PostgreSQL则可以通过调整一些配置来运行的快些。 Matt Sergeant 报道说他已经调整了他的PostgreSQL装置，并且像下面所显示的一样重新进行测试。他的结果显示 PostgreSQL和MySQL运行速度一样。如想查看结果，访问：

http://www.sergeant.org/sqlite_vs_pgsync.html

SQLite实在同样的配置下被测试的，它是用 -O6 optimization 和 -DNDEBUG=1 交叉编写，这样使许多SQLite代码中的"assert()"语句 无法运行。

所有的测试都是在一个静止的机器上进行的。所有的测试时由一个简单的TCL文稿编排程序产生和运行的。 A copy of this Tcl script can be found in the你可以在源文件目录文件SQLite source tree in the file tools/speedtest.tcl中发现TCL文稿编排程序的副本.

所有测试中的时间都是以精确到秒的背景时钟来计算的.SQLite有两个单独的时间值. 第一个时间值在一个完整磁盘同步化打开的默认装置里.同步话打开后,为了确保重要数据已被真正的写入磁盘驱动表面,SQLite在关键的时候执行 fsync()系统调用. 在数据库更新过程中,当操作系统崩溃时或者计算机突然断电时,为了保证数据库的完整性,同步化是非常有必要的.第二个时间值是当同步化关闭的时候.关闭同步化, SQLite有时会运行的快些,但如果系统崩溃或者突然断电数据库将会受到损失. 通常来说,同步化的SQLite的时间是为了和PostgreSQL(因为他也是同步化的)比较,异步化的SQLite是为了和也是异步化的MySQL引擎比较.

 

http://www.sqlite.com.cn/MySqlite/5/180.Html

阅读更多...
Sql

Adobe&#174; Kuler&#174; API

2008-5-12 10:05:21 开发者 抢沙发(0)

This is a Action Script 3 API for accessing the Adobe® Kuler® API. klib-as3's goal is to be the simplest way to get color swatches from the Adobe® Kuler® website.

klib-as3 is still in development but you can use the svn until release version 1.

Any use of klib-as3 must abide by the Adobe® Kuler® terms of use and download the Adobe® Kuler® API logo. This logo must be included on your website/application

you can find more info on the Adobe® Kuler® API here  

example use

阅读更多...
Adobe-Front-End-Technology, OpenAPI

Dopplr-as3

2008-5-12 9:59:06 开发者 抢沙发(0)

This project is intended to get you up and running with accessing Dopplr data from Flash 9 applications.

It is also a playground for me to experiment with finding the most elegant and aesthetically pleasing way to code such applications. Your input is welcome if you have opinions on how the code might be improved, or if you want to implement some of the Dopplr API methods I didn't get to yet.

Initial Documentation is online, there is example code in the source tree and running examples will follow soon

 

 

License: New BSD License
Labels: actionscript3, dopplr, flash, flex, api, as3

Show all Featured Wiki Pages:
Documentation
Links:
Join project
Project owners:
  tom.carden

 

阅读更多...
Adobe-Front-End-Technology, OpenSource
28/28, 223«‹25262728›»
系统公告
Blog具有长期的置顶项，欢迎同学使用RSS订阅本Blog，便于在第一时间获知最新文章。
文章分类
搜索
随机文章
最新评论
标签云集
My-X-Intend Experience Front-End-Technology Adobe-Front-End-Technology code Sql Rules Algorithms Settings Web-Technology
站点数据
文章数量: 223 篇
评论数量: 31 条
标签数量: 19 个
引用通告: 1 条
总访问数: 43718 次
友情链接

Powered by Roclog v5.0.2

Copyright © 2009-2010 X-Intend. All rights reserved.

浙ICP备09082105号