Was am besten für eine Datenbank benutzen?

[DoctorBlack]

Für ein Schulprojekt müssen ein Mitschüler und Ich eine Stundeplan-App programmieren. Wir wollen das so machen, dass die Fächer in einer Datenbank angelegt werden, das heißt mit Fachname, Kürzel, Raum und Lehrer. Wir wissen jetzt nur nicht genau was man da am Besten für die Datenbank benutzen kann.

Danke schon mal für die Hilfe im Voraus!

 

[swa00]

Hallo Doctor,

ich denke , die Datenbank sollte wohl lokal sein.

Dann definitiv SQLITE, die Bibliothek ist auch bereits im Standard SDK vorhanden ,

 

[deek]

Es kommt jetzt so ein bisschen auf das Ziel an. Ist es ein Ziel sich mit SQL zu beschäftigen, dann ja definitiv mit Bordmitteln die sqlite ansprechen.
Ist es ein Ziel eine elegante App zu programmieren würde ich auf ein orm wie Room, SugarORM oder ormlite setzen.
Damit kannst du Java Objekte direkt gegen die lokale Datenbank mappen.

 

[Jaiel]

Falls du Beispiele brauchst hier ist ein Kotlin Code um Kontakte in einer SQL Datenbank zu pflegen.
Man kann Kontakten updaten, einfügen und löschen. Ist einfach nur etwas Logik mit SQL Befehlen.

Kann dir auch eine Java Version zeigen aber ich denke es sollte lesbar sein hoffe ich.

Spoiler: DataBaseHelper.kt

class DataBaseHelper internal constructor(context: Context) : SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL(SQL_CREATE)
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {

    }

    companion object {

        private val DB_NAME = "contacts.db"
        private val DB_VERSION = 1

        internal val TABLE_CONTACT_LIST = "contacts_list"

        internal val COLUMN_ID = "_id"
        internal val COLUMN_NAME = "name"
        internal val COLUMN_NUM = "telefon"
        internal val COLUMN_PHOTO = "photo"

        private val SQL_CREATE = ("CREATE TABLE " + TABLE_CONTACT_LIST + "(" +
                COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_NUM + " TEXT NOT NULL,"
                + COLUMN_PHOTO + " TEXT NOT NULL," + COLUMN_NAME + " TEXT NOT NULL);")
    }
}

Spoiler: DataBaseSource.kt

class DataBaseSource(context: Context) {

    private var database: SQLiteDatabase? = null
    private val dbHelper: DataBaseHelper

    private val columns = arrayOf(DataBaseHelper.COLUMN_ID, DataBaseHelper.COLUMN_PHOTO, DataBaseHelper.COLUMN_NAME, DataBaseHelper.COLUMN_NUM)

    val allContactsFromDB: List<Contact>
        get() {
            val contactList = ArrayList<Contact>()

            val cursor = database!!.query(DataBaseHelper.TABLE_CONTACT_LIST,
                    columns, null, null, null, null, null)

            cursor.moveToFirst()
            var contact: Contact

            while (!cursor.isAfterLast) {
                contact = cursorToContact(cursor)
                contactList.add(contact)
                cursor.moveToNext()
            }

            cursor.close()

            return contactList
        }

    init {

        dbHelper = DataBaseHelper(context)
    }

    fun open() {

        database = dbHelper.writableDatabase

    }

    fun close() {
        dbHelper.close()

    }

    fun insertContactToDB(name: String, num: String, photo: String): Contact {
        val values = ContentValues()
        values.put(DataBaseHelper.COLUMN_NAME, name)
        values.put(DataBaseHelper.COLUMN_NUM, num)
        values.put(DataBaseHelper.COLUMN_PHOTO, photo)


        val cursor = database!!.query(DataBaseHelper.TABLE_CONTACT_LIST,
                columns, DataBaseHelper.COLUMN_ID + "=" + database!!.insert(DataBaseHelper.TABLE_CONTACT_LIST, null, values), null, null, null, null)

        cursor.moveToFirst()
        val contact = cursorToContact(cursor)
        cursor.close()

        return contact
    }

