SQLite Android Bindings
Check-in [dafd530d60]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Fix remnant API 11 code and remove unused cruft from DatabaseUtils
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | api-level-9
Files: files | file ages | folders
SHA1:dafd530d608c102e28f0ee35415903d831f65964
User & Date: pjw 2017-05-02 06:27:44
Context
2017-05-02
12:45
Support for loadable extension to be ensabled/disabled by functions on SQLiteDatabase and flag on openDatabase() check-in: bd77d855a1 user: pjw tags: api-level-9
06:27
Fix remnant API 11 code and remove unused cruft from DatabaseUtils check-in: dafd530d60 user: pjw tags: api-level-9
2017-05-01
16:10
Define HAVE_USLEEP to avoid 1 second delays when sleep() is called. Cherrypick of [efde9e0e44]. check-in: b8ff3a7d22 user: dan tags: api-level-9
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Changes to sqlite3/src/main/java/org/sqlite/database/sqlite/DatabaseUtils.java.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


41

42
43
44
45
46
47
48
49
50
51
52
53
..
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
...
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395

1396
1397
1398
1399
1400




1401
1402

1403
1404

1405
1406

1407
1408

1409
1410

1411
1412

1413
1414
1415



1416
1417


1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
package org.sqlite.database.sqlite;

/**
 * Created by pjw on 20-Apr-2017.
 */

import android.content.ContentValues;
import android.content.Context;
import android.content.OperationApplicationException;
import android.database.AbstractWindowedCursor;
import android.database.Cursor;
import android.database.CursorWindow;
import android.database.DatabaseUtils.InsertHelper;
import android.database.SQLException;
import android.database.sqlite.SQLiteAbortException;
import android.database.sqlite.SQLiteConstraintException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabaseCorruptException;
import android.database.sqlite.SQLiteDiskIOException;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteFullException;
import android.database.sqlite.SQLiteProgram;
import android.database.sqlite.SQLiteStatement;
//import android.os.OperationCanceledException;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.text.TextUtils;
import android.util.Log;

import org.sqlite.os.OperationCanceledException;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.text.Collator;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
 * Static utility methods for dealing with databases and {@link Cursor}s.


 */

public class DatabaseUtils {
	private static final String TAG = "DatabaseUtils";

	private static final boolean DEBUG = false;

	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_SELECT = 1;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_UPDATE = 2;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_ATTACH = 3;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
................................................................................
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_DDL = 8;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_UNPREPARED = 9;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_OTHER = 99;

	/**
	 * Special function for writing an exception result at the header of
	 * a parcel, to be used when returning an exception from a transaction.
	 * exception will be re-thrown by the function in another process
	 * @param reply Parcel to write to
	 * @param e The Exception to be written.
	 * @see Parcel#writeNoException
	 * @see Parcel#writeException
	 */
	public static final void writeExceptionToParcel(Parcel reply, Exception e) {
		int code = 0;
		boolean logException = true;
		if (e instanceof FileNotFoundException) {
			code = 1;
			logException = false;
		} else if (e instanceof IllegalArgumentException) {
			code = 2;
		} else if (e instanceof UnsupportedOperationException) {
			code = 3;
		} else if (e instanceof SQLiteAbortException) {
			code = 4;
		} else if (e instanceof SQLiteConstraintException) {
			code = 5;
		} else if (e instanceof SQLiteDatabaseCorruptException) {
			code = 6;
		} else if (e instanceof SQLiteFullException) {
			code = 7;
		} else if (e instanceof SQLiteDiskIOException) {
			code = 8;
		} else if (e instanceof SQLiteException) {
			code = 9;
		} else if (e instanceof OperationApplicationException) {
			code = 10;
		} else if (e instanceof OperationCanceledException) {
			code = 11;
			logException = false;
		} else {
			reply.writeException(e);
			Log.e(TAG, "Writing exception to parcel", e);
			return;
		}
		reply.writeInt(code);
		reply.writeString(e.getMessage());

		if (logException) {
			Log.e(TAG, "Writing exception to parcel", e);
		}
	}

