Beste Möglichkeit, mit Datumsangaben in Android SQLite zu arbeiten [geschlossen]

Ich habe Probleme beim Arbeiten mit Datumsangaben in meiner Android-Anwendung, die SQLite verwendet. Ich habe ein paar Fragen:

1. Welchen Typ soll ich zum Speichern von Datumsangaben in SQLite verwenden (Text, Ganzzahl, ...)?
2. Wie speichere ich Datumsangaben mit ContentValues ​​ordnungsgemäß?
3. Wie kann das Datum am besten aus der SQLite-Datenbank abgerufen werden?
4. Wie kann man eine SQL-Auswahl in SQLite treffen und die Ergebnisse nach Datum sortieren?

Sie können ein Textfeld verwenden, um Daten darin zu speichern SQLite.

Wenn Sie Datumsangaben im UTC-Format speichern, können Sie standardmäßig nach der datetime('now') (yyyy-MM-dd HH:mm:ss)Datumsspalte sortieren.

Wenn Sie Datumsangaben als Zeichenfolgen abrufen SQLite, können Sie sie nach Bedarf mithilfe des Kalenders oder der android.text.format.DateUtils.formatDateTimeMethode formatieren / in lokale regionalisierte Formate konvertieren .

Hier ist eine regionalisierte Formatierungsmethode, die ich verwende.

public static String formatDateTime(Context context, String timeToFormat) {

    String finalDateTime = "";          

    SimpleDateFormat iso8601Format = new SimpleDateFormat(
            "yyyy-MM-dd HH:mm:ss");

    Date date = null;
    if (timeToFormat != null) {
        try {
            date = iso8601Format.parse(timeToFormat);
        } catch (ParseException e) {
            date = null;
        }

        if (date != null) {
            long when = date.getTime();
            int flags = 0;
            flags |= android.text.format.DateUtils.FORMAT_SHOW_TIME;
            flags |= android.text.format.DateUtils.FORMAT_SHOW_DATE;
            flags |= android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
            flags |= android.text.format.DateUtils.FORMAT_SHOW_YEAR;

            finalDateTime = android.text.format.DateUtils.formatDateTime(context,
            when + TimeZone.getDefault().getOffset(when), flags);               
        }
    }
    return finalDateTime;
}

Am besten speichern Sie die Daten als Zahl, die Sie mit dem Befehl Kalender erhalten.

//Building the table includes:
StringBuilder query=new StringBuilder();
query.append("CREATE TABLE "+TABLE_NAME+ " (");
query.append(COLUMN_ID+"int primary key autoincrement,");
query.append(COLUMN_DATETIME+" int)");

//And inserting the data includes this:
values.put(COLUMN_DATETIME, System.currentTimeMillis()); 

Warum das? Zunächst einmal ist es einfach, Werte aus einem Datumsbereich abzurufen. Konvertieren Sie einfach Ihr Datum in Millisekunden und fragen Sie dann entsprechend ab. Das Sortieren nach Datum ist ähnlich einfach. Die Aufrufe zum Konvertieren zwischen verschiedenen Formaten sind ebenfalls einfach, wie ich eingeschlossen habe. Unterm Strich können Sie mit dieser Methode alles tun, was Sie tun müssen, ohne Probleme. Es wird etwas schwierig sein, einen Rohwert zu lesen, aber es macht diesen kleinen Nachteil mehr als wett, weil es leicht maschinenlesbar und verwendbar ist. Tatsächlich ist es relativ einfach, einen Reader zu erstellen (und ich weiß, dass es einige gibt), der das Zeit-Tag automatisch in ein solches konvertiert, um das Lesen zu vereinfachen.

Es ist erwähnenswert, dass die Werte, die daraus entstehen, lang sein sollten, nicht int. Ganzzahl in SQLite kann viele Dinge bedeuten, alles von 1 bis 8 Bytes, aber für fast alle Daten funktionieren 64 Bit oder eine lange.

BEARBEITEN: Wie in den Kommentaren erwähnt, müssen Sie den verwenden cursor.getLong(), um den Zeitstempel richtig zu erhalten, wenn Sie dies tun.

1. Wie in diesem Kommentar angenommen , würde ich immer Ganzzahlen verwenden, um Daten zu speichern.

