public static Type convertTypeToCLRType(SQLite3.ColType colType)
{
switch (colType)
{
case SQLite3.ColType.Blob:
return typeof(byte[]);
case SQLite3.ColType.Float:
return typeof(float);
case SQLite3.ColType.Integer:
return typeof(int);
case SQLite3.ColType.Text:
return typeof(string);
case SQLite3.ColType.Null:
default:
return typeof(string);
}
}
internal IEnumerable <T> ExecuteDeferredQuery <T>() where T : IDictionary <string, object>
{
if (_conn.Trace)
{
Debug.WriteLine("Executing Query: " + this);
}
var stmt = Prepare();
try
{
var cols = new TableMapping.Column[SQLite3.ColumnCount(stmt)];
// We have a valid row, get the correct datatypes and columns
if (SQLite3.Step(stmt) == SQLite3.Result.Row)
{
for (int i = 0; i < cols.Length; i++)
{
var name = SQLite3.ColumnName16(stmt, i);
cols[i] = new TableMapping.Column(name, SQLiteTypeConverter.convertTypeToCLRType(SQLite3.ColumnType(stmt, i)));
}
}
else
{
yield break;
}
do
{
IDictionary <string, object> obj = new Dictionary <string, object>();
for (int i = 0; i < cols.Length; i++)
{
if (cols[i] == null)
{
continue;
}
var colType = SQLite3.ColumnType(stmt, i);
var val = ReadCol(stmt, i, colType, cols[i].ColumnType);
cols[i].SetValue(obj, val);
}
yield return((T)obj);
} while (SQLite3.Step(stmt) == SQLite3.Result.Row);
}
finally
{
SQLite3.Finalize(stmt);
}
}
object ReadCol(Sqlite3Statement stmt, int index, SQLite3.ColType type, Type clrType)
{
if (type == SQLite3.ColType.Null)
{
return(null);
}
else
{
if (clrType == typeof(String))
{
return(SQLite3.ColumnString(stmt, index));
}
else if (clrType == typeof(Int32))
{
return((int)SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(Boolean))
{
return(SQLite3.ColumnInt(stmt, index) == 1);
}
else if (clrType == typeof(double))
{
return(SQLite3.ColumnDouble(stmt, index));
}
else if (clrType == typeof(float))
{
return((float)SQLite3.ColumnDouble(stmt, index));
}
else if (clrType == typeof(TimeSpan))
{
return(new TimeSpan(SQLite3.ColumnInt64(stmt, index)));
}
else if (clrType == typeof(DateTime))
{
if (_conn.StoreDateTimeAsTicks)
{
return(new DateTime(SQLite3.ColumnInt64(stmt, index)));
}
else
{
var text = SQLite3.ColumnString(stmt, index);
return(DateTime.Parse(text));
}
}
else if (clrType == typeof(DateTimeOffset))
{
return(new DateTimeOffset(SQLite3.ColumnInt64(stmt, index), TimeSpan.Zero));
}
else if (clrType.GetTypeInfo().IsEnum)
{
return(SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(Int64))
{
return(SQLite3.ColumnInt64(stmt, index));
}
else if (clrType == typeof(UInt32))
{
return((uint)SQLite3.ColumnInt64(stmt, index));
}
else if (clrType == typeof(decimal))
{
return((decimal)SQLite3.ColumnDouble(stmt, index));
}
else if (clrType == typeof(Byte))
{
return((byte)SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(UInt16))
{
return((ushort)SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(Int16))
{
return((short)SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(sbyte))
{
return((sbyte)SQLite3.ColumnInt(stmt, index));
}
else if (clrType == typeof(byte[]))
{
return(SQLite3.ColumnByteArray(stmt, index));
}
else if (clrType == typeof(Guid))
{
var text = SQLite3.ColumnString(stmt, index);
return(new Guid(text));
}
else
{
throw new NotSupportedException("Don't know how to read " + clrType);
}
}
}
internal static void BindParameter(Sqlite3Statement stmt, int index, object value, bool storeDateTimeAsTicks)
{
if (value == null)
{
SQLite3.BindNull(stmt, index);
}
else
{
if (value is Int32)
{
SQLite3.BindInt(stmt, index, (int)value);
}
else if (value is String)
{
SQLite3.BindText(stmt, index, (string)value, -1, NegativePointer);
}
else if (value is Byte || value is UInt16 || value is SByte || value is Int16)
{
SQLite3.BindInt(stmt, index, Convert.ToInt32(value));
}
else if (value is Boolean)
{
SQLite3.BindInt(stmt, index, (bool)value ? 1 : 0);
}
else if (value is UInt32 || value is Int64)
{
SQLite3.BindInt64(stmt, index, Convert.ToInt64(value));
}
else if (value is Single || value is Double || value is Decimal)
{
SQLite3.BindDouble(stmt, index, Convert.ToDouble(value));
}
else if (value is TimeSpan)
{
SQLite3.BindInt64(stmt, index, ((TimeSpan)value).Ticks);
}
else if (value is DateTime)
{
if (storeDateTimeAsTicks)
{
SQLite3.BindInt64(stmt, index, ((DateTime)value).Ticks);
}
else
{
SQLite3.BindText(stmt, index, ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), -1, NegativePointer);
}
}
else if (value is DateTimeOffset)
{
SQLite3.BindInt64(stmt, index, ((DateTimeOffset)value).UtcTicks);
}
else if (value.GetType().GetTypeInfo().IsEnum)
{
SQLite3.BindInt(stmt, index, Convert.ToInt32(value));
}
else if (value is byte[])
{
SQLite3.BindBlob(stmt, index, (byte[])value, ((byte[])value).Length, NegativePointer);
}
else if (value is Guid)
{
SQLite3.BindText(stmt, index, ((Guid)value).ToString(), 72, NegativePointer);
}
else
{
throw new NotSupportedException("Cannot store type: " + value.GetType());
}
}
}
void Finalize(Sqlite3Statement stmt)
{
SQLite3.Finalize(stmt);
}