	/**
	 * Special function for reading an exception result from the header of
	 * a parcel, to be used after receiving the result of a transaction.  This
	 * will throw the exception for you if it had been written to the Parcel,
	 * otherwise return and let you read the normal result data from the Parcel.
	 * @param reply Parcel to read from
	 * @see Parcel#writeNoException
	 * @see Parcel#readException
	 */
//	public static final void readExceptionFromParcel(Parcel reply) {
//		int code = reply.readExceptionCode();
//		if (code == 0) return;
//		String msg = reply.readString();
//		android.database.DatabaseUtils.readExceptionFromParcel(reply, msg, code);
//	}
//
//	public static void readExceptionWithFileNotFoundExceptionFromParcel(
//			Parcel reply) throws FileNotFoundException {
//		int code = reply.readExceptionCode();
//		if (code == 0) return;
//		String msg = reply.readString();
//		if (code == 1) {
//			throw new FileNotFoundException(msg);
//		} else {
//			android.database.DatabaseUtils.readExceptionFromParcel(reply, msg, code);
//		}
//	}
//
//	public static void readExceptionWithOperationApplicationExceptionFromParcel(
//			Parcel reply) throws OperationApplicationException {
//		int code = reply.readExceptionCode();
//		if (code == 0) return;
//		String msg = reply.readString();
//		if (code == 10) {
//			throw new OperationApplicationException(msg);
//		} else {
//			android.database.DatabaseUtils.readExceptionFromParcel(reply, msg, code);
//		}
//	}

	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);
		}
	}

	/**
	 * Binds the given Object to the given SQLiteProgram using the proper
	 * typing. For example, bind numbers as longs/doubles, and everything else
	 * as a string by call toString() on it.
	 *
	 * @param prog the program to bind the object to
	 * @param index the 1-based index to bind at
	 * @param value the value to bind
	 */
	public static void bindObjectToProgram(SQLiteProgram prog, int index,
										   Object value) {
		if (value == null) {
			prog.bindNull(index);
		} else if (value instanceof Double || value instanceof Float) {
			prog.bindDouble(index, ((Number)value).doubleValue());
		} else if (value instanceof Number) {
			prog.bindLong(index, ((Number)value).longValue());
		} else if (value instanceof Boolean) {
			Boolean bool = (Boolean)value;
			if (bool) {
				prog.bindLong(index, 1);
			} else {
				prog.bindLong(index, 0);
			}
		} else if (value instanceof byte[]){
			prog.bindBlob(index, (byte[]) value);
		} else {
			prog.bindString(index, value.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;
		}
	}

	/**
	 * Fills the specified cursor window by iterating over the contents of the cursor.
	 * The window is filled until the cursor is exhausted or the window runs out
	 * of space.
	 *
	 * The original position of the cursor is left unchanged by this operation.
	 *
	 * @param cursor The cursor that contains the data to put in the window.
	 * @param position The start position for filling the window.
	 * @param window The window to fill.
	 * @hide
	 */
	public static void cursorFillWindow(final Cursor cursor,
										int position, final CursorWindow window) {
		if (position < 0 || position >= cursor.getCount()) {
			return;
		}
		final int oldPos = cursor.getPosition();
		final int numColumns = cursor.getColumnCount();
		window.clear();
		window.setStartPosition(position);
		window.setNumColumns(numColumns);
		if (cursor.moveToPosition(position)) {
			rowloop: do {
				if (!window.allocRow()) {
					break;
				}
				for (int i = 0; i < numColumns; i++) {
					final int type = cursor.getType(i);
					final boolean success;
					switch (type) {
						case Cursor.FIELD_TYPE_NULL:
							success = window.putNull(position, i);
							break;

						case Cursor.FIELD_TYPE_INTEGER:
							success = window.putLong(cursor.getLong(i), position, i);
							break;

						case Cursor.FIELD_TYPE_FLOAT:
							success = window.putDouble(cursor.getDouble(i), position, i);
							break;

						case Cursor.FIELD_TYPE_BLOB: {
							final byte[] value = cursor.getBlob(i);
							success = value != null ? window.putBlob(value, position, i)
									: window.putNull(position, i);
							break;
						}

						default: // assume value is convertible to String
						case Cursor.FIELD_TYPE_STRING: {
							final String value = cursor.getString(i);
							success = value != null ? window.putString(value, position, i)
									: window.putNull(position, i);
							break;
						}
					}
					if (!success) {
						window.freeLastRow();
						break rowloop;
					}
				}
				position += 1;
			} while (cursor.moveToNext());
		}
		cursor.moveToPosition(oldPos);
	}

	/**
	 * Appends an SQL string to the given StringBuilder, including the opening
	 * and closing single quotes. Any single quotes internal to sqlString will
	 * be escaped.
	 *
	 * This method is deprecated because we want to encourage everyone
	 * to use the "?" binding form.  However, when implementing a
................................................................................
				sb.append(c);
			}
		} else
			sb.append(sqlString);
		sb.append('\'');
	}

	/**
	 * SQL-escape a string.
	 */
	public static String sqlEscapeString(String value) {
		StringBuilder escaper = new StringBuilder();

		android.database.DatabaseUtils.appendEscapedSQLString(escaper, value);

		return escaper.toString();
	}

	/**
	 * Appends an Object to an SQL string with the proper escaping, etc.
	 */
	public static final void appendValueToSql(StringBuilder sql, Object value) {
		if (value == null) {
			sql.append("NULL");
		} else if (value instanceof Boolean) {
			Boolean bool = (Boolean)value;
			if (bool) {
				sql.append('1');
			} else {
				sql.append('0');
			}
		} else {
			appendEscapedSQLString(sql, value.toString());
		}
	}

	/**
	 * Concatenates two SQL WHERE clauses, handling empty or null values.
	 */
	public static String concatenateWhere(String a, String b) {
		if (TextUtils.isEmpty(a)) {
			return b;
		}
		if (TextUtils.isEmpty(b)) {
			return a;
		}

		return "(" + a + ") AND (" + b + ")";
	}

	/**
	 * return the collation key
	 * @param name
	 * @return the collation key
	 */
	public static String getCollationKey(String name) {
		byte [] arr = getCollationKeyInBytes(name);
		try {
			return new String(arr, 0, getKeyLen(arr), "ISO8859_1");
		} catch (Exception ex) {
			return "";
		}
	}

	/**
	 * return the collation key in hex format
	 * @param name
	 * @return the collation key in hex format
	 */
	public static String getHexCollationKey(String name) {
		byte[] arr = getCollationKeyInBytes(name);
		char[] keys = encodeHex(arr);
		return new String(keys, 0, getKeyLen(arr) * 2);
	}


	/**
	 * Used building output as Hex
	 */
	private static final char[] DIGITS = {
			'0', '1', '2', '3', '4', '5', '6', '7',
			'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
	};

	private static char[] encodeHex(byte[] input) {
		int l = input.length;
		char[] out = new char[l << 1];

		// two characters form the hex value.
		for (int i = 0, j = 0; i < l; i++) {
			out[j++] = DIGITS[(0xF0 & input[i]) >>> 4 ];
			out[j++] = DIGITS[ 0x0F & input[i] ];
		}

		return out;
	}

	private static int getKeyLen(byte[] arr) {
		if (arr[arr.length - 1] != 0) {
			return arr.length;
		} else {
			// remove zero "termination"
			return arr.length-1;
		}
	}

	private static byte[] getCollationKeyInBytes(String name) {
		if (mColl == null) {
			mColl = Collator.getInstance();
			mColl.setStrength(Collator.PRIMARY);
		}
		return mColl.getCollationKey(name).toByteArray();
	}

	private static Collator mColl = null;
	/**
	 * Prints the contents of a Cursor to System.out. The position is restored
	 * after printing.
	 *
	 * @param cursor the cursor to print
	 */
	public static void dumpCursor(Cursor cursor) {
		dumpCursor(cursor, System.out);
	}

	/**
	 * Prints the contents of a Cursor to a PrintSteam. The position is restored
	 * after printing.
	 *
	 * @param cursor the cursor to print
	 * @param stream the stream to print to
	 */
	public static void dumpCursor(Cursor cursor, PrintStream stream) {
		stream.println(">>>>> Dumping cursor " + cursor);
		if (cursor != null) {
			int startPos = cursor.getPosition();

			cursor.moveToPosition(-1);
			while (cursor.moveToNext()) {
				dumpCurrentRow(cursor, stream);
			}
			cursor.moveToPosition(startPos);
		}
		stream.println("<<<<<");
	}

	/**
	 * Prints the contents of a Cursor to a StringBuilder. The position
	 * is restored after printing.
	 *
	 * @param cursor the cursor to print
	 * @param sb the StringBuilder to print to
	 */
	public static void dumpCursor(Cursor cursor, StringBuilder sb) {
		sb.append(">>>>> Dumping cursor " + cursor + "\n");
		if (cursor != null) {
			int startPos = cursor.getPosition();

			cursor.moveToPosition(-1);
			while (cursor.moveToNext()) {
				dumpCurrentRow(cursor, sb);
			}
			cursor.moveToPosition(startPos);
		}
		sb.append("<<<<<\n");
	}

	/**
	 * Prints the contents of a Cursor to a String. The position is restored
	 * after printing.
	 *
	 * @param cursor the cursor to print
	 * @return a String that contains the dumped cursor
	 */
	public static String dumpCursorToString(Cursor cursor) {
		StringBuilder sb = new StringBuilder();
		dumpCursor(cursor, sb);
		return sb.toString();
	}

	/**
	 * Prints the contents of a Cursor's current row to System.out.
	 *
	 * @param cursor the cursor to print from
	 */
	public static void dumpCurrentRow(Cursor cursor) {
		dumpCurrentRow(cursor, System.out);
	}

	/**
	 * Prints the contents of a Cursor's current row to a PrintSteam.
	 *
	 * @param cursor the cursor to print
	 * @param stream the stream to print to
	 */
	public static void dumpCurrentRow(Cursor cursor, PrintStream stream) {
		String[] cols = cursor.getColumnNames();
		stream.println("" + cursor.getPosition() + " {");
		int length = cols.length;
		for (int i = 0; i< length; i++) {
			String value;
			try {
				value = cursor.getString(i);
			} catch (SQLiteException e) {
				// assume that if the getString threw this exception then the column is not
				// representable by a string, e.g. it is a BLOB.
				value = "<unprintable>";
			}
			stream.println("   " + cols[i] + '=' + value);
		}
		stream.println("}");
	}

	/**
	 * Prints the contents of a Cursor's current row to a StringBuilder.
	 *
	 * @param cursor the cursor to print
	 * @param sb the StringBuilder to print to
	 */
	public static void dumpCurrentRow(Cursor cursor, StringBuilder sb) {
		String[] cols = cursor.getColumnNames();
		sb.append("" + cursor.getPosition() + " {\n");
		int length = cols.length;
		for (int i = 0; i < length; i++) {
			String value;
			try {
				value = cursor.getString(i);
			} catch (SQLiteException e) {
				// assume that if the getString threw this exception then the column is not
				// representable by a string, e.g. it is a BLOB.
				value = "<unprintable>";
			}
			sb.append("   " + cols[i] + '=' + value + "\n");
		}
		sb.append("}\n");
	}

	/**
	 * Dump the contents of a Cursor's current row to a String.
	 *
	 * @param cursor the cursor to print
	 * @return a String that contains the dumped cursor row
	 */
	public static String dumpCurrentRowToString(Cursor cursor) {
		StringBuilder sb = new StringBuilder();
		dumpCurrentRow(cursor, sb);
		return sb.toString();
	}

	/**
	 * Reads a String out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The TEXT field to read
	 * @param values The {@link ContentValues} to put the value into, with the field as the key
	 */
	public static void cursorStringToContentValues(Cursor cursor, String field,
												   ContentValues values) {
		cursorStringToContentValues(cursor, field, values, field);
	}

	/**
	 * Reads a String out of a field in a Cursor and writes it to an InsertHelper.
	 *
	 * @param cursor The cursor to read from
	 * @param field The TEXT field to read
	 * @param inserter The InsertHelper to bind into
	 * @param index the index of the bind entry in the InsertHelper
	 */
	public static void cursorStringToInsertHelper(Cursor cursor, String field,
												  android.database.DatabaseUtils.InsertHelper inserter, int index) {
		inserter.bind(index, cursor.getString(cursor.getColumnIndexOrThrow(field)));
	}

	/**
	 * Reads a String out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The TEXT field to read
	 * @param values The {@link ContentValues} to put the value into, with the field as the key
	 * @param key The key to store the value with in the map
	 */
	public static void cursorStringToContentValues(Cursor cursor, String field,
												   ContentValues values, String key) {
		values.put(key, cursor.getString(cursor.getColumnIndexOrThrow(field)));
	}

	/**
	 * Reads an Integer out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The INTEGER field to read
	 * @param values The {@link ContentValues} to put the value into, with the field as the key
	 */
	public static void cursorIntToContentValues(Cursor cursor, String field, ContentValues values) {
		cursorIntToContentValues(cursor, field, values, field);
	}

	/**
	 * Reads a Integer out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The INTEGER field to read
	 * @param values The {@link ContentValues} to put the value into, with the field as the key
	 * @param key The key to store the value with in the map
	 */
	public static void cursorIntToContentValues(Cursor cursor, String field, ContentValues values,
												String key) {
		int colIndex = cursor.getColumnIndex(field);
		if (!cursor.isNull(colIndex)) {
			values.put(key, cursor.getInt(colIndex));
		} else {
			values.put(key, (Integer) null);
		}
	}

	/**
	 * Reads a Long out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The INTEGER field to read
	 * @param values The {@link ContentValues} to put the value into, with the field as the key
	 */
	public static void cursorLongToContentValues(Cursor cursor, String field, ContentValues values)
	{
		cursorLongToContentValues(cursor, field, values, field);
	}

	/**
	 * Reads a Long out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The INTEGER field to read
	 * @param values The {@link ContentValues} to put the value into
	 * @param key The key to store the value with in the map
	 */
	public static void cursorLongToContentValues(Cursor cursor, String field, ContentValues values,
												 String key) {
		int colIndex = cursor.getColumnIndex(field);
		if (!cursor.isNull(colIndex)) {
			Long value = Long.valueOf(cursor.getLong(colIndex));
			values.put(key, value);
		} else {
			values.put(key, (Long) null);
		}
	}

	/**
	 * Reads a Double out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The REAL field to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorDoubleToCursorValues(Cursor cursor, String field, ContentValues values)
	{
		cursorDoubleToContentValues(cursor, field, values, field);
	}

	/**
	 * Reads a Double out of a field in a Cursor and writes it to a Map.
	 *
	 * @param cursor The cursor to read from
	 * @param field The REAL field to read
	 * @param values The {@link ContentValues} to put the value into
	 * @param key The key to store the value with in the map
	 */
	public static void cursorDoubleToContentValues(Cursor cursor, String field,
												   ContentValues values, String key) {
		int colIndex = cursor.getColumnIndex(field);
		if (!cursor.isNull(colIndex)) {
			values.put(key, cursor.getDouble(colIndex));
		} else {
			values.put(key, (Double) null);
		}
	}

	/**
	 * Read the entire contents of a cursor row and store them in a ContentValues.
	 *
	 * @param cursor the cursor to read from.
	 * @param values the {@link ContentValues} to put the row into.
	 */
	public static void cursorRowToContentValues(Cursor cursor, ContentValues values) {
		AbstractWindowedCursor awc =
				(cursor instanceof AbstractWindowedCursor) ? (AbstractWindowedCursor) cursor : null;

		String[] columns = cursor.getColumnNames();
		int length = columns.length;
		for (int i = 0; i < length; i++) {
			if (awc != null && awc.isBlob(i)) {
				values.put(columns[i], cursor.getBlob(i));
			} else {
				values.put(columns[i], cursor.getString(i));
			}
		}
	}

	/**
	 * Picks a start position for {@link Cursor#fillWindow} such that the
	 * window will contain the requested row and a useful range of rows
	 * around it.
	 *
	 * When the data set is too large to fit in a cursor window, seeking the
	 * cursor can become a very expensive operation since we have to run the
	 * query again when we move outside the bounds of the current window.
	 *
	 * We try to choose a start position for the cursor window such that
	 * 1/3 of the window's capacity is used to hold rows before the requested
	 * position and 2/3 of the window's capacity is used to hold rows after the
	 * requested position.
	 *
	 * @param cursorPosition The row index of the row we want to get.
	 * @param cursorWindowCapacity The estimated number of rows that can fit in
	 * a cursor window, or 0 if unknown.
	 * @return The recommended start position, always less than or equal to
	 * the requested row.
	 * @hide
	 */
	public static int cursorPickFillWindowStartPosition(
			int cursorPosition, int cursorWindowCapacity) {
		return Math.max(cursorPosition - cursorWindowCapacity / 3, 0);
	}

	/**
	 * Query the table for the number of rows in the table.
	 * @param db the database the table is in
	 * @param table the name of the table to query
	 * @return the number of rows in the table
	 */
	public static long queryNumEntries(SQLiteDatabase db, String table) {
		return queryNumEntries(db, table, null, null);
	}

	/**
	 * Query the table for the number of rows in the table.
	 * @param db the database the table is in
	 * @param table the name of the table to query
	 * @param selection A filter declaring which rows to return,
	 *              formatted as an SQL WHERE clause (excluding the WHERE itself).
	 *              Passing null will count all rows for the given table
	 * @return the number of rows in the table filtered by the selection
	 */
	public static long queryNumEntries(SQLiteDatabase db, String table, String selection) {
		return queryNumEntries(db, table, selection, null);
	}

	/**
	 * Query the table for the number of rows in the table.
	 * @param db the database the table is in
	 * @param table the name of the table to query
	 * @param selection A filter declaring which rows to return,
	 *              formatted as an SQL WHERE clause (excluding the WHERE itself).
	 *              Passing null will count all rows for the given table
	 * @param selectionArgs You may include ?s in selection,
	 *              which will be replaced by the values from selectionArgs,
	 *              in order that they appear in the selection.
	 *              The values will be bound as Strings.
	 * @return the number of rows in the table filtered by the selection
	 */
	public static long queryNumEntries(SQLiteDatabase db, String table, String selection,
									   String[] selectionArgs) {
		String s = (!TextUtils.isEmpty(selection)) ? " where " + selection : "";
		return longForQuery(db, "select count(*) from " + table + s,
							selectionArgs);
	}

	/**
	 * Query the table to check whether a table is empty or not
	 * @param db the database the table is in
	 * @param table the name of the table to query
	 * @return True if the table is empty
	 * @hide
	 */
	public static boolean queryIsEmpty(SQLiteDatabase db, String table) {
		long isEmpty = longForQuery(db, "select exists(select 1 from " + table + ")", null);
		return isEmpty == 0;
	}

	/**
	 * Utility method to run the query on the db and return the value in the
	 * first column of the first row.
	 */
	public static long longForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
		SQLiteStatement prog = db.compileStatement(query);
		try {
			return longForQuery(prog, selectionArgs);
		} finally {
			prog.close();
		}
	}

	/**
	 * Utility method to run the pre-compiled query and return the value in the
	 * first column of the first row.
	 */
	public static long longForQuery(SQLiteStatement prog, String[] selectionArgs) {
		prog.bindAllArgsAsStrings(selectionArgs);
		return prog.simpleQueryForLong();
	}

	/**
	 * Utility method to run the query on the db and return the value in the
	 * first column of the first row.
	 */
	public static String stringForQuery(SQLiteDatabase db, String query, String[] selectionArgs) {
		SQLiteStatement prog = db.compileStatement(query);
		try {
			return stringForQuery(prog, selectionArgs);
		} finally {
			prog.close();
		}
	}

	/**
	 * Utility method to run the pre-compiled query and return the value in the
	 * first column of the first row.
	 */
	public static String stringForQuery(SQLiteStatement prog, String[] selectionArgs) {
		prog.bindAllArgsAsStrings(selectionArgs);
		return prog.simpleQueryForString();
	}

	/**
	 * Utility method to run the query on the db and return the blob value in the
	 * first column of the first row.
	 *
	 * @return A read-only file descriptor for a copy of the blob value.
	 */
	public static ParcelFileDescriptor blobFileDescriptorForQuery(SQLiteDatabase db,
																  String query, String[] selectionArgs) {
		SQLiteStatement prog = db.compileStatement(query);
		try {
			return blobFileDescriptorForQuery(prog, selectionArgs);
		} finally {
			prog.close();
		}
	}

	/**
	 * Utility method to run the pre-compiled query and return the blob value in the
	 * first column of the first row.
	 *
	 * @return A read-only file descriptor for a copy of the blob value.
	 */
	public static ParcelFileDescriptor blobFileDescriptorForQuery(SQLiteStatement prog,
																  String[] selectionArgs) {
		prog.bindAllArgsAsStrings(selectionArgs);
		return prog.simpleQueryForBlobFileDescriptor();
	}

	/**
	 * Reads a String out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorStringToContentValuesIfPresent(Cursor cursor, ContentValues values,
															String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getString(index));
		}
	}

	/**
	 * Reads a Long out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorLongToContentValuesIfPresent(Cursor cursor, ContentValues values,
														  String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getLong(index));
		}
	}

	/**
	 * Reads a Short out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorShortToContentValuesIfPresent(Cursor cursor, ContentValues values,
														   String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getShort(index));
		}
	}

	/**
	 * Reads a Integer out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorIntToContentValuesIfPresent(Cursor cursor, ContentValues values,
														 String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getInt(index));
		}
	}

	/**
	 * Reads a Float out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorFloatToContentValuesIfPresent(Cursor cursor, ContentValues values,
														   String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getFloat(index));
		}
	}

	/**
	 * Reads a Double out of a column in a Cursor and writes it to a ContentValues.
	 * Adds nothing to the ContentValues if the column isn't present or if its value is null.
	 *
	 * @param cursor The cursor to read from
	 * @param column The column to read
	 * @param values The {@link ContentValues} to put the value into
	 */
	public static void cursorDoubleToContentValuesIfPresent(Cursor cursor, ContentValues values,
															String column) {
		final int index = cursor.getColumnIndex(column);
		if (index != -1 && !cursor.isNull(index)) {
			values.put(column, cursor.getDouble(index));
		}
	}

	/**
	 * This class allows users to do multiple inserts into a table using
	 * the same statement.
	 * <p>
	 * This class is not thread-safe.
	 * </p>
	 *
	 * @deprecated Use {@link SQLiteStatement} instead.
	 */
	@Deprecated
	public static class InsertHelper {
		private final SQLiteDatabase mDb;
		private final String mTableName;
		private HashMap<String, Integer> mColumns;
		private String mInsertSQL = null;
		private SQLiteStatement mInsertStatement = null;
		private SQLiteStatement mReplaceStatement = null;
		private SQLiteStatement mPreparedStatement = null;

		/**
		 * {@hide}
		 *
		 * These are the columns returned by sqlite's "PRAGMA
		 * table_info(...)" command that we depend on.
		 */
		public static final int TABLE_INFO_PRAGMA_COLUMNNAME_INDEX = 1;

		/**
		 * This field was accidentally exposed in earlier versions of the platform
		 * so we can hide it but we can't remove it.
		 *
		 * @hide
		 */
		public static final int TABLE_INFO_PRAGMA_DEFAULT_INDEX = 4;

		/**
		 * @param db the SQLiteDatabase to insert into
		 * @param tableName the name of the table to insert into
		 */
		public InsertHelper(SQLiteDatabase db, String tableName) {
			mDb = db;
			mTableName = tableName;
		}

		private void buildSQL() throws SQLException {
			StringBuilder sb = new StringBuilder(128);
			sb.append("INSERT INTO ");
			sb.append(mTableName);
			sb.append(" (");

			StringBuilder sbv = new StringBuilder(128);
			sbv.append("VALUES (");

			int i = 1;
			Cursor cur = null;
			try {
				cur = mDb.rawQuery("PRAGMA table_info(" + mTableName + ")", null);
				mColumns = new HashMap<String, Integer>(cur.getCount());
				while (cur.moveToNext()) {
					String columnName = cur.getString(TABLE_INFO_PRAGMA_COLUMNNAME_INDEX);
					String defaultValue = cur.getString(TABLE_INFO_PRAGMA_DEFAULT_INDEX);

					mColumns.put(columnName, i);
					sb.append("'");
					sb.append(columnName);
					sb.append("'");

					if (defaultValue == null) {
						sbv.append("?");
					} else {
						sbv.append("COALESCE(?, ");
						sbv.append(defaultValue);
						sbv.append(")");
					}

					sb.append(i == cur.getCount() ? ") " : ", ");
					sbv.append(i == cur.getCount() ? ");" : ", ");
					++i;
				}
			} finally {
				if (cur != null) cur.close();
			}

			sb.append(sbv);

			mInsertSQL = sb.toString();
			if (DEBUG) Log.v(TAG, "insert statement is " + mInsertSQL);
		}

		private SQLiteStatement getStatement(boolean allowReplace) throws SQLException {
			if (allowReplace) {
				if (mReplaceStatement == null) {
					if (mInsertSQL == null) buildSQL();
					// chop "INSERT" off the front and prepend "INSERT OR REPLACE" instead.
					String replaceSQL = "INSERT OR REPLACE" + mInsertSQL.substring(6);
					mReplaceStatement = mDb.compileStatement(replaceSQL);
				}
				return mReplaceStatement;
			} else {
				if (mInsertStatement == null) {
					if (mInsertSQL == null) buildSQL();
					mInsertStatement = mDb.compileStatement(mInsertSQL);
				}
				return mInsertStatement;
			}
		}

		/**
		 * Performs an insert, adding a new row with the given values.
		 *
		 * @param values the set of values with which  to populate the
		 * new row
		 * @param allowReplace if true, the statement does "INSERT OR
		 *   REPLACE" instead of "INSERT", silently deleting any
		 *   previously existing rows that would cause a conflict
		 *
		 * @return the row ID of the newly inserted row, or -1 if an
		 * error occurred
		 */
		private long insertInternal(ContentValues values, boolean allowReplace) {
			// Start a transaction even though we don't really need one.
			// This is to help maintain compatibility with applications that
			// access InsertHelper from multiple threads even though they never should have.
			// The original code used to lock the InsertHelper itself which was prone
			// to deadlocks.  Starting a transaction achieves the same mutual exclusion
			// effect as grabbing a lock but without the potential for deadlocks.
			mDb.beginTransactionNonExclusive();
			try {
				SQLiteStatement stmt = getStatement(allowReplace);
				stmt.clearBindings();
				if (DEBUG) Log.v(TAG, "--- inserting in table " + mTableName);
				for (Map.Entry<String, Object> e: values.valueSet()) {
					final String key = e.getKey();
					int i = getColumnIndex(key);
					android.database.DatabaseUtils.bindObjectToProgram(stmt, i, e.getValue());
					if (DEBUG) {
						Log.v(TAG, "binding " + e.getValue() + " to column " +
								i + " (" + key + ")");
					}
				}
				long result = stmt.executeInsert();
				mDb.setTransactionSuccessful();
				return result;
			} catch (SQLException e) {
				Log.e(TAG, "Error inserting " + values + " into table  " + mTableName, e);
				return -1;
			} finally {
				mDb.endTransaction();
			}
		}

		/**
		 * Returns the index of the specified column. This is index is suitagble for use
		 * in calls to bind().
		 * @param key the column name
		 * @return the index of the column
		 */
		public int getColumnIndex(String key) {
			getStatement(false);
			final Integer index = mColumns.get(key);
			if (index == null) {
				throw new IllegalArgumentException("column '" + key + "' is invalid");
			}
			return index;
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, double value) {
			mPreparedStatement.bindDouble(index, value);
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, float value) {
			mPreparedStatement.bindDouble(index, value);
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, long value) {
			mPreparedStatement.bindLong(index, value);
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, int value) {
			mPreparedStatement.bindLong(index, value);
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, boolean value) {
			mPreparedStatement.bindLong(index, value ? 1 : 0);
		}

		/**
		 * Bind null to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 */
		public void bindNull(int index) {
			mPreparedStatement.bindNull(index);
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, byte[] value) {
			if (value == null) {
				mPreparedStatement.bindNull(index);
			} else {
				mPreparedStatement.bindBlob(index, value);
			}
		}

		/**
		 * Bind the value to an index. A prepareForInsert() or prepareForReplace()
		 * without a matching execute() must have already have been called.
		 * @param index the index of the slot to which to bind
		 * @param value the value to bind
		 */
		public void bind(int index, String value) {
			if (value == null) {
				mPreparedStatement.bindNull(index);
			} else {
				mPreparedStatement.bindString(index, value);
			}
		}

		/**
		 * Performs an insert, adding a new row with the given values.
		 * If the table contains conflicting rows, an error is
		 * returned.
		 *
		 * @param values the set of values with which to populate the
		 * new row
		 *
		 * @return the row ID of the newly inserted row, or -1 if an
		 * error occurred
		 */
		public long insert(ContentValues values) {
			return insertInternal(values, false);
		}

		/**
		 * Execute the previously prepared insert or replace using the bound values
		 * since the last call to prepareForInsert or prepareForReplace.
		 *
		 * <p>Note that calling bind() and then execute() is not thread-safe. The only thread-safe
		 * way to use this class is to call insert() or replace().
		 *
		 * @return the row ID of the newly inserted row, or -1 if an
		 * error occurred
		 */
		public long execute() {
			if (mPreparedStatement == null) {
				throw new IllegalStateException("you must prepare this inserter before calling "
														+ "execute");
			}
			try {
				if (DEBUG) Log.v(TAG, "--- doing insert or replace in table " + mTableName);
				return mPreparedStatement.executeInsert();
			} catch (SQLException e) {
				Log.e(TAG, "Error executing InsertHelper with table " + mTableName, e);
				return -1;
			} finally {
				// you can only call this once per prepare
				mPreparedStatement = null;
			}
		}

		/**
		 * Prepare the InsertHelper for an insert. The pattern for this is:
		 * <ul>
		 * <li>prepareForInsert()
		 * <li>bind(index, value);
		 * <li>bind(index, value);
		 * <li>...
		 * <li>bind(index, value);
		 * <li>execute();
		 * </ul>
		 */
		public void prepareForInsert() {
			mPreparedStatement = getStatement(false);
			mPreparedStatement.clearBindings();
		}

		/**
		 * Prepare the InsertHelper for a replace. The pattern for this is:
		 * <ul>
		 * <li>prepareForReplace()
		 * <li>bind(index, value);
		 * <li>bind(index, value);
		 * <li>...
		 * <li>bind(index, value);
		 * <li>execute();
		 * </ul>
		 */
		public void prepareForReplace() {
			mPreparedStatement = getStatement(true);
			mPreparedStatement.clearBindings();
		}

		/**
		 * Performs an insert, adding a new row with the given values.
		 * If the table contains conflicting rows, they are deleted
		 * and replaced with the new row.
		 *
		 * @param values the set of values with which to populate the
		 * new row
		 *
		 * @return the row ID of the newly inserted row, or -1 if an
		 * error occurred
		 */
		public long replace(ContentValues values) {
			return insertInternal(values, true);
		}

		/**
		 * Close this object and release any resources associated with
		 * it.  The behavior of calling <code>insert()</code> after
		 * calling this method is undefined.
		 */
		public void close() {
			if (mInsertStatement != null) {
				mInsertStatement.close();
				mInsertStatement = null;
			}
			if (mReplaceStatement != null) {
				mReplaceStatement.close();
				mReplaceStatement = null;
			}
			mInsertSQL = null;
			mColumns = null;
		}
	}

	/**
	 * Creates a db and populates it with the sql statements in sqlStatements.
	 *
	 * @param context the context to use to create the db
	 * @param dbName the name of the db to create
	 * @param dbVersion the version to set on the db
	 * @param sqlStatements the statements to use to populate the db. This should be a single string
	 *   of the form returned by sqlite3's <tt>.dump</tt> command (statements separated by
	 *   semicolons)
	 */
	static public void createDbFromSqlStatements(
			Context context, String dbName, int dbVersion, String sqlStatements) {
		SQLiteDatabase db = context.openOrCreateDatabase(dbName, 0, null);
		// TODO: this is not quite safe since it assumes that all semicolons at the end of a line
		// terminate statements. It is possible that a text field contains ;\n. We will have to fix
		// this if that turns out to be a problem.
		String[] statements = TextUtils.split(sqlStatements, ";\n");
		for (String statement : statements) {
			if (TextUtils.isEmpty(statement)) continue;
			db.execSQL(statement);
		}
		db.setVersion(dbVersion);
		db.close();
	}

	/**
	 * Returns one of the following which represent the type of the given SQL statement.
	 * <ol>
	 *   <li>{@link #STATEMENT_SELECT}</li>
	 *   <li>{@link #STATEMENT_UPDATE}</li>
	 *   <li>{@link #STATEMENT_ATTACH}</li>
	 *   <li>{@link #STATEMENT_BEGIN}</li>
	 *   <li>{@link #STATEMENT_COMMIT}</li>
	 *   <li>{@link #STATEMENT_ABORT}</li>
	 *   <li>{@link #STATEMENT_OTHER}</li>
	 * </ol>
	 * @param sql the SQL statement whose type is returned by this method
	 * @return one of the values listed above
	 */
	public static int getSqlStatementType(String sql) {
		sql = sql.trim();
		if (sql.length() < 3) {
			return STATEMENT_OTHER;
		}
		String prefixSql = sql.substring(0, 3).toUpperCase(Locale.ROOT);
		if (prefixSql.equals("SEL")) {

			return STATEMENT_SELECT;
		} else if (prefixSql.equals("INS") ||
				prefixSql.equals("UPD") ||
				prefixSql.equals("REP") ||
				prefixSql.equals("DEL")) {




			return STATEMENT_UPDATE;
		} else if (prefixSql.equals("ATT")) {

			return STATEMENT_ATTACH;
		} else if (prefixSql.equals("COM")) {

			return STATEMENT_COMMIT;
		} else if (prefixSql.equals("END")) {

			return STATEMENT_COMMIT;
		} else if (prefixSql.equals("ROL")) {

			return STATEMENT_ABORT;
		} else if (prefixSql.equals("BEG")) {

			return STATEMENT_BEGIN;
		} else if (prefixSql.equals("PRA")) {

			return STATEMENT_PRAGMA;
		} else if (prefixSql.equals("CRE") || prefixSql.equals("DRO") ||
				prefixSql.equals("ALT")) {



			return STATEMENT_DDL;
		} else if (prefixSql.equals("ANA") || prefixSql.equals("DET")) {


			return STATEMENT_UNPREPARED;
		}
		return STATEMENT_OTHER;
	}

	/**
	 * Appends one set of selection args to another. This is useful when adding a selection
	 * argument to a user provided set.
	 */
	public static String[] appendSelectionArgs(String[] originalValues, String[] newValues) {
		if (originalValues == null || originalValues.length == 0) {
			return newValues;
		}
		String[] result = new String[originalValues.length + newValues.length ];
		System.arraycopy(originalValues, 0, result, 0, originalValues.length);
		System.arraycopy(newValues, 0, result, originalValues.length, newValues.length);
		return result;
	}

	/**
	 * Returns column index of "_id" column, or -1 if not found.
	 * @hide
	 */
	public static int findRowIdColumnIndex(String[] columnNames) {
		int length = columnNames.length;
		for (int i = 0; i < length; i++) {
			if (columnNames[i].equals("_id")) {
				return i;
			}
		}
		return -1;
	}
}


