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, " + "SELECTED"
  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                 stmt.bindLong(i++, node.isSelected()? 1 : 0);
 347                 id = stmt.executeInsert();
 348                 return id;
 349         }
 350
 351         /*
 352          * (non-Javadoc)
 353          *
 354          * @see com.yuji.ef.dao.NodeDao#addChildrenId(com.yuji.ef.dao.Node, long)
 355          */
 356         @Override
 357         public long addChildrenId(Node node, long id) {
 358                 DatabaseHelper helper = DatabaseHelper.getInstance();
 359                 SQLiteDatabase db = helper.getWritableDatabase();
 360                 return addChildrenId(db, node, id);
 361         }
 362
 363         private long addChildrenId(SQLiteDatabase db, Node node, long aid) {
 364                 long id = -1;
 365                 db.beginTransaction();
 366                 try {
 367                         id = addChildrenIdNT(node, aid);
 368                         db.setTransactionSuccessful();
 369                 } finally {
 370                         db.endTransaction();
 371                 }
 372                 return id;
 373         }
 374
 375         /*
 376          * (non-Javadoc)
 377          *
 378          * @see com.yuji.ef.dao.NodeDao#addChildrenIdNT(com.yuji.ef.dao.Node, long)
 379          */
 380         @Override
 381         public long addChildrenIdNT(Node node, long id) {
 382                 List<Long> l = node.getChildren();
 383                 if (l.contains(id)) {
 384                         return -1;
 385                 }
 386                 l.add(id);
 387                 // node.add(id);
 388                 return updateChildrenNT(node, Node.concatChildren(l));
 389         }
 390
 391         /*
 392          * (non-Javadoc)
 393          *
 394          * @see com.yuji.ef.dao.NodeDao#updateChildrenNT(com.yuji.ef.dao.Node,
 395          * java.lang.String)
 396          */
 397         @Override
 398         public long updateChildrenNT(Node node, String children) {
 399                 long id = -1;
 400                 int i = 1;
 401                 SQLiteStatement stmt = updateChildrenStmt;
 402                 //stmt.bindString(i++, node.getChildrenString());
 403                 stmt.bindString(i++, children);
 404                 stmt.bindLong(i++, node.getId());
 405                 id = stmt.executeInsert();
 406                 return id;
 407         }
 408
 409         /*
 410          * (non-Javadoc)
 411          *
 412          * @see com.yuji.ef.dao.NodeDao#remoteChildrenId(com.yuji.ef.dao.Node, long)
 413          */
 414         @Override
 415         public long removeChildrenId(Node node, long id) {
 416                 DatabaseHelper helper = DatabaseHelper.getInstance();
 417                 SQLiteDatabase db = helper.getWritableDatabase();
 418                 return remoteChildrenId(db, node, id);
 419         }
 420
 421         private long remoteChildrenId(SQLiteDatabase db, Node node, long aid) {
 422                 long id = -1;
 423                 db.beginTransaction();
 424                 try {
 425                         id = removeChildrenIdNT(node, aid);
 426                         db.setTransactionSuccessful();
 427                 } finally {
 428                         db.endTransaction();
 429                 }
 430                 return id;
 431         }
 432
 433         /*
 434          * (non-Javadoc)
 435          *
 436          * @see com.yuji.ef.dao.NodeDao#remoteChildrenIdNT(com.yuji.ef.dao.Node,
 437          * long)
 438          */
 439         @Override
 440         public long removeChildrenIdNT(Node node, long id) {
 441                 List<Long> l = node.getChildren();
 442                 if (!l.contains(id)) {
 443                         return -1;
 444                 }
 445                 l.remove(id);
 446                 // node.add(id);
 447                 return updateChildrenNT(node, Node.concatChildren(l));
 448         }
 449
 450         /*
 451          * (non-Javadoc)
 452          *
 453          * @see com.yuji.ef.dao.NodeDao#updateStatus(com.yuji.ef.dao.Node,
 454          * com.yuji.ef.dao.Node.Status)
 455          */
 456         @Override
 457         public long updateStatus(Node node, Node.Status status) {
 458                 return updateStatus(DatabaseHelper.getInstance().getSQLiteDatabase(),
 459                                 node, status);
 460         }
 461
 462         /*
 463          * (non-Javadoc)
 464          *
 465          * @see
 466          * com.yuji.ef.dao.NodeDao#updateStatus(android.database.sqlite.SQLiteDatabase
 467          * , com.yuji.ef.dao.Node, com.yuji.ef.dao.Node.Status)
 468          */
 469         @Override
 470         public long updateStatus(SQLiteDatabase db, Node node, Node.Status status) {
 471                 long id = -1;
 472
 473                 db.beginTransaction();
 474                 try {
 475                         id = updateStatusNT(node, status);
 476                         db.setTransactionSuccessful();
 477                 } finally {
 478                         db.endTransaction();
 479                 }
 480                 return id;
 481         }
 482
 483         /*
 484          * (non-Javadoc)
 485          *
 486          * @see com.yuji.ef.dao.NodeDao#updateStatusNT(com.yuji.ef.dao.Node,
 487          * com.yuji.ef.dao.Node.Status)
 488          */
 489         @Override
 490         public long updateStatusNT(Node node, Node.Status status) {
 491                 long id = -1;
 492                 int i = 1;
 493                 int code = Node.getStatusCode(status);
 494
 495                 SQLiteStatement stmt = updateStatusStmt;
 496                 stmt.bindLong(i++, code);
 497                 stmt.bindLong(i++, node.getId());
 498                 id = stmt.executeInsert();
 499                 return id;
 500         }
 501
 502         /*
 503          * (non-Javadoc)
 504          *
 505          * @see com.yuji.ef.dao.NodeDao#updateName(com.yuji.ef.dao.Node,
 506          * java.lang.String)
 507          */
 508         @Override
 509         public long updateName(Node node, String name) {
 510                 return updateName(DatabaseHelper.getInstance().getSQLiteDatabase(),
 511                                 node, name);
 512         }
 513
 514         /*
 515          * (non-Javadoc)
 516          *
 517          * @see
 518          * com.yuji.ef.dao.NodeDao#updateName(android.database.sqlite.SQLiteDatabase
 519          * , com.yuji.ef.dao.Node, java.lang.String)
 520          */
 521         @Override
 522         public long updateName(SQLiteDatabase db, Node node, String name) {
 523                 long id = -1;
 524
 525                 db.beginTransaction();
 526                 try {
 527                         id = updateNameNT(node, name);
 528                         db.setTransactionSuccessful();
 529                 } finally {
 530                         db.endTransaction();
 531                 }
 532                 return id;
 533         }
 534
 535         /*
 536          * (non-Javadoc)
 537          *
 538          * @see com.yuji.ef.dao.NodeDao#updateNameNT(com.yuji.ef.dao.Node,
 539          * java.lang.String)
 540          */
 541         @Override
 542         public long updateNameNT(Node node, String name) {
 543                 long id = -1;
 544                 int i = 1;
 545
 546                 SQLiteStatement stmt = updateNameStmt;
 547                 stmt.bindString(i++, name);
 548                 stmt.bindLong(i++, node.getId());
 549                 id = stmt.executeInsert();
 550                 return id;
 551         }
 552
 553         @Override
 554         public long updateGuid(Node node, String guid) {
 555                 return updateGuid(DatabaseHelper.getInstance().getSQLiteDatabase(),
 556                                 node, guid);
 557         }
 558
 559         @Override
 560         public long updateGuid(SQLiteDatabase db, Node node, String guid) {
 561                 long id = -1;
 562
 563                 db.beginTransaction();
 564                 try {
 565                         id = updateGuid(node, guid);
 566                         db.setTransactionSuccessful();
 567                 } finally {
 568                         db.endTransaction();
 569                 }
 570                 return id;
 571         }
 572
 573         @Override
 574         public long updateGuidNT(Node node, String guid) {
 575                 long id = -1;
 576                 int i = 1;
 577
 578                 SQLiteStatement stmt = updateGuidStmt;
 579                 if (CommonUtil.isNull(guid)) {
 580                         stmt.bindNull(i++);
 581                         stmt.bindLong(i++, (node instanceof FileNode) ? Node.TYPE_NOTE
 582                                         : Node.TYPE_DIR);
 583                 } else {
 584                         stmt.bindString(i++, guid);
 585                         stmt.bindLong(i++, (node instanceof FileNode) ? Node.TYPE_NOTE
 586                                         : Node.TYPE_BOOK);
 587                 }
 588                 stmt.bindLong(i++, node.getId());
 589                 id = stmt.executeInsert();
 590                 return id;
 591         }
 592
 593         @Override
 594         public long updateSelected(Node node, boolean isSelected) {
 595                 return updateSelected(DatabaseHelper.getInstance().getSQLiteDatabase(),
 596                                 node, isSelected);
 597         }
 598
 599         @Override
 600         public long updateSelected(SQLiteDatabase db, Node node, boolean isSelected) {
 601                 long id = -1;
 602
 603                 db.beginTransaction();
 604                 try {
 605                         id = updateSelectedNT(node, isSelected);
 606                         db.setTransactionSuccessful();
 607                 } finally {
 608                         db.endTransaction();
 609                 }
 610                 return id;
 611         }
 612
 613         @Override
 614         public long updateSelectedNT(Node node, boolean isSelected) {
 615                 long id = -1;
 616                 int i = 1;
 617
 618                 SQLiteStatement stmt = updateSelectedStmt;
 619                 stmt.bindLong(i++, isSelected ? 1 : 0);
 620                 stmt.bindLong(i++, node.getId());
 621                 id = stmt.executeInsert();
 622                 return id;
 623         }
 624
 625         /*
 626          * (non-Javadoc)
 627          *
 628          * @see com.yuji.ef.dao.NodeDao#updateParent(com.yuji.ef.dao.Node, long)
 629          */
 630         @Override
 631         public long updateParent(Node node, long parent) {
 632                 return updateParent(DatabaseHelper.getInstance().getSQLiteDatabase(),
 633                                 node, parent);
 634         }
 635
 636         /*
 637          * (non-Javadoc)
 638          *
 639          * @see
 640          * com.yuji.ef.dao.NodeDao#updateParent(android.database.sqlite.SQLiteDatabase
 641          * , com.yuji.ef.dao.Node, long)
 642          */
 643         @Override
 644         public long updateParent(SQLiteDatabase db, Node node, long parent) {
 645                 long id = -1;
 646
 647                 db.beginTransaction();
 648                 try {
 649                         id = updateParentNT(node, parent);
 650                         db.setTransactionSuccessful();
 651                 } finally {
 652                         db.endTransaction();
 653                 }
 654                 return id;
 655         }
 656
 657         /*
 658          * (non-Javadoc)
 659          *
 660          * @see com.yuji.ef.dao.NodeDao#updateParentNT(com.yuji.ef.dao.Node, long)
 661          */
 662         @Override
 663         public long updateParentNT(Node node, long parent) {
 664                 long id = -1;
 665                 int i = 1;
 666
 667                 SQLiteStatement stmt = updateParentStmt;
 668                 stmt.bindLong(i++, parent);
 669                 stmt.bindLong(i++, node.getId());
 670                 id = stmt.executeInsert();
 671                 return id;
 672         }
 673
 674         @Override
 675         public long updateNoteFlag(int flag) {
 676                 return updateNoteFlag(DatabaseHelper.getInstance().getSQLiteDatabase(),
 677                                 flag);
 678         }
 679
 680         @Override
 681         public long updateNoteFlag(SQLiteDatabase db, int flag) {
 682                 long id = -1;
 683
 684                 db.beginTransaction();
 685                 try {
 686                         id = updateNoteFlagNT(flag);
 687                         db.setTransactionSuccessful();
 688                 } finally {
 689                         db.endTransaction();
 690                 }
 691                 return id;
 692         }
 693
 694         @Override
 695         public long updateNoteFlagNT(int flag) {
 696                 long id = -1;
 697                 int i = 1;
 698
 699                 SQLiteStatement stmt = updateNoteFlagStmt;
 700                 stmt.bindLong(i++, flag);
 701                 stmt.bindLong(i++, Node.TYPE_NOTE);
 702                 id = stmt.executeInsert();
 703                 return id;
 704         }
 705
 706         @Override
 707         public long updateFlag(Node node, int flag) {
 708                 return updateFlag(DatabaseHelper.getInstance().getSQLiteDatabase(),
 709                                 node, flag);
 710         }
 711
 712         @Override
 713         public long updateFlag(SQLiteDatabase db, Node node, int flag) {
 714                 long id = -1;
 715
 716                 db.beginTransaction();
 717                 try {
 718                         id = updateFlagNT(node, flag);
 719                         db.setTransactionSuccessful();
 720                 } finally {
 721                         db.endTransaction();
 722                 }
 723                 return id;
 724         }
 725
 726         @Override
 727         public long updateFlagNT(Node node, int flag) {
 728                 long id = -1;
 729                 int i = 1;
 730
 731                 SQLiteStatement stmt = updateFlagStmt;
 732                 stmt.bindLong(i++, flag);
 733                 stmt.bindLong(i++, node.getId());
 734                 id = stmt.executeInsert();
 735                 return id;
 736         }
 737
 738         /*
 739          * (non-Javadoc)
 740          *
 741          * @see com.yuji.ef.dao.NodeDao#updateChildren(com.yuji.ef.dao.Node,
 742          * java.lang.String)
 743          */
 744         @Override
 745         public long updateChildren(Node node, String children) {
 746                 DatabaseHelper helper = DatabaseHelper.getInstance();
 747                 SQLiteDatabase db = helper.getWritableDatabase();
 748                 return updateChildren(db, node, children);
 749         }
 750
 751         private long updateChildren(SQLiteDatabase db, Node node, String children) {
 752                 long id = -1;
 753                 db.beginTransaction();
 754                 try {
 755                         id = updateChildrenNT(node, children);
 756                         db.setTransactionSuccessful();
 757                 } finally {
 758                         db.endTransaction();
 759                 }
 760                 return id;
 761         }
 762
 763         /*
 764          * (non-Javadoc)
 765          *
 766          * @see com.yuji.ef.dao.NodeDao#delete(long)
 767          */
 768         @Override
 769         public long delete(long id) {
 770                 DatabaseHelper helper = DatabaseHelper.getInstance();
 771                 SQLiteDatabase db = helper.getWritableDatabase();
 772                 return delete(db, id);
 773         }
 774
 775         /*
 776          * (non-Javadoc)
 777          *
 778          * @see
 779          * com.yuji.ef.dao.NodeDao#delete(android.database.sqlite.SQLiteDatabase,
 780          * long)
 781          */
 782         @Override
 783         public long delete(SQLiteDatabase db, long did) {
 784                 long id = -1;
 785
 786                 db.beginTransaction();
 787                 try {
 788                         id = deleteNT(did);
 789                         db.setTransactionSuccessful();
 790                 } finally {
 791                         db.endTransaction();
 792                 }
 793                 return id;
 794         }
 795
 796         /*
 797          * (non-Javadoc)
 798          *
 799          * @see com.yuji.ef.dao.NodeDao#deleteNT(long)
 800          */
 801         @Override
 802         public long deleteNT(long did) {
 803                 long id = -1; // TODO
 804                 int i = 1;
 805
 806                 SQLiteStatement stmt = deleteIdStmt;
 807                 stmt.bindLong(i++, did);
 808                 stmt.execute();
 809                 return id;
 810         }
 811
 812         /*
 813          * (non-Javadoc)
 814          *
 815          * @see com.yuji.ef.dao.NodeDao#delete()
 816          */
 817         @Override
 818         public long delete() {
 819                 DatabaseHelper helper = DatabaseHelper.getInstance();
 820                 SQLiteDatabase db = helper.getWritableDatabase();
 821                 return delete(db);
 822         }
 823
 824         /*
 825          * (non-Javadoc)
 826          *
 827          * @see
 828          * com.yuji.ef.dao.NodeDao#delete(android.database.sqlite.SQLiteDatabase)
 829          */
 830         @Override
 831         public long delete(SQLiteDatabase db) {
 832                 long id = -1;
 833
 834                 db.beginTransaction();
 835                 try {
 836                         deleteNT();
 837                         db.setTransactionSuccessful();
 838                 } finally {
 839                         db.endTransaction();
 840                 }
 841                 return id;
 842         }
 843
 844         /*
 845          * (non-Javadoc)
 846          *
 847          * @see com.yuji.ef.dao.NodeDao#deleteNT()
 848          */
 849         @Override
 850         public void deleteNT() {
 851                 SQLiteStatement stmt = deleteStmt;
 852                 stmt.execute();
 853         }
 854 }