    fun deleteContactFromDB(benutzer: Contact) {
        val id = benutzer.id.toLong()

        database!!.delete(DataBaseHelper.TABLE_CONTACT_LIST,
                DataBaseHelper.COLUMN_ID + "=" + id, null)


    }

    fun updateContactInDB(id: Long, newName: String, newTelefon: String, newPhoto: String): Contact? {
        val values = ContentValues()
        values.put(DataBaseHelper.COLUMN_PHOTO, newPhoto)
        values.put(DataBaseHelper.COLUMN_NUM, newTelefon)
        values.put(DataBaseHelper.COLUMN_NAME, newName)


        if (!database!!.isOpen)
            return null

        database!!.update(DataBaseHelper.TABLE_CONTACT_LIST,
                values,
                DataBaseHelper.COLUMN_ID + "=" + id, null)

        val cursor = database!!.query(DataBaseHelper.TABLE_CONTACT_LIST,
                columns, DataBaseHelper.COLUMN_ID + "=" + id, null, null, null, null)

        cursor.moveToFirst()
        val contact = cursorToContact(cursor)
        cursor.close()

        return contact
    }

    private fun cursorToContact(cursor: Cursor): Contact {
        return Contact(cursor.getInt(cursor.getColumnIndex(DataBaseHelper.COLUMN_ID)),
                cursor.getString(cursor.getColumnIndex(DataBaseHelper.COLUMN_NAME)),
                cursor.getString(cursor.getColumnIndex(DataBaseHelper.COLUMN_NUM)),
                cursor.getString(cursor.getColumnIndex(DataBaseHelper.COLUMN_PHOTO)))
    }

    companion object {

        private val LOG_TAG = DataBaseSource::class.java!!.getSimpleName()
    }
}

 

[markus.tullius]

Hi @Jaiel,

kurze Frage - habe gerade keine Lust mich durch die Doku zu prügeln - soweit ich sehe, muss du bei Kotlin keine explizite Datentypen deklarieren. Weiß du, ob Kotlin dafür Generics benutzt (das ganze läuft ja in der JavaVM)?

 

[deek]

Nein, alle Typen sind zur compile-Zeit bekannt und stehen so im ByteCode wie bei Java. Was nicht zur compile-Zeit inferiert werden kann muss deklariert werden.

 

[Jaiel]

Interessante Frage. Ohne Nachforschung wüsste ich es selber nicht. Ich vertraue da mal deeks Antwort aber.

 

[keen]

Es werden doch auch in dem Beispiel die Datentypen angeben. Es sieht evtl etwas anderes aus als bei anderen Sprachen.

Zum Beispiel in der Funktion wird 'parametername: Datentyp' angeben.

Bei Kotlin ist ein Vorteil, dass die Datentypen nicht ständig wiederholt werden müssen, wie zB in Java.

Wenn eine Funktion in Kotlin ein String zurückgibt wird automatisch der Datentyp String zugewiesen.
Beispiel:

fun concat(a:String, b:String): String = a+b
val str = concat("Hallo", " Welt")
println(str)

Wobei auch hier der Returntype der Funktion optional ist.

Functions: infix, vararg, tailrec - Kotlin Programming Language

 

[markus.tullius]

Danke @keen, also ist Kotlin auch statisch typisiert. So wie bei VB oder Swift. Auf einer der Seite muss explizit der Datentyp stehen.

 

[deek]

Der Typ muss nicht zwingend da stehen, in dem Beispiel von keen könnte man das :String von concat (Rückgabetyp) weglassen, weil es durch den return von a+b (wobei a und b String sind) bereits wohldefiniert ist.
Aber ja, Kotlin ist statisch typisiert. Nur musst du den Typ nur dann schreiben wenn es für den Compiler nicht eindeutig herleitbar ist.