2. Zum Speichern können Sie eine Dienstprogrammmethode verwenden

   public static Long persistDate(Date date) {
       if (date != null) {
           return date.getTime();
       }
       return null;
   }

   wie so:

   ContentValues values = new ContentValues();
   values.put(COLUMN_NAME, persistDate(entity.getDate()));
   long id = db.insertOrThrow(TABLE_NAME, null, values);

3. Eine andere Gebrauchsmethode kümmert sich um das Laden

   public static Date loadDate(Cursor cursor, int index) {
       if (cursor.isNull(index)) {
           return null;
       }
       return new Date(cursor.getLong(index));
   }

   kann wie folgt verwendet werden:

   entity.setDate(loadDate(cursor, INDEX));

4. Die Reihenfolge nach Datum ist eine einfache SQL ORDER-Klausel (da wir eine numerische Spalte haben). Folgendes wird absteigend sortiert (das neueste Datum steht an erster Stelle):

   public static final String QUERY = "SELECT table._id, table.dateCol FROM table ORDER BY table.dateCol DESC";
   
   //...
   
       Cursor cursor = rawQuery(QUERY, null);
       cursor.moveToFirst();
   
       while (!cursor.isAfterLast()) {
           // Process results
       }

Stellen Sie immer sicher, dass Sie die UTC / GMT-Zeit speichern , insbesondere wenn Sie mit der Standardzeitzone (dh der Zeitzone Ihres Geräts) arbeiten java.util.Calendarund java.text.SimpleDateFormatdiese verwenden. java.util.Date.Date()ist sicher zu verwenden, da es einen UTC-Wert erstellt.

SQLite kann Text-, Real- oder Integer-Datentypen zum Speichern von Datumsangaben verwenden. Darüber hinaus werden die Ergebnisse bei jeder Abfrage im Format angezeigt %Y-%m-%d %H:%M:%S.

Wenn Sie jetzt Datums- / Zeitwerte mithilfe von SQLite-Datums- / Uhrzeitfunktionen einfügen / aktualisieren, können Sie auch Millisekunden speichern. In diesem Fall werden die Ergebnisse im Format angezeigt %Y-%m-%d %H:%M:%f. Beispielsweise:

sqlite> create table test_table(col1 text, col2 real, col3 integer);
sqlite> insert into test_table values (
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.123'),
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.123'),
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.123')
        );
sqlite> insert into test_table values (
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.126'),
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.126'),
            strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.126')
        );
sqlite> select * from test_table;
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123
2014-03-01 13:01:01.126|2014-03-01 13:01:01.126|2014-03-01 13:01:01.126

Führen Sie nun einige Abfragen durch, um zu überprüfen, ob wir die Zeiten tatsächlich vergleichen können:

sqlite> select * from test_table /* using col1 */
           where col1 between 
               strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.121') and
               strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.125');
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123

Sie können das gleiche SELECTmit col2und überprüfen col3und erhalten die gleichen Ergebnisse. Wie Sie sehen können, wird die zweite Zeile (126 Millisekunden) nicht zurückgegeben.

Beachten Sie, dass dies BETWEENinklusive ist, daher ...

sqlite> select * from test_table 
            where col1 between 
                 /* Note that we are using 123 milliseconds down _here_ */
                strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.123') and
                strftime('%Y-%m-%d %H:%M:%f', '2014-03-01 13:01:01.125');

... gibt den gleichen Satz zurück.

Versuchen Sie, mit verschiedenen Datums- / Zeitbereichen herumzuspielen, und alles wird sich wie erwartet verhalten.

Was ist ohne strftimeFunktion?

sqlite> select * from test_table /* using col1 */
           where col1 between 
               '2014-03-01 13:01:01.121' and
               '2014-03-01 13:01:01.125';
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123

Was ist ohne strftimeFunktion und ohne Millisekunden?

sqlite> select * from test_table /* using col1 */
           where col1 between 
               '2014-03-01 13:01:01' and
               '2014-03-01 13:01:02';
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123
2014-03-01 13:01:01.126|2014-03-01 13:01:01.126|2014-03-01 13:01:01.126

Was ist mit ORDER BY?

sqlite> select * from test_table order by 1 desc;
2014-03-01 13:01:01.126|2014-03-01 13:01:01.126|2014-03-01 13:01:01.126
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123
sqlite> select * from test_table order by 1 asc;
2014-03-01 13:01:01.123|2014-03-01 13:01:01.123|2014-03-01 13:01:01.123
2014-03-01 13:01:01.126|2014-03-01 13:01:01.126|2014-03-01 13:01:01.126

