Java 类android.database.sqlite.SQLiteConstraintException 实例源码

private static final void readExceptionFromParcel(Parcel reply, String msg, int code) {
    switch (code) {
        case 2:
            throw new IllegalArgumentException(msg);
        case 3:
            throw new UnsupportedOperationException(msg);
        case 4:
            throw new SQLiteAbortException(msg);
        case 5:
            throw new SQLiteConstraintException(msg);
        case 6:
            throw new SQLiteDatabaseCorruptException(msg);
        case 7:
            throw new SQLiteFullException(msg);
        case 8:
            throw new SQLiteDiskIOException(msg);
        case 9:
            throw new SQLiteException(msg);
        case 11:
            throw new OperationCanceledException(msg);
        default:
            reply.readException(code, msg);
    }
}

@Nullable
@Override
public Uri insert(@NonNull Uri uri, ContentValues values) {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    MovieUriEnum matchingUriEnum = mUriMatcher.matchUri(uri);

    if (matchingUriEnum.table != null) {
        try {
            db.insertOrThrow(matchingUriEnum.table, null, values);
        } catch (SQLiteConstraintException e) {
            throw e;
        }
    }

    switch (matchingUriEnum) {
        case MOVIES:
            return Movies.buildMovieUri(values.getAsString(Movies.MOVIE_ID));
        case TVS:
            return TVs.buildTVUri(values.getAsString(TVs.TV_ID));
        case PERSONS:
            return Persons.buildPersonUri(values.getAsString(Persons.PERSON_ID));
        default:
            throw new UnsupportedOperationException("Unknown insert URI: " + uri);
    }
}

/**
 * Returns a Task (with Reminder and Attachments) given a taskId
 * @param taskId    The ID of the Task to get.
 */
public Task getTask(int taskId) throws CouldNotGetDataException, SQLiteConstraintException {
    SQLiteDatabase db = mDatabaseHelper.getReadableDatabase();
    Cursor cursor = db.query(RemindyContract.TaskTable.TABLE_NAME, null, RemindyContract.PlaceTable._ID + "=?",
            new String[]{String.valueOf(taskId)}, null, null, null);

    if (cursor.getCount() == 0)
        throw new CouldNotGetDataException("Specified Task not found in the database. Passed id=" + taskId);
    if (cursor.getCount() > 1)
        throw new SQLiteConstraintException("Database UNIQUE constraint failure, more than one record found. Passed value=" + taskId);

    cursor.moveToNext();
    Task task = getTaskFromCursor(cursor);
    task.setAttachments(getAttachmentsOfTask(taskId));

    if(task.getReminderType() != ReminderType.NONE)
        task.setReminder(getReminderOfTask(taskId, task.getReminderType()));
    return task;
}

public synchronized long insertEmoticonBean(EmoticonBean bean, String beanSetName) {
    SQLiteDatabase db = mOpenDbHelper.getWritableDatabase();
    long result = -1;
    if (bean == null || db == null) {
        return result;
    }
    ContentValues values = new ContentValues();
    values.put(TableColumns.EmoticonColumns.EVENT_TYPE, bean.getEventType());
    values.put(TableColumns.EmoticonColumns.TAG, bean.getTag());
    values.put(TableColumns.EmoticonColumns.NAME, bean.getName());
    values.put(TableColumns.EmoticonColumns.ICON_URI, bean.getIconUri());
    values.put(TableColumns.EmoticonColumns.MSG_URI, bean.getMsgUri());
    values.put(TableColumns.EmoticonColumns.EMOTICON_SET_NAME, beanSetName);
    try {
        result = db.insert(TABLE_NAME_EMOTICONS, null, values);
    } catch (SQLiteConstraintException e) {
        Log.e(TAG, "insert failed", e);
    }
    return result;
}

private static final void readExceptionFromParcel(Parcel reply, String msg, int code) {
    switch (code) {
        case 2:
            throw new IllegalArgumentException(msg);
        case 3:
            throw new UnsupportedOperationException(msg);
        case 4:
            throw new SQLiteAbortException(msg);
        case 5:
            throw new SQLiteConstraintException(msg);
        case 6:
            throw new SQLiteDatabaseCorruptException(msg);
        case 7:
            throw new SQLiteFullException(msg);
        case 8:
            throw new SQLiteDiskIOException(msg);
        case 9:
            throw new SQLiteException(msg);
        case 11:
            throw new OperationCanceledException(msg);
        default:
            reply.readException(code, msg);
    }
}

