src/com/android/providers/media/util/DatabaseUtils.java - platform/packages/providers/MediaProvider - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.providers.media.util;

 import static android.content.ContentResolver.QUERY_ARG_GROUP_COLUMNS;
 import static android.content.ContentResolver.QUERY_ARG_LIMIT;
 import static android.content.ContentResolver.QUERY_ARG_OFFSET;
 import static android.content.ContentResolver.QUERY_ARG_SORT_COLLATION;
 import static android.content.ContentResolver.QUERY_ARG_SORT_COLUMNS;
 import static android.content.ContentResolver.QUERY_ARG_SORT_DIRECTION;
 import static android.content.ContentResolver.QUERY_ARG_SORT_LOCALE;
 import static android.content.ContentResolver.QUERY_ARG_SQL_GROUP_BY;
 import static android.content.ContentResolver.QUERY_ARG_SQL_LIMIT;
 import static android.content.ContentResolver.QUERY_ARG_SQL_SELECTION;
 import static android.content.ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS;
 import static android.content.ContentResolver.QUERY_ARG_SQL_SORT_ORDER;
 import static android.content.ContentResolver.QUERY_SORT_DIRECTION_ASCENDING;
 import static android.content.ContentResolver.QUERY_SORT_DIRECTION_DESCENDING;

 import static com.android.providers.media.util.Logging.TAG;

 import android.content.ContentResolver;
 import android.content.ContentValues;
 import android.database.Cursor;
 import android.database.SQLException;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteStatement;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Trace;
 import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.Log;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;

 import java.util.Locale;
 import java.util.function.Consumer;
 import java.util.function.Function;

 public class DatabaseUtils {
     /**
      * Bind the given selection with the given selection arguments.
      * <p>
      * Internally assumes that '?' is only ever used for arguments, and doesn't
      * appear as a literal or escaped value.
      * <p>
      * This method is typically useful for trusted code that needs to cook up a
      * fully-bound selection.
      *
      * @hide
      */
     public static @Nullable String bindSelection(@Nullable String selection,
             @Nullable Object... selectionArgs) {
         if (selection == null) return null;
         // If no arguments provided, so we can't bind anything
         if ((selectionArgs == null) || (selectionArgs.length == 0)) return selection;
         // If no bindings requested, so we can shortcut
         if (selection.indexOf('?') == -1) return selection;

         // Track the chars immediately before and after each bind request, to
         // decide if it needs additional whitespace added
         char before = ' ';
         char after = ' ';

         int argIndex = 0;
         final int len = selection.length();
         final StringBuilder res = new StringBuilder(len);
         for (int i = 0; i < len; ) {
             char c = selection.charAt(i++);
             if (c == '?') {
                 // Assume this bind request is guarded until we find a specific
                 // trailing character below
                 after = ' ';

                 // Sniff forward to see if the selection is requesting a
                 // specific argument index
                 int start = i;
                 for (; i < len; i++) {
                     c = selection.charAt(i);
                     if (c < '0' || c > '9') {
                         after = c;
                         break;
                     }
                 }
                 if (start != i) {
                     argIndex = Integer.parseInt(selection.substring(start, i)) - 1;
                 }

                 // Manually bind the argument into the selection, adding
                 // whitespace when needed for clarity
                 final Object arg = selectionArgs[argIndex++];
                 if (before != ' ' && before != '=') res.append(' ');
                 switch (DatabaseUtils.getTypeOfObject(arg)) {
                     case Cursor.FIELD_TYPE_NULL:
                         res.append("NULL");
                         break;
                     case Cursor.FIELD_TYPE_INTEGER:
                         res.append(((Number) arg).longValue());
                         break;
                     case Cursor.FIELD_TYPE_FLOAT:
                         res.append(((Number) arg).doubleValue());
                         break;
                     case Cursor.FIELD_TYPE_BLOB:
                         throw new IllegalArgumentException("Blobs not supported");
                     case Cursor.FIELD_TYPE_STRING:
                     default:
                         if (arg instanceof Boolean) {
                             // Provide compatibility with legacy applications which may pass
                             // Boolean values in bind args.
                             res.append(((Boolean) arg).booleanValue() ? 1 : 0);
                         } else {
                             res.append('\'');
                             // Escape single quote character while appending the string.
                             res.append(arg.toString().replace("'", "''"));
                             res.append('\'');
                         }
                         break;
                 }
                 if (after != ' ') res.append(' ');
             } else {
                 res.append(c);
                 before = c;
             }
         }
         return res.toString();
     }

     /**
      * Returns data type of the given object's value.
      *<p>
      * Returned values are
      * <ul>
      *   <li>{@link Cursor#FIELD_TYPE_NULL}</li>
      *   <li>{@link Cursor#FIELD_TYPE_INTEGER}</li>
      *   <li>{@link Cursor#FIELD_TYPE_FLOAT}</li>
      *   <li>{@link Cursor#FIELD_TYPE_STRING}</li>
      *   <li>{@link Cursor#FIELD_TYPE_BLOB}</li>
      *</ul>
      *</p>
      *
      * @param obj the object whose value type is to be returned
      * @return object value type
      * @hide
      */
     public static int getTypeOfObject(Object obj) {
         if (obj == null) {
             return Cursor.FIELD_TYPE_NULL;
         } else if (obj instanceof byte[]) {
             return Cursor.FIELD_TYPE_BLOB;
         } else if (obj instanceof Float || obj instanceof Double) {
             return Cursor.FIELD_TYPE_FLOAT;
         } else if (obj instanceof Long || obj instanceof Integer
                 || obj instanceof Short || obj instanceof Byte) {
             return Cursor.FIELD_TYPE_INTEGER;
         } else {
             return Cursor.FIELD_TYPE_STRING;
         }
     }

     public static void copyFromCursorToContentValues(@NonNull String column, @NonNull Cursor cursor,
             @NonNull ContentValues values) {
         final int index = cursor.getColumnIndex(column);
         if (index != -1) {
             if (cursor.isNull(index)) {
                 values.putNull(column);
             } else {
                 values.put(column, cursor.getString(index));
             }
         }
     }

     /**
      * Simple attempt to balance the given SQL expression by adding parenthesis
      * when needed.
      * <p>
      * Since this is only used for recovering from abusive apps, we're not
      * interested in trying to build a fully valid SQL parser up in Java. It'll
      * give up when it encounters complex SQL, such as string literals.
      */
     public static @Nullable String maybeBalance(@Nullable String sql) {
         if (sql == null) return null;

         int count = 0;
         char literal = '\0';
         for (int i = 0; i < sql.length(); i++) {
             final char c = sql.charAt(i);

             if (c == '\'' || c == '"') {
                 if (literal == '\0') {
                     // Start literal
                     literal = c;
                 } else if (literal == c) {
                     // End literal
                     literal = '\0';
                 }
             }

             if (literal == '\0') {
                 if (c == '(') {
                     count++;
                 } else if (c == ')') {
                     count--;
                 }
             }
         }
         while (count > 0) {
             sql = sql + ")";
             count--;
         }
         while (count < 0) {
             sql = "(" + sql;
             count++;
         }
         return sql;
     }

     /**
      * {@link ContentResolver} offers several query arguments, ranging from
      * helpful higher-level concepts like
      * {@link ContentResolver#QUERY_ARG_GROUP_COLUMNS} to raw SQL like
      * {@link ContentResolver#QUERY_ARG_SQL_GROUP_BY}. We prefer the
      * higher-level concepts when defined by the caller, but we'll fall back to
      * the raw SQL if that's all the caller provided.
      * <p>
      * This method will "resolve" all higher-level query arguments into the raw
      * SQL arguments, giving us easy values to carry over into
      * {@link SQLiteQueryBuilder}.
      */
     public static void resolveQueryArgs(@NonNull Bundle queryArgs,
             @NonNull Consumer<String> honored,
             @NonNull Function<String, String> collatorFactory) {
         // We're always going to handle selections
         honored.accept(QUERY_ARG_SQL_SELECTION);
         honored.accept(QUERY_ARG_SQL_SELECTION_ARGS);

         resolveGroupBy(queryArgs, honored);
         resolveSortOrder(queryArgs, honored, collatorFactory);
         resolveLimit(queryArgs, honored);
     }

     private static void resolveGroupBy(@NonNull Bundle queryArgs,
             @NonNull Consumer<String> honored) {
         final String[] columns = queryArgs.getStringArray(QUERY_ARG_GROUP_COLUMNS);
         if (columns != null && columns.length != 0) {
             String groupBy = TextUtils.join(", ", columns);
             honored.accept(QUERY_ARG_GROUP_COLUMNS);

             queryArgs.putString(QUERY_ARG_SQL_GROUP_BY, groupBy);
         } else {
             honored.accept(QUERY_ARG_SQL_GROUP_BY);
         }
     }

     private static void resolveSortOrder(@NonNull Bundle queryArgs,
             @NonNull Consumer<String> honored,
             @NonNull Function<String, String> collatorFactory) {
         final String[] columns = queryArgs.getStringArray(QUERY_ARG_SORT_COLUMNS);
         if (columns != null && columns.length != 0) {
             String sortOrder = TextUtils.join(", ", columns);
             honored.accept(QUERY_ARG_SORT_COLUMNS);

             if (queryArgs.containsKey(QUERY_ARG_SORT_LOCALE)) {
                 final String collatorName = collatorFactory.apply(
                         queryArgs.getString(QUERY_ARG_SORT_LOCALE));
                 sortOrder += " COLLATE " + collatorName;
                 honored.accept(QUERY_ARG_SORT_LOCALE);
             } else {
                 // Interpret PRIMARY and SECONDARY collation strength as no-case collation based
                 // on their javadoc descriptions.
                 final int collation = queryArgs.getInt(
                         QUERY_ARG_SORT_COLLATION, java.text.Collator.IDENTICAL);
                 switch (collation) {
                     case java.text.Collator.IDENTICAL:
                         honored.accept(QUERY_ARG_SORT_COLLATION);
                         break;
                     case java.text.Collator.PRIMARY:
                     case java.text.Collator.SECONDARY:
                         sortOrder += " COLLATE NOCASE";
                         honored.accept(QUERY_ARG_SORT_COLLATION);
                         break;
                 }
             }

             final int sortDir = queryArgs.getInt(QUERY_ARG_SORT_DIRECTION, Integer.MIN_VALUE);
             switch (sortDir) {
                 case QUERY_SORT_DIRECTION_ASCENDING:
                     sortOrder += " ASC";
                     honored.accept(QUERY_ARG_SORT_DIRECTION);
                     break;
                 case QUERY_SORT_DIRECTION_DESCENDING:
                     sortOrder += " DESC";
                     honored.accept(QUERY_ARG_SORT_DIRECTION);
                     break;
             }

             queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
         } else {
             honored.accept(QUERY_ARG_SQL_SORT_ORDER);
         }
     }

     private static void resolveLimit(@NonNull Bundle queryArgs,
             @NonNull Consumer<String> honored) {
         final int limit = queryArgs.getInt(QUERY_ARG_LIMIT, Integer.MIN_VALUE);
         if (limit != Integer.MIN_VALUE) {
             String limitString = Integer.toString(limit);
             honored.accept(QUERY_ARG_LIMIT);

             final int offset = queryArgs.getInt(QUERY_ARG_OFFSET, Integer.MIN_VALUE);
             if (offset != Integer.MIN_VALUE) {
                 limitString += " OFFSET " + offset;
                 honored.accept(QUERY_ARG_OFFSET);
             }

             queryArgs.putString(QUERY_ARG_SQL_LIMIT, limitString);
         } else {
             honored.accept(QUERY_ARG_SQL_LIMIT);
         }
     }

     /**
      * Gracefully recover from abusive callers that are smashing limits into
      * {@link Uri}.
      */
     public static void recoverAbusiveLimit(@NonNull Uri uri, @NonNull Bundle queryArgs) {
         final String origLimit = queryArgs.getString(QUERY_ARG_SQL_LIMIT);
         final String uriLimit = uri.getQueryParameter("limit");

         if (!TextUtils.isEmpty(uriLimit)) {
             // Yell if we already had a group by requested
             if (!TextUtils.isEmpty(origLimit)) {
                 throw new IllegalArgumentException(
                         "Abusive '" + uriLimit + "' conflicts with requested '" + origLimit + "'");
             }

             Log.w(TAG, "Recovered abusive '" + uriLimit + "' from '" + uri + "'");

             queryArgs.putString(QUERY_ARG_SQL_LIMIT, uriLimit);
         }
     }

     /**
      * Gracefully recover from abusive callers that are smashing invalid
      * {@code GROUP BY} clauses into {@code WHERE} clauses.
      */
     public static void recoverAbusiveSelection(@NonNull Bundle queryArgs) {
         final String origSelection = queryArgs.getString(QUERY_ARG_SQL_SELECTION);
         final String origGroupBy = queryArgs.getString(QUERY_ARG_SQL_GROUP_BY);

         final int index = (origSelection != null)
                 ? origSelection.toUpperCase(Locale.ROOT).indexOf(" GROUP BY ") : -1;
         if (index != -1) {
             String selection = origSelection.substring(0, index);
             String groupBy = origSelection.substring(index + " GROUP BY ".length());

             // Try balancing things out
             selection = maybeBalance(selection);
             groupBy = maybeBalance(groupBy);

             // Yell if we already had a group by requested
             if (!TextUtils.isEmpty(origGroupBy)) {
                 throw new IllegalArgumentException(
                         "Abusive '" + groupBy + "' conflicts with requested '" + origGroupBy + "'");
             }

             Log.w(TAG, "Recovered abusive '" + selection + "' and '" + groupBy + "' from '"
                     + origSelection + "'");

             queryArgs.putString(QUERY_ARG_SQL_SELECTION, selection);
             queryArgs.putString(QUERY_ARG_SQL_GROUP_BY, groupBy);
         }
     }

     /**
      * Gracefully recover from abusive callers that are smashing limits into
      * {@code ORDER BY} clauses.
      */
     public static void recoverAbusiveSortOrder(@NonNull Bundle queryArgs) {
         final String origSortOrder = queryArgs.getString(QUERY_ARG_SQL_SORT_ORDER);
         final String origLimit = queryArgs.getString(QUERY_ARG_SQL_LIMIT);

         final int index = (origSortOrder != null)
                 ? origSortOrder.toUpperCase(Locale.ROOT).indexOf(" LIMIT ") : -1;
         if (index != -1) {
             String sortOrder = origSortOrder.substring(0, index);
             String limit = origSortOrder.substring(index + " LIMIT ".length());

             // Yell if we already had a limit requested
             if (!TextUtils.isEmpty(origLimit)) {
                 throw new IllegalArgumentException(
                         "Abusive '" + limit + "' conflicts with requested '" + origLimit + "'");
             }

             Log.w(TAG, "Recovered abusive '" + sortOrder + "' and '" + limit + "' from '"
                     + origSortOrder + "'");

             queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
             queryArgs.putString(QUERY_ARG_SQL_LIMIT, limit);
         }
     }

     /**
      * Shamelessly borrowed from {@link ContentResolver}.
      */
     public static @Nullable Bundle createSqlQueryBundle(
             @Nullable String selection,
             @Nullable String[] selectionArgs,
             @Nullable String sortOrder) {

         if (selection == null && selectionArgs == null && sortOrder == null) {
             return null;
         }

         Bundle queryArgs = new Bundle();
         if (selection != null) {
             queryArgs.putString(QUERY_ARG_SQL_SELECTION, selection);
         }
         if (selectionArgs != null) {
             queryArgs.putStringArray(QUERY_ARG_SQL_SELECTION_ARGS, selectionArgs);
         }
         if (sortOrder != null) {
             queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
         }
         return queryArgs;
     }

     public static @NonNull ArrayMap<String, Object> getValues(@NonNull ContentValues values) {
         final ArrayMap<String, Object> res = new ArrayMap<>();
         for (String key : values.keySet()) {
             res.put(key, values.get(key));
         }
         return res;
     }

     public static long executeInsert(@NonNull SQLiteDatabase db, @NonNull String sql,
             @Nullable Object[] bindArgs) throws SQLException {
         Trace.beginSection("executeInsert");
         try (SQLiteStatement st = db.compileStatement(sql)) {
             bindArgs(st, bindArgs);
             return st.executeInsert();
         } finally {
             Trace.endSection();
         }
     }

     public static int executeUpdateDelete(@NonNull SQLiteDatabase db, @NonNull String sql,
             @Nullable Object[] bindArgs) throws SQLException {
         Trace.beginSection("executeUpdateDelete");
         try (SQLiteStatement st = db.compileStatement(sql)) {
             bindArgs(st, bindArgs);
             return st.executeUpdateDelete();
         } finally {
             Trace.endSection();
         }
     }

     private static void bindArgs(@NonNull SQLiteStatement st, @Nullable Object[] bindArgs) {
         if (bindArgs == null) return;

         for (int i = 0; i < bindArgs.length; i++) {
             final Object bindArg = bindArgs[i];
             switch (getTypeOfObject(bindArg)) {
                 case Cursor.FIELD_TYPE_NULL:
                     st.bindNull(i + 1);
                     break;
                 case Cursor.FIELD_TYPE_INTEGER:
                     st.bindLong(i + 1, ((Number) bindArg).longValue());
                     break;
                 case Cursor.FIELD_TYPE_FLOAT:
                     st.bindDouble(i + 1, ((Number) bindArg).doubleValue());
                     break;
                 case Cursor.FIELD_TYPE_BLOB:
                     st.bindBlob(i + 1, (byte[]) bindArg);
                     break;
                 case Cursor.FIELD_TYPE_STRING:
                 default:
                     if (bindArg instanceof Boolean) {
                         // Provide compatibility with legacy
                         // applications which may pass Boolean values in
                         // bind args.
                         st.bindLong(i + 1, ((Boolean) bindArg).booleanValue() ? 1 : 0);
                     } else {
                         st.bindString(i + 1, bindArg.toString());
                     }
                     break;
             }
         }
     }

     public static @NonNull String bindList(@NonNull Object... args) {
         final StringBuilder sb = new StringBuilder();
         sb.append('(');
         for (int i = 0; i < args.length; i++) {
             sb.append('?');
             if (i < args.length - 1) {
                 sb.append(',');
             }
         }
         sb.append(')');
         return DatabaseUtils.bindSelection(sb.toString(), args);
     }

     /**
      * Escape the given argument for use in a {@code LIKE} statement.
      */
     public static String escapeForLike(@NonNull String arg) {
         final StringBuilder sb = new StringBuilder();
         for (int i = 0; i < arg.length(); i++) {
             final char c = arg.charAt(i);
             switch (c) {
                 case '%': sb.append('\\');
                     break;
                 case '_': sb.append('\\');
                     break;
             }
             sb.append(c);
         }
         return sb.toString();
     }

     public static boolean parseBoolean(@Nullable Object value, boolean def) {
         if (value instanceof Boolean) {
             return (Boolean) value;
         } else if (value instanceof Number) {
             return ((Number) value).intValue() != 0;
         } else if (value instanceof String) {
             final String stringValue = ((String) value).toLowerCase(Locale.ROOT);
             return (!"false".equals(stringValue) && !"0".equals(stringValue));
         } else {
             return def;
         }
     }

     public static boolean getAsBoolean(@NonNull Bundle extras,
             @NonNull String key, boolean def) {
         return parseBoolean(extras.get(key), def);
     }

     public static boolean getAsBoolean(@NonNull ContentValues values,
             @NonNull String key, boolean def) {
         return parseBoolean(values.get(key), def);
     }

     public static long getAsLong(@NonNull ContentValues values,
             @NonNull String key, long def) {
         final Long value = values.getAsLong(key);
         return (value != null) ? value : def;
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.providers.media.util;

	import static android.content.ContentResolver.QUERY_ARG_GROUP_COLUMNS;
	import static android.content.ContentResolver.QUERY_ARG_LIMIT;
	import static android.content.ContentResolver.QUERY_ARG_OFFSET;
	import static android.content.ContentResolver.QUERY_ARG_SORT_COLLATION;
	import static android.content.ContentResolver.QUERY_ARG_SORT_COLUMNS;
	import static android.content.ContentResolver.QUERY_ARG_SORT_DIRECTION;
	import static android.content.ContentResolver.QUERY_ARG_SORT_LOCALE;
	import static android.content.ContentResolver.QUERY_ARG_SQL_GROUP_BY;
	import static android.content.ContentResolver.QUERY_ARG_SQL_LIMIT;
	import static android.content.ContentResolver.QUERY_ARG_SQL_SELECTION;
	import static android.content.ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS;
	import static android.content.ContentResolver.QUERY_ARG_SQL_SORT_ORDER;
	import static android.content.ContentResolver.QUERY_SORT_DIRECTION_ASCENDING;
	import static android.content.ContentResolver.QUERY_SORT_DIRECTION_DESCENDING;

	import static com.android.providers.media.util.Logging.TAG;

	import android.content.ContentResolver;
	import android.content.ContentValues;
	import android.database.Cursor;
	import android.database.SQLException;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteStatement;
	import android.net.Uri;
	import android.os.Bundle;
	import android.os.Trace;
	import android.text.TextUtils;
	import android.util.ArrayMap;
	import android.util.Log;

	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;
	import androidx.annotation.VisibleForTesting;

	import java.util.Locale;
	import java.util.function.Consumer;
	import java.util.function.Function;

	public class DatabaseUtils {
	/**
	* Bind the given selection with the given selection arguments.
	* <p>
	* Internally assumes that '?' is only ever used for arguments, and doesn't
	* appear as a literal or escaped value.
	* <p>
	* This method is typically useful for trusted code that needs to cook up a
	* fully-bound selection.
	*
	* @hide
	*/
	public static @Nullable String bindSelection(@Nullable String selection,
	@Nullable Object... selectionArgs) {
	if (selection == null) return null;
	// If no arguments provided, so we can't bind anything
	if ((selectionArgs == null) \|\| (selectionArgs.length == 0)) return selection;
	// If no bindings requested, so we can shortcut
	if (selection.indexOf('?') == -1) return selection;

	// Track the chars immediately before and after each bind request, to
	// decide if it needs additional whitespace added
	char before = ' ';
	char after = ' ';

	int argIndex = 0;
	final int len = selection.length();
	final StringBuilder res = new StringBuilder(len);
	for (int i = 0; i < len; ) {
	char c = selection.charAt(i++);
	if (c == '?') {
	// Assume this bind request is guarded until we find a specific
	// trailing character below
	after = ' ';

	// Sniff forward to see if the selection is requesting a
	// specific argument index
	int start = i;
	for (; i < len; i++) {
	c = selection.charAt(i);
	if (c < '0' \|\| c > '9') {
	after = c;
	break;
	}
	}
	if (start != i) {
	argIndex = Integer.parseInt(selection.substring(start, i)) - 1;
	}

	// Manually bind the argument into the selection, adding
	// whitespace when needed for clarity
	final Object arg = selectionArgs[argIndex++];
	if (before != ' ' && before != '=') res.append(' ');
	switch (DatabaseUtils.getTypeOfObject(arg)) {
	case Cursor.FIELD_TYPE_NULL:
	res.append("NULL");
	break;
	case Cursor.FIELD_TYPE_INTEGER:
	res.append(((Number) arg).longValue());
	break;
	case Cursor.FIELD_TYPE_FLOAT:
	res.append(((Number) arg).doubleValue());
	break;
	case Cursor.FIELD_TYPE_BLOB:
	throw new IllegalArgumentException("Blobs not supported");
	case Cursor.FIELD_TYPE_STRING:
	default:
	if (arg instanceof Boolean) {
	// Provide compatibility with legacy applications which may pass
	// Boolean values in bind args.
	res.append(((Boolean) arg).booleanValue() ? 1 : 0);
	} else {
	res.append('\'');
	// Escape single quote character while appending the string.
	res.append(arg.toString().replace("'", "''"));
	res.append('\'');
	}
	break;
	}
	if (after != ' ') res.append(' ');
	} else {
	res.append(c);
	before = c;
	}
	}
	return res.toString();
	}

	/**
	* Returns data type of the given object's value.
	*<p>
	* Returned values are
	* <ul>
	* <li>{@link Cursor#FIELD_TYPE_NULL}</li>
	* <li>{@link Cursor#FIELD_TYPE_INTEGER}</li>
	* <li>{@link Cursor#FIELD_TYPE_FLOAT}</li>
	* <li>{@link Cursor#FIELD_TYPE_STRING}</li>
	* <li>{@link Cursor#FIELD_TYPE_BLOB}</li>
	*</ul>
	*</p>
	*
	* @param obj the object whose value type is to be returned
	* @return object value type
	* @hide
	*/
	public static int getTypeOfObject(Object obj) {
	if (obj == null) {
	return Cursor.FIELD_TYPE_NULL;
	} else if (obj instanceof byte[]) {
	return Cursor.FIELD_TYPE_BLOB;
	} else if (obj instanceof Float \|\| obj instanceof Double) {
	return Cursor.FIELD_TYPE_FLOAT;
	} else if (obj instanceof Long \|\| obj instanceof Integer
	\|\| obj instanceof Short \|\| obj instanceof Byte) {
	return Cursor.FIELD_TYPE_INTEGER;
	} else {
	return Cursor.FIELD_TYPE_STRING;
	}
	}

	public static void copyFromCursorToContentValues(@NonNull String column, @NonNull Cursor cursor,
	@NonNull ContentValues values) {
	final int index = cursor.getColumnIndex(column);
	if (index != -1) {
	if (cursor.isNull(index)) {
	values.putNull(column);
	} else {
	values.put(column, cursor.getString(index));
	}
	}
	}

	/**
	* Simple attempt to balance the given SQL expression by adding parenthesis
	* when needed.
	* <p>
	* Since this is only used for recovering from abusive apps, we're not
	* interested in trying to build a fully valid SQL parser up in Java. It'll
	* give up when it encounters complex SQL, such as string literals.
	*/
	public static @Nullable String maybeBalance(@Nullable String sql) {
	if (sql == null) return null;

	int count = 0;
	char literal = '\0';
	for (int i = 0; i < sql.length(); i++) {
	final char c = sql.charAt(i);

	if (c == '\'' \|\| c == '"') {
	if (literal == '\0') {
	// Start literal
	literal = c;
	} else if (literal == c) {
	// End literal
	literal = '\0';
	}
	}

	if (literal == '\0') {
	if (c == '(') {
	count++;
	} else if (c == ')') {
	count--;
	}
	}
	}
	while (count > 0) {
	sql = sql + ")";
	count--;
	}
	while (count < 0) {
	sql = "(" + sql;
	count++;
	}
	return sql;
	}

	/**
	* {@link ContentResolver} offers several query arguments, ranging from
	* helpful higher-level concepts like
	* {@link ContentResolver#QUERY_ARG_GROUP_COLUMNS} to raw SQL like
	* {@link ContentResolver#QUERY_ARG_SQL_GROUP_BY}. We prefer the
	* higher-level concepts when defined by the caller, but we'll fall back to
	* the raw SQL if that's all the caller provided.
	* <p>
	* This method will "resolve" all higher-level query arguments into the raw
	* SQL arguments, giving us easy values to carry over into
	* {@link SQLiteQueryBuilder}.
	*/
	public static void resolveQueryArgs(@NonNull Bundle queryArgs,
	@NonNull Consumer<String> honored,
	@NonNull Function<String, String> collatorFactory) {
	// We're always going to handle selections
	honored.accept(QUERY_ARG_SQL_SELECTION);
	honored.accept(QUERY_ARG_SQL_SELECTION_ARGS);

	resolveGroupBy(queryArgs, honored);
	resolveSortOrder(queryArgs, honored, collatorFactory);
	resolveLimit(queryArgs, honored);
	}

	private static void resolveGroupBy(@NonNull Bundle queryArgs,
	@NonNull Consumer<String> honored) {
	final String[] columns = queryArgs.getStringArray(QUERY_ARG_GROUP_COLUMNS);
	if (columns != null && columns.length != 0) {
	String groupBy = TextUtils.join(", ", columns);
	honored.accept(QUERY_ARG_GROUP_COLUMNS);

	queryArgs.putString(QUERY_ARG_SQL_GROUP_BY, groupBy);
	} else {
	honored.accept(QUERY_ARG_SQL_GROUP_BY);
	}
	}

	private static void resolveSortOrder(@NonNull Bundle queryArgs,
	@NonNull Consumer<String> honored,
	@NonNull Function<String, String> collatorFactory) {
	final String[] columns = queryArgs.getStringArray(QUERY_ARG_SORT_COLUMNS);
	if (columns != null && columns.length != 0) {
	String sortOrder = TextUtils.join(", ", columns);
	honored.accept(QUERY_ARG_SORT_COLUMNS);

	if (queryArgs.containsKey(QUERY_ARG_SORT_LOCALE)) {
	final String collatorName = collatorFactory.apply(
	queryArgs.getString(QUERY_ARG_SORT_LOCALE));
	sortOrder += " COLLATE " + collatorName;
	honored.accept(QUERY_ARG_SORT_LOCALE);
	} else {
	// Interpret PRIMARY and SECONDARY collation strength as no-case collation based
	// on their javadoc descriptions.
	final int collation = queryArgs.getInt(
	QUERY_ARG_SORT_COLLATION, java.text.Collator.IDENTICAL);
	switch (collation) {
	case java.text.Collator.IDENTICAL:
	honored.accept(QUERY_ARG_SORT_COLLATION);
	break;
	case java.text.Collator.PRIMARY:
	case java.text.Collator.SECONDARY:
	sortOrder += " COLLATE NOCASE";
	honored.accept(QUERY_ARG_SORT_COLLATION);
	break;
	}
	}

	final int sortDir = queryArgs.getInt(QUERY_ARG_SORT_DIRECTION, Integer.MIN_VALUE);
	switch (sortDir) {
	case QUERY_SORT_DIRECTION_ASCENDING:
	sortOrder += " ASC";
	honored.accept(QUERY_ARG_SORT_DIRECTION);
	break;
	case QUERY_SORT_DIRECTION_DESCENDING:
	sortOrder += " DESC";
	honored.accept(QUERY_ARG_SORT_DIRECTION);
	break;
	}

	queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
	} else {
	honored.accept(QUERY_ARG_SQL_SORT_ORDER);
	}
	}

	private static void resolveLimit(@NonNull Bundle queryArgs,
	@NonNull Consumer<String> honored) {
	final int limit = queryArgs.getInt(QUERY_ARG_LIMIT, Integer.MIN_VALUE);
	if (limit != Integer.MIN_VALUE) {
	String limitString = Integer.toString(limit);
	honored.accept(QUERY_ARG_LIMIT);

	final int offset = queryArgs.getInt(QUERY_ARG_OFFSET, Integer.MIN_VALUE);
	if (offset != Integer.MIN_VALUE) {
	limitString += " OFFSET " + offset;
	honored.accept(QUERY_ARG_OFFSET);
	}

	queryArgs.putString(QUERY_ARG_SQL_LIMIT, limitString);
	} else {
	honored.accept(QUERY_ARG_SQL_LIMIT);
	}
	}

	/**
	* Gracefully recover from abusive callers that are smashing limits into
	* {@link Uri}.
	*/
	public static void recoverAbusiveLimit(@NonNull Uri uri, @NonNull Bundle queryArgs) {
	final String origLimit = queryArgs.getString(QUERY_ARG_SQL_LIMIT);
	final String uriLimit = uri.getQueryParameter("limit");

	if (!TextUtils.isEmpty(uriLimit)) {
	// Yell if we already had a group by requested
	if (!TextUtils.isEmpty(origLimit)) {
	throw new IllegalArgumentException(
	"Abusive '" + uriLimit + "' conflicts with requested '" + origLimit + "'");
	}

	Log.w(TAG, "Recovered abusive '" + uriLimit + "' from '" + uri + "'");

	queryArgs.putString(QUERY_ARG_SQL_LIMIT, uriLimit);
	}
	}

	/**
	* Gracefully recover from abusive callers that are smashing invalid
	* {@code GROUP BY} clauses into {@code WHERE} clauses.
	*/
	public static void recoverAbusiveSelection(@NonNull Bundle queryArgs) {
	final String origSelection = queryArgs.getString(QUERY_ARG_SQL_SELECTION);
	final String origGroupBy = queryArgs.getString(QUERY_ARG_SQL_GROUP_BY);

	final int index = (origSelection != null)
	? origSelection.toUpperCase(Locale.ROOT).indexOf(" GROUP BY ") : -1;
	if (index != -1) {
	String selection = origSelection.substring(0, index);
	String groupBy = origSelection.substring(index + " GROUP BY ".length());

	// Try balancing things out
	selection = maybeBalance(selection);
	groupBy = maybeBalance(groupBy);

	// Yell if we already had a group by requested
	if (!TextUtils.isEmpty(origGroupBy)) {
	throw new IllegalArgumentException(
	"Abusive '" + groupBy + "' conflicts with requested '" + origGroupBy + "'");
	}

	Log.w(TAG, "Recovered abusive '" + selection + "' and '" + groupBy + "' from '"
	+ origSelection + "'");

	queryArgs.putString(QUERY_ARG_SQL_SELECTION, selection);
	queryArgs.putString(QUERY_ARG_SQL_GROUP_BY, groupBy);
	}
	}

	/**
	* Gracefully recover from abusive callers that are smashing limits into
	* {@code ORDER BY} clauses.
	*/
	public static void recoverAbusiveSortOrder(@NonNull Bundle queryArgs) {
	final String origSortOrder = queryArgs.getString(QUERY_ARG_SQL_SORT_ORDER);
	final String origLimit = queryArgs.getString(QUERY_ARG_SQL_LIMIT);

	final int index = (origSortOrder != null)
	? origSortOrder.toUpperCase(Locale.ROOT).indexOf(" LIMIT ") : -1;
	if (index != -1) {
	String sortOrder = origSortOrder.substring(0, index);
	String limit = origSortOrder.substring(index + " LIMIT ".length());

	// Yell if we already had a limit requested
	if (!TextUtils.isEmpty(origLimit)) {
	throw new IllegalArgumentException(
	"Abusive '" + limit + "' conflicts with requested '" + origLimit + "'");
	}

	Log.w(TAG, "Recovered abusive '" + sortOrder + "' and '" + limit + "' from '"
	+ origSortOrder + "'");

	queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
	queryArgs.putString(QUERY_ARG_SQL_LIMIT, limit);
	}
	}

	/**
	* Shamelessly borrowed from {@link ContentResolver}.
	*/
	public static @Nullable Bundle createSqlQueryBundle(
	@Nullable String selection,
	@Nullable String[] selectionArgs,
	@Nullable String sortOrder) {

	if (selection == null && selectionArgs == null && sortOrder == null) {
	return null;
	}

	Bundle queryArgs = new Bundle();
	if (selection != null) {
	queryArgs.putString(QUERY_ARG_SQL_SELECTION, selection);
	}
	if (selectionArgs != null) {
	queryArgs.putStringArray(QUERY_ARG_SQL_SELECTION_ARGS, selectionArgs);
	}
	if (sortOrder != null) {
	queryArgs.putString(QUERY_ARG_SQL_SORT_ORDER, sortOrder);
	}
	return queryArgs;
	}

	public static @NonNull ArrayMap<String, Object> getValues(@NonNull ContentValues values) {
	final ArrayMap<String, Object> res = new ArrayMap<>();
	for (String key : values.keySet()) {
	res.put(key, values.get(key));
	}
	return res;
	}

	public static long executeInsert(@NonNull SQLiteDatabase db, @NonNull String sql,
	@Nullable Object[] bindArgs) throws SQLException {
	Trace.beginSection("executeInsert");
	try (SQLiteStatement st = db.compileStatement(sql)) {
	bindArgs(st, bindArgs);
	return st.executeInsert();
	} finally {
	Trace.endSection();
	}
	}

	public static int executeUpdateDelete(@NonNull SQLiteDatabase db, @NonNull String sql,
	@Nullable Object[] bindArgs) throws SQLException {
	Trace.beginSection("executeUpdateDelete");
	try (SQLiteStatement st = db.compileStatement(sql)) {
	bindArgs(st, bindArgs);
	return st.executeUpdateDelete();
	} finally {
	Trace.endSection();
	}
	}

	private static void bindArgs(@NonNull SQLiteStatement st, @Nullable Object[] bindArgs) {
	if (bindArgs == null) return;

	for (int i = 0; i < bindArgs.length; i++) {
	final Object bindArg = bindArgs[i];
	switch (getTypeOfObject(bindArg)) {
	case Cursor.FIELD_TYPE_NULL:
	st.bindNull(i + 1);
	break;
	case Cursor.FIELD_TYPE_INTEGER:
	st.bindLong(i + 1, ((Number) bindArg).longValue());
	break;
	case Cursor.FIELD_TYPE_FLOAT:
	st.bindDouble(i + 1, ((Number) bindArg).doubleValue());
	break;
	case Cursor.FIELD_TYPE_BLOB:
	st.bindBlob(i + 1, (byte[]) bindArg);
	break;
	case Cursor.FIELD_TYPE_STRING:
	default:
	if (bindArg instanceof Boolean) {
	// Provide compatibility with legacy
	// applications which may pass Boolean values in
	// bind args.
	st.bindLong(i + 1, ((Boolean) bindArg).booleanValue() ? 1 : 0);
	} else {
	st.bindString(i + 1, bindArg.toString());
	}
	break;
	}
	}
	}

	public static @NonNull String bindList(@NonNull Object... args) {
	final StringBuilder sb = new StringBuilder();
	sb.append('(');
	for (int i = 0; i < args.length; i++) {
	sb.append('?');
	if (i < args.length - 1) {
	sb.append(',');
	}
	}
	sb.append(')');
	return DatabaseUtils.bindSelection(sb.toString(), args);
	}

	/**
	* Escape the given argument for use in a {@code LIKE} statement.
	*/
	public static String escapeForLike(@NonNull String arg) {
	final StringBuilder sb = new StringBuilder();
	for (int i = 0; i < arg.length(); i++) {
	final char c = arg.charAt(i);
	switch (c) {
	case '%': sb.append('\\');
	break;
	case '_': sb.append('\\');
	break;
	}
	sb.append(c);
	}
	return sb.toString();
	}

	public static boolean parseBoolean(@Nullable Object value, boolean def) {
	if (value instanceof Boolean) {
	return (Boolean) value;
	} else if (value instanceof Number) {
	return ((Number) value).intValue() != 0;
	} else if (value instanceof String) {
	final String stringValue = ((String) value).toLowerCase(Locale.ROOT);
	return (!"false".equals(stringValue) && !"0".equals(stringValue));
	} else {
	return def;
	}
	}

	public static boolean getAsBoolean(@NonNull Bundle extras,
	@NonNull String key, boolean def) {
	return parseBoolean(extras.get(key), def);
	}

	public static boolean getAsBoolean(@NonNull ContentValues values,
	@NonNull String key, boolean def) {
	return parseBoolean(values.get(key), def);
	}

	public static long getAsLong(@NonNull ContentValues values,
	@NonNull String key, long def) {
	final Long value = values.getAsLong(key);
	return (value != null) ? value : def;
	}
	}