public override object ExecuteScalar()
{
if (OpenReader != null)
{
throw new InvalidOperationException(Strings.OpenReaderExists);
}
if (_connection == null ||
_connection.State != ConnectionState.Open)
{
throw new InvalidOperationException(Strings.FormatCallRequiresOpenConnection("ExecuteScalar"));
}
if (string.IsNullOrWhiteSpace(_commandText))
{
throw new InvalidOperationException(Strings.FormatCallRequiresSetCommandText("ExecuteScalar"));
}
ValidateTransaction();
Prepare();
Bind();
object result = null;
var gotResult = false;
foreach (var handle in _handles)
{
try
{
var rc = NativeMethods.sqlite3_step(handle);
if (rc != Constants.SQLITE_DONE &&
rc != Constants.SQLITE_ROW)
{
MarshalEx.ThrowExceptionForRC(rc);
}
var hasResults = NativeMethods.sqlite3_stmt_readonly(handle) != 0;
if (!gotResult && hasResults)
{
if (rc == Constants.SQLITE_ROW)
{
var declaredType = NativeMethods.sqlite3_column_decltype(handle, 0);
var sqliteType = (SQLiteType)NativeMethods.sqlite3_column_type(handle, 0);
var map = SQLiteTypeMap.FromDeclaredType(declaredType, sqliteType);
var value = ColumnReader.Read(map.SQLiteType, handle, 0);
result = map.FromInterop(value);
}
gotResult = true;
}
}
finally
{
var rc = NativeMethods.sqlite3_reset(handle);
MarshalEx.ThrowExceptionForRC(rc);
}
}
return(result);
}
internal void Bind(IEnumerable <StatementHandle> handles)
{
Debug.Assert(handles != null, "handles is null.");
if (_parameterName == null)
{
throw new InvalidOperationException(Strings.FormatRequiresSet("ParameterName"));
}
if (_value == null)
{
throw new InvalidOperationException(Strings.FormatRequiresSet("Value"));
}
foreach (var handle in handles)
{
var index = NativeMethods.sqlite3_bind_parameter_index(handle, _parameterName);
if (index != 0)
{
var typeMap = SQLiteTypeMap.FromClrType(_value.GetType());
switch (typeMap.SQLiteType)
{
case SQLiteType.Integer:
var rc = NativeMethods.sqlite3_bind_int64(handle, index, (long)typeMap.ToInterop(_value));
MarshalEx.ThrowExceptionForRC(rc);
break;
case SQLiteType.Float:
rc = NativeMethods.sqlite3_bind_double(handle, index, (double)typeMap.ToInterop(_value));
MarshalEx.ThrowExceptionForRC(rc);
break;
case SQLiteType.Text:
rc = NativeMethods.sqlite3_bind_text(handle, index, (string)typeMap.ToInterop(_value));
MarshalEx.ThrowExceptionForRC(rc);
break;
case SQLiteType.Blob:
rc = NativeMethods.sqlite3_bind_blob(handle, index, (byte[])typeMap.ToInterop(_value));
MarshalEx.ThrowExceptionForRC(rc);
break;
case SQLiteType.Null:
rc = NativeMethods.sqlite3_bind_null(handle, index);
MarshalEx.ThrowExceptionForRC(rc);
break;
default:
Debug.Assert(false, "Unexpected value.");
break;
}
}
}
_bound = true;
}
public override RelationalTypeMapping GetTypeMapping(
string specifiedType, string storageName, Type propertyType, bool isKey, bool isConcurrencyToken)
{
var map = SQLiteTypeMap.FromClrType(propertyType);
if (specifiedType != null)
{
map = SQLiteTypeMap.FromDeclaredType(specifiedType, map.SQLiteType);
}
// TODO: Leverage base implementation more
return(new RelationalTypeMapping(map.DeclaredTypes.First(), map.DbType));
}
public override T GetFieldValue <T>(int ordinal)
{
CheckClosed("GetFieldValue");
if (typeof(T) == typeof(object))
{
return((T)GetValue(ordinal));
}
var map = SQLiteTypeMap.FromClrType <T>();
var value = ColumnReader.Read(map.SQLiteType, _currentHandle, ordinal);
return((T)map.FromInterop(value));
}
public override RelationalTypeMapping GetTypeMapping(
string specifiedType, string storageName, Type propertyType, bool isKey, bool isConcurrencyToken)
{
// TODO: This is a hacky implementation for getting the DbType to use.
var baseMapping = base.GetTypeMapping(specifiedType, storageName, propertyType, isKey, isConcurrencyToken);
if (specifiedType != null)
{
return(new RelationalTypeMapping(specifiedType, baseMapping.StoreType));
}
var types = SQLiteTypeMap.FromClrType(Nullable.GetUnderlyingType(propertyType) ?? propertyType)
.DeclaredTypes;
Contract.Assert(types.Any(), "types is empty.");
return(new RelationalTypeMapping(types.First(), baseMapping.StoreType));
}
public override IValueGeneratorFactory Select(IProperty property)
{
if (property.ValueGenerationOnAdd == ValueGenerationOnAdd.Client)
{
// If INTEGER PRIMARY KEY column...
var keyProperties = property.EntityType.GetKey().Properties;
if (keyProperties.Count == 1 &&
keyProperties[0] == property)
{
// TODO: Consider using RelationalTypeMapper service
var integerClrType = SQLiteTypeMap.FromDeclaredType("INTEGER", SQLiteType.Integer).ClrType;
if (property.PropertyType == integerClrType ||
string.Equals(property.ColumnType(), "INTEGER", StringComparison.OrdinalIgnoreCase))
{
// NOTE: This assumes no WITHOUT ROWID tables
return(_tempFactory);
}
}
}
return(base.Select(property));
}
private SQLiteTypeMap GetTypeMap(int ordinal)
{
return(SQLiteTypeMap.FromDeclaredType(GetDataTypeName(ordinal), GetSQLiteType(ordinal)));
}