@Nullable
@Override
public Uri insert(@NonNull Uri uri, ContentValues values) {
    final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
    MovieUriEnum matchingUriEnum = mUriMatcher.matchUri(uri);

    if (matchingUriEnum.table != null) {
        try {
            db.insertOrThrow(matchingUriEnum.table, null, values);
        } catch (SQLiteConstraintException e) {
            throw e;
        }
    }

    switch (matchingUriEnum) {
        case MOVIES:
            return Movies.buildMovieUri(values.getAsString(Movies.MOVIE_ID));
        case TVS:
            return TVs.buildTVUri(values.getAsString(TVs.TV_ID));
        case PERSONS:
            return Persons.buildPersonUri(values.getAsString(Persons.PERSON_ID));
        default:
            throw new UnsupportedOperationException("Unknown insert URI: " + uri);
    }
}

public void addNewUser()
{
    User person = new User();
    person.setFirstname(getData(txtFirstname));
    person.setAge(getData(txtAge));
    person.setNic(getData(txtNIC));
    person.setSurname(getData(txtSurname));
    try {
        long f = user.insert(person);

        if (f > 0) {
            showToast("User added");
            clearAllTextData();
        }
        else
        {
            showToast("User not added");
        }
    }
    catch (SQLiteConstraintException e)
    {
        showToast("User with the same NFC id Exists");
    }
}

@MediumTest
public void testStatementConstraint() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (num INTEGER NOT NULL);");
    SQLiteStatement statement = mDatabase.compileStatement("INSERT INTO test (num) VALUES (?)");

    // Try to insert NULL, which violates the constraint
    try {
        statement.clearBindings();
        statement.execute();
        fail("expected exception not thrown");
    } catch (SQLiteConstraintException e) {
        // expected
    }

    // Make sure the statement can still be used
    statement.bindLong(1, 1);
    statement.execute();
    statement.close();

    Cursor c = mDatabase.query("test", null, null, null, null, null, null);
    int numCol = c.getColumnIndexOrThrow("num");
    c.moveToFirst();
    long num = c.getLong(numCol);
    assertEquals(1, num);
    c.close();
}

@MediumTest
public void testStatementConstraint() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (num INTEGER NOT NULL);");
    SQLiteStatement statement = mDatabase.compileStatement("INSERT INTO test (num) VALUES (?)");

    // Try to insert NULL, which violates the constraint
    try {
        statement.clearBindings();
        statement.execute();
        fail("expected exception not thrown");
    } catch (SQLiteConstraintException e) {
        // expected
    }

    // Make sure the statement can still be used
    statement.bindLong(1, 1);
    statement.execute();
    statement.close();

    Cursor c = mDatabase.query("test", null, null, null, null, null, null);
    int numCol = c.getColumnIndexOrThrow("num");
    c.moveToFirst();
    long num = c.getLong(numCol);
    assertEquals(1, num);
    c.close();
}

public boolean insertAchievementExplorer(final Context preferenceContext, String email, int idAchievement) {
    try{
        setAction(false);
        AchievementExplorerRequest achievementExplorerRequest = new AchievementExplorerRequest(email, idAchievement);
        achievementExplorerRequest.requestUpdateAchievements(preferenceContext, new AchievementExplorerRequest.Callback() {
            @Override
            public void callbackResponse(boolean response) {
                setResponse(true);
                setAction(true);
            }

            @Override
            public void callbackResponse(List<Achievement> achievements) {}
        });
    }catch(SQLiteConstraintException exception){
        exception.printStackTrace();
    }

    return true;
}

public boolean insertExplorerElement(final Context preferenceContext, String email, int idElement, String userImage, String catchDate) {
    try{
        setAction(false);
        ElementExplorerRequest elementExplorerRequest = new ElementExplorerRequest(email,idElement,userImage,catchDate);
        elementExplorerRequest.requestUpdateElements(preferenceContext, new ElementExplorerRequest.Callback() {
            @Override
            public void callbackResponse(boolean response) {
                setResponse(true);
                setAction(true);
            }
            MainController mainController = new MainController();

            @Override
            public void callbackResponse(List<Element> elements) {}
        });
    }catch(SQLiteConstraintException exception){
        throw exception;
    }

    return true;
}