<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<

<


|
>
>

>

<
<
<
<







 







<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<







 







<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






|
>
|
<
<
<
<
>
>
>
>
|
<
>
|
<
>
|
<
>
|
<
>
|
<
>
|
<
>
|
<
<
>
>
>
|
<
>
>
|



|
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
1
2

































3

4
5
6
7
8
9
10
11




12
13
14
15
16
17
18
..
26
27
28
29
30
31
32






















































































































































































































































33
34
35
36
37
38
39
..
61
62
63
64
65
66
67
















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































68
69
70
71
72
73
74
75
76




77
78
79
80
81

82
83

84
85

86
87

88
89

90
91

92
93


94
95
96
97

98
99
100
101
102
103
104




























package org.sqlite.database.sqlite;


































import java.util.Locale;


/**
 * Static utility methods for dealing with databases; cloned and trimed from Android source.
 *
 * Created by pjw on 20-Apr-2017.
 */
@SuppressWarnings("WeakerAccess")
public class DatabaseUtils {




	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_SELECT = 1;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_UPDATE = 2;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_ATTACH = 3;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
................................................................................
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_DDL = 8;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_UNPREPARED = 9;
	/** One of the values returned by {@link #getSqlStatementType(String)}. */
	public static final int STATEMENT_OTHER = 99;























































































































































































































































