下面是在Android4.0上，利用Sqlite数据库的insert，query，update，delete函数以及execSql，rawQuery函数执行插入，查询，更新，删除操作花费时间的对比结果。

是在执行相同的动作，记录条数也一样的情况下的对比，多次验证的结果是：

（1）如果批量执行的记录数在1000条，则Android SqliteDatabase提供的insert，query，update，delete函数和直接写SQL文的execSql，rawQuery的效率差不多，几乎一样。所以使用哪种放到都可以，不会影响到执行效率。

（2）如果批量执行的记录数在10万条，则会存在差别。在某台手机上SqliteDatabase提供的insert执行插入操作耗时45秒，要比execSql插入35秒慢10秒左右。

可见在数据库大的情况下，还是有差别的。execSql省去了拼接sql语句的步骤，要比SqliteDatabase提供的insert，query，update，delete等函数效率高。当数据库越大，差别也越大。

下面是验证代码：

  1. public class MainActivity extends Activity {
  2. private static final String TAG = "MainActivity";
  3. private DBHelper mDbHelper = null;
  4. private static TextView mTvInfo;
  5. private static ProgressDialog mDialog = null;
  6. private static Handler mHandler = new Handler() {
  7. @Override
  8. public void handleMessage(Message msg) {
  9. // TODO Auto-generated method stub
  10. if(mDialog != null) {
  11. mDialog.dismiss();
  12. mDialog = null;
  13. }
  14. if (msg.what == 0) {
  15. Bundle b = msg.getData();
  16. int seconds = b.getInt("seconds");
  17. int ms = b.getInt("ms");
  18. StringBuilder builder = new StringBuilder("insert插入1000条记录花费时间：");
  19. if (seconds > 0) {
  20. builder.append(seconds).append("s ");
  21. }
  22. builder.append(ms).append("ms");
  23. String strLines[] = mTvInfo.getText().toString().split("\n");
  24. // 最多显示8条信息
  25. for (int i = 0; i < strLines.length; i++) {
  26. builder.append('\n').append(strLines[i]);
  27. if (i == 6) {
  28. break; // 加上原来最多7条信息，共显示8条信息
  29. }
  30. }
  31. mTvInfo.setText(builder.toString());
  32. } else if (msg.what == 1) {
  33. Bundle b = msg.getData();
  34. int seconds = b.getInt("seconds");
  35. int ms = b.getInt("ms");
  36. StringBuilder builder = new StringBuilder("execSql插入1000条记录花费时间：");
  37. if (seconds > 0) {
  38. builder.append(seconds).append("s ");
  39. }
  40. builder.append(ms).append("ms");
  41. String strLines[] = mTvInfo.getText().toString().split("\n");
  42. // 最多显示8条信息
  43. for (int i = 0; i < strLines.length; i++) {
  44. builder.append('\n').append(strLines[i]);
  45. if (i == 6) {
  46. break; // 加上原来最多7条信息，共显示8条信息
  47. }
  48. }
  49. mTvInfo.setText(builder.toString());
  50. } else if (msg.what == 10) {
  51. Bundle b = msg.getData();
  52. int count = b.getInt("count");
  53. int seconds = b.getInt("seconds");
  54. int ms = b.getInt("ms");
  55. StringBuilder builder = new StringBuilder("query查询");
  56. builder.append(count).append("条记录花费时间：");
  57. if (seconds > 0) {
  58. builder.append(seconds).append("s ");
  59. }
  60. builder.append(ms).append("ms");
  61. String strLines[] = mTvInfo.getText().toString().split("\n");
  62. // 最多显示8条信息
  63. for (int i = 0; i < strLines.length; i++) {
  64. builder.append('\n').append(strLines[i]);
  65. if (i == 6) {
  66. break; // 加上原来最多7条信息，共显示8条信息
  67. }
  68. }
  69. mTvInfo.setText(builder.toString());
  70. } else if (msg.what == 11) {
  71. Bundle b = msg.getData();
  72. int count = b.getInt("count");
  73. int seconds = b.getInt("seconds");
  74. int ms = b.getInt("ms");
  75. StringBuilder builder = new StringBuilder("rawQuery查询");
  76. builder.append(count).append("条记录花费时间：");
  77. if (seconds > 0) {
  78. builder.append(seconds).append("s ");
  79. }
  80. builder.append(ms).append("ms");
  81. String strLines[] = mTvInfo.getText().toString().split("\n");
  82. // 最多显示8条信息
  83. for (int i = 0; i < strLines.length; i++) {
  84. builder.append('\n').append(strLines[i]);
  85. if (i == 6) {
  86. break; // 加上原来最多7条信息，共显示8条信息
  87. }
  88. }
  89. mTvInfo.setText(builder.toString());
  90. } else if (msg.what == 20) {
  91. Bundle b = msg.getData();
  92. int count = b.getInt("count");
  93. int seconds = b.getInt("seconds");
  94. int ms = b.getInt("ms");
  95. StringBuilder builder = new StringBuilder("update更新");
  96. builder.append(count).append("条记录花费时间：");
  97. if (seconds > 0) {
  98. builder.append(seconds).append("s ");
  99. }
  100. builder.append(ms).append("ms");
  101. String strLines[] = mTvInfo.getText().toString().split("\n");
  102. // 最多显示8条信息
  103. for (int i = 0; i < strLines.length; i++) {
  104. builder.append('\n').append(strLines[i]);
  105. if (i == 6) {
  106. break; // 加上原来最多7条信息，共显示8条信息
  107. }
  108. }
  109. mTvInfo.setText(builder.toString());
  110. } else if (msg.what == 21) {
  111. Bundle b = msg.getData();
  112. int seconds = b.getInt("seconds");
  113. int ms = b.getInt("ms");
  114. StringBuilder builder = new StringBuilder("execSql更新1000条记录花费时间：");
  115. if (seconds > 0) {
  116. builder.append(seconds).append("s ");
  117. }
  118. builder.append(ms).append("ms");
  119. String strLines[] = mTvInfo.getText().toString().split("\n");
  120. // 最多显示8条信息
  121. for (int i = 0; i < strLines.length; i++) {
  122. builder.append('\n').append(strLines[i]);
  123. if (i == 6) {
  124. break; // 加上原来最多7条信息，共显示8条信息
  125. }
  126. }
  127. mTvInfo.setText(builder.toString());
  128. } else if (msg.what == 30) {
  129. Bundle b = msg.getData();
  130. int count = b.getInt("count");
  131. int seconds = b.getInt("seconds");
  132. int ms = b.getInt("ms");
  133. StringBuilder builder = new StringBuilder("delete删除");
  134. builder.append(count).append("条记录花费时间：");
  135. if (seconds > 0) {
  136. builder.append(seconds).append("s ");
  137. }
  138. builder.append(ms).append("ms");
  139. String strLines[] = mTvInfo.getText().toString().split("\n");
  140. // 最多显示8条信息
  141. for (int i = 0; i < strLines.length; i++) {
  142. builder.append('\n').append(strLines[i]);
  143. if (i == 6) {
  144. break; // 加上原来最多7条信息，共显示8条信息
  145. }
  146. }
  147. mTvInfo.setText(builder.toString());
  148. } else if (msg.what == 31) {
  149. Bundle b = msg.getData();
  150. int seconds = b.getInt("seconds");
  151. int ms = b.getInt("ms");
  152. StringBuilder builder = new StringBuilder("execSql删除1000条记录花费时间：");
  153. if (seconds > 0) {
  154. builder.append(seconds).append("s ");
  155. }
  156. builder.append(ms).append("ms");
  157. String strLines[] = mTvInfo.getText().toString().split("\n");
  158. // 最多显示8条信息
  159. for (int i = 0; i < strLines.length; i++) {
  160. builder.append('\n').append(strLines[i]);
  161. if (i == 6) {
  162. break; // 加上原来最多7条信息，共显示8条信息
  163. }
  164. }
  165. mTvInfo.setText(builder.toString());
  166. }
  167. }
  168. };
  169. @Override
  170. public void onCreate(Bundle savedInstanceState) {
  171. super.onCreate(savedInstanceState);
  172. setContentView(R.layout.activity_main);
  173. Button btnCreateDb = (Button)findViewById(R.id.btnCreateDb);
  174. btnCreateDb.setOnClickListener(new OnClickListener() {
  175. @Override
  176. public void onClick(View arg0) {
  177. // TODO Auto-generated method stub
  178. mDbHelper = new DBHelper(MainActivity.this, "test", null, 1);
  179. }
  180. });
  181. // insert插入
  182. Button btnInsert = (Button)findViewById(R.id.btnInsert);
  183. btnInsert.setOnClickListener(new OnClickListener() {
  184. @Override
  185. public void onClick(View arg0) {
  186. // TODO Auto-generated method stub
  187. if (mDbHelper != null) {
  188. mDialog = ProgressDialog.show(MainActivity.this, "insert插入", "正在插入1000条记录，请稍等……", true);
  189. new Thread() { // 开启线程执行防止阻塞
  190. @Override
  191. public void run() {
  192. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  193. try {
  194. // 利用事物批量插入数据以提高效率
  195. ContentValues values = new ContentValues();
  196. long startms = System.currentTimeMillis();
  197. db.beginTransaction();
  198. for (int i = 0; i < 1000; i++) {
  199. values.put("name", new String("张三") + i);
  200. values.put("birthday", "2012-12-08");
  201. values.put("gender", i%2);
  202. db.insert("student", null, values);
  203. }
  204. db.setTransactionSuccessful();
  205. db.endTransaction();
  206. long endms = System.currentTimeMillis();
  207. int seconds = (int)((endms - startms)/1000);
  208. int ms = (int)((endms - startms)%1000);
  209. Message msg = new Message();
  210. msg.what = 0;
  211. // 使用bundle对象来传递数据
  212. Bundle b = new Bundle();
  213. if(seconds > 0) {
  214. b.putInt("seconds", seconds);
  215. }
  216. b.putInt("ms", ms);
  217. msg.setData(b);
  218. mHandler.sendMessage(msg);
  219. } catch(Exception e) {
  220. e.printStackTrace();
  221. } finally {
  222. db.close(); // 关闭数据库
  223. }
  224. }
  225. }.start();
  226. } else {
  227. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  228. }
  229. }
  230. });
  231. // execSQL插入
  232. Button btnExecSqlInsert = (Button)findViewById(R.id.btnExecSqlInsert);
  233. btnExecSqlInsert.setOnClickListener(new OnClickListener() {
  234. @Override
  235. public void onClick(View arg0) {
  236. // TODO Auto-generated method stub
  237. if (mDbHelper != null) {
  238. mDialog = ProgressDialog.show(MainActivity.this, "execSQL插入", "正在插入1000条记录，请稍等……", true);
  239. new Thread() { // 开启线程执行防止阻塞
  240. @Override
  241. public void run() {
  242. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  243. try {
  244. // 利用事物批量插入数据以提高效率
  245. long startms = System.currentTimeMillis();
  246. db.beginTransaction();
  247. for (int i = 0; i < 1000; i++) {
  248. db.execSQL("INSERT INTO student(name, birthday, gender) values(?, ?, ?)" ,
  249. new Object[]{new String("李四" + i), "2012-12-08", i%2});
  250. }
  251. db.setTransactionSuccessful();
  252. db.endTransaction();
  253. long endms = System.currentTimeMillis();
  254. int seconds = (int)((endms - startms)/1000);
  255. int ms = (int)((endms - startms)%1000);
  256. Message msg = new Message();
  257. msg.what = 1;
  258. // 使用bundle对象来传递数据
  259. Bundle b = new Bundle();
  260. if(seconds > 0) {
  261. b.putInt("seconds", seconds);
  262. }
  263. b.putInt("ms", ms);
  264. msg.setData(b);
  265. mHandler.sendMessage(msg);
  266. } catch(Exception e) {
  267. e.printStackTrace();
  268. } finally {
  269. db.close(); // 关闭数据库
  270. }
  271. }
  272. }.start();
  273. }else {
  274. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  275. }
  276. }
  277. });
  278. // query查询
  279. Button btnQuery = (Button)findViewById(R.id.btnQuery);
  280. btnQuery.setOnClickListener(new OnClickListener() {
  281. @Override
  282. public void onClick(View arg0) {
  283. // TODO Auto-generated method stub
  284. if (mDbHelper != null) {
  285. mDialog = ProgressDialog.show(MainActivity.this, "query查询", "正在查询记录，请稍等……", true);
  286. new Thread() { // 开启线程执行防止阻塞
  287. @Override
  288. public void run() {
  289. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  290. try {
  291. Log.d(TAG, "query Start：" + getDate());
  292. long startms = System.currentTimeMillis();
  293. // 查询所有记录
  294. Cursor c = db.query("student", null, null, null, null, null, new String("id ASC LIMIT 0,1000"));
  295. Log.d(TAG, "query End：" + getDate());
  296. long endms = System.currentTimeMillis();
  297. int seconds = (int)((endms - startms)/1000);
  298. int ms = (int)((endms - startms)%1000);
  299. if (c != null) {
  300. Message msg = new Message();
  301. msg.what = 10;
  302. // 使用bundle对象来传递数据
  303. Bundle b = new Bundle();
  304. b.putInt("count", c.getCount());
  305. if(seconds > 0) {
  306. b.putInt("seconds", seconds);
  307. }
  308. b.putInt("ms", ms);
  309. msg.setData(b);
  310. mHandler.sendMessage(msg);
  311. c.close();
  312. }
  313. } catch(Exception e) {
  314. e.printStackTrace();
  315. } finally {
  316. db.close(); // 关闭数据库
  317. }
  318. }
  319. }.start();
  320. }else {
  321. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  322. }
  323. }
  324. });
  325. // rawQuery查询
  326. Button btnRawQuery = (Button)findViewById(R.id.btnRawQuery);
  327. btnRawQuery.setOnClickListener(new OnClickListener() {
  328. @Override
  329. public void onClick(View arg0) {
  330. // TODO Auto-generated method stub
  331. if (mDbHelper != null) {
  332. mDialog = ProgressDialog.show(MainActivity.this, "rawQuery查询", "正在查询记录，请稍等……", true);
  333. new Thread() { // 开启线程执行防止阻塞
  334. @Override
  335. public void run() {
  336. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  337. try {
  338. Log.d(TAG, "rawQuery Start：" + getDate());
  339. long startms = System.currentTimeMillis();
  340. // 查询所有记录
  341. Cursor c = db.rawQuery("SELECT * FROM student ORDER BY id ASC LIMIT 0,1000", null);
  342. Log.d(TAG, "rawQuery End：" + getDate());
  343. long endms = System.currentTimeMillis();
  344. int seconds = (int)((endms - startms)/1000);
  345. int ms = (int)((endms - startms)%1000);
  346. if (c != null) {
  347. Message msg = new Message();
  348. msg.what = 11;
  349. // 使用bundle对象来传递数据
  350. Bundle b = new Bundle();
  351. b.putInt("count", c.getCount());
  352. if(seconds > 0) {
  353. b.putInt("seconds", seconds);
  354. }
  355. b.putInt("ms", ms);
  356. msg.setData(b);
  357. mHandler.sendMessage(msg);
  358. c.close();
  359. }
  360. } catch(Exception e) {
  361. e.printStackTrace();
  362. } finally {
  363. db.close(); // 关闭数据库
  364. }
  365. }
  366. }.start();
  367. } else {
  368. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  369. }
  370. }
  371. });
  372. // update更新
  373. Button btnUpdate = (Button)findViewById(R.id.btnUpdate);
  374. btnUpdate.setOnClickListener(new OnClickListener() {
  375. @Override
  376. public void onClick(View arg0) {
  377. // TODO Auto-generated method stub
  378. if (mDbHelper != null) {
  379. mDialog = ProgressDialog.show(MainActivity.this, "update更新", "正在更新1000条记录，请稍等……", true);
  380. new Thread() { // 开启线程执行防止阻塞
  381. @Override
  382. public void run() {
  383. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  384. try {
  385. ContentValues values = new ContentValues();
  386. long startms = System.currentTimeMillis();
  387. values.put("name", new String("王五"));
  388. values.put("birthday", "2012-12-09");
  389. values.put("gender", 0);
  390. int count = db.update("student", values, new String("id IN (SELECT id FROM student ORDER BY id ASC LIMIT 0,1000)"), null);
  391. long endms = System.currentTimeMillis();
  392. int seconds = (int)((endms - startms)/1000);
  393. int ms = (int)((endms - startms)%1000);
  394. Message msg = new Message();
  395. msg.what = 20;
  396. // 使用bundle对象来传递数据
  397. Bundle b = new Bundle();
  398. b.putInt("count", count);
  399. if(seconds > 0) {
  400. b.putInt("seconds", seconds);
  401. }
  402. b.putInt("ms", ms);
  403. msg.setData(b);
  404. mHandler.sendMessage(msg);
  405. } catch(Exception e) {
  406. e.printStackTrace();
  407. } finally {
  408. db.close(); // 关闭数据库
  409. }
  410. }
  411. }.start();
  412. } else {
  413. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  414. }
  415. }
  416. });
  417. // execSQL更新
  418. Button btnExecSqlUpdate = (Button)findViewById(R.id.btnExecSqlUpdate);
  419. btnExecSqlUpdate.setOnClickListener(new OnClickListener() {
  420. @Override
  421. public void onClick(View arg0) {
  422. // TODO Auto-generated method stub
  423. if (mDbHelper != null) {
  424. mDialog = ProgressDialog.show(MainActivity.this, "execSQL更新", "正在更新1000条记录，请稍等……", true);
  425. new Thread() { // 开启线程执行防止阻塞
  426. @Override
  427. public void run() {
  428. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  429. try {
  430. long startms = System.currentTimeMillis();
  431. db.execSQL("UPDATE student SET name = ?, birthday = ?, gender = ? WHERE id IN (SELECT id FROM student ORDER BY id ASC LIMIT 0,1000)" ,
  432. new Object[]{new String("马六"), "2012-12-10", 1});
  433. long endms = System.currentTimeMillis();
  434. int seconds = (int)((endms - startms)/1000);
  435. int ms = (int)((endms - startms)%1000);
  436. Message msg = new Message();
  437. msg.what = 21;
  438. // 使用bundle对象来传递数据
  439. Bundle b = new Bundle();
  440. if(seconds > 0) {
  441. b.putInt("seconds", seconds);
  442. }
  443. b.putInt("ms", ms);
  444. msg.setData(b);
  445. mHandler.sendMessage(msg);
  446. } catch(Exception e) {
  447. e.printStackTrace();
  448. } finally {
  449. db.close(); // 关闭数据库
  450. }
  451. }
  452. }.start();
  453. }else {
  454. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  455. }
  456. }
  457. });
  458. // delete删除
  459. Button btnDelete = (Button)findViewById(R.id.btnDelete);
  460. btnDelete.setOnClickListener(new OnClickListener() {
  461. @Override
  462. public void onClick(View arg0) {
  463. // TODO Auto-generated method stub
  464. if (mDbHelper != null) {
  465. mDialog = ProgressDialog.show(MainActivity.this, "delete删除", "正在删除1000条记录，请稍等……", true);
  466. new Thread() { // 开启线程执行防止阻塞
  467. @Override
  468. public void run() {
  469. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  470. try {
  471. long startms = System.currentTimeMillis();
  472. int count = db.delete("student", new String("id IN (SELECT id FROM student ORDER BY id ASC LIMIT 0,1000)"), null);
  473. long endms = System.currentTimeMillis();
  474. int seconds = (int)((endms - startms)/1000);
  475. int ms = (int)((endms - startms)%1000);
  476. Message msg = new Message();
  477. msg.what = 30;
  478. // 使用bundle对象来传递数据
  479. Bundle b = new Bundle();
  480. b.putInt("count", count);
  481. if(seconds > 0) {
  482. b.putInt("seconds", seconds);
  483. }
  484. b.putInt("ms", ms);
  485. msg.setData(b);
  486. mHandler.sendMessage(msg);
  487. } catch(Exception e) {
  488. e.printStackTrace();
  489. } finally {
  490. db.close(); // 关闭数据库
  491. }
  492. }
  493. }.start();
  494. } else {
  495. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  496. }
  497. }
  498. });
  499. // execSQL删除
  500. Button btnExecSqlDelete = (Button)findViewById(R.id.btnExecSqlDelete);
  501. btnExecSqlDelete.setOnClickListener(new OnClickListener() {
  502. @Override
  503. public void onClick(View arg0) {
  504. // TODO Auto-generated method stub
  505. if (mDbHelper != null) {
  506. mDialog = ProgressDialog.show(MainActivity.this, "execSQL删除", "正在删除1000条记录，请稍等……", true);
  507. new Thread() { // 开启线程执行防止阻塞
  508. @Override
  509. public void run() {
  510. SQLiteDatabase db = mDbHelper.getWritableDatabase();
  511. try {
  512. long startms = System.currentTimeMillis();
  513. db.execSQL("DELETE FROM student WHERE id IN (SELECT id FROM student ORDER BY id ASC LIMIT 0,1000)");
  514. long endms = System.currentTimeMillis();
  515. int seconds = (int)((endms - startms)/1000);
  516. int ms = (int)((endms - startms)%1000);
  517. Message msg = new Message();
  518. msg.what = 31;
  519. // 使用bundle对象来传递数据
  520. Bundle b = new Bundle();
  521. if(seconds > 0) {
  522. b.putInt("seconds", seconds);
  523. }
  524. b.putInt("ms", ms);
  525. msg.setData(b);
  526. mHandler.sendMessage(msg);
  527. } catch(Exception e) {
  528. e.printStackTrace();
  529. } finally {
  530. db.close(); // 关闭数据库
  531. }
  532. }
  533. }.start();
  534. }else {
  535. Toast.makeText(MainActivity.this, "请先创建数据库！", Toast.LENGTH_SHORT).show();
  536. }
  537. }
  538. });
  539. mTvInfo = (TextView)findViewById(R.id.tvInfo);
  540. }
  541. @Override
  542. public boolean onCreateOptionsMenu(Menu menu) {
  543. getMenuInflater().inflate(R.menu.activity_main, menu);
  544. return true;
  545. }
  546. /**
  547. * 获取系统时间
  548. * @return
  549. */
  550. public static String getDate(){
  551. Calendar ca = Calendar.getInstance();
  552. int year = ca.get(Calendar.YEAR);           // 获取年份
  553. int month = ca.get(Calendar.MONTH);         // 获取月份
  554. int day = ca.get(Calendar.DATE);            // 获取日
  555. int minute = ca.get(Calendar.MINUTE);       // 分
  556. int hour = ca.get(Calendar.HOUR);           // 小时
  557. int second = ca.get(Calendar.SECOND);       // 秒
  558. int millisecond = ca.get(Calendar.MILLISECOND); // 毫秒
  559. String date = year + "/" + (month + 1 )+ "/" + day + " "+ hour + ":" + minute + ":" + second + ":" + millisecond;
  560. return date;
  561. }
  562. }