public static boolean insert(DBHelper dbHelper, NewGankData.Results data) {
    SQLiteDatabase db = dbHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        ContentValues values = new ContentValues();
        values.put(Constants.DB_ITEM_DESC, data.getDesc());
        values.put(Constants.DB_ITEM_TYPE, data.getType());
        values.put(Constants.DB_ITEM_URL, data.getUrl());
        db.insert(Constants.DB_TABLE_NAME, null, values);
        db.setTransactionSuccessful();
        return true;
    } catch (SQLiteConstraintException e) {
        LogUtils.e("DBTools -> insert", "insert data error");
        return false;
    } finally {
        db.endTransaction();
    }
}

/**
 * Add a new UserDevice.
 *
 * @param userDevice The new UserDevice.
 */
public void addUserDevice(UserDevice userDevice) throws DatabaseControllerException {
    try {
        databaseConnector.executeSql("insert into "
                        + DatabaseContract.UserDevice.TABLE_NAME
                        + " (" + DatabaseContract.UserDevice.COLUMN_NAME + ","
                        + DatabaseContract.UserDevice.COLUMN_FINGERPRINT + ","
                        + DatabaseContract.UserDevice.COLUMN_GROUP_ID + ") values (?, ?,("
                        + DatabaseContract.SqlQueries.GROUP_ID_FROM_NAME_SQL_QUERY + "))",
                new String[]{userDevice.getName(), userDevice.getUserDeviceID().getIDString(),
                        userDevice.getInGroup()});
    } catch (SQLiteConstraintException sqlce) {
        throw new DatabaseControllerException(
                "Either the given Group does not exist in the database"
                        + " or a UserDevice already has the given name or fingerprint.", sqlce);
    }
}

/**
 * Add a new action to the database.
 *
 * @param action     Action to be added to the database.
 * @param moduleName Module where the action occurs.
 * @param timestamp  The timestamp of the action.
 */
public void addHolidayLogEntry(String action, String moduleName, long timestamp) throws UnknownReferenceException {
    if (Strings.isNullOrEmpty(moduleName)) {
        databaseConnector.executeSql(
                "insert into " + DatabaseContract.HolidayLog.TABLE_NAME
                        + " (" + DatabaseContract.HolidayLog.COLUMN_ACTION
                        + ", " + DatabaseContract.HolidayLog.COLUMN_TIMESTAMP + ") values (?, ?)",
                new String[]{action, String.valueOf(timestamp)}
        );
    } else {
        try {
            databaseConnector.executeSql(
                    "insert into " + DatabaseContract.HolidayLog.TABLE_NAME
                            + " (" + DatabaseContract.HolidayLog.COLUMN_ACTION
                            + ", " + DatabaseContract.HolidayLog.COLUMN_ELECTRONIC_MODULE_ID
                            + ", " + DatabaseContract.HolidayLog.COLUMN_TIMESTAMP + ") values (?,("
                            + DatabaseContract.SqlQueries.MODULE_ID_FROM_NAME_SQL_QUERY + "),?)",
                    new String[]{action, moduleName, String.valueOf(timestamp)}
            );
        } catch (SQLiteConstraintException sqlce) {
            throw new UnknownReferenceException("The given module doesn't exist.", sqlce);
        }
    }
}

/**
 * Add a new Module.
 *
 * @param module Module to add.
 */
