func sqlOpen(name string, flags int, vfs string) (conn *sqlConnection, rc int) { conn = new(sqlConnection) p := C.CString(name) if len(vfs) > 0 { q := C.CString(vfs) rc = int(C.sqlite3_open_v2(p, &conn.handle, C.int(flags), q)) C.free(unsafe.Pointer(q)) } else { rc = int(C.sqlite3_open_v2(p, &conn.handle, C.int(flags), nil)) } C.free(unsafe.Pointer(p)) // We could get a handle even if there's an error, see // http://www.sqlite.org/c3ref/open.html for details. // Initially we didn't want to return a connection on // error, but we actually have to since we want to fill // in a SystemError struct. Sigh. // if rc != StatusOk && conn.handle != nil { // _ = conn.sqlClose(); // conn = nil; // } return }
// OpenVfs opens a new database with a specified virtual file system. func OpenVfs(filename string, vfsname string, flags ...OpenFlag) (*Conn, error) { if C.sqlite3_threadsafe() == 0 { return nil, errors.New("sqlite library was not compiled for thread-safe operation") } var openFlags int if len(flags) > 0 { for _, flag := range flags { openFlags |= int(flag) } } else { openFlags = C.SQLITE_OPEN_FULLMUTEX | C.SQLITE_OPEN_READWRITE | C.SQLITE_OPEN_CREATE } var db *C.sqlite3 name := C.CString(filename) defer C.free(unsafe.Pointer(name)) var vfs *C.char if len(vfsname) > 0 { vfs = C.CString(vfsname) defer C.free(unsafe.Pointer(vfs)) } rv := C.sqlite3_open_v2(name, &db, C.int(openFlags), vfs) if rv != C.SQLITE_OK { if db != nil { C.sqlite3_close(db) } return nil, Errno(rv) } if db == nil { return nil, errors.New("sqlite succeeded without returning a database") } return &Conn{db: db, stmtCache: newCache()}, nil }
func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) { if C.sqlite3_threadsafe() == 0 { return nil, errors.New("sqlite library was not compiled for thread-safe operation") } var db *C.sqlite3 name := C.CString(dsn) defer C.free(unsafe.Pointer(name)) rv := C.sqlite3_open_v2(name, &db, C.SQLITE_OPEN_FULLMUTEX| C.SQLITE_OPEN_READWRITE| C.SQLITE_OPEN_CREATE, nil) if rv != 0 { return nil, errors.New(C.GoString(C.sqlite3_errmsg(db))) } if db == nil { return nil, errors.New("sqlite succeeded without returning a database") } rv = C.sqlite3_busy_timeout(db, 5000) if rv != C.SQLITE_OK { return nil, errors.New(C.GoString(C.sqlite3_errmsg(db))) } return &SQLiteConn{db}, nil }
// OpenVfs opens a new database with a specified virtual file system. func OpenVfs(filename string, vfsname string, flags ...OpenFlag) (*Conn, error) { if C.sqlite3_threadsafe() == 0 { return nil, errors.New("sqlite library was not compiled for thread-safe operation") } var openFlags int if len(flags) > 0 { for _, flag := range flags { openFlags |= int(flag) } } else { openFlags = C.SQLITE_OPEN_FULLMUTEX | C.SQLITE_OPEN_READWRITE | C.SQLITE_OPEN_CREATE } var db *C.sqlite3 cname := C.CString(filename) defer C.free(unsafe.Pointer(cname)) var vfs *C.char if len(vfsname) > 0 { vfs = C.CString(vfsname) defer C.free(unsafe.Pointer(vfs)) } rv := C.sqlite3_open_v2(cname, &db, C.int(openFlags), vfs) if rv != C.SQLITE_OK { if db != nil { // try to extract futher details from db... err := OpenError{Code: Errno(rv), ExtendedCode: int(C.sqlite3_extended_errcode(db)), Msg: C.GoString(C.sqlite3_errmsg(db)), Filename: filename, } C.sqlite3_close(db) return nil, err } return nil, Errno(rv) } if db == nil { return nil, errors.New("sqlite succeeded without returning a database") } c := &Conn{db: db, stmtCache: newCache(), DefaultTimeLayout: "2006-01-02 15:04:05.000Z07:00"} if os.Getenv("SQLITE_DEBUG") != "" { //c.SetAuthorizer(authorizer, c.db) c.Trace(trace, "TRACE") //c.SetCacheSize(0) } return c, nil }
func (db *Database) Open(flags ...int) (e error) { if C.sqlite3_threadsafe() == 0 { panic("sqlite library is not thread-safe") } if db.handle != nil { e = CANTOPEN } else { db.Flags = 0 for _, v := range flags { db.Flags = db.Flags | C.int(v) } if err := Errno(C.sqlite3_open_v2(C.CString(db.Filename), &db.handle, db.Flags, nil)); err != OK { e = err } else if db.handle == nil { e = CANTOPEN } } return }
// Open creates a new connection to a SQLite database. The name can be 1) a path // to a file, which is created if it does not exist, 2) a URI using the syntax // described at http://www.sqlite.org/uri.html, 3) the string ":memory:", which // creates a temporary in-memory database, or 4) an empty string, which creates // a temporary on-disk database (deleted when closed) in the directory returned // by os.TempDir(). // [http://www.sqlite.org/c3ref/open.html] func Open(name string) (*Conn, error) { if initErr != nil { return nil, initErr } name += "\x00" var db *C.sqlite3 rc := C.sqlite3_open_v2(cStr(name), &db, C.SQLITE_OPEN_READWRITE|C.SQLITE_OPEN_CREATE, nil) if rc != OK { err := libErr(rc, db) C.sqlite3_close(db) return nil, err } c := &Conn{db: db} C.sqlite3_extended_result_codes(db, 1) runtime.SetFinalizer(c, (*Conn).Close) return c, nil }
func OpenV2(filename string, flags int) (*Conn, error) { if C.sqlite3_threadsafe() == 0 { return nil, errors.New("sqlite library was not compiled for thread-safe operation") } var db *C.sqlite3 name := C.CString(filename) defer C.free(unsafe.Pointer(name)) rv := C.sqlite3_open_v2(name, &db, C.int(flags), nil) if rv != 0 { return nil, Errno(rv) } if db == nil { return nil, errors.New("sqlite succeeded without returning a database") } return &Conn{db}, nil }
func Open(filename string) (*Conn, error) { if C.sqlite3_threadsafe() == 0 { return nil, errors.New("sqlite library was not compiled for thread-safe operation") } var db *C.sqlite3 name := C.CString(filename) defer C.free(unsafe.Pointer(name)) rv := C.sqlite3_open_v2(name, &db, C.SQLITE_OPEN_FULLMUTEX| C.SQLITE_OPEN_READWRITE| C.SQLITE_OPEN_CREATE, nil) if rv != 0 { return nil, Errno(rv) } if db == nil { return nil, errors.New("sqlite succeeded without returning a database") } return &Conn{db}, nil }
// Open initializes and opens the database. func (db *Database) Open(flags ...DBFlag) (e error) { if C.sqlite3_threadsafe() == 0 { panic("sqlite library is not thread-safe") } if db.handle != nil { e = CANTOPEN } else { db.DBFlag = 0 for _, v := range flags { db.DBFlag |= v } cs := C.CString(db.Filename) defer C.free(unsafe.Pointer(cs)) e = SQLiteError(C.sqlite3_open_v2(cs, &db.handle, C.int(db.DBFlag), nil)) if e == nil && db.handle == nil { e = CANTOPEN } } return }