执行效果图：

版权声明：本文为博主原创文章，未经博主允许不得转载。

Android Sqlite数据库执行插入查询更新删除的操作对比的更多相关文章

  1. 42.QT-QSqlQuery类操作SQLite数据库(创建、查询、删除、修改)详解

    Qt 提供了 QtSql 模块来提供平台独立的基于 SQL 的数据库操作.这里我们所说的“平台 独立”,既包括操作系统平台,也包括各个数据库平台,Qt支持以下几种数据库: QT自带SQLITE数据库, ...

  2. MongoDB中的映射，限制记录和记录拼排序 文档的插入查询更新删除操作

    映射 在 MongoDB 中,映射(Projection)指的是只选择文档中的必要数据,而非全部数据.如果文档有 5 个字段,而你只需要显示 3 个,则只需选择 3 个字段即可. find() 方法 ...

  3. PHP5: mysqli 插入, 查询, 更新和删除 Insert Update Delete Using mysqli (CRUD)

    原文: PHP5: mysqli 插入, 查询, 更新和删除  Insert Update Delete Using mysqli (CRUD) PHP 5 及以上版本建议使用以下方式连接 MySQL ...

  4. php+mysqli实现批量执行插入、更新及删除数据的方法

    本文实例讲述了php+mysqli实现批量执行插入.更新及删除数据的方法.分享给大家供大家参考.具体如下: mysqli批量执行插入/更新/删除数据,函数为 multi_query(). 下面的代码只 ...

  5. Android Sqlite 数据库版本更新

      Android Sqlite 数据库版本更新 http://87426628.blog.163.com/blog/static/6069361820131069485844/ 1.自己写一个类继承 ...

  6. Android SQLite 数据库 增删改查操作

    Android SQLite 数据库 增删改查操作 转载▼ 一.使用嵌入式关系型SQLite数据库存储数据 在Android平台上,集成了一个嵌入式关系型数据库--SQLite,SQLite3支持NU ...

  7. Android SQLite 数据库详细介绍

    Android SQLite 数据库详细介绍 我们在编写数据库应用软件时,需要考虑这样的问题:因为我们开发的软件可能会安装在很多用户的手机上,如果应用使用到了SQLite数据库,我们必须在用户初次使用 ...

  8. TODO：MongoDB的查询更新删除总结

    TODO:MongoDB的查询更新删除总结 常用查询,条件操作符查询,< .<=.>.>=.!= 对应 MongoDB的查询操作符是$lt.$lte.$gt.$gte.$ne ...

  9. 图解IntelliJ IDEA 13版本对Android SQLite数据库的支持

    IntelliJ IDEA 13版本的重要构建之一是支持Android程序开发.当然对Android SQLite数据库的支持也就成为了Android开发者对IntelliJ IDEA 13版本的绝对 ...

