source/workspace/EverFolder/src/com/yuji/ef/dao/NodeDaoImpl.java

   1 package com.yuji.ef.dao;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import android.database.Cursor;
   7 import android.database.SQLException;
   8 import android.database.sqlite.SQLiteDatabase;
   9 import android.database.sqlite.SQLiteStatement;
  10
  11 import com.yuji.ef.common.CommonUtil;
  12 import com.yuji.ef.utility.Debug;
  13
  14 public class NodeDaoImpl implements IDao<Node>, NodeDao {
  15         private static IDao<Node> instance = null;
  16         private SQLiteStatement insertStmt = null;
  17         private SQLiteStatement updateChildrenStmt = null;
  18         private SQLiteStatement updateStatusStmt = null;
  19         private SQLiteStatement updateNameStmt = null;
  20         private SQLiteStatement updateGuidStmt = null;
  21         private SQLiteStatement updateSelectedStmt = null;
  22         private SQLiteStatement updateNoteFlagStmt = null;
  23         private SQLiteStatement updateFlagStmt = null;
  24         private SQLiteStatement updateParentStmt = null;
  25         private SQLiteStatement deleteStmt = null;
  26         private SQLiteStatement deleteIdStmt = null;
  27
  28         public static IDao<Node> getInstance() {
  29                 if (instance == null) {
  30                         instance = new NodeDaoImpl();
  31                 }
  32                 return instance;
  33         }
  34
  35         protected NodeDaoImpl() {
  36
  37         }
  38
  39         /*
  40          * (non-Javadoc)
  41          *
  42          * @see
  43          * com.yuji.ef.dao.NodeDao#onCreate(android.database.sqlite.SQLiteDatabase)
  44          */
  45         @Override
  46         public void onCreate(SQLiteDatabase db) {
  47                 db.execSQL("CREATE TABLE Node (" + android.provider.BaseColumns._ID
  48                                 + " INTEGER PRIMARY KEY AUTOINCREMENT," + "TYPE INTEGER,"
  49                                 + "GUID TEXT," + "PARENT INTEGER," + "NAME TEXT,"
  50                                 + "CHILDREN TEXT," + "STATUS INTEGER," + "SELECTED INTEGER,"
  51                                  + "FLAG INTEGER"
  52                                 + ");");
  53         }
  54
  55         /*
  56          * (non-Javadoc)
  57          *
  58          * @see com.yuji.ef.dao.NodeDao#init(android.database.sqlite.SQLiteDatabase)
  59          */
  60         @Override
  61         public void init(SQLiteDatabase db) {
  62                 insertStmt = db.compileStatement("INSERT INTO Node (" + "TYPE,"
  63                                 + "GUID," + "PARENT," + "NAME," + "CHILDREN," + "STATUS"
  64                                 + ") VALUES (" + "?,?,?,?,?,?" + ");");
  65                 updateChildrenStmt = db
  66                                 .compileStatement("UPDATE Node SET CHILDREN = ? WHERE "
  67                                                 + android.provider.BaseColumns._ID + " = ?");
  68                 updateStatusStmt = db
  69                                 .compileStatement("UPDATE Node SET STATUS = ? WHERE "
  70                                                 + android.provider.BaseColumns._ID + " = ?");
  71                 updateNameStmt = db.compileStatement("UPDATE Node SET NAME = ? WHERE "
  72                                 + android.provider.BaseColumns._ID + " = ?");
  73                 updateGuidStmt = db
  74                                 .compileStatement("UPDATE Node SET GUID = ?, TYPE = ? WHERE "
  75                                                 + android.provider.BaseColumns._ID + " = ?");
  76                 updateSelectedStmt = db
  77                                 .compileStatement("UPDATE Node SET SELECTED = ? WHERE "
  78                                                 + android.provider.BaseColumns._ID + " = ?");
  79                 updateNoteFlagStmt = db
  80                                 .compileStatement("UPDATE Node SET FLAG = ? WHERE "
  81                                                 + "TYPE = ?");
  82                 updateFlagStmt = db
  83                                 .compileStatement("UPDATE Node SET FLAG = ? WHERE "
  84                                                 + android.provider.BaseColumns._ID + " = ?");
  85                 updateParentStmt = db
  86                                 .compileStatement("UPDATE Node SET PARENT = ? WHERE "
  87                                                 + android.provider.BaseColumns._ID + " = ?");
  88                 deleteStmt = db.compileStatement("DELETE FROM Node");
  89                 deleteIdStmt = db.compileStatement("DELETE FROM Node WHERE "
  90                                 + android.provider.BaseColumns._ID + " = ?");
  91         }
  92
  93         /*
  94          * (non-Javadoc)
  95          *
  96          * @see
  97          * com.yuji.ef.dao.NodeDao#start(android.database.sqlite.SQLiteDatabase)
  98          */
  99         @Override
 100         public void start(SQLiteDatabase db) {
 101
 102         }
 103
 104         /*
 105          * (non-Javadoc)
 106          *
 107          * @see com.yuji.ef.dao.NodeDao#search()
 108          */
 109         @Override
 110         public List<Node> search() {
 111                 return search(DatabaseHelper.getInstance().getSQLiteDatabase(), null,
 112                                 null, null);
 113         }
 114
 115         /*
 116          * (non-Javadoc)
 117          *
 118          * @see com.yuji.ef.dao.NodeDao#searchRoot()
 119          */
 120         @Override
 121         public Node searchRoot() {
 122                 return searchRoot(DatabaseHelper.getInstance().getSQLiteDatabase());
 123         }
 124
 125         /*
 126          * (non-Javadoc)
 127          *
 128          * @see
 129          * com.yuji.ef.dao.NodeDao#searchRoot(android.database.sqlite.SQLiteDatabase
 130          * )
 131          */
 132         @Override
 133         public Node searchRoot(SQLiteDatabase db) {
 134                 String selection = "TYPE = ?";
 135                 String[] selectionArgs = { String.valueOf(Node.TYPE_ROOT) };
 136                 String orderBy = null;
 137                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 138                 if (list.size() <= 0) {
 139                         return null;
 140                 }
 141                 return list.get(0);
 142         }
 143
 144         @Override
 145         public List<Node> searchNote() {
 146                 return searchNote(DatabaseHelper.getInstance().getSQLiteDatabase());
 147         }
 148
 149         @Override
 150         public List<Node> searchNote(SQLiteDatabase db) {
 151                 String selection = "TYPE = ?";
 152                 String[] selectionArgs = { String.valueOf(Node.TYPE_NOTE) };
 153                 String orderBy = null;
 154                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 155                 return list;
 156         }
 157
 158         @Override
 159         public List<Node> searchBook() {
 160                 return searchBook(DatabaseHelper.getInstance().getSQLiteDatabase());
 161         }
 162
 163         @Override
 164         public List<Node> searchBook(SQLiteDatabase db) {
 165                 String selection = "TYPE = ?";
 166                 String[] selectionArgs = { String.valueOf(Node.TYPE_BOOK) };
 167                 String orderBy = "NAME";;
 168                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 169                 return list;
 170         }
 171
 172         @Override
 173         public List<Node> searchSelectedBook() {
 174                 return searchSelectedBook(DatabaseHelper.getInstance()
 175                                 .getSQLiteDatabase());
 176         }
 177
 178         @Override
 179         public List<Node> searchSelectedBook(SQLiteDatabase db) {
 180                 String selection = "TYPE = ? AND SELECTED = ?";
 181                 String[] selectionArgs = { String.valueOf(Node.TYPE_BOOK), "1" };
 182                 String orderBy = null;
 183                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 184                 return list;
 185         }
 186
 187         @Override
 188         public List<Node> searchNoteByFlag(int flag) {
 189                 return searchNoteByFlag(DatabaseHelper.getInstance()
 190                                 .getSQLiteDatabase(), flag);
 191         }
 192
 193         @Override
 194         public List<Node> searchNoteByFlag(SQLiteDatabase db, int flag) {
 195                 String selection = "TYPE = ? AND FLAG = ?";
 196                 String[] selectionArgs = { String.valueOf(Node.TYPE_NOTE),
 197                                 String.valueOf(flag) };
 198                 String orderBy = null;
 199                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 200                 return list;
 201         }
 202
 203         /*
 204          * (non-Javadoc)
 205          *
 206          * @see com.yuji.ef.dao.NodeDao#searchById(long)
 207          */
 208         @Override
 209         public Node searchById(long id) {
 210                 return searchById(DatabaseHelper.getInstance().getSQLiteDatabase(), id);
 211         }
 212
 213         /*
 214          * (non-Javadoc)
 215          *
 216          * @see
 217          * com.yuji.ef.dao.NodeDao#searchById(android.database.sqlite.SQLiteDatabase
 218          * , long)
 219          */
 220         @Override
 221         public Node searchById(SQLiteDatabase db, long id) {
 222                 String selection = android.provider.BaseColumns._ID + " = ?";
 223                 String[] selectionArgs = { String.valueOf(id) };
 224                 String orderBy = null;
 225                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 226                 if (list.size() <= 0) {
 227                         return null;
 228                 }
 229                 return list.get(0);
 230         }
 231
 232         /*
 233          * (non-Javadoc)
 234          *
 235          * @see
 236          * com.yuji.ef.dao.NodeDao#searchByGuid(android.database.sqlite.SQLiteDatabase
 237          * , java.lang.String)
 238          */
 239         @Override
 240         public Node searchByGuid(SQLiteDatabase db, String guid) {
 241                 String selection = "GUID = ?";
 242                 String[] selectionArgs = { guid };
 243                 String orderBy = null;
 244                 List<Node> list = search(db, selection, selectionArgs, orderBy);
 245                 if (list.size() <= 0) {
 246                         return null;
 247                 }
 248                 return list.get(0);
 249         }
 250
 251         private List<Node> search(SQLiteDatabase db, String selection,
 252                         String[] selectionArgs, String orderBy) {
 253                 List<Node> list = new ArrayList<Node>();
 254                 Cursor cursor = null;
 255                 try {
 256                         NodeFactory factory = NodeFactory.getInstance();
 257
 258                         cursor = db.query("Node", new String[] {
 259                                         android.provider.BaseColumns._ID, "TYPE", "GUID", "PARENT",
 260                                         "NAME", "CHILDREN", "STATUS", "SELECTED" }, selection,
 261                                         selectionArgs, null, null, orderBy);
 262                         cursor.moveToFirst();
 263                         int size = cursor.getCount();
 264                         for (int i = 0; i < size; i++) {
 265                                 // TODO Factory
 266                                 // Node Node = new Node(
 267                                 // cursor.getLong(0),
 268                                 // cursor.getString(1),
 269                                 // cursor.getString(2),
 270                                 // cursor.getLong(3),
 271                                 // cursor.getLong(4));
 272                                 Node node = factory.create(cursor.getLong(0), cursor.getInt(1),
 273                                                 cursor.getString(2), cursor.getLong(3),
 274                                                 cursor.getString(4), cursor.getString(5),
 275                                                 cursor.getInt(6), (cursor.getInt(7) != 0));
 276                                 list.add(node);
 277                                 cursor.moveToNext();
 278                         }
 279                 } catch (SQLException e) {
 280                         Debug.d(this, null, e);
 281                         list = null;
 282                 } catch (Exception e) {
 283                         Debug.d(this, null, e);
 284                         list = null;
 285                 } finally {
 286                         if (cursor != null) {
 287                                 cursor.close();
 288                                 cursor = null;
 289                         }
 290                 }
 291                 return list;
 292         }
 293
 294         /*
 295          * (non-Javadoc)
 296          *
 297          * @see com.yuji.ef.dao.NodeDao#isEmpty()
 298          */
 299         @Override
 300         public boolean isEmpty() {
 301                 // List<Node> list = search();
 302                 // return list == null || list.size() <= 0;
 303                 return this.searchRoot() == null;
 304         }
 305
 306         /*
 307          * (non-Javadoc)
 308          *
 309          * @see com.yuji.ef.dao.NodeDao#add(com.yuji.ef.dao.Node)
 310          */
 311         @Override
 312         public long add(Node node) {
 313                 DatabaseHelper helper = DatabaseHelper.getInstance();
 314                 SQLiteDatabase db = helper.getWritableDatabase();
 315                 return add(db, node);
 316         }
 317
 318         private long add(SQLiteDatabase db, Node node) {
 319                 long id = -1;
 320                 db.beginTransaction();
 321                 try {
 322                         id = addNT(node);
 323                         db.setTransactionSuccessful();
 324                 } finally {
 325                         db.endTransaction();
 326                 }
 327                 return id;
 328         }
 329
 330         /*
 331          * (non-Javadoc)
 332          *
 333          * @see com.yuji.ef.dao.NodeDao#addNT(com.yuji.ef.dao.Node)
 334          */
 335         @Override
 336         public long addNT(Node node) {
 337                 long id = -1;
 338                 int i = 1;
 339                 SQLiteStatement stmt = insertStmt;
 340                 stmt.bindLong(i++, node.getType());
 341                 stmt.bindString(i++, CommonUtil.nz(node.getGuid()));
 342                 stmt.bindLong(i++, node.getParent());
 343                 stmt.bindString(i++, node.getName());
 344                 stmt.bindString(i++, CommonUtil.nz(node.getChildrenString()));
 345                 stmt.bindLong(i++, Node.getStatusCode(node.getStatus()));
 346                 id = stmt.executeInsert();
 347                 return id;
 348         }
 349
 350         /*
 351          * (non-Javadoc)
 352          *
 353          * @see com.yuji.ef.dao.NodeDao#addChildrenId(com.yuji.ef.dao.Node, long)
 354          */
 355         @Override
 356         public long addChildrenId(Node node, long id) {
 357                 DatabaseHelper helper = DatabaseHelper.getInstance();
 358                 SQLiteDatabase db = helper.getWritableDatabase();
 359                 return addChildrenId(db, node, id);
 360         }
 361
 362         private long addChildrenId(SQLiteDatabase db, Node node, long aid) {
 363                 long id = -1;
 364                 db.beginTransaction();
 365                 try {
 366                         id = addChildrenIdNT(node, aid);
 367                         db.setTransactionSuccessful();
 368                 } finally {
 369                         db.endTransaction();
 370                 }
 371                 return id;
 372         }
 373
 374         /*
 375          * (non-Javadoc)
 376          *
 377          * @see com.yuji.ef.dao.NodeDao#addChildrenIdNT(com.yuji.ef.dao.Node, long)
 378          */
 379         @Override
 380         public long addChildrenIdNT(Node node, long id) {
 381                 List<Long> l = node.getChildren();
 382                 if (l.contains(id)) {
 383                         return -1;
 384                 }
 385                 l.add(id);
 386                 // node.add(id);
 387                 return updateChildrenNT(node, Node.concatChildren(l));
 388         }
 389
 390         /*
 391          * (non-Javadoc)
 392          *
 393          * @see com.yuji.ef.dao.NodeDao#updateChildrenNT(com.yuji.ef.dao.Node,
 394          * java.lang.String)
 395          */
 396         @Override
 397         public long updateChildrenNT(Node node, String children) {
 398                 long id = -1;
 399                 int i = 1;
 400                 SQLiteStatement stmt = updateChildrenStmt;
 401                 //stmt.bindString(i++, node.getChildrenString());
 402                 stmt.bindString(i++, children);
 403                 stmt.bindLong(i++, node.getId());
 404                 id = stmt.executeInsert();
 405                 return id;
 406         }
 407
 408         /*
 409          * (non-Javadoc)
 410          *
 411          * @see com.yuji.ef.dao.NodeDao#remoteChildrenId(com.yuji.ef.dao.Node, long)
 412          */
 413         @Override
 414         public long removeChildrenId(Node node, long id) {
 415                 DatabaseHelper helper = DatabaseHelper.getInstance();
 416                 SQLiteDatabase db = helper.getWritableDatabase();
 417                 return remoteChildrenId(db, node, id);
 418         }
 419
 420         private long remoteChildrenId(SQLiteDatabase db, Node node, long aid) {
 421                 long id = -1;
 422                 db.beginTransaction();
 423                 try {
 424                         id = removeChildrenIdNT(node, aid);
 425                         db.setTransactionSuccessful();
 426                 } finally {
 427                         db.endTransaction();
 428                 }
 429                 return id;
 430         }
 431
 432         /*
 433          * (non-Javadoc)
 434          *
 435          * @see com.yuji.ef.dao.NodeDao#remoteChildrenIdNT(com.yuji.ef.dao.Node,
 436          * long)
 437          */
 438         @Override
 439         public long removeChildrenIdNT(Node node, long id) {
 440                 List<Long> l = node.getChildren();
 441                 if (!l.contains(id)) {
 442                         return -1;
 443                 }
 444                 l.remove(id);
 445                 // node.add(id);
 446                 return updateChildrenNT(node, Node.concatChildren(l));
 447         }
 448
 449         /*
 450          * (non-Javadoc)
 451          *
 452          * @see com.yuji.ef.dao.NodeDao#updateStatus(com.yuji.ef.dao.Node,
 453          * com.yuji.ef.dao.Node.Status)
 454          */
 455         @Override
 456         public long updateStatus(Node node, Node.Status status) {
 457                 return updateStatus(DatabaseHelper.getInstance().getSQLiteDatabase(),
 458                                 node, status);
 459         }
 460
 461         /*
 462          * (non-Javadoc)
 463          *
 464          * @see
 465          * com.yuji.ef.dao.NodeDao#updateStatus(android.database.sqlite.SQLiteDatabase
 466          * , com.yuji.ef.dao.Node, com.yuji.ef.dao.Node.Status)
 467          */
 468         @Override
 469         public long updateStatus(SQLiteDatabase db, Node node, Node.Status status) {
 470                 long id = -1;
 471
 472                 db.beginTransaction();
 473                 try {
 474                         id = updateStatusNT(node, status);
 475                         db.setTransactionSuccessful();
 476                 } finally {
 477                         db.endTransaction();
 478                 }
 479                 return id;
 480         }
 481
 482         /*
 483          * (non-Javadoc)
 484          *
 485          * @see com.yuji.ef.dao.NodeDao#updateStatusNT(com.yuji.ef.dao.Node,
 486          * com.yuji.ef.dao.Node.Status)
 487          */
 488         @Override
 489         public long updateStatusNT(Node node, Node.Status status) {
 490                 long id = -1;
 491                 int i = 1;
 492                 int code = Node.getStatusCode(status);
 493
 494                 SQLiteStatement stmt = updateStatusStmt;
 495                 stmt.bindLong(i++, code);
 496                 stmt.bindLong(i++, node.getId());
 497                 id = stmt.executeInsert();
 498                 return id;
 499         }
 500
 501         /*
 502          * (non-Javadoc)
 503          *
 504          * @see com.yuji.ef.dao.NodeDao#updateName(com.yuji.ef.dao.Node,
 505          * java.lang.String)
 506          */
 507         @Override
 508         public long updateName(Node node, String name) {
 509                 return updateName(DatabaseHelper.getInstance().getSQLiteDatabase(),
 510                                 node, name);
 511         }
 512
 513         /*
 514          * (non-Javadoc)
 515          *
 516          * @see
 517          * com.yuji.ef.dao.NodeDao#updateName(android.database.sqlite.SQLiteDatabase
 518          * , com.yuji.ef.dao.Node, java.lang.String)
 519          */
 520         @Override
 521         public long updateName(SQLiteDatabase db, Node node, String name) {
 522                 long id = -1;
 523
 524                 db.beginTransaction();
 525                 try {
 526                         id = updateNameNT(node, name);
 527                         db.setTransactionSuccessful();
 528                 } finally {
 529                         db.endTransaction();
 530                 }
 531                 return id;
 532         }
 533
 534         /*
 535          * (non-Javadoc)
 536          *
 537          * @see com.yuji.ef.dao.NodeDao#updateNameNT(com.yuji.ef.dao.Node,
 538          * java.lang.String)
 539          */
 540         @Override
 541         public long updateNameNT(Node node, String name) {
 542                 long id = -1;
 543                 int i = 1;
 544
 545                 SQLiteStatement stmt = updateNameStmt;
 546                 stmt.bindString(i++, name);
 547                 stmt.bindLong(i++, node.getId());
 548                 id = stmt.executeInsert();
 549                 return id;
 550         }
 551
 552         @Override
 553         public long updateGuid(Node node, String guid) {
 554                 return updateGuid(DatabaseHelper.getInstance().getSQLiteDatabase(),
 555                                 node, guid);
 556         }
 557
 558         @Override
 559         public long updateGuid(SQLiteDatabase db, Node node, String guid) {
 560                 long id = -1;
 561
 562                 db.beginTransaction();
 563                 try {
 564                         id = updateGuid(node, guid);
 565                         db.setTransactionSuccessful();
 566                 } finally {
 567                         db.endTransaction();
 568                 }
 569                 return id;
 570         }
 571
 572         @Override
 573         public long updateGuidNT(Node node, String guid) {
 574                 long id = -1;
 575                 int i = 1;
 576
 577                 SQLiteStatement stmt = updateGuidStmt;
 578                 if (CommonUtil.isNull(guid)) {
 579                         stmt.bindNull(i++);
 580                         stmt.bindLong(i++, (node instanceof FileNode) ? Node.TYPE_NOTE
 581                                         : Node.TYPE_DIR);
 582                 } else {
 583                         stmt.bindString(i++, guid);
 584                         stmt.bindLong(i++, (node instanceof FileNode) ? Node.TYPE_NOTE
 585                                         : Node.TYPE_BOOK);
 586                 }
 587                 stmt.bindLong(i++, node.getId());
 588                 id = stmt.executeInsert();
 589                 return id;
 590         }
 591
 592         @Override
 593         public long updateSelected(Node node, boolean isSelected) {
 594                 return updateSelected(DatabaseHelper.getInstance().getSQLiteDatabase(),
 595                                 node, isSelected);
 596         }
 597
 598         @Override
 599         public long updateSelected(SQLiteDatabase db, Node node, boolean isSelected) {
 600                 long id = -1;
 601
 602                 db.beginTransaction();
 603                 try {
 604                         id = updateSelectedNT(node, isSelected);
 605                         db.setTransactionSuccessful();
 606                 } finally {
 607                         db.endTransaction();
 608                 }
 609                 return id;
 610         }
 611
 612         @Override
 613         public long updateSelectedNT(Node node, boolean isSelected) {
 614                 long id = -1;
 615                 int i = 1;
 616
 617                 SQLiteStatement stmt = updateSelectedStmt;
 618                 stmt.bindLong(i++, isSelected ? 1 : 0);
 619                 stmt.bindLong(i++, node.getId());
 620                 id = stmt.executeInsert();
 621                 return id;
 622         }
 623
 624         /*
 625          * (non-Javadoc)
 626          *
 627          * @see com.yuji.ef.dao.NodeDao#updateParent(com.yuji.ef.dao.Node, long)
 628          */
 629         @Override
 630         public long updateParent(Node node, long parent) {
 631                 return updateParent(DatabaseHelper.getInstance().getSQLiteDatabase(),
 632                                 node, parent);
 633         }
 634
 635         /*
 636          * (non-Javadoc)
 637          *
 638          * @see
 639          * com.yuji.ef.dao.NodeDao#updateParent(android.database.sqlite.SQLiteDatabase
 640          * , com.yuji.ef.dao.Node, long)
 641          */
 642         @Override
 643         public long updateParent(SQLiteDatabase db, Node node, long parent) {
 644                 long id = -1;
 645
 646                 db.beginTransaction();
 647                 try {
 648                         id = updateParentNT(node, parent);
 649                         db.setTransactionSuccessful();
 650                 } finally {
 651                         db.endTransaction();
 652                 }
 653                 return id;
 654         }
 655
 656         /*
 657          * (non-Javadoc)
 658          *
 659          * @see com.yuji.ef.dao.NodeDao#updateParentNT(com.yuji.ef.dao.Node, long)
 660          */
 661         @Override
 662         public long updateParentNT(Node node, long parent) {
 663                 long id = -1;
 664                 int i = 1;
 665
 666                 SQLiteStatement stmt = updateParentStmt;
 667                 stmt.bindLong(i++, parent);
 668                 stmt.bindLong(i++, node.getId());
 669                 id = stmt.executeInsert();
 670                 return id;
 671         }
 672
 673         @Override
 674         public long updateNoteFlag(int flag) {
 675                 return updateNoteFlag(DatabaseHelper.getInstance().getSQLiteDatabase(),
 676                                 flag);
 677         }
 678
 679         @Override
 680         public long updateNoteFlag(SQLiteDatabase db, int flag) {
 681                 long id = -1;
 682
 683                 db.beginTransaction();
 684                 try {
 685                         id = updateNoteFlagNT(flag);
 686                         db.setTransactionSuccessful();
 687                 } finally {
 688                         db.endTransaction();
 689                 }
 690                 return id;
 691         }
 692
 693         @Override
 694         public long updateNoteFlagNT(int flag) {
 695                 long id = -1;
 696                 int i = 1;
 697
 698                 SQLiteStatement stmt = updateNoteFlagStmt;
 699                 stmt.bindLong(i++, flag);
 700                 stmt.bindLong(i++, Node.TYPE_NOTE);
 701                 id = stmt.executeInsert();
 702                 return id;
 703         }
 704
 705         @Override
 706         public long updateFlag(Node node, int flag) {
 707                 return updateFlag(DatabaseHelper.getInstance().getSQLiteDatabase(),
 708                                 node, flag);
 709         }
 710
 711         @Override
 712         public long updateFlag(SQLiteDatabase db, Node node, int flag) {
 713                 long id = -1;
 714
 715                 db.beginTransaction();
 716                 try {
 717                         id = updateFlagNT(node, flag);
 718                         db.setTransactionSuccessful();
 719                 } finally {
 720                         db.endTransaction();
 721                 }
 722                 return id;
 723         }
 724
 725         @Override
 726         public long updateFlagNT(Node node, int flag) {
 727                 long id = -1;
 728                 int i = 1;
 729
 730                 SQLiteStatement stmt = updateFlagStmt;
 731                 stmt.bindLong(i++, flag);
 732                 stmt.bindLong(i++, node.getId());
 733                 id = stmt.executeInsert();
 734                 return id;
 735         }
 736
 737         /*
 738          * (non-Javadoc)
 739          *
 740          * @see com.yuji.ef.dao.NodeDao#updateChildren(com.yuji.ef.dao.Node,
 741          * java.lang.String)
 742          */
 743         @Override
 744         public long updateChildren(Node node, String children) {
 745                 DatabaseHelper helper = DatabaseHelper.getInstance();
 746                 SQLiteDatabase db = helper.getWritableDatabase();
 747                 return updateChildren(db, node, children);
 748         }
 749
 750         private long updateChildren(SQLiteDatabase db, Node node, String children) {
 751                 long id = -1;
 752                 db.beginTransaction();
 753                 try {
 754                         id = updateChildrenNT(node, children);
 755                         db.setTransactionSuccessful();
 756                 } finally {
 757                         db.endTransaction();
 758                 }
 759                 return id;
 760         }
 761
 762         /*
 763          * (non-Javadoc)
 764          *
 765          * @see com.yuji.ef.dao.NodeDao#delete(long)
 766          */
 767         @Override
 768         public long delete(long id) {
 769                 DatabaseHelper helper = DatabaseHelper.getInstance();
 770                 SQLiteDatabase db = helper.getWritableDatabase();
 771                 return delete(db, id);
 772         }
 773
 774         /*
 775          * (non-Javadoc)
 776          *
 777          * @see
 778          * com.yuji.ef.dao.NodeDao#delete(android.database.sqlite.SQLiteDatabase,
 779          * long)
 780          */
 781         @Override
 782         public long delete(SQLiteDatabase db, long did) {
 783                 long id = -1;
 784
 785                 db.beginTransaction();
 786                 try {
 787                         id = deleteNT(did);
 788                         db.setTransactionSuccessful();
 789                 } finally {
 790                         db.endTransaction();
 791                 }
 792                 return id;
 793         }
 794
 795         /*
 796          * (non-Javadoc)
 797          *
 798          * @see com.yuji.ef.dao.NodeDao#deleteNT(long)
 799          */
 800         @Override
 801         public long deleteNT(long did) {
 802                 long id = -1; // TODO
 803                 int i = 1;
 804
 805                 SQLiteStatement stmt = deleteIdStmt;
 806                 stmt.bindLong(i++, did);
 807                 stmt.execute();
 808                 return id;
 809         }
 810
 811         /*
 812          * (non-Javadoc)
 813          *
 814          * @see com.yuji.ef.dao.NodeDao#delete()
 815          */
 816         @Override
 817         public long delete() {
 818                 DatabaseHelper helper = DatabaseHelper.getInstance();
 819                 SQLiteDatabase db = helper.getWritableDatabase();
 820                 return delete(db);
 821         }
 822
 823         /*
 824          * (non-Javadoc)
 825          *
 826          * @see
 827          * com.yuji.ef.dao.NodeDao#delete(android.database.sqlite.SQLiteDatabase)
 828          */
 829         @Override
 830         public long delete(SQLiteDatabase db) {
 831                 long id = -1;
 832
 833                 db.beginTransaction();
 834                 try {
 835                         deleteNT();
 836                         db.setTransactionSuccessful();
 837                 } finally {
 838                         db.endTransaction();
 839                 }
 840                 return id;
 841         }
 842
 843         /*
 844          * (non-Javadoc)
 845          *
 846          * @see com.yuji.ef.dao.NodeDao#deleteNT()
 847          */
 848         @Override
 849         public void deleteNT() {
 850                 SQLiteStatement stmt = deleteStmt;
 851                 stmt.execute();
 852         }
 853 }