Union clause in android sqlite? - android

How can we perform Union operation on multiple tables in android sqlite using SQLiteQueryBuilder class?

Perhaps you can use buildUnionQuery(). From the documentation, it looks pretty straightforward, you just need to construct the individual SELECT statements yourself.
There is also this method buildUnionSubQuery(), but i have absolutely no idea how to use it and the documentation is not very helpful...
I actually prefer a library called SquiDB, which has much better query building capabilities with an API that is more clear. (There are other libraries out there with good APIs as well. The point is you aren't stuck with using Android's SQLiteQueryBuilder, whose API is somewhat lacking in my opinion.)

Related

Can I use Room Persistence for a different type of Database?

I know that room is an abstraction layer over SQLite, I just want to know if I can use it for a different type of Database. I want to use Room to a special version of SQLite with geospatial support, is it possible? I really can't find an answer about this one.
Android Spatialite
Thanks in advance!
Yes, if you are willing to write the bridge code for it.
One of the methods that you can call on a RoomDatabase.Builder is openHelperFactory(). This takes an instance of SupportSQLiteOpenHelper.Factory, and this is what Room uses for interacting with the underlying database implementation. By default, Room uses FrameworkSQLiteOpenHelper.Factory, but via openHelperFactory() you can provide your own.
This, in turn, will require you to implement other interfaces on other classes, such as SupportSQLiteDatabase. This is basically a wrapper, with an API that somewhat resembles the framework API. You translate those calls to the SQLite implementation that you wish to use.
I did this for SQLCipher for Android, in the form of the SafeRoom library. Right now, my implementation is a bit clunky, due to some limitations in SQLCipher for Android that hopefully will be lifted soon. You would create the same sort of classes for your particular SQLite implementation. Then, plug your SupportSQLiteHelper.Factory into your RoomDatabase.Builder, and now Room will talk to your database implementation.
Note that you cannot actually extend Room itself. For example, you cannot invent new Room annotations that know about geospatial stuff. And the Room compiler may have issues with your geospatial SQL, if that SQL breaks what Room is expecting (e.g., new keywords). It seems like what they added are "just" a lot of functions, so hopefully Room will behave OK.
You could use my current implementation of spatialite for Android room:
https://github.com/anboralabs/spatia-room

What is Fastest way to query a database android?

I have a database that contains 35000 records, and can easily get up to about 60000 records,
What is the best way to query these data? Will ORMLite or GreenDAO be usefull? Or should i just stick with Cursor?
That depends on what you mean by "best".
Fastest, most flexible, best integration with Android library functions: Stick with Cursor. Since ORMs are just wrappers around the native Android cursors, they are unlikely to be faster than direct access. In many cases, the Android UI library classes are optimized for Cursors (e.g. SimpleCursorAdapter, which allows you to bind a cursor to a UI list).
Most readable, most maintainable: An ORM might help here, but that depends on a lot of factors, including your project complexity, your application architecture, etc.
See the following programmers.se question for more information:
Does it make sense to use ORM in Android development?

Android database framework for complex queries and comfortable engineering

I've been using the native Android SQLite library in the last time, but I am not pleased with the re-usability and readability. There are some ORM database libraries I found for Android, but I wonder whether those are useful as I got a whole bunch of complex select and delete operations I have to be able to run.
Can you suggest me any appropriate library?
Tried this once. Pretty good I must say.
http://ormlite.com/

Does Android support any other database system other than SQLite?

I have been searching and have found out, that android supports only SQLite databse and no other. Is this true?
Yes. The Android library provides native support to only SQLite. Of course, this doesn't mean you absolutely can't use other databases on Android; if you need to use other databases, you'll have to either look for already-existing third-party libraries(1), or roll out your own API.
(1) Careful there: If you look for third-party libraries, make sure they're built specifically for Android, since Android includes only a subset of the Java standard library. If they're not specifically built for Android, there's a possibility that the libraries won't work due to missing classes.
Yes, Android Supports H2 Database too. please check it out with below link,
http://www.h2database.com/html/tutorial.html#android
Thanks,
Though SQLite is natively supported on Android and is most used database, there exists other options as well. Listing a few of them below;
Realm:
Reactive, concurrent, and lightweight, allowing you to work with live, native objects.
https://realm.io/docs/
H2:
Full Unicode support including UPPER() and LOWER().
Streaming API for BLOB and CLOB data.
Fulltext search.
Multiple connections.
http://www.h2database.com/html/tutorial.html#android
CouchDB:
Full CRUD and query functionality, NoSQL, lightweight, embedded, syncable
https://developer.couchbase.com/mobile/
LevelDB:
Lightweight and single purpose (not an SQL database)
http://leveldb.org/
Java wrapper: https://github.com/hf/leveldb-android
I am not including BerkeleyDB here as (AFAIK) it needs OS level changes to be made to replace the SQLite routines. More info here https://blogs.oracle.com/berkeleydb/now-you-can-build-berkeley-db-into-your-android-apps
SQLite is the only one I ever actually see being used. I would suggest using it because it is lightweight and free to use. When developing your App, lightweight is key, memory is limited on these devices! Is there any specific reason why you wouldn't want to use SQLite? Any feature that you're looking for that you don't see in SQLite?