public void addModule(Module module) throws DatabaseControllerException {
    try {
        //Notice: Changed order of values to avoid having to concat twice!
        databaseConnector.executeSql("insert into "
                        + DatabaseContract.ElectronicModule.TABLE_NAME + " ("
                        + DatabaseContract.ElectronicModule.COLUMN_GPIO_PIN + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_USB_PORT + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_WLAN_PORT + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_WLAN_USERNAME + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_WLAN_PASSWORD + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_WLAN_IP + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_MODULE_TYPE + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_CONNECTOR_TYPE + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_SLAVE_ID + ", "
                        + DatabaseContract.ElectronicModule.COLUMN_NAME + ") values "
                        + "(?, ?, ?, ?, ?, ?, ?, ?, (" + DatabaseContract.SqlQueries.SLAVE_ID_FROM_FINGERPRINT_SQL_QUERY + "), ?)",
                ObjectArrays.concat(
                        createCombinedModulesAccessInformationFromSingle(module.getModuleAccessPoint()),
                        new String[]{module.getModuleType().toString(), module.getModuleAccessPoint().getType(),
                                module.getAtSlave().getIDString(), module.getName()}, String.class));
    } catch (SQLiteConstraintException sqlce) {
        throw new DatabaseControllerException("The given Slave does not exist in the database"
                + " or the name is already used by another Module", sqlce);
    }
}

/**
 * Adds a new Permission to the database.
 *
 * @param permission Permission to add.
 * @param moduleName Module the permission applies for.
 */
public void addPermission(de.unipassau.isl.evs.ssh.core.sec.Permission permission,
                          String moduleName) throws DatabaseControllerException {
    try {
        if (Strings.isNullOrEmpty(moduleName)) {
            databaseConnector.executeSql("insert into "
                    + DatabaseContract.Permission.TABLE_NAME
                    + " (" + DatabaseContract.Permission.COLUMN_NAME + ")"
                    + " values (?)", new String[] { permission.toString() }
            );
        } else {
            databaseConnector.executeSql("insert into "
                            + DatabaseContract.Permission.TABLE_NAME
                            + " (" + DatabaseContract.Permission.COLUMN_NAME
                            + ", " + DatabaseContract.Permission.COLUMN_ELECTRONIC_MODULE_ID + ")"
                            + "values (?, (" + DatabaseContract.SqlQueries.MODULE_ID_FROM_NAME_SQL_QUERY + "))",
                    new String[] { permission.toString(), moduleName }
            );
        }
    } catch (SQLiteConstraintException sqlce) {
        throw new DatabaseControllerException("Either the name-module combination is already exists in the database"
                + " or the given module doesn't exist.", sqlce);
    }
}

@Test
public void testOnUpgradeWithColumnChangeToNotNull() throws Exception {
    getHelperInstance()
            .getReadableDatabase()
            .execSQL("CREATE TABLE testTable3 ("
                    + "    `xx` INTEGER PRIMARY KEY AUTOINCREMENT, "
                    + "    `str` TEXT,"
                    + "    `unique` UNIQUE,"
                    + "    `foreign` INTEGER,"
                    + "    FOREIGN KEY(`foreign`) REFERENCES test_table(`unique`)"
                    + ");"
            );

    SQLiteOperator<TestTable3> operator = SQLiteOperator.from(getContext(), TestTable3.class);
    TestTable3 t = new TestTable3();
    operator.save(t).executeBlocking();
    operator.delete(t).executeBlocking();
    getHelperInstance().onUpgrade(getHelperInstance().getWritableDatabase(), 1, 2);
    exception.expect(SQLiteConstraintException.class);
    operator.save(new TestTable3()).executeBlocking();
}

@Test
public void testOnUpgradeWithColumnChangeToUnique() throws Exception {
    getHelperInstance()
            .getReadableDatabase()
            .execSQL("CREATE TABLE testTable3 ("
                    + "    `xx` INTEGER PRIMARY KEY AUTOINCREMENT, "
                    + "    `str` TEXT,"
                    + "    `unique` TEXT,"
                    + "    `foreign` INTEGER,"
                    + "    FOREIGN KEY(`foreign`) REFERENCES test_table(`unique`)"
                    + ");"
            );

    SQLiteOperator<TestTable3> operator = SQLiteOperator.from(getContext(), TestTable3.class);
    getHelperInstance().onUpgrade(getHelperInstance().getWritableDatabase(), 1, 2);
    exception.expect(SQLiteConstraintException.class);
    TestTable3 t = new TestTable3();
    t.str = "not null";
    t.unique = "a";
    operator.save(t).executeBlocking();
    t = new TestTable3();
    t.str = "xxx";
    t.unique = "a";
    operator.save(t).executeBlocking();
}

/**
 * Inserts a new category into the database.
 * @param c the current context.
 * @param name the name of the category
 */