Funktioniert gut.

Schließlich, wenn es um tatsächliche Operationen innerhalb eines Programms geht (ohne die ausführbare SQLite-Datei zu verwenden ...)

Übrigens: Ich verwende JDBC (bei anderen Sprachen nicht sicher) ... den sqlite-jdbc-Treiber v3.7.2 von xerial - möglicherweise ändern neuere Versionen das unten erläuterte Verhalten ... Wenn Sie in Android entwickeln, tun Sie dies nicht brauche einen JDBC-Treiber. Alle SQL-Operationen können mit dem gesendet werden SQLiteOpenHelper.

JDBC hat verschiedene Methoden aktuelle Datum / Zeit - Werte aus einer Datenbank zu erhalten: java.sql.Date, java.sql.Time, und java.sql.Timestamp.

Die zugehörigen Verfahren in java.sql.ResultSetsind (natürlich) getDate(..), getTime(..)und getTimestamp()jeweils.

Beispielsweise:

Statement stmt = ... // Get statement from connection
ResultSet rs = stmt.executeQuery("SELECT * FROM TEST_TABLE");
while (rs.next()) {
    System.out.println("COL1 : "+rs.getDate("COL1"));
    System.out.println("COL1 : "+rs.getTime("COL1"));
    System.out.println("COL1 : "+rs.getTimestamp("COL1"));
    System.out.println("COL2 : "+rs.getDate("COL2"));
    System.out.println("COL2 : "+rs.getTime("COL2"));
    System.out.println("COL2 : "+rs.getTimestamp("COL2"));
    System.out.println("COL3 : "+rs.getDate("COL3"));
    System.out.println("COL3 : "+rs.getTime("COL3"));
    System.out.println("COL3 : "+rs.getTimestamp("COL3"));
}
// close rs and stmt.

Da SQLite keinen tatsächlichen Datentyp DATE / TIME / TIMESTAMP hat, geben alle diese 3 Methoden Werte zurück, als ob die Objekte mit 0 initialisiert worden wären:

new java.sql.Date(0)
new java.sql.Time(0)
new java.sql.Timestamp(0)

Die Frage ist also: Wie können wir Datums- / Zeit- / Zeitstempelobjekte tatsächlich auswählen, einfügen oder aktualisieren? Es gibt keine einfache Antwort. Sie können verschiedene Kombinationen ausprobieren, diese zwingen Sie jedoch dazu, SQLite-Funktionen in alle SQL-Anweisungen einzubetten. Es ist viel einfacher, eine Dienstprogrammklasse zu definieren, um Text in Datumsobjekte in Ihrem Java-Programm umzuwandeln. Denken Sie jedoch immer daran, dass SQLite einen beliebigen Datumswert in UTC + 0000 umwandelt.

Zusammenfassend lässt sich sagen, dass ich trotz der allgemeinen Regel, immer den richtigen Datentyp oder sogar Ganzzahlen zu verwenden, die die Unix-Zeit (Millisekunden seit der Epoche) angeben, die Verwendung des Standard-SQLite-Formats ( '%Y-%m-%d %H:%M:%f'oder in Java 'yyyy-MM-dd HH:mm:ss.SSS') viel einfacher finde , als alle Ihre SQL-Anweisungen zu komplizieren SQLite-Funktionen. Der erstere Ansatz ist viel einfacher zu pflegen.

TODO: Ich werde die Ergebnisse überprüfen, wenn ich getDate / getTime / getTimestamp in Android (API15 oder besser) verwende ... vielleicht unterscheidet sich der interne Treiber von sqlite-jdbc ...

Normalerweise (wie in MySQL / Postgres) speichere ich Datumsangaben in Int (MySQL / Post) oder Text (SQLite), um sie im Zeitstempelformat zu speichern.

Dann werde ich sie in Datumsobjekte konvertieren und Aktionen basierend auf dem Benutzer TimeZone ausführen

Der beste Weg, um datein SQlite DB zu speichern, ist das Speichern des aktuellen DateTimeMilliseconds. Unten finden Sie das Code-Snippet, um dies zu tun

1. Bekommen das DateTimeMilliseconds

public static long getTimeMillis(String dateString, String dateFormat) throws ParseException {
    /*Use date format as according to your need! Ex. - yyyy/MM/dd HH:mm:ss */
    String myDate = dateString;//"2017/12/20 18:10:45";
    SimpleDateFormat sdf = new SimpleDateFormat(dateFormat/*"yyyy/MM/dd HH:mm:ss"*/);
    Date date = sdf.parse(myDate);
    long millis = date.getTime();

    return millis;
}

