public void HasRows_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(reader.HasRows);
}
}
}
}
public void FieldCount_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.FieldCount);
}
}
}
}
public void ParameterName_doesnt_unset_bound_when_unchanged()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
var parameter = command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
command.ExecuteNonQuery();
parameter.ParameterName = "@Parameter";
Assert.True(parameter.Bound);
}
}
}
public void RecordsAffected_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
connection.Open();
CreateTestTable(connection);
command.CommandText = "INSERT INTO TestTable (Int32Column) VALUES (2)";
using (var reader = command.ExecuteReader())
{
Assert.Equal(1, reader.RecordsAffected);
}
}
}
}
public void GetChar_not_supported()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 't'";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
var ex = Assert.Throws<ArgumentException>(() => reader.GetChar(0));
Assert.Equal(Strings.FormatUnknownDataType(typeof(char)), ex.Message);
}
}
}
}
public void IsDBNull_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(reader.IsDBNull(0));
}
}
}
}
public void Prepare_can_be_called_when_disposed()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
command.Dispose();
command.Connection = connection;
connection.Open();
command.Prepare();
}
}
}
public void Dispose_closes_open_reader()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
using (var reader = command.ExecuteReader())
{
command.Dispose();
Assert.True(reader.IsClosed);
}
}
}
}
public void GetOrdinal_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1 AS Column1";
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.Equal(0, reader.GetOrdinal("Column1"));
}
}
}
}
public void GetInt32_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
CreateTestTable(connection);
command.CommandText = "SELECT Int32Column FROM TestTable";
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(1, reader.GetInt32(0));
}
}
}
}
public void Bind_binds_float_values()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Float";
command.Parameters.AddWithValue("@Float", 3.14);
connection.Open();
var result = command.ExecuteScalar();
Assert.Equal(3.14, result);
}
}
}
public void Item_string_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1 AS Column1";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(1L, reader["Column1"]);
}
}
}
}
public void GetFieldValue_throws_when_null()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<long>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<double>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<string>(0));
Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<byte[]>(0));
}
}
}
}
public void Bind_sets_bound()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
var parameter = command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
command.ExecuteNonQuery();
Assert.True(parameter.Bound);
}
}
}
public void Bind_requres_set_value()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter";
command.Parameters.Add(new SQLiteParameter { ParameterName = "@Parameter" });
connection.Open();
var ex = Assert.Throws<InvalidOperationException>(() => command.ExecuteNonQuery());
Assert.Equal(Strings.FormatRequiresSet("Value"), ex.Message);
}
}
}
public void Bind_binds_null_value()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Null";
command.Parameters.AddWithValue("@Null", DBNull.Value);
connection.Open();
var result = command.ExecuteScalar();
Assert.Equal(DBNull.Value, result);
}
}
}
public void Bind_binds_blob_values()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Blob";
command.Parameters.AddWithValue("@Blob", new byte[] { 0x7e, 0x57 });
connection.Open();
var result = command.ExecuteScalar();
Assert.Equal(new byte[] { 0x7e, 0x57 }, result);
}
}
}
public void Bind_binds_text_values_without_embedded_nulls()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Text || 'ing'";
command.Parameters.AddWithValue("@Text", "test");
connection.Open();
var result = command.ExecuteScalar();
Assert.Equal("testing", result);
}
}
}
public void GetDateTime_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
CreateTestTable(connection);
command.CommandText = "SELECT DateTimeColumn FROM TestTable";
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(new DateTime(2014, 4, 1, 14, 45, 0), reader.GetDateTime(0));
}
}
}
}
public void GetValues_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT NULL, 1, 3.14, 'test', x'7e57'";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
var values = new object[5];
var count = reader.GetValues(values);
Assert.Equal(5, count);
Assert.Equal(DBNull.Value, values[0]);
Assert.Equal(1L, values[1]);
Assert.Equal(3.14, values[2]);
Assert.Equal("test", values[3]);
Assert.Equal(new byte[] { 0x7e, 0x57 }, values[4]);
}
}
}
}
public void GetGuid_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
CreateTestTable(connection);
command.CommandText = "SELECT GuidColumn FROM TestTable";
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(new Guid("dc13b11c-e6fb-449f-a892-5e2a47b05350"), reader.GetGuid(0));
}
}
}
}
public void CreateCommand_returns_command()
{
using (var connection = new SQLiteConnection())
{
using (var command = connection.CreateCommand())
{
Assert.NotNull(command);
Assert.Same(connection, command.Connection);
}
}
}
public void NextResult_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1; SELECT 2;";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(1L, reader[0]);
var result = reader.NextResult();
Assert.True(result);
reader.Read();
Assert.Equal(2L, reader[0]);
result = reader.NextResult();
Assert.False(result);
}
}
}
}
public void Bind_is_noop_on_unknown_parameter()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
command.Parameters.AddWithValue("@Unknown", 1);
connection.Open();
command.ExecuteNonQuery();
}
}
}
public void GetValue_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
Assert.Equal(1L, reader.GetValue(0));
}
}
}
}
public void Close_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1 UNION SELECT 2";
connection.Open();
using (var reader = command.ExecuteReader())
{
reader.Read();
reader.Read();
reader.Close();
Assert.Null(command.OpenReader);
Assert.True(reader.IsClosed);
}
// NOTE: This would equal two if not reset
Assert.Equal(1L, command.ExecuteScalar());
}
}
}
public void GetValues_when_null_scalar_column()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
connection.Open();
connection.ExecuteNonQuery(@"CREATE TABLE TestTable (Int32Column INT)");
connection.ExecuteNonQuery(@"INSERT INTO TestTable VALUES (NULL)");
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT * FROM TestTable";
using (var reader = command.ExecuteReader())
{
reader.Read();
var values = new object[1];
var count = reader.GetValues(values);
Assert.Equal(1, count);
Assert.Equal(DBNull.Value, values[0]);
}
}
}
}
public void GetOrdinal_throws_when_unknown()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT 1";
connection.Open();
using (var reader = command.ExecuteReader())
{
var ex = Assert.Throws<IndexOutOfRangeException>(() => reader.GetOrdinal("Unknown"));
Assert.Equal("Unknown", ex.Message);
}
}
}
}
public void Dispose_works()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
CreateTestTable(connection);
using (var transaction = connection.BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.CommandText = "INSERT INTO TestTable VALUES (1)";
command.ExecuteNonQuery();
transaction.Dispose();
Assert.Null(connection.Transaction);
Assert.Null(transaction.Connection);
}
}
Assert.Equal(0L, connection.ExecuteScalar<long>("SELECT COUNT(*) FROM TestTable"));
}
}
public void ExecuteReader_works_when_batching()
{
using (var connection = new SQLiteConnection("Filename=:memory:"))
{
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT @Parameter; SELECT @Parameter + 1;";
command.Parameters.AddWithValue("@Parameter", 1);
connection.Open();
using (var reader = command.ExecuteReader())
{
Assert.True(command.Parameters.Bound);
Assert.NotNull(command.OpenReader);
Assert.NotNull(reader);
reader.Read();
Assert.Equal(1L, reader[0]);
reader.NextResult();
reader.Read();
Assert.Equal(2L, reader[0]);
}
}
}
}