public static boolean addCategory(Context c, String name) {
    boolean success = true;
    DbOpenHelper dbHelper = new DbOpenHelper(c);
    SQLiteDatabase db = dbHelper.getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(CategoryEntry.COLUMN_NAME, name.trim());
    try {
        db.insertOrThrow(CategoryEntry.TABLE_NAME, null, values);
    } catch (SQLiteConstraintException e) {
        success = false;
    }
    db.close();
    return success;
}

/**
 * Insert a news feed into the database
 * @param newsFeed the news feed to add to the database
 * @param category the title of the category
 * @return true if the news feed was successfully inserted, false otherwise
 */
public boolean insertNewsFeed(NewsFeed newsFeed, String category) {
    SQLiteDatabase db = getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(DatabaseContract.NewsFeed.COLUMN_NAME_LABEL, newsFeed.getLabel());
    values.put(DatabaseContract.NewsFeed.COLUMN_NAME_LINK, newsFeed.getLink());
    values.put(DatabaseContract.NewsFeed.COLUMN_NAME_CATEGORY, category);
    try {
        db.insertWithOnConflict(DatabaseContract.NewsFeed.TABLE_NAME, null, values, SQLiteDatabase.CONFLICT_ABORT);
    } catch (SQLiteConstraintException e) {
        Log.d("DB", "Conflict on insertion");
        return false;
    }

    return true;
}

/**
 * Insert a news category into the database
 * @param newsCategory the news category to add to the database
 * @return true if the news category was successfully inserted, false otherwise
 */
public boolean insertNewsCategory(NewsCategory newsCategory) {
    SQLiteDatabase db = getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(DatabaseContract.NewsCategory.COLUMN_NAME_TITLE, newsCategory.getTitle());

    try {
        db.insertWithOnConflict(DatabaseContract.NewsCategory.TABLE_NAME, null, values, SQLiteDatabase
                .CONFLICT_ABORT);
    } catch (SQLiteConstraintException e) {
        Log.d("DB", "Conflict on insertion");
        return false;
    }

    for (NewsFeed newsFeed : newsCategory.getFeeds()) {
        insertNewsFeed(newsFeed, newsCategory.getTitle());
    }

    return true;
}

/**
 * Remove a news category from the database
 * @param newsCategory the news category to remove
 * @return true if the news category was successfully removed, false otherwise
 */
public boolean removeNewsCategory(NewsCategory newsCategory) {
    SQLiteDatabase db = getWritableDatabase();

    for (NewsFeed newsFeed : newsCategory.getFeeds()) {
        removeNewsFeed(newsFeed.getLabel());
    }

    try {
        db.delete(DatabaseContract.NewsCategory.TABLE_NAME, "title = ?", new String[]{newsCategory.getTitle()});
    } catch (SQLiteConstraintException e) {
        Log.d("DB", "Conflict on deletion");
        return false;
    }

    return true;
}

public void addDataStore(DataStore_Data Data) {
    SQLiteDatabase db = this.getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(KEY_ID, Data.getID()); // Data ID
    values.put(KEY_DEVID, Data.getDevID()); // Device ID
    values.put(KEY_ADDRESS, Data.getAddress()); // Data Address
    values.put(KEY_FUNC, Data.getFunction()); // Data Function
    values.put(KEY_STATUS, Data.getStatus()); // Data Status
    values.put(KEY_ACTIV, Data.getisActive()); // Data Active

    // Inserting Row
    db.insert(TABLE_DataStoreS, null, values);
    try {
        db.insertOrThrow(TABLE_DataStoreS, null, values);
    } catch (SQLiteConstraintException e) {
        Log.e(TAG, "Database insert error try update..");
        db.update(TABLE_DataStoreS, values, KEY_ID + " = ?", new String[]{String.valueOf(Data.getID())});
        Log.d(TAG, "Success");
    }
    db.close(); // Closing database connection
}

private void insertContentValues(ContentValues cv, FormIndex index) {
    synchronized(mScrollActions) {
     try {
        while ( !mScrollActions.isEmpty() ) {
            ContentValues scv = mScrollActions.removeFirst();
            mDb.insert(DATABASE_TABLE, null, scv);
        }

        if ( cv != null ) {
            String idx = "";
            if ( index != null ) {
                idx = getXPath(index);
            }
            cv.put(QUESTION,idx);
            mDb.insert(DATABASE_TABLE, null, cv);
        }
     } catch (SQLiteConstraintException e) {
         System.err.println("Error: " + e.getMessage());
     }
    }
}