2. Fügen Sie die Daten in Ihre Datenbank ein

public void insert(Context mContext, long dateTimeMillis, String msg) {
    //Your DB Helper
    MyDatabaseHelper dbHelper = new MyDatabaseHelper(mContext);
    database = dbHelper.getWritableDatabase();

    ContentValues contentValue = new ContentValues();
    contentValue.put(MyDatabaseHelper.DATE_MILLIS, dateTimeMillis);
    contentValue.put(MyDatabaseHelper.MESSAGE, msg);

    //insert data in DB
    database.insert("your_table_name", null, contentValue);

   //Close the DB connection.
   dbHelper.close(); 

}

Now, your data (date is in currentTimeMilliseconds) is get inserted in DB .

Der nächste Schritt ist, wenn Sie Daten aus der Datenbank abrufen möchten, müssen Sie die entsprechenden Datums- und Uhrzeit-Millisekunden in das entsprechende Datum konvertieren. Unten finden Sie das Beispielcode-Snippet, um dasselbe zu tun

1. Konvertieren Sie Datums-Millisekunden in eine Datumszeichenfolge.

public static String getDate(long milliSeconds, String dateFormat)
{
    // Create a DateFormatter object for displaying date in specified format.
    SimpleDateFormat formatter = new SimpleDateFormat(dateFormat/*"yyyy/MM/dd HH:mm:ss"*/);

    // Create a calendar object that will convert the date and time value in milliseconds to date.
    Calendar calendar = Calendar.getInstance();
    calendar.setTimeInMillis(milliSeconds);
    return formatter.format(calendar.getTime());
}

2. Holen Sie sich jetzt endlich die Daten und sehen Sie, wie sie funktionieren ...

public ArrayList<String> fetchData() {

    ArrayList<String> listOfAllDates = new ArrayList<String>();
    String cDate = null;

    MyDatabaseHelper dbHelper = new MyDatabaseHelper("your_app_context");
    database = dbHelper.getWritableDatabase();

    String[] columns = new String[] {MyDatabaseHelper.DATE_MILLIS, MyDatabaseHelper.MESSAGE};
    Cursor cursor = database.query("your_table_name", columns, null, null, null, null, null);

    if (cursor != null) {

        if (cursor.moveToFirst()){
            do{
                //iterate the cursor to get data.
                cDate = getDate(cursor.getLong(cursor.getColumnIndex(MyDatabaseHelper.DATE_MILLIS)), "yyyy/MM/dd HH:mm:ss");

                listOfAllDates.add(cDate);

            }while(cursor.moveToNext());
        }
        cursor.close();

    //Close the DB connection.
    dbHelper.close(); 

    return listOfAllDates;

}

Hoffe das wird allen helfen! :) :)

1 - Genau wie StErMi sagte.

2 - Bitte lesen Sie dies: http://www.vogella.de/articles/AndroidSQLite/article.html

3 -

Cursor cursor = db.query(TABLE_NAME, new String[] {"_id", "title", "title_raw", "timestamp"}, 
                "//** YOUR REQUEST**//", null, null, "timestamp", null);

siehe hier:

Query () in SQLiteDatabase

4 - siehe Antwort 3

Ich bevorzuge das. Dies ist nicht der beste Weg, aber eine schnelle Lösung.

//Building the table includes:
StringBuilder query= new StringBuilder();
query.append("CREATE TABLE "+TABLE_NAME+ " (");
query.append(COLUMN_ID+"int primary key autoincrement,");
query.append(COLUMN_CREATION_DATE+" DATE)");

//Inserting the data includes this:
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
values.put(COLUMN_CREATION_DATE,dateFormat.format(reactionGame.getCreationDate())); 

// Fetching the data includes this:
try {
   java.util.Date creationDate = dateFormat.parse(cursor.getString(0);
   YourObject.setCreationDate(creationDate));
} catch (Exception e) {
   YourObject.setCreationDate(null);
}

"SELECT  "+_ID+" ,  "+_DESCRIPTION +","+_CREATED_DATE +","+_DATE_TIME+" FROM "+TBL_NOTIFICATION+" ORDER BY "+"strftime(%s,"+_DATE_TIME+") DESC";