	/**
	 * Appends an SQL string to the given StringBuilder, including the opening
	 * and closing single quotes. Any single quotes internal to sqlString will
	 * be escaped.
	 *
	 * This method is deprecated because we want to encourage everyone
	 * to use the "?" binding form.  However, when implementing a
................................................................................
				sb.append(c);
			}
		} else
			sb.append(sqlString);
		sb.append('\'');
	}

















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































	public static int getSqlStatementType(String sql) {
		sql = sql.trim();
		if (sql.length() < 3) {
			return STATEMENT_OTHER;
		}
		String prefixSql = sql.substring(0, 3).toUpperCase(Locale.ROOT);
		switch (prefixSql) {
			case "SEL":
				return STATEMENT_SELECT;




			case "INS":
			case "UPD":
			case "REP":
			case "DEL":
				return STATEMENT_UPDATE;

			case "ATT":
				return STATEMENT_ATTACH;

			case "COM":
				return STATEMENT_COMMIT;

			case "END":
				return STATEMENT_COMMIT;

			case "ROL":
				return STATEMENT_ABORT;

			case "BEG":
				return STATEMENT_BEGIN;

			case "PRA":
				return STATEMENT_PRAGMA;


			case "CRE":
			case "DRO":
			case "ALT":
				return STATEMENT_DDL;

			case "ANA":
			case "DET":
				return STATEMENT_UNPREPARED;
		}
		return STATEMENT_OTHER;
	}
}




























Changes to sqlite3/src/main/java/org/sqlite/database/sqlite/SQLiteDatabase.java.

43
44
45
46
47
48
49

50
51
52
53
54
55
56
....
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
....
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import java.util.WeakHashMap;

/**
 * Exposes methods to manage a SQLite database.
 *
 * <p>
 * SQLiteDatabase has methods to create, delete, execute SQL commands, and
................................................................................

            Object[] bindArgs = null;
            int size = (initialValues != null && initialValues.size() > 0)
                    ? initialValues.size() : 0;
            if (size > 0) {
                bindArgs = new Object[size];
                int i = 0;
                for (String colName : initialValues.keySet()) {
                    sql.append((i > 0) ? "," : "");
                    sql.append(colName);
                    bindArgs[i++] = initialValues.get(colName);
                }
                sql.append(')');
                sql.append(" VALUES (");
                for (i = 0; i < size; i++) {
                    sql.append((i > 0) ? ",?" : "?");
                }
            } else {
................................................................................
            sql.append(" SET ");

            // move all bind args to one array
            int setValuesSize = values.size();
            int bindArgsSize = (whereArgs == null) ? setValuesSize : (setValuesSize + whereArgs.length);
            Object[] bindArgs = new Object[bindArgsSize];
            int i = 0;
            for (String colName : values.keySet()) {
                sql.append((i > 0) ? "," : "");
                sql.append(colName);
                bindArgs[i++] = values.get(colName);
                sql.append("=?");
            }
            if (whereArgs != null) {
                for (i = setValuesSize; i < bindArgsSize; i++) {
                    bindArgs[i] = whereArgs[i - setValuesSize];
                }
            }







>







 







|

|
|







 







|

|
|







43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
....
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
....
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.WeakHashMap;

/**
 * Exposes methods to manage a SQLite database.
 *
 * <p>
 * SQLiteDatabase has methods to create, delete, execute SQL commands, and
................................................................................

            Object[] bindArgs = null;
            int size = (initialValues != null && initialValues.size() > 0)
                    ? initialValues.size() : 0;
            if (size > 0) {
                bindArgs = new Object[size];
                int i = 0;
                for (Entry<String, Object> entry : initialValues.valueSet()) {
                    sql.append((i > 0) ? "," : "");
                    sql.append(entry.getKey());
                    bindArgs[i++] = entry.getValue();
                }
                sql.append(')');
                sql.append(" VALUES (");
                for (i = 0; i < size; i++) {
                    sql.append((i > 0) ? ",?" : "?");
                }
            } else {
................................................................................
            sql.append(" SET ");

            // move all bind args to one array
            int setValuesSize = values.size();
            int bindArgsSize = (whereArgs == null) ? setValuesSize : (setValuesSize + whereArgs.length);
            Object[] bindArgs = new Object[bindArgsSize];
            int i = 0;
            for (Entry<String, Object> entry : values.valueSet()) {
                sql.append((i > 0) ? "," : "");
                sql.append(entry.getKey());
                bindArgs[i++] = entry.getValue();
                sql.append("=?");
            }
            if (whereArgs != null) {
                for (i = setValuesSize; i < bindArgsSize; i++) {
                    bindArgs[i] = whereArgs[i - setValuesSize];
                }
            }

Changes to sqlite3/src/main/java/org/sqlite/database/sqlite/SQLiteQueryBuilder.java.

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
** Modified to support SQLite extensions by the SQLite developers: 
** sqlite-dev@sqlite.org.
*/

package org.sqlite.database.sqlite;

import android.database.Cursor;
import android.database.DatabaseUtils;
import org.sqlite.os.CancellationSignal;
import org.sqlite.os.OperationCanceledException;
import android.provider.BaseColumns;
import android.text.TextUtils;
import android.util.Log;

import java.util.Iterator;







<







17
18
19
20
21
22
23

24
25
26
27
28
29
30
** Modified to support SQLite extensions by the SQLite developers: 
** sqlite-dev@sqlite.org.
*/

package org.sqlite.database.sqlite;

import android.database.Cursor;

import org.sqlite.os.CancellationSignal;
import org.sqlite.os.OperationCanceledException;
import android.provider.BaseColumns;
import android.text.TextUtils;
import android.util.Log;

import java.util.Iterator;