/**
  * Build a simple {@link SelectionBuilder} to match the requested {@link Uri}. This is usually
  * enough to support {@link #insert}, {@link #update}, and {@link #delete} operations.
  */
 private SelectionBuilder buildSimpleSelection(Uri uri) {
   final SelectionBuilder builder = new SelectionBuilder();
   final int match = sUriMatcher.match(uri);
   switch (match) {
     case BLOCKS:
       {
         return builder.table(Tables.BLOCKS);
       }
     case BLOCKS_ID:
       {
         final String blockId = Blocks.getBlockId(uri);
         return builder.table(Tables.BLOCKS).where(Blocks.BLOCK_ID + "=?", blockId);
       }
     case TRACKS:
       {
         return builder.table(Tables.TRACKS);
       }
     case TRACKS_ID:
       {
         final String trackId = Tracks.getTrackId(uri);
         return builder.table(Tables.TRACKS).where(Tracks.TRACK_ID + "=?", trackId);
       }
     case ROOMS:
       {
         return builder.table(Tables.ROOMS);
       }
     case ROOMS_ID:
       {
         final String roomId = Rooms.getRoomId(uri);
         return builder.table(Tables.ROOMS).where(Rooms.ROOM_ID + "=?", roomId);
       }
     case SESSIONS:
       {
         return builder.table(Tables.SESSIONS);
       }
     case SESSIONS_STARRED:
       {
         return builder.table(Tables.SESSIONS).where(Sessions.SESSION_STARRED + "=1");
       }
     case SESSIONS_NEW:
       {
         return builder.table(Tables.SESSIONS).where(Sessions.SESSION_NEW + "=1");
       }
     case SESSIONS_ID:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder.table(Tables.SESSIONS).where(Sessions.SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_SPEAKERS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_SPEAKERS)
             .where(Sessions.SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_TAGS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder.table(Tables.SESSIONS_TAGS).where(Sessions.SESSION_ID + "=?", sessionId);
       }
     case SPEAKERS:
       {
         return builder.table(Tables.SPEAKERS);
       }
     case SPEAKERS_ID:
       {
         final String speakerId = Speakers.getSpeakerId(uri);
         return builder.table(Tables.SPEAKERS).where(Speakers.SPEAKER_ID + "=?", speakerId);
       }
     case TAGS:
       {
         return builder.table(Tables.TAGS);
       }
     case TAGS_ID:
       {
         final String tagId = Tags.getTagId(uri);
         return builder.table(Tables.TAGS).where(Tags.TAG_ID + "=?", tagId);
       }
     case SESSION_TYPES:
       {
         return builder.table(Tables.SESSION_TYPES);
       }
     case SESSION_TYPES_ID:
       {
         final String sessionTypeId = SessionTypes.getSessionTypeId(uri);
         return builder
             .table(Tables.SESSION_TYPES)
             .where(SessionTypes.SESSION_TYPE_ID + "=?", sessionTypeId);
       }
     case TWEETS:
       {
         return builder.table(Tables.TWEETS);
       }
     case TWEETS_ID:
       {
         final String tweetId = Tweets.getTweetId(uri);
         return builder.table(Tables.TWEETS).where(Tweets.TWEET_ID + "=?", tweetId);
       }
     case NEWS:
       {
         return builder.table(Tables.NEWS);
       }
     case NEWS_NEW:
       {
         return builder.table(Tables.NEWS).where(News.NEWS_NEW + "=1");
       }
     case NEWS_ID:
       {
         final String newsId = News.getNewsId(uri);
         return builder.table(Tables.NEWS).where(News.NEWS_ID + "=?", newsId);
       }
     case PARLEYS:
       {
         return builder.table(Tables.PARLEYS_PRESENTATIONS);
       }
     case PARLEYS_ID:
       {
         final String presentationId = ParleysPresentations.getParleysId(uri);
         return builder
             .table(Tables.PARLEYS_PRESENTATIONS)
             .where(ParleysPresentations.PRESENTATION_ID + "=?", presentationId);
       }
     case PARLEYS_ID_TAGS:
       {
         final String presentationId = ParleysPresentations.getParleysId(uri);
         return builder
             .table(Tables.PARLEYS_PRESENTATIONS_TAGS)
             .where(ParleysPresentations.PRESENTATION_ID + "=?", presentationId);
       }
     case SEARCH_SUGGEST:
       {
         return builder.table(Tables.SEARCH_SUGGEST);
       }
     default:
       {
         throw new UnsupportedOperationException("Unknown uri: " + uri);
       }
   }
 }
 /**
  * Build an advanced {@link SelectionBuilder} to match the requested {@link Uri}. This is usually
  * only used by {@link #query}, since it performs table joins useful for {@link Cursor} data.
  */
 private SelectionBuilder buildExpandedSelection(Uri uri, int match) {
   final SelectionBuilder builder = new SelectionBuilder();
   switch (match) {
     case BLOCKS:
       {
         return builder.table(Tables.BLOCKS);
       }
     case BLOCKS_BETWEEN:
       {
         final List<String> segments = uri.getPathSegments();
         final String startTime = segments.get(2);
         final String endTime = segments.get(3);
         return builder
             .table(Tables.BLOCKS)
             .map(Blocks.SESSIONS_COUNT, Subquery.BLOCK_SESSIONS_COUNT)
             .map(Blocks.CONTAINS_STARRED, Subquery.BLOCK_CONTAINS_STARRED)
             .where(Blocks.BLOCK_START + ">=?", startTime)
             .where(Blocks.BLOCK_START + "<=?", endTime);
       }
     case BLOCKS_ID:
       {
         final String blockId = Blocks.getBlockId(uri);
         return builder
             .table(Tables.BLOCKS)
             .map(Blocks.SESSIONS_COUNT, Subquery.BLOCK_SESSIONS_COUNT)
             .map(Blocks.CONTAINS_STARRED, Subquery.BLOCK_CONTAINS_STARRED)
             .where(Blocks.BLOCK_ID + "=?", blockId);
       }
     case BLOCKS_ID_SESSION:
       {
         final String blockId = Blocks.getBlockId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS_TRACKS)
             .map(Blocks.SESSIONS_COUNT, Subquery.BLOCK_SESSIONS_COUNT)
             .map(Blocks.CONTAINS_STARRED, Subquery.BLOCK_CONTAINS_STARRED)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .mapToTable(Sessions.TRACK_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_BLOCK_ID + "=?", blockId);
       }
     case BLOCKS_ID_SESSIONS:
       {
         final String blockId = Blocks.getBlockId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS_TRACKS)
             .map(Blocks.SESSIONS_COUNT, Subquery.BLOCK_SESSIONS_COUNT)
             .map(Blocks.CONTAINS_STARRED, Subquery.BLOCK_CONTAINS_STARRED)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_BLOCK_ID + "=?", blockId);
       }
     case TRACKS:
       {
         return builder
             .table(Tables.TRACKS)
             .map(Tracks.SESSIONS_COUNT, Subquery.TRACK_SESSIONS_COUNT);
       }
     case TRACKS_ID:
       {
         final String trackId = Tracks.getTrackId(uri);
         return builder.table(Tables.TRACKS).where(Tracks.TRACK_ID + "=?", trackId);
       }
     case TRACKS_ID_SESSIONS:
       {
         final String trackId = Tracks.getTrackId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS_TRACKS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .mapToTable(Sessions.TRACK_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_TRACK_ID + "=?", trackId);
       }
     case ROOMS:
       {
         return builder.table(Tables.ROOMS);
       }
     case ROOMS_ID:
       {
         final String roomId = Rooms.getRoomId(uri);
         return builder.table(Tables.ROOMS).where(Rooms.ROOM_ID + "=?", roomId);
       }
     case ROOMS_ID_SESSIONS:
       {
         final String roomId = Rooms.getRoomId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_ROOM_ID + "=?", roomId);
       }
     case SESSIONS:
       {
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS);
       }
     case SESSIONS_BETWEEN:
       {
         final List<String> segments = uri.getPathSegments();
         final String startTime = segments.get(2);
         final String endTime = segments.get(3);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS_TRACKS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .mapToTable(Sessions.TRACK_ID, Tables.SESSIONS)
             .where(Sessions.BLOCK_START + ">=?", startTime)
             .where(Sessions.BLOCK_END + "<=?", endTime);
       }
     case SESSIONS_STARRED:
       {
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Sessions.SESSION_STARRED + "=1");
       }
     case SESSIONS_NEW:
       {
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Sessions.SESSION_NEW + "=1");
       }
     case SESSIONS_SEARCH:
       {
         final String query = Sessions.getSearchQuery(uri);
         return builder
             .table(Tables.SESSIONS_SEARCH_JOIN_SESSIONS_BLOCKS_ROOMS)
             .map(Sessions.SEARCH_SNIPPET, Subquery.SESSIONS_SNIPPET)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(SessionsSearchColumns.BODY + " MATCH ?", query);
       }
     case SESSIONS_PARALLEL:
       {
         final List<String> segments = uri.getPathSegments();
         final String sessionId = segments.get(2);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .map(Sessions.STARRED_IN_BLOCK_COUNT, Subquery.BLOCK_STARRED_SESSIONS_COUNT)
             .mapToTable(Tracks.TRACK_COLOR, Tables.TRACKS)
             .where(WhereClause.SESSIONS_PARALLEL, sessionId, sessionId)
             .where(Sessions.SESSION_ID + "<>?", sessionId);
       }
     case SESSIONS_AT:
       {
         final List<String> segments = uri.getPathSegments();
         final String time = segments.get(2);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Sessions.BLOCK_START + "<=?", time)
             .where(Sessions.BLOCK_END + ">=?", time);
       }
     case SESSIONS_ID:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_BLOCKS_ROOMS_TRACKS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .mapToTable(Sessions.TRACK_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_SPEAKERS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_SPEAKERS_JOIN_SPEAKERS)
             .mapToTable(Speakers._ID, Tables.SPEAKERS)
             .mapToTable(Speakers.SPEAKER_ID, Tables.SPEAKERS)
             .where(Qualified.SESSIONS_SPEAKERS_SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_TAGS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_TAGS_JOIN_TAGS)
             .mapToTable(Tags._ID, Tables.TAGS)
             .mapToTable(Tags.TAG_ID, Tables.TAGS)
             .where(Qualified.SESSIONS_TAGS_SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_TRACKS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_JOIN_TRACKS)
             .mapToTable(Tracks._ID, Tables.TRACKS)
             .mapToTable(Tracks.TRACK_ID, Tables.TRACKS)
             .where(Qualified.SESSIONS_SESSION_ID + "=?", sessionId);
       }
     case SESSIONS_ID_PARLEYS:
       {
         final String sessionId = Sessions.getSessionId(uri);
         return builder
             .table(Tables.SESSIONS_TAGS_JOIN_PARLAYS_PRESENTATIONS_TAGS_PARLEYS_PRESENTATIONS)
             .groupBy(Qualified.PARLEYS_PRESENTATIONS_PRESENTATION_ID)
             .mapToTable(ParleysPresentations._ID, Tables.PARLEYS_PRESENTATIONS)
             .mapToTable(ParleysPresentations.PRESENTATION_ID, Tables.PARLEYS_PRESENTATIONS)
             .where(
                 Qualified.PARLEYS_PRESENTATIONS_PRESENTATION_ID
                     + " IS NOT NULL AND "
                     + Qualified.SESSIONS_TAGS_SESSION_ID
                     + "=?",
                 sessionId);
       }
     case SPEAKERS:
       {
         return builder.table(Tables.SPEAKERS);
       }
     case SPEAKERS_SEARCH:
       {
         final String query = Sessions.getSearchQuery(uri);
         return builder
             .table(Tables.SPEAKERS_SEARCH_JOIN_SPEAKERS)
             .map(Speakers.SEARCH_SNIPPET, Subquery.SPEAKERS_SNIPPET)
             .mapToTable(Speakers._ID, Tables.SPEAKERS)
             .mapToTable(Speakers.SPEAKER_ID, Tables.SPEAKERS)
             .where(SpeakersSearchColumns.BODY + " MATCH ?", query);
       }
     case SPEAKERS_ID:
       {
         final String speakerId = Speakers.getSpeakerId(uri);
         return builder.table(Tables.SPEAKERS).where(Speakers.SPEAKER_ID + "=?", speakerId);
       }
     case SPEAKERS_ID_SESSIONS:
       {
         final String speakerId = Speakers.getSpeakerId(uri);
         return builder
             .table(Tables.SESSIONS_SPEAKERS_JOIN_SESSIONS_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_SPEAKERS_SPEAKER_ID + "=?", speakerId);
       }
     case TAGS:
       {
         return builder.table(Tables.TAGS);
       }
     case TAGS_ID:
       {
         final String tagId = Tags.getTagId(uri);
         return builder.table(Tables.TAGS).where(Tags.TAG_ID + "=?", tagId);
       }
     case TAGS_ID_SESSIONS:
       {
         final String tagId = Tags.getTagId(uri);
         return builder
             .table(Tables.SESSIONS_TAGS_JOIN_SESSIONS_BLOCKS_ROOMS)
             .mapToTable(Sessions._ID, Tables.SESSIONS)
             .mapToTable(Sessions.SESSION_ID, Tables.SESSIONS)
             .mapToTable(Sessions.BLOCK_ID, Tables.SESSIONS)
             .mapToTable(Sessions.ROOM_ID, Tables.SESSIONS)
             .where(Qualified.SESSIONS_TAGS_TAG_ID + "=?", tagId);
       }
     case SESSION_TYPES:
       {
         return builder.table(Tables.SESSION_TYPES);
       }
     case SESSION_TYPES_ID:
       {
         final String sessionTypeId = SessionTypes.getSessionTypeId(uri);
         return builder
             .table(Tables.SESSION_TYPES)
             .where(SessionTypes.SESSION_TYPE_ID + "=?", sessionTypeId);
       }
     case TWEETS:
       {
         return builder.table(Tables.TWEETS);
       }
     case TWEETS_ID:
       {
         final String tweetId = Tweets.getTweetId(uri);
         return builder.table(Tables.TWEETS).where(Tweets.TWEET_ID + "=?", tweetId);
       }
     case NEWS:
       {
         return builder.table(Tables.NEWS);
       }
     case NEWS_NEW:
       {
         return builder.table(Tables.NEWS).where(News.NEWS_NEW + "=1");
       }
     case NEWS_ID:
       {
         final String newsId = News.getNewsId(uri);
         return builder.table(Tables.NEWS).where(News.NEWS_ID + "=?", newsId);
       }
     case PARLEYS:
       {
         return builder.table(Tables.PARLEYS_PRESENTATIONS);
       }
     case PARLEYS_ID:
       {
         final String presentationId = ParleysPresentations.getParleysId(uri);
         return builder
             .table(Tables.PARLEYS_PRESENTATIONS)
             .where(Qualified.PARLEYS_PRESENTATIONS_PRESENTATION_ID + "=?", presentationId);
       }
     case PARLEYS_ID_TAGS:
       {
         final String presentationId = ParleysPresentations.getParleysId(uri);
         return builder
             .table(Tables.PARLEYS_PRESENTATIONS_TAGS_JOIN_TAGS)
             .mapToTable(Tags._ID, Tables.TAGS)
             .mapToTable(Tags.TAG_ID, Tables.TAGS)
             .where(Qualified.PARLEYS_PRESENTATIONS_TAGS_PRESENTATION_ID + "=?", presentationId);
       }
     default:
       {
         throw new UnsupportedOperationException("Unknown uri: " + uri);
       }
   }
 }
 /** {@inheritDoc} */
 @Override
 public Uri insert(Uri uri, ContentValues values) {
   if (LOGV) Log.v(TAG, "insert(uri=" + uri + ", values=" + values.toString() + ")");
   final SQLiteDatabase db = mOpenHelper.getWritableDatabase();
   final int match = sUriMatcher.match(uri);
   switch (match) {
     case BLOCKS:
       {
         db.insertOrThrow(Tables.BLOCKS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Blocks.buildBlockUri(values.getAsString(Blocks.BLOCK_ID));
       }
     case TRACKS:
       {
         db.insertOrThrow(Tables.TRACKS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Tracks.buildTrackUri(values.getAsString(Tracks.TRACK_ID));
       }
     case ROOMS:
       {
         db.insertOrThrow(Tables.ROOMS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Rooms.buildRoomUri(values.getAsString(Rooms.ROOM_ID));
       }
     case SESSIONS:
       {
         db.insertOrThrow(Tables.SESSIONS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Sessions.buildSessionUri(values.getAsString(Sessions.SESSION_ID));
       }
     case SESSIONS_ID_SPEAKERS:
       {
         db.insertOrThrow(Tables.SESSIONS_SPEAKERS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Speakers.buildSpeakerUri(values.getAsString(SessionsSpeakers.SPEAKER_ID));
       }
     case SESSIONS_ID_TAGS:
       {
         db.insertOrThrow(Tables.SESSIONS_TAGS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Tags.buildTagUri(values.getAsString(SessionsTags.TAG_ID));
       }
     case SPEAKERS:
       {
         db.insertOrThrow(Tables.SPEAKERS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Speakers.buildSpeakerUri(values.getAsString(Speakers.SPEAKER_ID));
       }
     case TAGS:
       {
         db.insertOrThrow(Tables.TAGS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Tags.buildTagUri(values.getAsString(Tags.TAG_ID));
       }
     case SESSION_TYPES:
       {
         db.insertOrThrow(Tables.SESSION_TYPES, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return SessionTypes.buildSessionTypeUri(values.getAsString(SessionTypes.SESSION_TYPE_ID));
       }
     case TWEETS:
       {
         db.insertOrThrow(Tables.TWEETS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Tweets.buildTweetUri(values.getAsString(Tweets.TWEET_ID));
       }
     case NEWS:
       {
         db.insertOrThrow(Tables.NEWS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return News.buildNewsUri(values.getAsString(News.NEWS_ID));
       }
     case PARLEYS:
       {
         db.insertOrThrow(Tables.PARLEYS_PRESENTATIONS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Sessions.buildSessionUri(values.getAsString(ParleysPresentations.PRESENTATION_ID));
       }
     case PARLEYS_ID_TAGS:
       {
         db.insertOrThrow(Tables.PARLEYS_PRESENTATIONS_TAGS, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return Tags.buildTagUri(values.getAsString(ParleysPresentationsTags.TAG_ID));
       }
     case SEARCH_SUGGEST:
       {
         db.insertOrThrow(Tables.SEARCH_SUGGEST, null, values);
         getContext().getContentResolver().notifyChange(uri, null);
         return SearchSuggest.CONTENT_URI;
       }
     default:
       {
         throw new UnsupportedOperationException("Unknown uri: " + uri);
       }
   }
 }