/**
 * Decide come interpretare gli out e logga
 */
public void logTypical() {
    ContentValues values = new ContentValues();

    // wrap values from object
    values.put(SoulissDBOpenHelper.COLUMN_LOG_NODE_ID, getNodeId());
    values.put(SoulissDBOpenHelper.COLUMN_LOG_DATE, Calendar.getInstance().getTime().getTime());
    values.put(SoulissDBOpenHelper.COLUMN_LOG_SLOT, getSlot());
    if (isSensor()) {
        Log.d(it.angelic.soulissclient.Constants.TAG, getDefaultName() + " saving sensor loggi: " + ((ISoulissTypicalSensor) this).getOutputFloat());
        values.put(SoulissDBOpenHelper.COLUMN_LOG_VAL, ((ISoulissTypicalSensor) this).getOutputFloat());
    } else {
        Log.d(it.angelic.soulissclient.Constants.TAG, getDefaultName() + " saving loggi: " + getOutput());
        values.put(SoulissDBOpenHelper.COLUMN_LOG_VAL, getOutput());
    }
    try {
        SoulissDBHelper.getDatabase().insert(SoulissDBOpenHelper.TABLE_LOGS, null, values);
    } catch (SQLiteConstraintException e) {
        // sensori NaN violano il constraint
        Log.e(it.angelic.soulissclient.Constants.TAG, "error saving log: " + e);
    }

}

@Override
public Uri insert(Uri uri, ContentValues values) {
    ContentConstants.ProtocolURLs vrUrl = convertURIToProtocolURL(uri);
    long rowId = -1;
    switch (vrUrl) {
        case URLProtocol:
            rowId = db.getWritableDatabase().insert(Protocol.TABLE_NAME, null, values);
            new BackupManager(getContext()).dataChanged();
            break;
        default:
            throw new SQLiteConstraintException("Failed to switch insert protocol " + uri);

    }

    // If the insert succeeded, the row ID exists.
    if (rowId > 0) {
        // Creates a URI with the note ID pattern and the new row ID appended to it.
        Uri noteUri = ContentConstants.getUriFor(vrUrl, rowId);

        // Notifies observers registered against this provider that the data changed.
        getContext().getContentResolver().notifyChange(noteUri, null);
        return noteUri;
    } else {
        throw new SQLiteConstraintException("Failed to insert row into " + uri);
    }
}

private void onSqliteError(SQLiteException e) {
    if (
        e instanceof SQLiteBindOrColumnIndexOutOfRangeException ||
        e instanceof SQLiteConstraintException ||
        e instanceof SQLiteDatabaseCorruptException ||
        e instanceof SQLiteDatatypeMismatchException
    ) {
        // If a migration did not go well, the best we can do is drop the database and re-create
        // it from scratch. This is hackish but should allow more or less graceful recoveries.
        TrackHelper.track().event("Office", "cache.db.error").name("critical").value(1f).with(tracker);
        Log.e(TAG, "Critical database error. Droping + Re-creating", e);
        close();
        ctx.deleteDatabase(DB_NAME);
    } else {
        // Generic error. Close + re-open
        Log.e(TAG, "Datable "+e.getClass().getName()+". Closing + re-opening", e);
        TrackHelper.track().event("Office", "cache.db.error").name(e.getClass().getName()).value(1f).with(tracker);
        close();
    }
}

@Test(expected = SQLiteConstraintException.class)
public void throw_sqlite_constraint_exception_when_persist_a_data_element_with_invalid_option_set_foreign_key() {
    String fakeOptionSetUid = "fake_option_set_uid";
    store.insert(
            UID,
            CODE,
            NAME,
            DISPLAY_NAME,
            date,
            date,
            SHORT_NAME,
            DISPLAY_SHORT_NAME,
            DESCRIPTION,
            DISPLAY_DESCRIPTION,
            VALUE_TYPE,
            ZERO_IS_SIGNIFICANT,
            AGGREGATION_OPERATOR,
            FORM_NAME,
            NUMBER_TYPE,
            DOMAIN_TYPE,
            DIMENSION,
            DISPLAY_FORM_NAME,
            fakeOptionSetUid,
            null
            );
}

