{
18 |
19 | private final UriMatcher mUriMatcher;
20 |
21 | private final List
mTables;
22 |
23 | SQLiteSchema() {
24 | mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
25 | mTables = new ArrayList<>();
26 | }
27 |
28 | /**
29 | * This method adds you table to the ContentProvider
30 | *
31 | * @param table - table to add to the database
32 | */
33 | public void register(@NonNull Table table) {
34 | mUriMatcher.addURI(SQLiteContentProvider.getContentAuthority(), table.getTableName(), mTables.size());
35 | mTables.add(table);
36 | }
37 |
38 | int calculateVersion() {
39 | int version = 1;
40 | for (Table table : mTables) {
41 | int tableVersion = table.getLastUpgradeVersion();
42 | if (tableVersion > version) {
43 | version = tableVersion;
44 | }
45 | }
46 | return version;
47 | }
48 |
49 | @NonNull
50 | String findTable(@NonNull Uri uri) {
51 | int index = mUriMatcher.match(uri);
52 | if (index < 0 || index >= mTables.size()) {
53 | return "";
54 | }
55 | return mTables.get(index).getTableName();
56 | }
57 |
58 | @Override
59 | public Iterator
iterator() {
60 | return mTables.iterator();
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 |
3 | android {
4 | compileSdkVersion 25
5 | buildToolsVersion "25.0.2"
6 |
7 | defaultConfig {
8 | minSdkVersion 16
9 | targetSdkVersion 25
10 | versionCode 1
11 | versionName project.PUBLISH_VERSION
12 |
13 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
14 | }
15 | buildTypes {
16 | release {
17 | minifyEnabled false
18 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
19 | }
20 | debug {
21 | testCoverageEnabled true
22 | }
23 | }
24 |
25 | compileOptions {
26 | sourceCompatibility JavaVersion.VERSION_1_7
27 | targetCompatibility JavaVersion.VERSION_1_7
28 | }
29 |
30 | testOptions {
31 | unitTests {
32 | all {
33 | jvmArgs '-noverify'
34 | jacoco {
35 | includeNoLocationClasses = true
36 | }
37 | }
38 | }
39 | }
40 | }
41 |
42 | dependencies {
43 | compile 'ru.arturvasilov:sqlite-bindings:0.1.2'
44 |
45 | compile 'com.android.support:appcompat-v7:25.1.1'
46 | compile 'io.reactivex.rxjava2:rxjava:2.0.5'
47 | compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
48 |
49 | testCompile 'junit:junit:4.12'
50 | testCompile 'org.mockito:mockito-core:1.10.19'
51 |
52 | androidTestCompile 'com.android.support:support-annotations:25.1.1'
53 | androidTestCompile 'com.android.support.test:runner:0.5'
54 | androidTestCompile 'com.android.support.test:rules:0.5'
55 | androidTestCompile "com.crittercism.dexmaker:dexmaker:1.4"
56 | androidTestCompile "com.crittercism.dexmaker:dexmaker-dx:1.4"
57 | androidTestCompile "com.crittercism.dexmaker:dexmaker-mockito:1.4"
58 | androidTestCompile 'org.mockito:mockito-core:1.10.19'
59 | }
60 |
61 | apply from: 'jacoco.gradle'
62 | apply from: 'bintray.gradle'
63 |
--------------------------------------------------------------------------------
/app/src/androidTest/java/ru/arturvasilov/sqlite/core/ContentProviderErrorsTest.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.core;
2 |
3 | import android.content.ContentValues;
4 | import android.database.Cursor;
5 | import android.support.annotation.NonNull;
6 | import android.support.test.InstrumentationRegistry;
7 |
8 | import org.junit.Before;
9 | import org.junit.Test;
10 | import org.junit.runner.RunWith;
11 | import org.junit.runners.JUnit4;
12 | import org.sqlite.database.sqlite.SQLiteDatabase;
13 |
14 | /**
15 | * @author Artur Vasilov
16 | */
17 | @RunWith(JUnit4.class)
18 | public class ContentProviderErrorsTest {
19 |
20 | private static final Table BAD_TABLE = new BadTable();
21 |
22 | @Before
23 | public void setUp() throws Exception {
24 | SQLite.initialize(InstrumentationRegistry.getContext());
25 | }
26 |
27 | @Test(expected = IllegalArgumentException.class)
28 | public void testBadQuery() throws Exception {
29 | SQLite.get().query(BAD_TABLE);
30 | }
31 |
32 | @Test(expected = IllegalArgumentException.class)
33 | public void testBadInsert() throws Exception {
34 | SQLite.get().insert(BAD_TABLE, 5);
35 | }
36 |
37 | @Test(expected = IllegalArgumentException.class)
38 | public void testBadUpdate() throws Exception {
39 | SQLite.get().update(BAD_TABLE, Where.create(), 100);
40 | }
41 |
42 | @Test(expected = IllegalArgumentException.class)
43 | public void testBadDelete() throws Exception {
44 | SQLite.get().delete(BAD_TABLE);
45 | }
46 |
47 | private static class BadTable extends BaseTable {
48 |
49 | @Override
50 | public void onCreate(@NonNull SQLiteDatabase database) {
51 | throw new RuntimeException("Stub!");
52 | }
53 |
54 | @NonNull
55 | @Override
56 | public ContentValues toValues(@NonNull Integer integer) {
57 | return new ContentValues();
58 | }
59 |
60 | @NonNull
61 | @Override
62 | public Integer fromCursor(@NonNull Cursor cursor) {
63 | throw new RuntimeException("Stub!");
64 | }
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/utils/SQLiteUtils.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.utils;
2 |
3 | import android.database.Cursor;
4 | import android.support.annotation.NonNull;
5 | import android.support.annotation.Nullable;
6 |
7 | import ru.arturvasilov.sqlite.core.SQLite;
8 | import ru.arturvasilov.sqlite.core.Table;
9 |
10 | /**
11 | * Utility class for safe methods to work with database.
12 | *
13 | * @author Artur Vasilov
14 | */
15 | public class SQLiteUtils {
16 |
17 | private SQLiteUtils() {
18 | }
19 |
20 | /**
21 | * Fast method to determine if any rows in database exists in table
22 | *
23 | * @param table to test if it's empty
24 | * @return whatever table is empty or not
25 | */
26 | public static boolean isTableEmpty(@NonNull Table table) {
27 | Cursor cursor = SQLite.get().getContentResolver().query(
28 | table.getUri(),
29 | new String[] {"count(*) AS count"},
30 | null,
31 | null,
32 | null);
33 | try {
34 | return cursor == null || cursor.getCount() == 0
35 | || !cursor.moveToFirst() || cursor.getInt(0) == 0;
36 | }
37 | finally {
38 | safeCloseCursor(cursor);
39 | }
40 | }
41 |
42 | /**
43 | * Method to test if any rows in cursor exists. It's safe, you can pass null cursor or closed, e.g.
44 | *
45 | * @param cursor - cursor you want to check if it's empty
46 | * @return - true if cursor is null, closed or empty or false in other cases
47 | */
48 | public static boolean isEmptyCursor(@Nullable Cursor cursor) {
49 | if (cursor == null) {
50 | return true;
51 | }
52 |
53 | //noinspection SimplifiableIfStatement
54 | if (cursor.isClosed()) {
55 | return true;
56 | }
57 |
58 | return !cursor.moveToFirst();
59 | }
60 |
61 | /**
62 | * Closing cursor was always the hell (since you have to check if it's null or closed and so on,
63 | * but this method handles all the cases and safely closes the cursor.
64 | *
65 | * @param cursor - cursor you want to close
66 | */
67 | public static void safeCloseCursor(@Nullable Cursor cursor) {
68 | if (cursor == null || cursor.isClosed()) {
69 | return;
70 | }
71 |
72 | try {
73 | cursor.close();
74 | } catch (Exception ignored) {
75 | }
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/app/src/androidTest/java/ru/arturvasilov/sqlite/utils/EmptyTableTest.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.utils;
2 |
3 | import android.support.test.InstrumentationRegistry;
4 | import android.support.test.runner.AndroidJUnit4;
5 |
6 | import org.junit.After;
7 | import org.junit.Before;
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 |
11 | import java.util.ArrayList;
12 | import java.util.List;
13 |
14 | import ru.arturvasilov.sqlite.core.SQLite;
15 | import ru.arturvasilov.sqlite.testutils.TestObject;
16 | import ru.arturvasilov.sqlite.testutils.TestTable;
17 |
18 | import static org.junit.Assert.assertFalse;
19 | import static org.junit.Assert.assertTrue;
20 |
21 | /**
22 | * @author Artur Vasilov
23 | */
24 | @RunWith(AndroidJUnit4.class)
25 | public class EmptyTableTest {
26 |
27 | @Before
28 | public void setUp() throws Exception {
29 | SQLite.initialize(InstrumentationRegistry.getContext());
30 | SQLite.get().disableAutomaticNotifications();
31 | }
32 |
33 | @Test
34 | public void testEmptyTable() throws Exception {
35 | SQLite.get().delete(TestTable.TABLE);
36 | boolean isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
37 | assertTrue(isEmpty);
38 | }
39 |
40 | @Test
41 | public void testNotEmptyTable() throws Exception {
42 | SQLite.get().insert(TestTable.TABLE, new TestObject(1, 6.4, "test"));
43 | boolean isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
44 | assertFalse(isEmpty);
45 | }
46 |
47 | @Test
48 | public void testTableChanges() throws Exception {
49 | SQLite.get().insert(TestTable.TABLE, new TestObject(7, 9.1, "testing empty table"));
50 | boolean isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
51 | assertFalse(isEmpty);
52 |
53 | SQLite.get().delete(TestTable.TABLE);
54 | isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
55 | assertTrue(isEmpty);
56 |
57 | List list = new ArrayList<>();
58 | list.add(new TestObject(8, 7.6, ""));
59 | list.add(new TestObject(9, 4, "any"));
60 | SQLite.get().insert(TestTable.TABLE, list);
61 |
62 | isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
63 | assertFalse(isEmpty);
64 |
65 | SQLite.get().delete(TestTable.TABLE);
66 | isEmpty = SQLiteUtils.isTableEmpty(TestTable.TABLE);
67 | assertTrue(isEmpty);
68 | }
69 |
70 | @After
71 | public void tearDown() throws Exception {
72 | SQLite.get().delete(TestTable.TABLE);
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @if "%DEBUG%" == "" @echo off
2 | @rem ##########################################################################
3 | @rem
4 | @rem Gradle startup script for Windows
5 | @rem
6 | @rem ##########################################################################
7 |
8 | @rem Set local scope for the variables with windows NT shell
9 | if "%OS%"=="Windows_NT" setlocal
10 |
11 | set DIRNAME=%~dp0
12 | if "%DIRNAME%" == "" set DIRNAME=.
13 | set APP_BASE_NAME=%~n0
14 | set APP_HOME=%DIRNAME%
15 |
16 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
17 | set DEFAULT_JVM_OPTS=
18 |
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 |
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 |
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 |
32 | goto fail
33 |
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 |
38 | if exist "%JAVA_EXE%" goto init
39 |
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 |
46 | goto fail
47 |
48 | :init
49 | @rem Get command-line arguments, handling Windows variants
50 |
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 |
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 |
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 |
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 |
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 |
69 | :execute
70 | @rem Setup the command line
71 |
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 |
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 |
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 |
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 |
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 |
90 | :omega
91 |
--------------------------------------------------------------------------------
/app/src/test/java/ru/arturvasilov/sqlite/utils/SQLiteUtilsTest.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.utils;
2 |
3 | import android.database.Cursor;
4 |
5 | import org.junit.Test;
6 | import org.junit.runner.RunWith;
7 | import org.junit.runners.JUnit4;
8 |
9 | import static junit.framework.Assert.assertFalse;
10 | import static junit.framework.Assert.assertTrue;
11 | import static org.mockito.Mockito.doNothing;
12 | import static org.mockito.Mockito.doThrow;
13 | import static org.mockito.Mockito.mock;
14 | import static org.mockito.Mockito.never;
15 | import static org.mockito.Mockito.verify;
16 | import static org.mockito.Mockito.when;
17 |
18 | /**
19 | * @author Artur Vasilov
20 | */
21 | @RunWith(JUnit4.class)
22 | public class SQLiteUtilsTest {
23 |
24 | @Test
25 | public void testCursorEmptyNull() throws Exception {
26 | boolean isEmpty = SQLiteUtils.isEmptyCursor(null);
27 | //noinspection ConstantConditions
28 | assertTrue(isEmpty);
29 | }
30 |
31 | @Test
32 | public void testCursorEmptyClosed() throws Exception {
33 | Cursor cursor = mock(Cursor.class);
34 | when(cursor.isClosed()).thenReturn(true);
35 |
36 | boolean isEmpty = SQLiteUtils.isEmptyCursor(cursor);
37 | //noinspection ConstantConditions
38 | assertTrue(isEmpty);
39 | }
40 |
41 | @Test
42 | public void testCursorEmpty() throws Exception {
43 | Cursor cursor = mock(Cursor.class);
44 | when(cursor.isClosed()).thenReturn(true);
45 | when(cursor.moveToFirst()).thenReturn(false);
46 |
47 | boolean isEmpty = SQLiteUtils.isEmptyCursor(cursor);
48 | //noinspection ConstantConditions
49 | assertTrue(isEmpty);
50 | }
51 |
52 | @Test
53 | public void testCursorNotEmpty() throws Exception {
54 | Cursor cursor = mock(Cursor.class);
55 | when(cursor.isClosed()).thenReturn(false);
56 | when(cursor.moveToFirst()).thenReturn(true);
57 |
58 | boolean isEmpty = SQLiteUtils.isEmptyCursor(cursor);
59 | //noinspection ConstantConditions
60 | assertFalse(isEmpty);
61 | }
62 |
63 | @Test
64 | public void testCloseNullCursor() throws Exception {
65 | SQLiteUtils.safeCloseCursor(null);
66 | }
67 |
68 | @Test
69 | public void testClosedCursor() throws Exception {
70 | Cursor cursor = mock(Cursor.class);
71 | when(cursor.isClosed()).thenReturn(true);
72 | SQLiteUtils.safeCloseCursor(cursor);
73 |
74 | verify(cursor, never()).close();
75 | }
76 |
77 | @Test
78 | public void testExceptionCursor() throws Exception {
79 | Cursor cursor = mock(Cursor.class);
80 | when(cursor.isClosed()).thenReturn(false);
81 | doThrow(new RuntimeException()).when(cursor).close();
82 | SQLiteUtils.safeCloseCursor(cursor);
83 | }
84 |
85 | @Test
86 | public void testCloseCursor() throws Exception {
87 | Cursor cursor = mock(Cursor.class);
88 | when(cursor.isClosed()).thenReturn(false);
89 | doNothing().when(cursor).close();
90 | SQLiteUtils.safeCloseCursor(cursor);
91 |
92 | verify(cursor).close();
93 | }
94 |
95 | }
96 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/rx/TableObservable.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.rx;
2 |
3 | import android.support.annotation.NonNull;
4 |
5 | import java.util.List;
6 |
7 | import io.reactivex.Observable;
8 | import io.reactivex.ObservableSource;
9 | import io.reactivex.Observer;
10 | import io.reactivex.android.MainThreadDisposable;
11 | import io.reactivex.functions.Function;
12 | import io.reactivex.schedulers.Schedulers;
13 | import ru.arturvasilov.sqlite.core.BasicTableObserver;
14 | import ru.arturvasilov.sqlite.core.SQLite;
15 | import ru.arturvasilov.sqlite.core.Table;
16 | import ru.arturvasilov.sqlite.core.Where;
17 |
18 | /**
19 | * Class which allows you to observe changes in {@link Table} in reactive way
20 | *
21 | * Simple call of {@link RxSQLite#observeChanges(Table)} will return you an instance of this observable,
22 | * and you can any operations with this observable.
23 | *
24 | * For this Observable {@link Observer#onNext(Object)} called each time when table changes
25 | * and {@link Observer#onComplete()} is never called.
26 | *
27 | * This observable add {@link TableObservable#withQuery()} method to allow you query all rows from the observed tabled.
28 | *
29 | * @author Artur Vasilov
30 | */
31 | public class TableObservable extends Observable {
32 |
33 | private final Table mTable;
34 |
35 | TableObservable(@NonNull Table table) {
36 | mTable = table;
37 | }
38 |
39 | @Override
40 | protected void subscribeActual(Observer observer) {
41 | TableListener tableListener = new TableListener(observer);
42 | observer.onSubscribe(tableListener);
43 | SQLite.get().registerObserver(mTable, tableListener);
44 | }
45 |
46 | /**
47 | * This method transforms notifications observable to the observable with list of all objects in the table.
48 | *
49 | * It also works in the background.
50 | *
51 | * @return observable with all elements from the table
52 | */
53 | @NonNull
54 | public Observable> withQuery() {
55 | return withQuery(Where.create());
56 | }
57 |
58 | /**
59 | * This method transforms notifications observable to the observable
60 | * with list of all objects in the table which satisfies where parameter
61 | *
62 | * It also works in the background.
63 | *
64 | * @param where - arguments to query table
65 | * @return observable with all elements from the table
66 | */
67 | @NonNull
68 | public Observable> withQuery(@NonNull final Where where) {
69 | return flatMap(new Function>>() {
70 | @Override
71 | public ObservableSource> apply(Boolean value) throws Exception {
72 | return RxSQLite.get().query(mTable, where);
73 | }
74 | }).subscribeOn(Schedulers.io());
75 | }
76 |
77 | private class TableListener extends MainThreadDisposable implements BasicTableObserver {
78 |
79 | private final Observer mObserver;
80 |
81 | TableListener(@NonNull Observer observer) {
82 | mObserver = observer;
83 | }
84 |
85 | @Override
86 | public void onTableChanged() {
87 | mObserver.onNext(true);
88 | }
89 |
90 | @Override
91 | protected void onDispose() {
92 | SQLite.get().unregisterObserver(this);
93 | }
94 | }
95 |
96 | }
97 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/core/Observers.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.core;
2 |
3 | import android.content.Context;
4 | import android.database.ContentObserver;
5 | import android.support.annotation.NonNull;
6 | import android.support.v4.util.Pair;
7 |
8 | import java.util.ArrayList;
9 | import java.util.List;
10 |
11 | import io.reactivex.android.schedulers.AndroidSchedulers;
12 | import io.reactivex.functions.Consumer;
13 | import io.reactivex.schedulers.Schedulers;
14 | import ru.arturvasilov.sqlite.rx.RxSQLite;
15 |
16 | /**
17 | * @author Artur Vasilov
18 | */
19 | final class Observers {
20 |
21 | private final List> mObservers = new ArrayList<>();
22 |
23 | public void registerObserver(@NonNull Context context, @NonNull Table table,
24 | @NonNull final BasicTableObserver observer) {
25 | ContentObserver contentObserver = new DatabaseObserver() {
26 | @Override
27 | public void onChange(boolean selfChange) {
28 | super.onChange(selfChange);
29 | MainHandler.getHandler().post(new Runnable() {
30 | @Override
31 | public void run() {
32 | observer.onTableChanged();
33 | }
34 | });
35 | }
36 | };
37 | context.getContentResolver().registerContentObserver(table.getUri(), false, contentObserver);
38 | mObservers.add(new Pair(observer, contentObserver));
39 | }
40 |
41 | public void registerObserver(@NonNull Context context, @NonNull final Table table,
42 | @NonNull final ContentTableObserver observer, @NonNull final Where where) {
43 | ContentObserver contentObserver = new DatabaseObserver() {
44 | @Override
45 | public void onChange(boolean selfChange) {
46 | super.onChange(selfChange);
47 | RxSQLite.get().query(table, where)
48 | .subscribeOn(Schedulers.io())
49 | .observeOn(AndroidSchedulers.mainThread())
50 | .subscribe(new Consumer>() {
51 | @Override
52 | public void accept(List list) throws Exception {
53 | observer.onTableChanged(list);
54 | }
55 | });
56 | }
57 | };
58 | context.getContentResolver().registerContentObserver(table.getUri(), false, contentObserver);
59 | mObservers.add(new Pair(observer, contentObserver));
60 | }
61 |
62 | public void unregisterObserver(@NonNull Context context, @NonNull BasicTableObserver observer) {
63 | unregisterObserver(context, (Object) observer);
64 | }
65 |
66 | public void unregisterObserver(@NonNull Context context, @NonNull ContentTableObserver observer) {
67 | unregisterObserver(context, (Object) observer);
68 | }
69 |
70 | private void unregisterObserver(@NonNull Context context, @NonNull Object object) {
71 | int index = -1;
72 | for (int i = 0; i < mObservers.size(); i++) {
73 | if (mObservers.get(i).first == object) {
74 | index = i;
75 | }
76 | }
77 |
78 | if (index >= 0) {
79 | context.getContentResolver().unregisterContentObserver(mObservers.get(index).second);
80 | mObservers.remove(index);
81 | }
82 | }
83 |
84 | }
85 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/core/Table.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.core;
2 |
3 | import android.content.ContentValues;
4 | import android.database.Cursor;
5 | import android.net.Uri;
6 | import android.support.annotation.NonNull;
7 |
8 | import org.sqlite.database.sqlite.SQLiteDatabase;
9 |
10 | /**
11 | * Interface for creating a single table in SQLite database.
12 | *
13 | * You normally won't implement this interface but extend {@link BaseTable},
14 | * which provides good enough implementations for most of the methods.
15 | *
16 | * @author Artur Vasilov
17 | */
18 | public interface Table {
19 |
20 | /**
21 | * Each table is registered in ContentProvider with Uri from this method.
22 | * Default implementation returns ContentProvider uri appended with table name.
23 | *
24 | * @return Uri for table in database
25 | */
26 | @NonNull
27 | Uri getUri();
28 |
29 | /**
30 | * This method is used for creating and dropping table in database
31 | * and in the default implementation for {@link Table#getUri()}
32 | *
33 | * Default implementation returns simple class name (e.g. UsersTable)
34 | *
35 | * @return name of the table in SQLite database
36 | */
37 | @NonNull
38 | String getTableName();
39 |
40 | /**
41 | * This method creates and adds table to the database.
42 | *
43 | * You can create it manually with SQL, but it's recommended to use {@link ru.arturvasilov.sqlite.utils.TableBuilder}
44 | *
45 | * @param database - instance of SQLite database where you should create the table
46 | */
47 | void onCreate(@NonNull SQLiteDatabase database);
48 |
49 | /**
50 | * This method is provided for data migration purposes.
51 | *
52 | * In this method you should decide how you want to update this table
53 | * (how data migration works - {@link Table#getLastUpgradeVersion()}
54 | *
55 | * Default implementation in {@link BaseTable} simple drops table and call {@link Table#onCreate(SQLiteDatabase)}
56 | *
57 | * @param database - instance of SQLite database where you should update the table
58 | */
59 | void onUpgrade(@NonNull SQLiteDatabase database);
60 |
61 | /**
62 | * This method is also provided for data migration purposes.
63 | *
64 | * Version of database is calculated as a maximum from all tables in {@link SQLiteSchema}.
65 | * When you have updated the table, you just have to override this method to return maximum value from all tables
66 | * (e.g. current version of database is 5, you overridden this method to return 6 - database version will be six
67 | * and {@link Table#onUpgrade(SQLiteDatabase)} will be called)
68 | * If this method returns value which is less than updated database version,
69 | * {@link Table#onUpgrade(SQLiteDatabase)} won't be called.
70 | *
71 | * @return the version of database where the table was lastly updated
72 | */
73 | int getLastUpgradeVersion();
74 |
75 | /**
76 | * @param t - object for this table which you need to convert to {@link ContentValues} to insert in to database
77 | * @return ContentValues instance for object
78 | */
79 | @NonNull
80 | ContentValues toValues(@NonNull T t);
81 |
82 | /**
83 | * In this method you need to create instance of class for this table from cursor.
84 | * It's guarantee that cursor at the right position and its' state is OK.
85 | *
86 | * @param cursor - cursor (opened and ready to be read)
87 | * @return instance of class for this table
88 | */
89 | @NonNull
90 | T fromCursor(@NonNull Cursor cursor);
91 |
92 | }
93 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/utils/TableBuilder.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.utils;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.VisibleForTesting;
5 |
6 | import org.sqlite.database.sqlite.SQLiteDatabase;
7 |
8 | import java.util.ArrayList;
9 | import java.util.List;
10 |
11 | import ru.arturvasilov.sqlite.core.Table;
12 |
13 | /**
14 | * @author Artur Vasilov
15 | */
16 | public final class TableBuilder {
17 |
18 | private String mTableName;
19 | private final List mPrimaryKeys;
20 | private final List mIntegerColumns;
21 | private final List mRealColumns;
22 | private final List mTextColumns;
23 |
24 | private TableBuilder() {
25 | mPrimaryKeys = new ArrayList<>();
26 | mIntegerColumns = new ArrayList<>();
27 | mRealColumns = new ArrayList<>();
28 | mTextColumns = new ArrayList<>();
29 | }
30 |
31 | @NonNull
32 | public static TableBuilder create(@NonNull Table table) {
33 | TableBuilder builder = new TableBuilder();
34 | builder.mTableName = table.getTableName();
35 | return builder;
36 | }
37 |
38 | @NonNull
39 | public TableBuilder primaryKey(@NonNull String... keys) {
40 | mPrimaryKeys.clear();
41 | for (String key : keys) {
42 | if (!mPrimaryKeys.contains(key)) {
43 | mPrimaryKeys.add(key);
44 | }
45 | }
46 | return this;
47 | }
48 |
49 | @NonNull
50 | public TableBuilder intColumn(@NonNull String columnName) {
51 | if (!mIntegerColumns.contains(columnName)) {
52 | mIntegerColumns.add(columnName);
53 | }
54 | return this;
55 | }
56 |
57 | @NonNull
58 | public TableBuilder realColumn(@NonNull String columnName) {
59 | if (!mRealColumns.contains(columnName)) {
60 | mRealColumns.add(columnName);
61 | }
62 | return this;
63 | }
64 |
65 | @NonNull
66 | public TableBuilder textColumn(@NonNull String columnName) {
67 | if (!mTextColumns.contains(columnName)) {
68 | mTextColumns.add(columnName);
69 | }
70 | return this;
71 | }
72 |
73 | public void execute(@NonNull SQLiteDatabase database) {
74 | database.execSQL(buildSQL());
75 | }
76 |
77 | @VisibleForTesting
78 | String buildSQL() {
79 | if (mIntegerColumns.isEmpty() && mRealColumns.isEmpty() && mTextColumns.isEmpty()) {
80 | throw new IllegalStateException("Cannot create table with no columns");
81 | }
82 |
83 | StringBuilder builder = new StringBuilder();
84 | builder.append("CREATE TABLE IF NOT EXISTS ")
85 | .append(mTableName)
86 | .append("(");
87 |
88 | if (!mIntegerColumns.isEmpty()) {
89 | String column = mIntegerColumns.remove(0);
90 | builder.append(column)
91 | .append(" INTEGER");
92 | } else if (!mRealColumns.isEmpty()) {
93 | String column = mRealColumns.remove(0);
94 | builder.append(column)
95 | .append(" REAL");
96 | } else {
97 | String column = mTextColumns.remove(0);
98 | builder.append(column)
99 | .append(" TEXT");
100 | }
101 |
102 | for (String column : mIntegerColumns) {
103 | builder.append(", ")
104 | .append(column)
105 | .append(" INTEGER");
106 | }
107 |
108 | for (String column : mRealColumns) {
109 | builder.append(", ")
110 | .append(column)
111 | .append(" REAL");
112 | }
113 |
114 | for (String column : mTextColumns) {
115 | builder.append(", ")
116 | .append(column)
117 | .append(" TEXT");
118 | }
119 |
120 | if (!mPrimaryKeys.isEmpty()) {
121 | builder.append(", PRIMARY KEY (")
122 | .append(mPrimaryKeys.get(0));
123 | }
124 | for (int i = 1; i < mPrimaryKeys.size(); i++) {
125 | builder.append(", ").append(mPrimaryKeys.get(i));
126 | }
127 | if (!mPrimaryKeys.isEmpty()) {
128 | builder.append(")");
129 | }
130 | builder.append(");");
131 |
132 | return builder.toString();
133 | }
134 |
135 | }
136 |
--------------------------------------------------------------------------------
/app/src/test/java/ru/arturvasilov/sqlite/utils/TableBuilderTest.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.utils;
2 |
3 | import org.junit.Test;
4 | import org.junit.runner.RunWith;
5 | import org.junit.runners.JUnit4;
6 |
7 | import ru.arturvasilov.sqlite.testutils.JUnitTestTable;
8 |
9 | import static junit.framework.TestCase.assertEquals;
10 |
11 | @RunWith(JUnit4.class)
12 | public class TableBuilderTest {
13 |
14 | @Test(expected = IllegalStateException.class)
15 | public void testEmptyColumnsList() throws Exception {
16 | TableBuilder.create(JUnitTestTable.TABLE).buildSQL();
17 | }
18 |
19 | @Test
20 | public void testSingleIntegerColumn() throws Exception {
21 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(test INTEGER);";
22 |
23 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
24 | .intColumn("test")
25 | .buildSQL());
26 | }
27 |
28 | @Test
29 | public void testSingleRealColumn() throws Exception {
30 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(test REAL);";
31 |
32 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
33 | .realColumn("test")
34 | .buildSQL());
35 | }
36 |
37 | @Test
38 | public void testSingleStringColumn() throws Exception {
39 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(test TEXT);";
40 |
41 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
42 | .textColumn("test")
43 | .buildSQL());
44 | }
45 |
46 | @Test
47 | public void testPrimaryKeyWithIntColumn() throws Exception {
48 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(test INTEGER, PRIMARY KEY (test));";
49 |
50 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
51 | .intColumn("test")
52 | .primaryKey("test")
53 | .buildSQL());
54 | }
55 |
56 | @Test
57 | public void testManyColumnsWithoutPrimaryKey() throws Exception {
58 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(int1 INTEGER, int2 INTEGER, " +
59 | "real1 REAL, string1 TEXT, string2 TEXT);";
60 |
61 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
62 | .intColumn("int1")
63 | .textColumn("string1")
64 | .intColumn("int2")
65 | .realColumn("real1")
66 | .textColumn("string2")
67 | .buildSQL());
68 | }
69 |
70 | @Test
71 | public void testManyColumnsWithPrimaryKey() throws Exception {
72 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(int1 INTEGER, int2 INTEGER," +
73 | " real1 REAL, string1 TEXT, string2 TEXT, PRIMARY KEY (int1));";
74 |
75 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
76 | .intColumn("int1")
77 | .textColumn("string1")
78 | .intColumn("int2")
79 | .realColumn("real1")
80 | .textColumn("string2")
81 | .primaryKey("int1")
82 | .buildSQL());
83 | }
84 |
85 | @Test
86 | public void testManyColumnsWithMultiplePrimaryKey() throws Exception {
87 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(int1 INTEGER, int2 INTEGER, " +
88 | "real1 REAL, real2 REAL, string1 TEXT, string2 TEXT, PRIMARY KEY (int1, real1, string2));";
89 |
90 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
91 | .intColumn("int1")
92 | .realColumn("real1")
93 | .textColumn("string1")
94 | .intColumn("int2")
95 | .textColumn("string2")
96 | .realColumn("real2")
97 | .primaryKey("int1", "real1", "string2")
98 | .buildSQL());
99 | }
100 |
101 | @Test
102 | public void testSameColumnsIgnored() throws Exception {
103 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(testInt INTEGER, testReal REAL, testText TEXT);";
104 |
105 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
106 | .intColumn("testInt")
107 | .intColumn("testInt")
108 | .realColumn("testReal")
109 | .realColumn("testReal")
110 | .textColumn("testText")
111 | .textColumn("testText")
112 | .buildSQL());
113 | }
114 |
115 | @Test
116 | public void testSamePrimaryKeysIgnored() throws Exception {
117 | String sql = "CREATE TABLE IF NOT EXISTS JUnitTestTable(test INTEGER, PRIMARY KEY (test));";
118 |
119 | assertEquals(sql, TableBuilder.create(JUnitTestTable.TABLE)
120 | .intColumn("test")
121 | .primaryKey("test", "test")
122 | .buildSQL());
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | ##############################################################################
4 | ##
5 | ## Gradle start up script for UN*X
6 | ##
7 | ##############################################################################
8 |
9 | # Attempt to set APP_HOME
10 | # Resolve links: $0 may be a link
11 | PRG="$0"
12 | # Need this for relative symlinks.
13 | while [ -h "$PRG" ] ; do
14 | ls=`ls -ld "$PRG"`
15 | link=`expr "$ls" : '.*-> \(.*\)$'`
16 | if expr "$link" : '/.*' > /dev/null; then
17 | PRG="$link"
18 | else
19 | PRG=`dirname "$PRG"`"/$link"
20 | fi
21 | done
22 | SAVED="`pwd`"
23 | cd "`dirname \"$PRG\"`/" >/dev/null
24 | APP_HOME="`pwd -P`"
25 | cd "$SAVED" >/dev/null
26 |
27 | APP_NAME="Gradle"
28 | APP_BASE_NAME=`basename "$0"`
29 |
30 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
31 | DEFAULT_JVM_OPTS=""
32 |
33 | # Use the maximum available, or set MAX_FD != -1 to use that value.
34 | MAX_FD="maximum"
35 |
36 | warn ( ) {
37 | echo "$*"
38 | }
39 |
40 | die ( ) {
41 | echo
42 | echo "$*"
43 | echo
44 | exit 1
45 | }
46 |
47 | # OS specific support (must be 'true' or 'false').
48 | cygwin=false
49 | msys=false
50 | darwin=false
51 | nonstop=false
52 | case "`uname`" in
53 | CYGWIN* )
54 | cygwin=true
55 | ;;
56 | Darwin* )
57 | darwin=true
58 | ;;
59 | MINGW* )
60 | msys=true
61 | ;;
62 | NONSTOP* )
63 | nonstop=true
64 | ;;
65 | esac
66 |
67 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
68 |
69 | # Determine the Java command to use to start the JVM.
70 | if [ -n "$JAVA_HOME" ] ; then
71 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
72 | # IBM's JDK on AIX uses strange locations for the executables
73 | JAVACMD="$JAVA_HOME/jre/sh/java"
74 | else
75 | JAVACMD="$JAVA_HOME/bin/java"
76 | fi
77 | if [ ! -x "$JAVACMD" ] ; then
78 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
79 |
80 | Please set the JAVA_HOME variable in your environment to match the
81 | location of your Java installation."
82 | fi
83 | else
84 | JAVACMD="java"
85 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
86 |
87 | Please set the JAVA_HOME variable in your environment to match the
88 | location of your Java installation."
89 | fi
90 |
91 | # Increase the maximum file descriptors if we can.
92 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
93 | MAX_FD_LIMIT=`ulimit -H -n`
94 | if [ $? -eq 0 ] ; then
95 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
96 | MAX_FD="$MAX_FD_LIMIT"
97 | fi
98 | ulimit -n $MAX_FD
99 | if [ $? -ne 0 ] ; then
100 | warn "Could not set maximum file descriptor limit: $MAX_FD"
101 | fi
102 | else
103 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
104 | fi
105 | fi
106 |
107 | # For Darwin, add options to specify how the application appears in the dock
108 | if $darwin; then
109 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
110 | fi
111 |
112 | # For Cygwin, switch paths to Windows format before running java
113 | if $cygwin ; then
114 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
115 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
116 | JAVACMD=`cygpath --unix "$JAVACMD"`
117 |
118 | # We build the pattern for arguments to be converted via cygpath
119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 | SEP=""
121 | for dir in $ROOTDIRSRAW ; do
122 | ROOTDIRS="$ROOTDIRS$SEP$dir"
123 | SEP="|"
124 | done
125 | OURCYGPATTERN="(^($ROOTDIRS))"
126 | # Add a user-defined pattern to the cygpath arguments
127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 | fi
130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 | i=0
132 | for arg in "$@" ; do
133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
135 |
136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 | else
139 | eval `echo args$i`="\"$arg\""
140 | fi
141 | i=$((i+1))
142 | done
143 | case $i in
144 | (0) set -- ;;
145 | (1) set -- "$args0" ;;
146 | (2) set -- "$args0" "$args1" ;;
147 | (3) set -- "$args0" "$args1" "$args2" ;;
148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 | esac
155 | fi
156 |
157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
158 | function splitJvmOpts() {
159 | JVM_OPTS=("$@")
160 | }
161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
163 |
164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
165 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/core/SQLiteContentProvider.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.core;
2 |
3 | import android.content.ContentProvider;
4 | import android.content.ContentUris;
5 | import android.content.ContentValues;
6 | import android.database.Cursor;
7 | import android.net.Uri;
8 | import android.support.annotation.NonNull;
9 | import android.support.annotation.Nullable;
10 | import android.text.TextUtils;
11 |
12 | import org.sqlite.database.sqlite.SQLiteDatabase;
13 |
14 | /**
15 | * This class provides implementation for all operations in ContentProvider
16 | * and based on SQLite database.
17 | *
18 | * You only have to implement two methods {@link SQLiteContentProvider#prepareConfig(SQLiteConfig)}
19 | * and {@link SQLiteContentProvider#prepareSchema(SQLiteSchema)}, the rest is handled by the library.
20 | *
21 | * @author Artur Vasilov
22 | */
23 | public abstract class SQLiteContentProvider extends ContentProvider {
24 |
25 | private SQLiteSchema mSchema;
26 |
27 | private SQLiteHelper mSQLiteHelper;
28 |
29 | private static String sContentAuthority;
30 | private static Uri sBaseUri;
31 |
32 | /**
33 | * In this method you can specify configuration for your database (for this moment only name and authority)
34 | *
35 | * @param config - configuration for SQLite database
36 | */
37 | protected abstract void prepareConfig(@NonNull SQLiteConfig config);
38 |
39 | /**
40 | * In this method you must add all tables you want to use in your app.
41 | * To add table call {@link SQLiteSchema#register(Table)}
42 | *
43 | * @param schema - schema for SQLite database
44 | */
45 | protected abstract void prepareSchema(@NonNull SQLiteSchema schema);
46 |
47 | @Override
48 | public final boolean onCreate() {
49 | SQLiteConfig config = new SQLiteConfig(getContext());
50 | prepareConfig(config);
51 |
52 | sContentAuthority = config.getAuthority();
53 | sBaseUri = Uri.parse("content://" + sContentAuthority);
54 |
55 | mSchema = new SQLiteSchema();
56 | prepareSchema(mSchema);
57 |
58 | mSQLiteHelper = new SQLiteHelper(getContext(), config, mSchema);
59 | return true;
60 | }
61 |
62 | @Nullable
63 | @Override
64 | public final String getType(@NonNull Uri uri) {
65 | return mSchema.findTable(uri);
66 | }
67 |
68 | @Nullable
69 | @Override
70 | public final Cursor query(@NonNull Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
71 | SQLiteDatabase database = mSQLiteHelper.getWritableDatabase();
72 | String table = getType(uri);
73 | if (TextUtils.isEmpty(table)) {
74 | throw new IllegalArgumentException("No such table to query");
75 | } else {
76 | return database.query(table,
77 | projection,
78 | selection,
79 | selectionArgs,
80 | null,
81 | null,
82 | sortOrder);
83 | }
84 | }
85 |
86 | @NonNull
87 | @Override
88 | public final Uri insert(@NonNull Uri uri, ContentValues values) {
89 | SQLiteDatabase database = mSQLiteHelper.getWritableDatabase();
90 | String table = getType(uri);
91 | if (TextUtils.isEmpty(table)) {
92 | throw new IllegalArgumentException("No such table to insert");
93 | } else {
94 | long id = database.insertWithOnConflict(table, null, values, SQLiteDatabase.CONFLICT_REPLACE);
95 | return ContentUris.withAppendedId(uri, id);
96 | }
97 | }
98 |
99 | @Override
100 | public final int bulkInsert(@NonNull Uri uri, @NonNull ContentValues[] values) {
101 | SQLiteDatabase database = mSQLiteHelper.getWritableDatabase();
102 | String table = getType(uri);
103 | if (TextUtils.isEmpty(table)) {
104 | throw new IllegalArgumentException("No such table to insert");
105 | } else {
106 | int numInserted = 0;
107 | database.beginTransaction();
108 | try {
109 | for (ContentValues contentValues : values) {
110 | long id = database.insertWithOnConflict(table, null, contentValues, SQLiteDatabase.CONFLICT_REPLACE);
111 | if (id > 0) {
112 | numInserted++;
113 | }
114 | }
115 | database.setTransactionSuccessful();
116 | } finally {
117 | database.endTransaction();
118 | }
119 | return numInserted;
120 | }
121 | }
122 |
123 | @Override
124 | public final int delete(@NonNull Uri uri, String selection, String[] selectionArgs) {
125 | SQLiteDatabase database = mSQLiteHelper.getWritableDatabase();
126 | String table = getType(uri);
127 | if (TextUtils.isEmpty(table)) {
128 | throw new IllegalArgumentException("No such table to delete");
129 | } else {
130 | return database.delete(table, selection, selectionArgs);
131 | }
132 | }
133 |
134 | @Override
135 | public final int update(@NonNull Uri uri, ContentValues values,
136 | String selection, String[] selectionArgs) {
137 | SQLiteDatabase database = mSQLiteHelper.getWritableDatabase();
138 | String table = getType(uri);
139 | if (TextUtils.isEmpty(table)) {
140 | throw new IllegalArgumentException("No such table to update");
141 | } else {
142 | return database.update(table, values, selection, selectionArgs);
143 | }
144 | }
145 |
146 | @NonNull
147 | static String getContentAuthority() {
148 | return sContentAuthority;
149 | }
150 |
151 | @NonNull
152 | static Uri getBaseUri() {
153 | return sBaseUri;
154 | }
155 | }
156 |
--------------------------------------------------------------------------------
/app/src/main/java/ru/arturvasilov/sqlite/core/Where.java:
--------------------------------------------------------------------------------
1 | package ru.arturvasilov.sqlite.core;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.Nullable;
5 |
6 | import java.util.ArrayList;
7 | import java.util.Collections;
8 | import java.util.List;
9 |
10 | /**
11 | * Class for constructing SQL queries using Java methods.
12 | * All most popular operators (=, <>, >, <, >=, <=, LIKE, BETWEEN, IN, OR, AND) are supported.
13 | *
14 | * If there is no method that you need, you can always construct query manually with {@link Where#where(String, Object...)}.
15 | *
16 | * Class also supports LIMIT and OFFSET with methods {@link Where#limit(int)} and {@link Where#offset(int)} respectively.
17 | *
18 | * Typical usage of this class looks like this:
19 | *
32 | *
33 | * @author Artur Vasilov
34 | */
35 | public class Where {
36 |
37 | private final StringBuilder mWhereBuilder;
38 |
39 | private final List