Higher level database layer for Android?

Are there any good database abstraction layers/object relational mappers/ActiveRecord implementations/whatever they are called for Android? I'm aware that db4o is officially supported, but it has quite a large footprint and I'd rather use a more conventional database (SQLite).
I am the main author of ORMLite which was designed to be small[ish] but still provide higher level functionality. ORMLite makes calls to the native Android OS database APIs to support its ORM functionality. See the following for general information
http://ormlite.com/sqlite_java_android_orm.shtml
Here are some Android example applications:
http://ormlite.com/docs/android-examples
I tried the Sugar ORM, which is very basic (and easy to use) but it worked for my needs.
Sugar website
There is an 'android-active-record' project which provides ActiveRecord abstraction for accessing Android SQLite database.
It's available here: http://code.google.com/p/android-active-record
It allows to eliminate most of boilerplate coding when performing CRUD operations on database entities and also minimizes efforts for creating/maintaining a database structure
Try ActiveAndroid. It is free and open source (Apache Version 2.0).
From the website:
ActiveAndroid is an active record style ORM (object relational
mapper). [...] ActiveAndroid allows you
to save and retrieve SQLite database records without ever writing a
single SQL statement. Each database record is wrapped neatly into a
class with methods like save() and delete().
[...] Accessing the database is a hassle, to say the least, in Android.
ActiveAndroid takes care of all the setup and messy stuff, and all
with just a few simple steps of configuration.
If performance and size matter, you should have a look at our open source ORM tool greenDAO. We wrote it because we did not want to compromise on speed. Other tools heavily rely on reflection, which is very slow on Android. Despite the tiny size (<100k), it supports relations, query builders, etc.
Shameless plug, but I've been working on a new open source Android framework called Infinitum. One of its main features is an ORM which has a criteria API similar to Hibernate and a few other nifty features (associations, lazy loading, etc.). It's still in its early stages, but I think it's coming along pretty nicely.
I have written a new ORM, for android, that's aimed and being as easy as possible to implement. It support lists and SQL free migration a couple things which I always found had an overhead in other libraries.
http://www.rushorm.com/
I faced the same problem and looked at both android-active-record and ActiveAndroid. I found android-active-record didn't handle the things I cared about (relationships for example), and ActiveAndroid isn't free. Therefore, I decided to write my own library. It's called AndroidRecord and it's hosted on GitHub and you're free to do with it what you want (I think I'm going to go with the MIT license). I use this every day and I'm content with it, but I'd love to get feedback.
If you need to know how to use it, I'm working on the documentation. If you need it right away, you can check out this lame example project which should be enough to dip your toes in. You can also email me of course.
There's also Neodatis and Perst (Lite).
I've toyed with Perst a year ago and concluded it's not worth it.
After all, a) Android runs on a rather restricted device with ~16mb of heap space per app and b) You customers would really appreciate performance and low power consumption.
So my advice is to go with SQLite and hand-written SQL. It's not hard at all and the wrappers provided by Android SDK are really nice.
EDIT: In 2012 the advice would be to use the ORM component of DroidParts (which is my project).
I was comparing basics of ormlite and greendao some time ago. You might want to take a look there. I plan to write some follow up with more advanced stuff in the near future but for now it's only a basic stuff. In my own project I'm using GreenDAO.
Have a look at Androrm. It is open source and well documented (see here). If you ever worked with django, you will notice, that the syntax is very similar.
Androrm also supports abstraction classes for the most common field types, plus relational fields. This way it enables you to query for your data in an very easy manner with only very little effort on your side.
SQLite is explicitly part of Android:
http://developer.android.com/reference/android/database/sqlite/SQLiteDatabase.html
However you might have to create your own abstraction layer (query builder for simple queries), or otherwise deal with SQL.
Maybe http://developer.android.com/reference/android/database/sqlite/SQLiteQueryBuilder.html is what you need?

Categories

Resources