随机推荐

  1. nginx自动切割访问日志

    Web 访问日志 (access_log) 记录了所有外部客户端对Web服务器的访问行为,包含了客户端IP,访问日期,访问的URL资源,服务器返回的HTTP状态码等重要信息. 一条典型的Web访问日志 ...

  2. 基于visual Studio2013解决C语言竞赛题之前言

    前言:关于VS2013 刚装完VS2013,新的IDE给人全新的编程体验,界面比以前更急简洁漂亮,不多说了,先上图吧 第一次启动VS2013

  3. 公共 DNS server IP 地址

    公共 DNS server IP 地址 名称 DNS server IP 地址 CNNIC SDNS 1.2.4.8 210.2.4.8 114 DNS 114.114.114.114 114.114 ...

  4. VS2012 创建项目失败，，提示为找到约束。。。。

    首先查看 控制面板里已安装的更新 在Microsoft .NET Freamewofk 4.5 小 查看 是否有KB2833957和KB2840642这两个补丁(如下图)  如果有 卸载它 然后 下载 ...

  5. UISearchBar去除底部黑线问题

    有时我们在设置搜索框的时候底部会出现一条黑线,要 去除这黑线只需设置. [self.searchBar setBackgroundImage:[UIImage new]];

  6. 什么是CALayer

    一.什么是CALayer * 在iOS系统中,你能看得见摸得着的东西基本上都是UIView,比如一个按钮.一个文本标签.一个文本输入框.一个图标等等,这些都是UIView. * 其实UIView之所以 ...

  7. Android:mimeType

    接收从其他应用传过来的数据,要用到清单文件 <activity android:name="com.terry.myActivity2" android:label=&quo ...

  8. mysql中if语句

    #1.IF表达式 IF(condition,expr1,expr2) //如果condition成立返回expr1,否则返回expr2 #2.IFNULL表达式 IFNULL(expr1,expr2) ...

  9. SDRAM 控制器的解析

    本篇博文非原创,是整理了网上的各家之言与一体,为自己以后方便查询所用.如有冒犯请告之. 1.Precharge与Refresh的区别? plj:两者都是对存储单元的电容进行充电.回写.但差异在于: P ...

  10. python IDE ulipad配置使用

    一直认为认为python自带的编辑器idle实在是太简陋了,连显示行号的功能都没有,也非常不好编辑.找了下windows平台下的Ide,发现ulipad很多人推荐使用,就开始安装了. 首先去官网: h ...