xorm/sqlite3_test.go

package xorm

import (
    //"database/sql"
    _ "github.com/mattn/go-sqlite3"
    "os"
    "testing"
)

func newSqlite3Engine() (*Engine, error) {
    os.Remove("./test.db")
    return NewEngine("sqlite3", "./test.db")
}

func TestSqlite3(t *testing.T) {
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    engine.ShowSQL = showTestSql
    engine.ShowErr = showTestSql
    engine.ShowWarn = showTestSql
    engine.ShowDebug = showTestSql

    testAll(engine, t)
    testAll2(engine, t)
    testAll3(engine, t)
}

func TestSqlite3WithCache(t *testing.T) {
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
    engine.ShowSQL = showTestSql
    engine.ShowErr = showTestSql
    engine.ShowWarn = showTestSql
    engine.ShowDebug = showTestSql

    testAll(engine, t)
    testAll2(engine, t)
}

/*func BenchmarkSqlite3DriverInsert(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    if err != nil {
        t.Error(err)
        return
    }

    err = engine.CreateTables(&BigStruct{})
    if err != nil {
        t.Error(err)
        return
    }
    engine.Close()

    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        t.Error(err)
        return
    }

    doBenchDriverInsertS(db, t)

    db.Close()

    engine, err = newSqlite3Engine()
    if err != nil {
        t.Error(err)
        return
    }

    err = engine.DropTables(&BigStruct{})
    if err != nil {
        t.Error(err)
        return
    }
    defer engine.Close()
}

func BenchmarkSqlite3DriverFind(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }

    err = engine.CreateTables(&BigStruct{})
    if err != nil {
        t.Error(err)
        return
    }
    engine.Close()

    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        t.Error(err)
        return
    }
    defer db.Close()

    doBenchDriverFindS(db, t)

    db.Close()

    engine, err = newSqlite3Engine()
    if err != nil {
        t.Error(err)
        return
    }

    err = engine.DropTables(&BigStruct{})
    if err != nil {
        t.Error(err)
        return
    }
    defer engine.Close()
}*/

func BenchmarkSqlite3NoCacheInsert(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    //engine.ShowSQL = true
    doBenchInsert(engine, t)
}

func BenchmarkSqlite3NoCacheFind(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    //engine.ShowSQL = true
    doBenchFind(engine, t)
}

func BenchmarkSqlite3NoCacheFindPtr(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    //engine.ShowSQL = true
    doBenchFindPtr(engine, t)
}

func BenchmarkSqlite3CacheInsert(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
    doBenchInsert(engine, t)
}

func BenchmarkSqlite3CacheFind(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
    doBenchFind(engine, t)
}

func BenchmarkSqlite3CacheFindPtr(t *testing.B) {
    t.StopTimer()
    engine, err := newSqlite3Engine()
    defer engine.Close()
    if err != nil {
        t.Error(err)
        return
    }
    engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
    doBenchFindPtr(engine, t)
}