private void insertRawContact(Cursor c, SQLiteStatement insert) {
    long id = c.getLong(PeopleQuery._ID);
    insert.bindLong(RawContactsInsert.ID, id);
    insert.bindLong(RawContactsInsert.CONTACT_ID, id);
    bindString(insert, RawContactsInsert.CUSTOM_RINGTONE, c.getString(PeopleQuery.CUSTOM_RINGTONE));
    bindString(insert, RawContactsInsert.DIRTY, c.getString(PeopleQuery._SYNC_DIRTY));
    insert.bindLong(
        RawContactsInsert.LAST_TIME_CONTACTED, c.getLong(PeopleQuery.LAST_TIME_CONTACTED));
    insert.bindLong(RawContactsInsert.SEND_TO_VOICEMAIL, c.getLong(PeopleQuery.SEND_TO_VOICEMAIL));
    insert.bindLong(RawContactsInsert.STARRED, c.getLong(PeopleQuery.STARRED));
    insert.bindLong(RawContactsInsert.TIMES_CONTACTED, c.getLong(PeopleQuery.TIMES_CONTACTED));
    bindString(insert, RawContactsInsert.SYNC1, c.getString(PeopleQuery._SYNC_TIME));
    bindString(insert, RawContactsInsert.SYNC2, c.getString(PeopleQuery._SYNC_LOCAL_ID));
    bindString(insert, RawContactsInsert.DISPLAY_NAME, c.getString(PeopleQuery.NAME));

    String account = c.getString(PeopleQuery._SYNC_ACCOUNT);
    if (!TextUtils.isEmpty(account)) {
      bindString(insert, RawContactsInsert.ACCOUNT_NAME, account);
      bindString(insert, RawContactsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
      bindString(insert, RawContactsInsert.SOURCE_ID, c.getString(PeopleQuery._SYNC_ID));
    } else {
      insert.bindNull(RawContactsInsert.ACCOUNT_NAME);
      insert.bindNull(RawContactsInsert.ACCOUNT_TYPE);
      insert.bindNull(RawContactsInsert.SOURCE_ID);
    }
    insert(insert);
  }
 private long getTagId(Tag tag) {
   if (myGetTagIdStatement == null) {
     myGetTagIdStatement =
         myDatabase.compileStatement("SELECT tag_id FROM Tags WHERE parent_id = ? AND name = ?");
     myCreateTagIdStatement =
         myDatabase.compileStatement("INSERT OR IGNORE INTO Tags (parent_id,name) VALUES (?,?)");
   }
   {
     final Long id = myIdByTag.get(tag);
     if (id != null) {
       return id;
     }
   }
   if (tag.Parent != null) {
     myGetTagIdStatement.bindLong(1, getTagId(tag.Parent));
   } else {
     myGetTagIdStatement.bindNull(1);
   }
   myGetTagIdStatement.bindString(2, tag.Name);
   long id;
   try {
     id = myGetTagIdStatement.simpleQueryForLong();
   } catch (SQLException e) {
     if (tag.Parent != null) {
       myCreateTagIdStatement.bindLong(1, getTagId(tag.Parent));
     } else {
       myCreateTagIdStatement.bindNull(1);
     }
     myCreateTagIdStatement.bindString(2, tag.Name);
     id = myCreateTagIdStatement.executeInsert();
   }
   myIdByTag.put(tag, id);
   myTagById.put(id, tag);
   return id;
 }
 private void bindLong(SQLiteStatement stmt, int index, Number value) {
   if (value == null) {
     stmt.bindNull(index);
   } else {
     stmt.bindLong(index, value.longValue());
   }
 }
 private void bindString(SQLiteStatement stmt, int index, String value) {
   if (value == null) {
     stmt.bindNull(index);
   } else {
     stmt.bindString(index, value);
   }
 }
Пример #5
0
 private void bindStringOrNull(SQLiteStatement statement, int index, String str) {
   if (str == null) {
     statement.bindNull(index);
   } else {
     statement.bindString(index, str);
   }
 }
 private void bindString(SQLiteStatement insert, int index, String string) {
   if (string == null) {
     insert.bindNull(index);
   } else {
     insert.bindString(index, string);
   }
 }
Пример #7
0
 /**
  * 绑定参数 Author: hyl Time: 2015-8-17上午10:42:43
  *
  * @param statement
  * @param position
  * @param args
  */
 private void bindArgs(SQLiteStatement statement, int position, Object args) {
   int type = FieldTypeManager.getValueType(args);
   switch (type) {
     case FieldTypeManager.VALUE_TYPE_NULL:
       statement.bindNull(position);
       break;
     case FieldTypeManager.BASE_TYPE_BYTE_ARRAY:
       statement.bindBlob(position, (byte[]) args);
       break;
     case FieldTypeManager.BASE_TYPE_CHAR:
     case FieldTypeManager.BASE_TYPE_STRING:
       statement.bindString(position, args.toString());
       break;
     case FieldTypeManager.BASE_TYPE_DATE:
       statement.bindString(position, DateUtil.formatDatetime((Date) args));
       break;
     case FieldTypeManager.BASE_TYPE_DOUBLE:
     case FieldTypeManager.BASE_TYPE_FLOAT:
       statement.bindDouble(position, Double.parseDouble(args.toString()));
       break;
     case FieldTypeManager.BASE_TYPE_INT:
     case FieldTypeManager.BASE_TYPE_LONG:
     case FieldTypeManager.BASE_TYPE_SHORT:
       statement.bindLong(position, Long.parseLong(args.toString()));
       break;
     case FieldTypeManager.NOT_BASE_TYPE:
       throw new IllegalArgumentException("未知参数类型,请检查绑定参数");
   }
 }
 private static void addEncryptedStringToStatement(
     Context context,
     SQLiteStatement statement,
     Cursor cursor,
     MasterSecret masterSecret,
     int index,
     String key) {
   int columnIndex = cursor.getColumnIndexOrThrow(key);
   if (cursor.isNull(columnIndex)) statement.bindNull(index);
   else
     statement.bindString(
         index, encryptIfNecessary(context, masterSecret, cursor.getString(columnIndex)));
 }
  private void insertGroup(Cursor c, SQLiteStatement insert) {
    long id = c.getLong(GroupsQuery.ID);

    insert.bindLong(GroupsInsert.ID, id);
    bindString(insert, GroupsInsert.TITLE, c.getString(GroupsQuery.NAME));
    bindString(insert, GroupsInsert.NOTES, c.getString(GroupsQuery.NOTES));
    bindString(insert, GroupsInsert.SYSTEM_ID, c.getString(GroupsQuery.SYSTEM_ID));
    insert.bindLong(GroupsInsert.DIRTY, c.getLong(GroupsQuery._SYNC_DIRTY));
    insert.bindLong(GroupsInsert.GROUP_VISIBLE, 1);

    String account = c.getString(GroupsQuery._SYNC_ACCOUNT);
    if (!TextUtils.isEmpty(account)) {
      bindString(insert, GroupsInsert.ACCOUNT_NAME, account);
      bindString(insert, GroupsInsert.ACCOUNT_TYPE, DEFAULT_ACCOUNT_TYPE);
      bindString(insert, GroupsInsert.SOURCE_ID, c.getString(GroupsQuery._SYNC_ID));
    } else {
      insert.bindNull(GroupsInsert.ACCOUNT_NAME);
      insert.bindNull(GroupsInsert.ACCOUNT_TYPE);
      insert.bindNull(GroupsInsert.SOURCE_ID);
    }
    insert(insert);
  }
 protected void saveFileInfo(FileInfo fileInfo) {
   final long id = fileInfo.Id;
   SQLiteStatement statement;
   if (id == -1) {
     if (myInsertFileInfoStatement == null) {
       myInsertFileInfoStatement =
           myDatabase.compileStatement(
               "INSERT OR IGNORE INTO Files (name,parent_id,size) VALUES (?,?,?)");
     }
     statement = myInsertFileInfoStatement;
   } else {
     if (myUpdateFileInfoStatement == null) {
       myUpdateFileInfoStatement =
           myDatabase.compileStatement(
               "UPDATE Files SET name = ?, parent_id = ?, size = ? WHERE file_id = ?");
     }
     statement = myUpdateFileInfoStatement;
   }
   statement.bindString(1, fileInfo.Name);
   final FileInfo parent = fileInfo.Parent;
   if (parent != null) {
     statement.bindLong(2, parent.Id);
   } else {
     statement.bindNull(2);
   }
   final long size = fileInfo.FileSize;
   if (size != -1) {
     statement.bindLong(3, size);
   } else {
     statement.bindNull(3);
   }
   if (id == -1) {
     fileInfo.Id = statement.executeInsert();
   } else {
     statement.bindLong(4, id);
     statement.execute();
   }
 }
 private void bindArgs(SQLiteStatement stmt, Object[] args, FieldType[] argFieldTypes)
     throws SQLException {
   if (args == null) {
     return;
   }
   for (int i = 0; i < args.length; i++) {
     Object arg = args[i];
     if (arg == null) {
       stmt.bindNull(i + 1);
     } else {
       SqlType sqlType = argFieldTypes[i].getSqlType();
       switch (sqlType) {
         case STRING:
         case LONG_STRING:
         case CHAR:
           stmt.bindString(i + 1, arg.toString());
           break;
         case BOOLEAN:
         case BYTE:
         case SHORT:
         case INTEGER:
         case LONG:
           stmt.bindLong(i + 1, ((Number) arg).longValue());
           break;
         case FLOAT:
         case DOUBLE:
           stmt.bindDouble(i + 1, ((Number) arg).doubleValue());
           break;
         case BYTE_ARRAY:
         case SERIALIZABLE:
           stmt.bindBlob(i + 1, (byte[]) arg);
           break;
         case DATE:
           // this is mapped to a STRING under Android
         case BLOB:
           // this is only for derby serializable
         case BIG_DECIMAL:
           // this should be handled as a STRING
           throw new SQLException("Invalid Android type: " + sqlType);
         case UNKNOWN:
         default:
           throw new SQLException("Unknown sql argument type: " + sqlType);
       }
     }
   }
 }
Пример #12
0
  private void insertPhoto(Cursor c, SQLiteStatement insert, SQLiteStatement photoIdUpdate) {
    if (c.isNull(PhotosQuery.DATA)) {
      return;
    }

    long personId = c.getLong(PhotosQuery.PERSON);

    insert.bindLong(PhotoInsert.RAW_CONTACT_ID, personId);
    insert.bindLong(PhotoInsert.MIMETYPE_ID, mPhotoMimetypeId);
    insert.bindBlob(PhotoInsert.PHOTO, c.getBlob(PhotosQuery.DATA));

    String account = c.getString(PhotosQuery._SYNC_ACCOUNT);
    if (!TextUtils.isEmpty(account)) {
      insert.bindString(PhotoInsert.SYNC1, c.getString(PhotosQuery._SYNC_ID));
    } else {
      insert.bindNull(PhotoInsert.SYNC1);
    }

    long rowId = insert(insert);
    photoIdUpdate.bindLong(PhotoIdUpdate.PHOTO_ID, rowId);
    photoIdUpdate.bindLong(PhotoIdUpdate.CONTACT_ID, personId);
    photoIdUpdate.execute();
  }
Пример #13
0
  /** 数据绑定 * */
  private void bindValues(SQLiteStatement stmt, T entity) {
    for (int i = 0; i < mSetArgs.length; i++) {
      int stmtIndex = i + 1;
      try {
        Field field = mClazz.getDeclaredField(mSetArgs[i]);
        field.setAccessible(true);

        Type columnType = field.getType();
        if (String.class.equals(columnType)) {
          String value = (String) field.get(entity);
          if (value == null) {
            stmt.bindNull(stmtIndex);
          } else {
            stmt.bindString(stmtIndex, value);
          }

        } else if (columnType.equals(Integer.class) || columnType.equals(int.class)) {
          int value = field.getInt(entity);
          stmt.bindLong(stmtIndex, value);

        } else if (columnType.equals(Float.class) || columnType.equals(float.class)) {
          float value = field.getFloat(entity);
          stmt.bindDouble(stmtIndex, value);

        } else if (columnType.equals(Double.class) || columnType.equals(double.class)) {
          double value = field.getDouble(entity);
          stmt.bindDouble(stmtIndex, value);

        } else if (columnType.equals(Long.class) || columnType.equals(long.class)) {
          long value = field.getLong(entity);
          stmt.bindLong(stmtIndex, value);

        } else {
          Object obj = field.get(entity);
          if (obj == null) {
            stmt.bindNull(stmtIndex);
          } else {
            byte[] value = SerializeHelper.serialize(obj);
            stmt.bindBlob(stmtIndex, value);
          }
        }

      } catch (NoSuchFieldException e) {
        e.printStackTrace();
        stmt.bindNull(stmtIndex);
        continue;
      } catch (IllegalAccessException e) {
        e.printStackTrace();
        stmt.bindNull(stmtIndex);
        continue;
      } catch (IllegalArgumentException e) {
        e.printStackTrace();
        stmt.bindNull(stmtIndex);
        continue;
      }
    }

    if (mWhereArgs != null) {
      for (int i = 0; i < mWhereArgs.length; i++) {
        int columnIndex = mSetArgs.length + i + 1;
        stmt.bindString(columnIndex, mWhereArgValues[i]);
      }
    }
  }
 private static void addIntToStatement(
     SQLiteStatement statement, Cursor cursor, int index, String key) {
   int columnIndex = cursor.getColumnIndexOrThrow(key);
   if (cursor.isNull(columnIndex)) statement.bindNull(index);
   else statement.bindLong(index, cursor.getLong(columnIndex));
 }
  /**
   * Executes a batch request and sends the results via sendJavascriptCB().
   *
   * @param dbname The name of the database.
   * @param queryarr Array of query strings
   * @param jsonparams Array of JSON query parameters
   * @param queryIDs Array of query ids
   * @param cbc Callback context from Cordova API
   */
  private void executeSqlBatch(
      String dbname,
      String[] queryarr,
      JSONArray[] jsonparams,
      String[] queryIDs,
      CallbackContext cbc) {
    SQLiteDatabase mydb = this.getDatabase(dbname);

    if (mydb == null) return;

    String query = "";
    String query_id = "";
    int len = queryarr.length;

    JSONArray batchResults = new JSONArray();

    for (int i = 0; i < len; i++) {
      query_id = queryIDs[i];

      JSONObject queryResult = null;
      String errorMessage = "unknown";

      try {
        boolean needRawQuery = true;

        query = queryarr[i];

        // UPDATE or DELETE:
        // NOTE: this code should be safe to RUN with old Android SDK.
        // To BUILD with old Android SDK remove lines from HERE: {{
        if (android.os.Build.VERSION.SDK_INT >= 11
            && (query.toLowerCase().startsWith("update")
                || query.toLowerCase().startsWith("delete"))) {
          SQLiteStatement myStatement = mydb.compileStatement(query);

          if (jsonparams != null) {
            for (int j = 0; j < jsonparams[i].length(); j++) {
              if (jsonparams[i].get(j) instanceof Float || jsonparams[i].get(j) instanceof Double) {
                myStatement.bindDouble(j + 1, jsonparams[i].getDouble(j));
              } else if (jsonparams[i].get(j) instanceof Number) {
                myStatement.bindLong(j + 1, jsonparams[i].getLong(j));
              } else if (jsonparams[i].isNull(j)) {
                myStatement.bindNull(j + 1);
              } else {
                myStatement.bindString(j + 1, jsonparams[i].getString(j));
              }
            }
          }

          int rowsAffected = -1; // (assuming invalid)

          // Use try & catch just in case android.os.Build.VERSION.SDK_INT >= 11 is lying:
          try {
            rowsAffected = myStatement.executeUpdateDelete();
            // Indicate valid results:
            needRawQuery = false;
          } catch (SQLiteException ex) {
            // Indicate problem & stop this query:
            ex.printStackTrace();
            errorMessage = ex.getMessage();
            Log.v(
                "executeSqlBatch", "SQLiteStatement.executeUpdateDelete(): Error=" + errorMessage);
            needRawQuery = false;
          } catch (Exception ex) {
            // Assuming SDK_INT was lying & method not found:
            // do nothing here & try again with raw query.
          }

          if (rowsAffected != -1) {
            queryResult = new JSONObject();
            queryResult.put("rowsAffected", rowsAffected);
          }
        } // to HERE. }}

        // INSERT:
        if (query.toLowerCase().startsWith("insert") && jsonparams != null) {
          needRawQuery = false;

          SQLiteStatement myStatement = mydb.compileStatement(query);

          for (int j = 0; j < jsonparams[i].length(); j++) {
            if (jsonparams[i].get(j) instanceof Float || jsonparams[i].get(j) instanceof Double) {
              myStatement.bindDouble(j + 1, jsonparams[i].getDouble(j));
            } else if (jsonparams[i].get(j) instanceof Number) {
              myStatement.bindLong(j + 1, jsonparams[i].getLong(j));
            } else if (jsonparams[i].isNull(j)) {
              myStatement.bindNull(j + 1);
            } else {
              myStatement.bindString(j + 1, jsonparams[i].getString(j));
            }
          }

          long insertId = -1; // (invalid)

          try {
            insertId = myStatement.executeInsert();
          } catch (SQLiteException ex) {
            ex.printStackTrace();
            errorMessage = ex.getMessage();
            Log.v("executeSqlBatch", "SQLiteDatabase.executeInsert(): Error=" + errorMessage);
          }

          if (insertId != -1) {
            queryResult = new JSONObject();
            queryResult.put("insertId", insertId);
            queryResult.put("rowsAffected", 1);
          }
        }

        if (query.toLowerCase().startsWith("begin")) {
          needRawQuery = false;
          try {
            mydb.beginTransaction();

            queryResult = new JSONObject();
            queryResult.put("rowsAffected", 0);
          } catch (SQLiteException ex) {
            ex.printStackTrace();
            errorMessage = ex.getMessage();
            Log.v("executeSqlBatch", "SQLiteDatabase.beginTransaction(): Error=" + errorMessage);
          }
        }

        if (query.toLowerCase().startsWith("commit")) {
          needRawQuery = false;
          try {
            mydb.setTransactionSuccessful();
            mydb.endTransaction();

            queryResult = new JSONObject();
            queryResult.put("rowsAffected", 0);
          } catch (SQLiteException ex) {
            ex.printStackTrace();
            errorMessage = ex.getMessage();
            Log.v(
                "executeSqlBatch",
                "SQLiteDatabase.setTransactionSuccessful/endTransaction(): Error=" + errorMessage);
          }
        }

        if (query.toLowerCase().startsWith("rollback")) {
          needRawQuery = false;
          try {
            mydb.endTransaction();

            queryResult = new JSONObject();
            queryResult.put("rowsAffected", 0);
          } catch (SQLiteException ex) {
            ex.printStackTrace();
            errorMessage = ex.getMessage();
            Log.v("executeSqlBatch", "SQLiteDatabase.endTransaction(): Error=" + errorMessage);
          }
        }

        // raw query for other statements:
        if (needRawQuery) {
          String[] params = null;

          if (jsonparams != null) {
            params = new String[jsonparams[i].length()];

            for (int j = 0; j < jsonparams[i].length(); j++) {
              if (jsonparams[i].isNull(j)) params[j] = "";
              else params[j] = jsonparams[i].getString(j);
            }
          }

          Cursor myCursor = mydb.rawQuery(query, params);

          if (query_id.length() > 0) {
            queryResult = this.getRowsResultFromQuery(myCursor);
          }

          myCursor.close();
        }
      } catch (Exception ex) {
        ex.printStackTrace();
        errorMessage = ex.getMessage();
        Log.v("executeSqlBatch", "SQLitePlugin.executeSql[Batch](): Error=" + errorMessage);
      }

      try {
        if (queryResult != null) {
          JSONObject r = new JSONObject();
          r.put("qid", query_id);

          r.put("type", "success");
          r.put("result", queryResult);

          batchResults.put(r);
        } else {
          JSONObject r = new JSONObject();
          r.put("qid", query_id);
          r.put("type", "error");

          JSONObject er = new JSONObject();
          er.put("message", errorMessage);
          r.put("result", er);

          batchResults.put(r);
        }
      } catch (JSONException ex) {
        ex.printStackTrace();
        Log.v("executeSqlBatch", "SQLitePlugin.executeSql[Batch](): Error=" + ex.getMessage());
        // TODO what to do?
      }
    }

    cbc.success(batchResults);
  }