public void Close() { if (_open && Handle != NullHandle) { try { if (_mappings != null) { foreach (TableMapping value in _mappings.Values) { value.Dispose(); } } SQLite3.Result result = SQLite3.Close(Handle); if (result != 0) { string errmsg = SQLite3.GetErrmsg(Handle); throw SQLiteException.New(result, errmsg); } } finally { Handle = NullHandle; _open = false; } } }
public T ExecuteScalar <T>() { if (_conn.Trace) { _conn.InvokeTrace("Executing Query: " + this); } T result = default(T); lock (_conn.SyncObject) { IntPtr stmt = Prepare(); try { SQLite3.Result result2 = SQLite3.Step(stmt); switch (result2) { case SQLite3.Result.Row: { SQLite3.ColType type = SQLite3.ColumnType(stmt, 0); return((T)ReadCol(stmt, 0, type, typeof(T))); } default: throw SQLiteException.New(result2, SQLite3.GetErrmsg(_conn.Handle)); case SQLite3.Result.Done: return(result); } } finally { Finalize(stmt); } } }
/// <summary> /// Return a list of table names /// </summary> public string[] GetTableNames() { string tableSQL = "SELECT name FROM sqlite_master WHERE type='table'"; List <string> tables = new List <string>(); var statement = SQLite3.Prepare2(connection.Handle, tableSQL); try { bool done = false; while (!done) { SQLite3.Result result = SQLite3.Step(statement); if (result == SQLite3.Result.Row) { var tableName = SQLite3.ColumnString(statement, 0); tables.Add(tableName); } else if (result == SQLite3.Result.Done) { done = true; } else { throw SQLiteException.New(result, SQLite3.GetErrmsg(connection.Handle)); } } } finally { SQLite3.Finalize(statement); } return(tables.ToArray()); }
protected NotNullConstraintViolationException(SQLite3.Result r, string message, TableMapping mapping, object obj) : base(r, message) { if (mapping != null && obj != null) { this.Columns = from c in mapping.Columns where c.IsNullable == false && c.GetValue(obj) == null select c; } }
public static ServiceResultStatus FromSQLiteResult( SQLite3.Result sqliterResult) { return(StatusDictionary.ContainsKey(sqliterResult) ? StatusDictionary[sqliterResult] : ServiceResultStatus.Unknown); }
public T ExecuteScalar <T>() { if (_conn.Trace) { Debug.WriteLine("Executing Query: " + this); } T val = default(T); IntPtr stmt = Prepare(); try { SQLite3.Result r = SQLite3.Step(stmt); if (r == SQLite3.Result.Row) { SQLite3.ColType colType = SQLite3.ColumnType(stmt, 0); val = (T)ReadCol(stmt, 0, colType, typeof(T)); } else if (r == SQLite3.Result.Done) { } else { throw SQLiteException.New(r, SQLite3.GetErrmsg(_conn.Handle)); } } finally { Finalize(stmt); } return(val); }
public int ExecuteNonQuery() { if (_conn.Trace) { Debug.WriteLine("Executing: " + this); } SQLite3.Result r = SQLite3.Result.OK; IntPtr stmt = Prepare(); r = SQLite3.Step(stmt); Finalize(stmt); if (r == SQLite3.Result.Done) { int rowsAffected = SQLite3.Changes(_conn.Handle); return(rowsAffected); } if (r == SQLite3.Result.Error) { string msg = SQLite3.GetErrmsg(_conn.Handle); throw SQLiteException.New(r, msg); } if (r == SQLite3.Result.Constraint) { if (SQLite3.ExtendedErrCode(_conn.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(_conn.Handle)); } } throw SQLiteException.New(r, r.ToString()); }
public int ExecuteNonQuery() { if (_conn.Trace) { _conn.InvokeTrace("Executing: " + this); } SQLite3.Result result = SQLite3.Result.OK; lock (_conn.SyncObject) { IntPtr stmt = Prepare(); result = SQLite3.Step(stmt); Finalize(stmt); } switch (result) { case SQLite3.Result.Done: return(SQLite3.Changes(_conn.Handle)); case SQLite3.Result.Error: { string errmsg = SQLite3.GetErrmsg(_conn.Handle); throw SQLiteException.New(result, errmsg); } case SQLite3.Result.Constraint: if (SQLite3.ExtendedErrCode(_conn.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { throw NotNullConstraintViolationException.New(result, SQLite3.GetErrmsg(_conn.Handle)); } break; } throw SQLiteException.New(result, result.ToString()); }
public static void Convert(string filename, string outFilename) { Trace.WriteLine("Opening " + filename); sqlite3 handle; SQLite3.Result result = SQLite3.Open(filename, out handle); try { if (result != SQLite3.Result.OK) { string msg = SQLite3.GetErrmsg(handle); throw new Exception(msg); } Trace.WriteLine("Opened"); List <string> tableNames = new List <string>(); var writer = new LiteWriter(); GetTableNames(handle, tableNames); // build the table definitions, add the data CreateTables(handle, tableNames, writer); writer.Write(outFilename); } finally { if (handle != null) { SQLite3.Close(handle); handle = null; } } }
private bool InitializeDB() { int result = -1; IntPtr db_namePtr = System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(DB_NAME); result = GoodDynamics.Sqlite3Enc.sqlite3enc_open(db_namePtr, out _database); if (result != 0) { return(false); } string query = SQL_CREATE_TABLE; IntPtr queryPtr = System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(query); IntPtr statement = IntPtr.Zero; IntPtr errorPtr = IntPtr.Zero; var sqliteResult = SQLite3.Prepare2(_database, queryPtr, query.Length, out statement, out errorPtr); if (sqliteResult != SQLite3.Result.OK) { return(false); } SQLite3.Result sqliteenum = (SQLite3.Result)SQLite3.Step(statement); if ((SQLite3.Result)sqliteResult != SQLite3.Result.OK) { SQLite3.Finalize(statement); return(false); } SQLite3.Finalize(statement); return(true); }
public static List <string> Tables(this SQLiteConnection connection) { const string GET_TABLES_QUERY = "SELECT NAME from sqlite_master"; List <string> tables = new List <string> (); var statement = SQLite3.Prepare2(connection.Handle, GET_TABLES_QUERY); try { bool done = false; while (!done) { SQLite3.Result result = SQLite3.Step(statement); if (result == SQLite3.Result.Row) { var tableName = SQLite3.ColumnString(statement, 0); tables.Add(tableName); } else if (result == SQLite3.Result.Done) { done = true; } else { throw SQLiteException.New(result, SQLite3.GetErrmsg(connection.Handle)); } } } finally { SQLite3.Finalize(statement); } return(tables); }
/// <summary> /// Internal convenience method to throw exception on replication error /// and log exception at the same time. /// </summary> /// <param name="dbResult">result from an SQLite function, expected to /// return OK if successful or error code otherwise</param> /// <param name="message">information about action being performed (that failed)</param> private void IfNotOKThenThrowReplicationException(SQLite3.Result dbResult, string message) { if (dbResult != SQLite3.Result.OK) { var e = new ReplicationException(message, dbResult); logger.Error(e, "Sync failed - " + message); throw e; } }
public void EnableLoadExtension(int onoff) { SQLite3.Result r = SQLite3.EnableLoadExtension(Handle, onoff); if (r != SQLite3.Result.OK) { string msg = SQLite3.GetErrmsg(Handle); throw SQLiteException.New(r, msg); } }
public void EnableLoadExtension(int onoff) { SQLite3.Result result = SQLite3.EnableLoadExtension(Handle, onoff); if (result != 0) { string errmsg = SQLite3.GetErrmsg(Handle); throw SQLiteException.New(result, errmsg); } }
public IntPtr Prepare() { IntPtr ppStmt = IntPtr.Zero; SQLite3.Result n = SQLite3.Prepare2(_db, CommandText, CommandText.Length, out ppStmt, IntPtr.Zero); if (n != SQLite3.Result.OK) { throw new SQLiteException(n, SQLiteLastError()); } BindAll(ppStmt); return(ppStmt); }
//------------------------------------------------------------------------------------------------------------- public void DatabaseEditorOpenKey(string tDatabasePathEditor) { if (IsSecure()) { string tEditorPass = NWDAppConfiguration.SharedInstance().GetEditorPass(); SQLite3.Result trResultPassword = SQLite3.Key(SQLiteEditorHandle, tEditorPass, tEditorPass.Length); if (trResultPassword != SQLite3.Result.OK) { throw SQLiteException.New(trResultPassword, string.Format("Could not open database file with password: {0} ({1})", tDatabasePathEditor, trResultPassword)); } } }
//------------------------------------------------------------------------------------------------------------- public void DatabaseAccountOpenKey(string tDatabasePathAccount, string sSurProtection) { if (IsSecure()) { string tAccountPass = NWDAppConfiguration.SharedInstance().GetAccountPass(sSurProtection); SQLite3.Result trResultPassword = SQLite3.Key(SQLiteDeviceHandle, tAccountPass, tAccountPass.Length); if (trResultPassword != SQLite3.Result.OK) { throw SQLiteException.New(trResultPassword, string.Format("Could not open database file with password: {0} ({1})", tDatabasePathAccount, trResultPassword)); } } }
public int ExecuteNonQuery(object[] source) { if (this.Connection.Trace) { Debug.WriteLine("Executing: " + this.CommandText); } SQLite3.Result r = SQLite3.Result.OK; if (!this.Initialized) { this.Statement = Prepare(); this.Initialized = true; } //bind the values. if (source != null) { for (int i = 0; i < source.Length; i++) { SQLiteCommand.BindParameter(this.Statement, i + 1, source[i], this.Connection.StoreDateTimeAsTicks); } } r = SQLite3.Step(this.Statement); if (r == SQLite3.Result.Done) { int rowsAffected = SQLite3.Changes(this.Connection.Handle); SQLite3.Reset(this.Statement); return(rowsAffected); } if (r == SQLite3.Result.Error) { string msg = SQLite3.GetErrmsg(this.Connection.Handle); SQLite3.Reset(this.Statement); throw SQLiteException.New(r, msg); } if (r == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(this.Connection.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { SQLite3.Reset(this.Statement); throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(this.Connection.Handle)); } SQLite3.Reset(this.Statement); throw SQLiteException.New(r, r.ToString()); }
public int ExecuteNonQuery <T>(T toInsert) { IntPtr stmt; SQLite3.Result n = SQLite3.Prepare2(_db, CommandText, CommandText.Length, out stmt, IntPtr.Zero); if (n != SQLite3.Result.OK) { throw new SQLiteException(n, SQLiteLastError()); } var props = GetProps(typeof(T)); var ncols = SQLite3.ColumnCount(stmt); var cols = new System.Reflection.PropertyInfo[ncols]; _bindings.Clear(); for (int i = 0; i < props.Length; i++) { Bind("@" + props[i].Name, props[i].GetValue(toInsert, null)); } BindAll(stmt); var r = SQLite3.Step(stmt); switch (r) { case SQLite3.Result.Error: string msg = SQLite3.GetErrmsg(_db); SQLite3.Finalize(stmt); throw new SQLiteException(r, msg); case SQLite3.Result.Done: int rowsAffected = SQLite3.Changes(_db); SQLite3.Finalize(stmt); return(rowsAffected); case SQLite3.Result.CannotOpen: SQLite3.Finalize(stmt); throw new SQLiteException(r, "Cannot open database file"); case SQLite3.Result.Constraint: string msgC = SQLite3.GetErrmsg(_db); SQLite3.Finalize(stmt); throw new SQLiteException(r, msgC); default: SQLite3.Finalize(stmt); throw new SQLiteException(r, "Unknown error"); } }
public int ExecuteNonQuery(object[] source) { if (Connection.Trace) { Connection.InvokeTrace("Executing: " + CommandText); } SQLite3.Result result = SQLite3.Result.OK; if (!Initialized) { Statement = Prepare(); Initialized = true; } if (source != null) { for (int i = 0; i < source.Length; i++) { SQLiteCommand.BindParameter(Statement, i + 1, source[i], Connection.StoreDateTimeAsTicks); } } result = SQLite3.Step(Statement); switch (result) { case SQLite3.Result.Done: { int result2 = SQLite3.Changes(Connection.Handle); SQLite3.Reset(Statement); return(result2); } case SQLite3.Result.Error: { string errmsg = SQLite3.GetErrmsg(Connection.Handle); SQLite3.Reset(Statement); throw SQLiteException.New(result, errmsg); } case SQLite3.Result.Constraint: if (SQLite3.ExtendedErrCode(Connection.Handle) == SQLite3.ExtendedResult.ConstraintNotNull) { SQLite3.Reset(Statement); throw NotNullConstraintViolationException.New(result, SQLite3.GetErrmsg(Connection.Handle)); } break; } SQLite3.Reset(Statement); throw SQLiteException.New(result, result.ToString()); }
public void Open() { SQLite3.Result n = SQLite3.Open(Database, out _db); if (n != SQLite3.Result.OK) { throw new SQLiteException(SQLite3.Result.OK, "Could not open database file: " + Database); } string errMsg = string.Empty; /*n = SQLite3.(_db, "PRAGMA journal_mode=PERSIST", (SQLite3.dx)this.callback, null, ref errMsg); * if (n != SQLite3.SQLITE_OK) * { * SQLite3.SQLite3_close(_db); * _db = null; * _open = false; * throw new SQLiteException(n, "Cannot set journal mode to PERSIST: " + Database); * } */ _open = true; }
public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = false) { if (string.IsNullOrEmpty(databasePath)) { throw new ArgumentException("Must be specified", "databasePath"); } DatabasePath = databasePath; mayCreateSyncObject(databasePath); byte[] nullTerminatedUtf = GetNullTerminatedUtf8(DatabasePath); IntPtr db; SQLite3.Result result = SQLite3.Open(nullTerminatedUtf, out db, (int)openFlags, IntPtr.Zero); Handle = db; if (result != 0) { throw SQLiteException.New(result, $"Could not open database file: {DatabasePath} ({result})"); } _open = true; StoreDateTimeAsTicks = storeDateTimeAsTicks; BusyTimeout = TimeSpan.FromSeconds(0.1); }
public SQLiteConnection(string databasePath, string password, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = false) { if (string.IsNullOrEmpty(databasePath)) { throw new ArgumentException("Must be specified", "databasePath"); } DatabasePath = databasePath; Sqlite3DatabaseHandle handle; byte[] databasePathAsBytes = GetNullTerminatedUtf8(this.DatabasePath); SQLite3.Result r = SQLite3.Open(databasePathAsBytes, out handle, (int)openFlags, IntPtr.Zero); Handle = handle; if (r != SQLite3.Result.OK) { throw SQLiteException.New(r, string.Format("Could not open database file: {0} ({1})", this.DatabasePath, r)); } if (!string.IsNullOrEmpty(password)) { SQLite3.Result result = SQLite3.Key(handle, password, password.Length); if (result != SQLite3.Result.OK) { throw SQLiteException.New(r, string.Format("Could not open database file: {0} ({1})", this.DatabasePath, r)); } } Opened = true; StoreDateTimeAsTicks = storeDateTimeAsTicks; BusyTimeout = TimeSpan.FromSeconds(0.1); }
public void Close() { if (Opened && this.Handle != NullHandle) { try { if (Mappings != null) { foreach (TableMapping sqlInsertCommand in Mappings.Values) { sqlInsertCommand.Dispose(); } } SQLite3.Result r = SQLite3.Close(this.Handle); if (r != SQLite3.Result.OK) { string msg = SQLite3.GetErrmsg(this.Handle); throw SQLiteException.New(r, msg); } } finally { this.Handle = NullHandle; Opened = false; } } }
private void Dispose(bool disposing) { if (Opened && NullHandle != Handle) { try { if (null != Mappings) { foreach (var item in Mappings.Values) { item.Dispose(); } } SQLite3.Result r = SQLite3.Close(Handle); if (r != SQLite3.Result.OK) { string msg = SQLite3.GetErrmsg(Handle); throw SQLiteException.New(r, msg); } } finally { Handle = NullHandle; Opened = false; } } }
public static NotNullConstraintViolationException New(SQLite3.Result r, string message, TableMapping mapping, object obj) { return(new NotNullConstraintViolationException(r, message, mapping, obj)); }
public new static NotNullConstraintViolationException New(SQLite3.Result r, string message) { return(new NotNullConstraintViolationException(r, message)); }
protected NotNullConstraintViolationException(SQLite3.Result r, string message) : this(r, message, null, null) { }
public static SQLiteException New(SQLite3.Result r, string message) { return(new SQLiteException(r, message)); }
protected SQLiteException(SQLite3.Result r, string message) : base(message) { this.Result = r; }
public SQLiteException(SQLite3.Result r, string message) : base(message) { Result = r; }