@Test(expected = SQLiteConstraintException.class)
public void not_insert_relationship_in_data_base_when_insert_null() {
    //Insert foreign keys in their respective tables:
    ContentValues relationshipType = CreateRelationshipTypeUtils.create(
            RELATIONSHIP_TYPE_ID,
            RELATIONSHIP_TYPE
    );
    database().insert(RelationshipTypeModel.TABLE, null, relationshipType);

    long rowId = store.insert(null, null, RELATIONSHIP_TYPE);
    Cursor cursor = database().query(RelationshipModel.TABLE, RELATIONSHIP_PROJECTION,
            null, null, null, null, null, null);

    assertThat(rowId).isEqualTo(1L);
    assertThatCursor(cursor).hasRow(null, null, RELATIONSHIP_TYPE).isExhausted();
}

@Test(expected = SQLiteConstraintException.class)
public void throw_exception_after_persist_event_with_invalid_program_foreign_key() {
    eventStore.insert(
            EVENT_UID,
            ENROLLMENT_UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            STATUS,
            LATITUDE,
            LONGITUDE,
            WRONG_UID, //supply wrong uid
            PROGRAM_STAGE,
            ORGANISATION_UNIT,
            date,
            date,
            date,
            STATE,
            ATTRIBUTE_CATEGORY_OPTION_UID,
            ATTRIBUTE_OPTION_COMBO_UID,
            TRACKED_ENTITY_INSTANCE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_exception_after_persist_event_with_invalid_program_stage_foreign_key() throws ParseException {
    eventStore.insert(
            EVENT_UID,
            ENROLLMENT_UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            STATUS,
            LATITUDE,
            LONGITUDE,
            PROGRAM,
            WRONG_UID, //supply wrong uid
            ORGANISATION_UNIT,
            date,
            date,
            date,
            STATE,
            ATTRIBUTE_CATEGORY_OPTION_UID,
            ATTRIBUTE_OPTION_COMBO_UID,
            TRACKED_ENTITY_INSTANCE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_exception_after_persist_event_with_invalid_organisation_unit_foreign_key() {
    eventStore.insert(
            EVENT_UID,
            ENROLLMENT_UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            STATUS,
            LATITUDE,
            LONGITUDE,
            PROGRAM,
            PROGRAM_STAGE,
            WRONG_UID, //supply wrong uid
            date,
            date,
            date,
            STATE,
            ATTRIBUTE_CATEGORY_OPTION_UID,
            ATTRIBUTE_OPTION_COMBO_UID,
            TRACKED_ENTITY_INSTANCE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_exception_after_persist_event_with_invalid_enrollment_foreign_key() {
    eventStore.insert(
            EVENT_UID,
            WRONG_UID, // supply wrong uid
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            STATUS,
            LATITUDE,
            LONGITUDE,
            PROGRAM,
            PROGRAM_STAGE,
            ORGANISATION_UNIT,
            date,
            date,
            date,
            STATE,
            ATTRIBUTE_CATEGORY_OPTION_UID,
            ATTRIBUTE_OPTION_COMBO_UID,
            TRACKED_ENTITY_INSTANCE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_sqlite_constraint_exception_when_insert_program_stage_data_element_with_invalid_foreign_key() {
    String fakeDataElementId = "fake_data_element_id";
    store.insert(
            UID,
            CODE,
            NAME,
            DISPLAY_NAME,
            date,
            date,
            DISPLAY_IN_REPORTS,
            COMPULSORY,
            ALLOW_PROVIDED_ELSEWHERE,
            SORT_ORDER,
            ALLOW_FUTURE_DATE,
            fakeDataElementId,
            PROGRAM_STAGE,
            null
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_sqlite_constraint_exception_when_persist_enrollment_with_invalid_org_unit_foreign_key() {
    store.insert(
            UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            WRONG_UID, //supply wrong uid
            PROGRAM,
            date,
            date,
            FOLLOW_UP,
            ENROLLMENT_STATUS,
            TRACKED_ENTITY_INSTANCE,
            LATITUDE,
            LONGITUDE,
            STATE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_sqlite_constraint_exception_when_persist_enrollment_with_invalid_program_foreign_key() {
    store.insert(
            UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            ORGANISATION_UNIT,
            WRONG_UID, //supply wrong uid
            date,
            date,
            FOLLOW_UP,
            ENROLLMENT_STATUS,
            TRACKED_ENTITY_INSTANCE,
            LATITUDE,
            LONGITUDE,
            STATE
    );
}

@Test(expected = SQLiteConstraintException.class)
public void throw_sqlite_constraint_exception_persist_enrollment_with_invalid_tracked_entity_instance_foreign_key() {
    store.insert(
            UID,
            date,
            date,
            CREATED_AT_CLIENT,
            LAST_UPDATED_AT_CLIENT,
            ORGANISATION_UNIT,
            PROGRAM,
            date,
            date,
            FOLLOW_UP,
            ENROLLMENT_STATUS,
            WRONG_UID, //supply wrong uid
            LATITUDE,
            LONGITUDE,
            STATE
    );
}

@Test
public void testInsertPrimaryKeyConflictCompoundKey() throws Exception {
    final TestDao dao = getDao();

    // create object
    final Compound orig = new Compound("1", "2", "orig", "orig");
    dao.insert(orig);

    // test PK conflict
    final Compound conflict = new Compound("1", "2", "conflict", "conflict");
    try {
        dao.insert(conflict);
        fail("There should have been a PK conflict");
    } catch (final SQLiteConstraintException expected) {
        // expected conflict, should be original
        final Compound refresh = dao.refresh(conflict);
        assertNotNull(refresh);
        assertThat(refresh.id1, is(orig.id1));
        assertThat(refresh.id2, is(orig.id2));
        assertThat(refresh.data1, allOf(is(orig.data1), is(not(conflict.data1))));
        assertThat(refresh.data2, allOf(is(orig.data2), is(not(conflict.data2))));
    }
}

public boolean insertarContacto(String nombre, String direccion, String telefono, String email,int miembrofacebook, int miembrotwitter, int miembrogoogle, int miembrolinkedin, int sexo, String tipocontacto, int imagen){
    SQLiteDatabase db = getWritableDatabase();
    if (db != null) {
        ContentValues valores = new ContentValues();
        valores.put("nombre", nombre);
        valores.put("direccion", direccion);
        valores.put("telefono", telefono);
        valores.put("email", email);
        valores.put("miembrofacebook", miembrofacebook);
        valores.put("miembrotwitter", miembrotwitter);
        valores.put("miembrogoogle", miembrogoogle);
        valores.put("miembrolinkedin", miembrolinkedin);
        valores.put("sexo", sexo);
        valores.put("tipocontacto", tipocontacto);
        valores.put("imagen", imagen);
        //db.insert("contactos", null, valores);
        try {
            db.insertOrThrow(TABLA, null, valores); //TABLA por "contactos"
            return true;
        } catch (SQLiteConstraintException e) {
            Log.d(TAG, "Fallo en la insercion: seguramente la clave ya existe.");
        }
    }
    db.close();   
    return false;
}

public boolean insertarContacto(SQLiteDatabase db, String nombre, String direccion, String telefono, String email,int miembrofacebook, int miembrotwitter, int miembrogoogle, int miembrolinkedin, int sexo, String tipocontacto, int imagen){

        if (db != null) {
            ContentValues valores = new ContentValues();
            valores.put("nombre", nombre);
            valores.put("direccion", direccion);
            valores.put("telefono", telefono);
            valores.put("email", email);
            valores.put("miembrofacebook", miembrofacebook);
            valores.put("miembrotwitter", miembrotwitter);
            valores.put("miembrogoogle", miembrogoogle);
            valores.put("miembrolinkedin", miembrolinkedin);
            valores.put("sexo", sexo);
            valores.put("tipocontacto", tipocontacto);
            valores.put("imagen", imagen);
            //db.insert("contactos", null, valores);
            try {
                db.insertOrThrow(TABLA, null, valores); //TABLA por "contactos"
                return true;
            } catch (SQLiteConstraintException e) {
                Log.d(TAG, "Fallo en la insercion: seguramente la clave ya existe.");
            }
        }   
        return false;
    }