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 int ExecuteNonQuery()
{
var r = SQLite3.Result.OK;
for (int i = 0; i < _conn.MaxExecuteAttempts; i++)
{
var stmt = Prepare();
r = SQLite3.Step(stmt);
SQLite3.Finalize(stmt);
if (r == SQLite3.Result.Error)
{
string msg = SQLite3.Errmsg(_conn.Handle);
throw SQLiteException.New(r, msg);
}
else if (r == SQLite3.Result.Done)
{
int rowsAffected = SQLite3.Changes(_conn.Handle);
return(rowsAffected);
}
else if (r == SQLite3.Result.Busy)
{
// We will retry
System.Threading.Thread.Sleep(1000);
}
else
{
throw SQLiteException.New(r, r.ToString());
}
}
throw SQLiteException.New(r, r.ToString());
}
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);
}
}
}
public int ExecuteNonQuery()
{
if (_conn.Trace)
{
Debug.WriteLine("Executing: " + this);
}
var r = SQLite3.Result.OK;
var stmt = Prepare();
r = SQLite3.Step(stmt);
Finalize(stmt);
if (r == SQLite3.Result.Done)
{
int rowsAffected = SQLite3.Changes(_conn.Handle);
return(rowsAffected);
}
else if (r == SQLite3.Result.Error)
{
string msg = SQLite3.GetErrmsg(_conn.Handle);
throw SQLiteException.New(r, msg);
}
else 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 T ExecuteScalar <T>()
{
if (_conn.Trace)
{
Debug.WriteLine("Executing Query: " + this);
}
T val = default(T);
var stmt = Prepare();
try {
var r = SQLite3.Step(stmt);
if (r == SQLite3.Result.Row)
{
var 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 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 static IntPtr Prepare2(IntPtr db, string query)
{
IntPtr stmt;
Result result = Prepare2(db, query, Encoding.UTF8.GetByteCount(query), out stmt, IntPtr.Zero);
if (result != 0)
{
throw SQLiteException.New(result, GetErrmsg(db));
}
return(stmt);
}
public SQLiteConnection(string database)
{
Database = database;
var r = SQLite3.Open(Database, out _db);
if (r != SQLite3.Result.OK)
{
throw SQLiteException.New(r, "Could not open database file: " + Database);
}
_open = true;
}
public static IntPtr Prepare(IntPtr db, string query)
{
IntPtr stmt;
var r = Prepare(db, query, query.Length, out stmt, IntPtr.Zero);
if (r != Result.OK)
{
throw SQLiteException.New(r, Errmsg(db));
}
return(stmt);
}
/// <summary>
/// Constructs a new SQLiteConnection and opens a SQLite database specified by databasePath.
/// </summary>
/// <param name="databasePath">
/// Specifies the path to the database file.
/// </param>
public SQLiteConnection(string databasePath)
{
MaxExecuteAttempts = 10;
DatabasePath = databasePath;
IntPtr handle;
var r = SQLite3.Open(DatabasePath, out handle);
Handle = handle;
if (r != SQLite3.Result.OK)
{
throw SQLiteException.New(r, "Could not open database file: " + DatabasePath);
}
_open = true;
}
public SQLiteCommand CreateCommand(string cmdText, params object[] ps)
{
if (!_open)
{
throw SQLiteException.New(SQLite3.Result.Error, "Cannot create commands from unopened database");
}
SQLiteCommand sQLiteCommand = NewCommand();
sQLiteCommand.CommandText = cmdText;
foreach (object val in ps)
{
sQLiteCommand.Bind(val);
}
return(sQLiteCommand);
}
public int ExecuteNonQuery(object[] source)
{
if (Connection.Trace)
{
Debug.WriteLine("Executing: " + CommandText);
}
var r = SQLite3.Result.OK;
if (!Initialized)
{
Statement = Prepare();
Initialized = true;
}
//bind the values.
if (source != null)
{
for (int i = 0; i < source.Length; i++)
{
SQLiteCommand.BindParameter(Statement, i + 1, source[i], Connection.StoreDateTimeAsTicks);
}
}
r = SQLite3.Step(Statement);
if (r == SQLite3.Result.Done)
{
int rowsAffected = SQLite3.Changes(Connection.Handle);
SQLite3.Reset(Statement);
return(rowsAffected);
}
else if (r == SQLite3.Result.Error)
{
string msg = SQLite3.GetErrmsg(Connection.Handle);
SQLite3.Reset(Statement);
throw SQLiteException.New(r, msg);
}
else if (r == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(Connection.Handle) == SQLite3.ExtendedResult.ConstraintNotNull)
{
SQLite3.Reset(Statement);
throw NotNullConstraintViolationException.New(r, SQLite3.GetErrmsg(Connection.Handle));
}
else
{
SQLite3.Reset(Statement);
throw SQLiteException.New(r, r.ToString());
}
}
public static IntPtr Prepare2(IntPtr db, string query)
{
IntPtr stmt;
#if NETFX_CORE
byte[] queryBytes = System.Text.UTF8Encoding.UTF8.GetBytes(query);
var r = Prepare2(db, queryBytes, queryBytes.Length, out stmt, IntPtr.Zero);
#else
var r = Prepare2(db, query, System.Text.UTF8Encoding.UTF8.GetByteCount(query), out stmt, IntPtr.Zero);
#endif
if (r != Result.OK)
{
throw SQLiteException.New(r, GetErrmsg(db));
}
return(stmt);
}
public static Sqlite3Statement Prepare2(Sqlite3DatabaseHandle db, string query)
{
Sqlite3Statement stmt = default(Sqlite3Statement);
#if USE_WP8_NATIVE_SQLITE || USE_SQLITEPCL_RAW
var r = Sqlite3.sqlite3_prepare_v2(db, query, out stmt);
#else
stmt = new Sqlite3Statement();
var r = Sqlite3.sqlite3_prepare_v2(db, query, -1, ref stmt, 0);
#endif
if (r != 0)
{
throw SQLiteException.New((Result)r, GetErrmsg(db));
}
return(stmt);
}
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 SQLiteCommand CreateCommand(string cmdText, params object[] ps)
{
if (!_open)
{
throw SQLiteException.New(SQLite3.Result.Error, "Cannot create commands from unopened database");
}
else
{
var cmd = new SQLiteCommand(_db);
cmd.CommandText = cmdText;
foreach (var o in ps)
{
cmd.Bind(o);
}
return(cmd);
}
}
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 int ExecuteNonQuery()
{
var stmt = Prepare();
var r = SQLite3.Step(stmt);
if (r == SQLite3.Result.Error)
{
string msg = SQLite3.Errmsg(_db);
SQLite3.Finalize(stmt);
throw SQLiteException.New(r, msg);
}
else if (r == SQLite3.Result.Done)
{
int rowsAffected = SQLite3.Changes(_db);
SQLite3.Finalize(stmt);
return(rowsAffected);
}
else
{
SQLite3.Finalize(stmt);
throw SQLiteException.New(r, "Unknown error");
}
}
public IEnumerable <T> ExecuteQuery <T>(TableMapping map, object[] source)
{
CheckDisposed();
Log(nameof(ExecuteQuery), source);
OnExecutionStarted();
var sw = Stopwatch.StartNew();
try
{
var r = Result.OK;
if (!Prepared)
{
Statement = Prepare();
Prepared = true;
}
//bind the values.
if (source != null)
{
for (int i = 0; i < source.Length; i++)
{
BindParameter(Statement, i + 1, source[i], Connection.StoreDateTimeAsTicks);
}
}
var cols = new TableColumn[SQLite3.ColumnCount(Statement)];
for (int i = 0; i < cols.Length; i++)
{
var name = SQLite3.ColumnNameUTF8(Statement, i);
cols[i] = map.FindColumn(name);
}
while (SQLite3.Step(Statement) == Result.Row)
{
var obj = map.CreateInstance();
for (int i = 0; i < cols.Length; i++)
{
if (cols[i] == null)
{
continue;
}
var colType = SQLite3.ColumnType(Statement, i);
var val = ReadCol(Statement, i, colType, cols[i].ColumnType, cols[i].PropertyDefaultValue);
cols[i].SetValue(obj, val);
}
OnInstanceCreated(obj);
yield return((T)obj);
}
if (r == Result.Done || r == Result.OK)
{
}
else
{
var msg = SQLite3.GetErrorMessageUTF8(Connection.Handle);
var ex = new SQLiteException(r, msg, sql: CommandText);
ex.PopulateColumnFromTableMapping(map);
throw ex;
}
}
finally
{
if (Statement != null)
{
SQLite3.Reset(Statement);
}
sw.Stop();
Log(sw);
OnExecutionEnded();
}
}
public static NotNullConstraintViolationException New(SQLiteException exception, TableMapping mapping, object obj)
{
return(new NotNullConstraintViolationException(exception.Result, exception.Message, mapping, obj));
}
