SqliteDataReaderTest.cs

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Data.Common;
using System.IO;
using Microsoft.Data.Sqlite.Properties;
using Xunit;

namespace Microsoft.Data.Sqlite
{
    public class SqliteDataReaderTest
    {
        [Fact]
        public void Depth_returns_zero()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    Assert.Equal(0, reader.Depth);
                }
            }
        }

        [Fact]
        public void FieldCount_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    Assert.Equal(1, reader.FieldCount);
                }
            }
        }

        [Fact]
        public void FieldCount_throws_when_closed()
            => X_throws_when_closed(
                r =>
                {
                    var x = r.FieldCount;
                }, "FieldCount");

        [Fact]
        public void FieldCount_returns_zero_when_non_query()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("CREATE TABLE dual(dummy);"))
                {
                    Assert.Equal(0, reader.FieldCount);
                }
            }
        }

        [Fact]
        public void GetBoolean_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetBoolean(0),
                true);

        [Fact]
        public void GetBoolean_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetBoolean(0), nameof(SqliteDataReader.GetBoolean));
        }

        [Fact]
        public void GetBoolean_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetBoolean(0));

        [Fact]
        public void GetByte_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetByte(0),
                (byte)1);

        [Fact]
        public void GetByte_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetByte(0), nameof(SqliteDataReader.GetByte));
        }

        [Fact]
        public void GetByte_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetByte(0));

        [Fact]
        public void GetBytes_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");
                connection.ExecuteNonQuery("INSERT INTO Test VALUES(x'427E5743');");
                connection.ExecuteNonQuery("INSERT INTO Test VALUES(x'538F6854');");
                connection.ExecuteNonQuery("INSERT INTO Test VALUES(x'649A7965');");

                using (var reader = connection.ExecuteReader("SELECT Value FROM Test;"))
                {
                    var list = new List<byte[]>();
                    while (reader.Read())
                    {
                        var buffer = new byte[6];
                        var bytesRead = reader.GetBytes(0, 0, buffer, 0, buffer.Length);
                        Assert.Equal(4, bytesRead);
                        list.Add(buffer);
                    }

                    Assert.Equal(3, list.Count);
                    Assert.Equal(new byte[6] { 0x42, 0x7E, 0x57, 0x43, 0, 0 }, list[0]);
                    Assert.Equal(new byte[6] { 0x53, 0x8F, 0x68, 0x54, 0, 0 }, list[1]);
                    Assert.Equal(new byte[6] { 0x64, 0x9A, 0x79, 0x65, 0, 0 }, list[2]);
                }
            }
        }

        [Fact]
        public void GetBytes_works_streaming()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Data (Value); INSERT INTO Data VALUES (x'01020304');");

                using (var reader = connection.ExecuteReader("SELECT rowid, Value FROM Data;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var buffer = new byte[2];
                    reader.GetBytes(1, 1, buffer, 0, buffer.Length);
                    Assert.Equal(new byte[] { 0x02, 0x03 }, buffer);
                }
            }
        }

        [Fact]
        public void GetBytes_NullBuffer()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT x'427E5743';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    long bytesRead = reader.GetBytes(0, 1, null, 0, 3);

                    Assert.Equal(4, bytesRead);
                }
            }
        }

        [Fact]
        public void GetBytes_works_with_overflow()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT x'427E5743';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var hugeBuffer = new byte[1024];
                    long bytesRead = reader.GetBytes(0, 1, hugeBuffer, 0, hugeBuffer.Length);
                    Assert.Equal(3, bytesRead);

                    var correctBytes = new byte[3] { 0x7E, 0x57, 0x43 };
                    for (int i = 0; i < bytesRead; i++)
                    {
                        Assert.Equal(correctBytes[i], hugeBuffer[i]);
                    }
                }
            }
        }

        [Fact]
        public void GetBytes_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetBytes(0, 0, null, 0, 0), nameof(SqliteDataReader.GetBytes));
        }

        [Fact]
        public void GetBytes_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetBytes(0, 0, null, 0, 0));

        [Fact]
        public void GetChar_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetChar(0),
                (char)1);

        [Fact]
        public void GetChar_works_with_text()
            => GetX_works(
                "SELECT 'A';",
                r => r.GetChar(0),
                'A');

        [Fact]
        public void GetChar_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetChar(0), nameof(SqliteDataReader.GetChar));
        }

        [Fact]
        public void GetChar_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetChar(0));

        [Fact]
        public void GetChars_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'têst';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var buffer = new char[2];
                    reader.GetChars(0, 1, buffer, 0, buffer.Length);
                    Assert.Equal(new char[2] { 'ê', 's' }, buffer);
                }
            }
        }

        [Fact]
        public void GetChars_works_when_buffer_null()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'têst';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    long bytesRead = reader.GetChars(0, 1, null, 0, 3);

                    Assert.Equal(4, bytesRead);
                }
            }
        }

        [Fact]
        public void GetChars_works_with_overflow()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'têst';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var hugeBuffer = new char[1024];
                    long charsRead = reader.GetChars(0, 1, hugeBuffer, 0, hugeBuffer.Length);
                    Assert.Equal(3, charsRead);

                    var correctBytes = new char[3] { 'ê', 's', 't' };
                    for (int i = 0; i < charsRead; i++)
                    {
                        Assert.Equal(correctBytes[i], hugeBuffer[i]);
                    }
                }
            }
        }

        [Fact]
        public void GetChars_throws_when_dataOffset_out_of_range()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'têst';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var buffer = new char[1];
                    var ex = Assert.Throws<ArgumentOutOfRangeException>(
                        () => reader.GetChars(0, 5, buffer, 0, buffer.Length));
                    Assert.Equal("dataOffset", ex.ParamName);
                }
            }
        }

        [Fact]
        public void GetChars_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetChars(0, 0, null!, 0, 0), nameof(SqliteDataReader.GetChars));
        }

        [Fact]
        public void GetChars_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetChars(0, 0, null!, 0, 0));

        [Fact]
        public void GetChars_works_streaming()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Data (Value); INSERT INTO Data VALUES ('têst');");

                using (var reader = connection.ExecuteReader("SELECT rowid, Value FROM Data;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var buffer = new char[2];
                    reader.GetChars(1, 1, buffer, 0, buffer.Length);
                    Assert.Equal(new[] { 'ê', 's' }, buffer);
                }
            }
        }

        [Fact]
        public void GetStream_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT x'427E5743';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var stream = reader.GetStream(0);
                    Assert.IsType<MemoryStream>(stream);
                    Assert.Equal(0x42, stream.ReadByte());
                    var stream2 = reader.GetStream(0);
                    Assert.Equal(0x42, stream2.ReadByte());
                    Assert.Equal(0x7E, stream.ReadByte());
                }
            }
        }

        [Fact]
        public void GetStream_works_with_text()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'abcdefghi';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var stream = reader.GetStream(0);
                    Assert.Equal((byte)'a', stream.ReadByte());
                    var stream2 = reader.GetStream(0);
                    Assert.Equal((byte)'a', stream2.ReadByte());
                    Assert.Equal((byte)'b', stream.ReadByte());
                }
            }
        }

        [Fact]
        public void GetStream_works_with_int()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 12;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var stream = reader.GetStream(0);
                    Assert.Equal((byte)'1', stream.ReadByte());
                    var stream2 = reader.GetStream(0);
                    Assert.Equal((byte)'1', stream2.ReadByte());
                    Assert.Equal((byte)'2', stream.ReadByte());
                }
            }
        }

        [Fact]
        public void GetStream_works_with_float()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1.2;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var stream = reader.GetStream(0);
                    Assert.Equal((byte)'1', stream.ReadByte());
                    var stream2 = reader.GetStream(0);
                    Assert.Equal((byte)'1', stream2.ReadByte());
                    Assert.Equal((byte)'.', stream.ReadByte());
                    Assert.Equal((byte)'2', stream.ReadByte());
                }
            }
        }

        [Theory]
        [InlineData("CREATE TABLE DataTable (Id INTEGER, Data BLOB);", "SELECT rowid, Data FROM DataTable WHERE Id = 5")]
        [InlineData("CREATE TABLE DataTable (Id INTEGER PRIMARY KEY, Data BLOB);", "SELECT rowid, Data FROM DataTable WHERE Id = 5")]
        [InlineData("CREATE TABLE DataTable (Id INTEGER PRIMARY KEY, Data BLOB);", "SELECT Id, Data FROM DataTable WHERE Id = 5")]
        public void GetStream_Blob_works(string createTableCmd, string selectCmd)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery(
                    createTableCmd + "INSERT INTO DataTable VALUES (5, X'01020304');");

                var selectCommand = connection.CreateCommand();
                selectCommand.CommandText = selectCmd;
                using (var reader = selectCommand.ExecuteReader())
                {
                    Assert.True(reader.Read());
                    using (var sourceStream = reader.GetStream(1))
                    {
                        Assert.IsType<SqliteBlob>(sourceStream);
                        var buffer = new byte[4];
                        var bytesRead = sourceStream.Read(buffer, 0, 4);
                        Assert.Equal(4, bytesRead);
                        Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, buffer);
                    }
                }
            }
        }

        [Fact]
        public void GetStream_works_when_composite_pk()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery(
                    @"CREATE TABLE DataTable (Id1 INTEGER, Id2 INTEGER, Data BLOB, PRIMARY KEY (Id1, Id2));
                    INSERT INTO DataTable VALUES (5, 6, X'01020304');");

                var selectCommand = connection.CreateCommand();
                selectCommand.CommandText = "SELECT Id1, Id2, Data FROM DataTable WHERE Id1 = 5 AND Id2 = 6";
                using (var reader = selectCommand.ExecuteReader())
                {
                    Assert.True(reader.Read());
                    using (var sourceStream = reader.GetStream(2))
                    {
                        Assert.IsType<MemoryStream>(sourceStream);
                        var buffer = new byte[4];
                        var bytesRead = sourceStream.Read(buffer, 0, 4);
                        Assert.Equal(4, bytesRead);
                        Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, buffer);
                    }
                }
            }
        }

        [Fact]
        public void GetStream_works_when_composite_pk_and_rowid()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery(
                    @"CREATE TABLE DataTable (Id1 INTEGER, Id2 INTEGER, Data BLOB, PRIMARY KEY (Id1, Id2));
                    INSERT INTO DataTable VALUES (5, 6, X'01020304');");

                var selectCommand = connection.CreateCommand();
                selectCommand.CommandText = "SELECT Id1, Id2, rowid, Data FROM DataTable WHERE Id1 = 5 AND Id2 = 6";
                using (var reader = selectCommand.ExecuteReader())
                {
                    Assert.True(reader.Read());
                    using (var sourceStream = reader.GetStream(3))
                    {
                        Assert.IsType<SqliteBlob>(sourceStream);
                        var buffer = new byte[4];
                        var bytesRead = sourceStream.Read(buffer, 0, 4);
                        Assert.Equal(4, bytesRead);
                        Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, buffer);
                    }
                }
            }
        }

        [Fact]
        public void GetStream_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetStream(0), nameof(SqliteDataReader.GetStream));
        }

        [Fact]
        public void GetStream_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetStream(0));

        [Fact]
        public void GetTextReader_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'test';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    using (var textReader = reader.GetTextReader(0))
                    {
                        Assert.IsType<MemoryStream>(Assert.IsType<StreamReader>(textReader).BaseStream);
                        Assert.Equal("test", textReader.ReadToEnd());
                    }
                }
            }
        }

        [Fact]
        public void GetTextReader_works_when_null()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT NULL;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    using (var textReader = reader.GetTextReader(0))
                    {
                        Assert.IsType<StringReader>(textReader);
                        Assert.Empty(textReader.ReadToEnd());
                    }
                }
            }
        }

        [Fact]
        public void GetTextReader_works_streaming()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Data (Value); INSERT INTO Data VALUES ('test');");

                using (var reader = connection.ExecuteReader("SELECT rowid, Value FROM Data;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    using (var textReader = reader.GetTextReader(1))
                    {
                        Assert.IsType<SqliteBlob>(Assert.IsType<StreamReader>(textReader).BaseStream);
                        Assert.Equal("test", textReader.ReadToEnd());
                    }
                }
            }
        }

        [Fact]
        public void GetDateTime_works_with_text()
            => GetX_works(
                "SELECT '2014-04-15 10:47:16';",
                r => r.GetDateTime(0),
                new DateTime(2014, 4, 15, 10, 47, 16));

        [Fact]
        public void GetDateTime_works_with_real()
            => GetX_works(
                "SELECT julianday('2013-10-07 08:23:19.120');",
                r => r.GetDateTime(0),
                new DateTime(2013, 10, 7, 8, 23, 19, 120));

        [Fact]
        public void GetDateTime_works_with_integer()
            => GetX_works(
                "SELECT CAST(julianday('2013-10-07 12:00') AS INTEGER);",
                r => r.GetDateTime(0),
                new DateTime(2013, 10, 7, 12, 0, 0));

        [Fact]
        public void GetDateTime_throws_when_null()
            => GetX_throws_when_null(r => r.GetDateTime(0));

        [Fact]
        public void GetDateTime_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetDateTime(0), nameof(SqliteDataReader.GetDateTime));
        }

        [Fact]
        public void GetDateTime_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetDateTime(0));

        [Fact]
        public void GetDateTimeOffset_works_with_text()
            => GetX_works(
                "SELECT '2014-04-15 10:47:16';",
                r => ((SqliteDataReader)r).GetDateTimeOffset(0),
                new DateTimeOffset(new DateTime(2014, 4, 15, 10, 47, 16)));

        [Fact]
        public void GetDateTimeOffset_works_with_real()
            => GetX_works(
                "SELECT julianday('2013-10-07 08:23:19.120');",
                r => ((SqliteDataReader)r).GetDateTimeOffset(0),
                new DateTimeOffset(new DateTime(2013, 10, 7, 8, 23, 19, 120)));

        [Fact]
        public void GetDateTimeOffset_works_with_integer()
            => GetX_works(
                "SELECT CAST(julianday('2013-10-07 12:00') AS INTEGER);",
                r => ((SqliteDataReader)r).GetDateTimeOffset(0),
                new DateTimeOffset(new DateTime(2013, 10, 7, 12, 0, 0)));

        [Fact]
        public void GetDateTimeOffset_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetDateTimeOffset(0), nameof(SqliteDataReader.GetDateTimeOffset));
        }

        [Fact]
        public void GetDateTimeOffset_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetDateTimeOffset(0));

        [Fact]
        public void GetTimeSpan_works_with_text()
            => GetX_works(
                "SELECT '12:06:29';",
                r => ((SqliteDataReader)r).GetTimeSpan(0),
                new TimeSpan(12, 06, 29));

        [Fact]
        public void GetTimeSpan_works_with_real()
            => GetX_works(
                "SELECT julianday('2013-10-12 09:25:22.120') - julianday('2013-10-07 08:23:19');",
                r => ((SqliteDataReader)r).GetTimeSpan(0),
                TimeSpan.FromDays(5.04309166688472));

        [Fact]
        public void GetTimeSpan_works_with_integer()
            => GetX_works(
                "SELECT CAST(julianday('2017-08-31') - julianday('1776-07-04') AS INTEGER);",
                r => ((SqliteDataReader)r).GetTimeSpan(0),
                new TimeSpan(88081, 0, 0, 0));

        [Fact]
        public void GetTimeSpan_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetTimeSpan(0), nameof(SqliteDataReader.GetTimeSpan));
        }

        [Fact]
        public void GetTimeSpan_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetTimeSpan(0));

        [Fact]
        public void GetDateTimeOffset_throws_when_null()
            => GetX_throws_when_null(r => ((SqliteDataReader)r).GetDateTimeOffset(0));

        [Theory]
        [InlineData("SELECT 1;", "INTEGER")]
        [InlineData("SELECT 3.14;", "REAL")]
        [InlineData("SELECT 'test';", "TEXT")]
        [InlineData("SELECT X'7E57';", "BLOB")]
        [InlineData("SELECT NULL;", "BLOB")]
        public void GetDataTypeName_works(string sql, string expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(sql))
                {
                    Assert.Equal(expected, reader.GetDataTypeName(0));
                }
            }
        }

        [Fact]
        public void GetDataTypeName_works_when_column()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Person ( Name nvarchar(4000) );");

                using (var reader = connection.ExecuteReader("SELECT Name FROM Person;"))
                {
                    Assert.Equal("nvarchar", reader.GetDataTypeName(0));
                }
            }
        }

        [Fact]
        public void GetDataTypeName_throws_when_ordinal_out_of_range()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var ex = Assert.Throws<ArgumentOutOfRangeException>(() => reader.GetDataTypeName(1));

                    Assert.Equal("ordinal", ex.ParamName);
                    Assert.Equal(1, ex.ActualValue);
                }
            }
        }

        [Fact]
        public void GetDataTypeName_throws_when_closed()
            => X_throws_when_closed(r => r.GetDataTypeName(0), "GetDataTypeName");

        [Fact]
        public void GetDataTypeName_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetDataTypeName(0));

        [Theory]
        [InlineData("3.14", 3.14)]
        [InlineData("1.0e-2", 0.01)]
        public void GetDecimal_works(string input, decimal expected)
            => GetX_works(
                "SELECT '" + input + "';",
                r => r.GetDecimal(0),
                expected);

        [Fact]
        public void GetDecimal_throws_when_null()
            => GetX_throws_when_null(r => r.GetDecimal(0));

        [Fact]
        public void GetDecimal_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetDecimal(0), nameof(SqliteDataReader.GetDecimal));
        }

        [Fact]
        public void GetDecimal_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetDecimal(0));

        [Fact]
        public void GetDouble_throws_when_null()
            => GetX_throws_when_null(
                r => r.GetDouble(0));

        [Fact]
        public void GetDouble_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetDouble(0), nameof(SqliteDataReader.GetDouble));
        }

        [Fact]
        public void GetDouble_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetDouble(0));

        [Fact]
        public void GetEnumerator_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    Assert.NotNull(reader.GetEnumerator());
                }
            }
        }

        [Theory]
        [InlineData("SELECT 1;", true)]
        [InlineData("SELECT 1;", (byte)1)]
        [InlineData("SELECT 1;", (char)1)]
        [InlineData("SELECT 3.14;", 3.14)]
        [InlineData("SELECT 3;", 3f)]
        [InlineData("SELECT 1;", 1)]
        [InlineData("SELECT 1;", 1L)]
        [InlineData("SELECT 1;", (sbyte)1)]
        [InlineData("SELECT 1;", (short)1)]
        [InlineData("SELECT 'test';", "test")]
        [InlineData("SELECT 1;", 1u)]
        [InlineData("SELECT 1;", 1ul)]
        [InlineData("SELECT 1;", (ushort)1)]
        public void GetFieldValue_works<T>(string sql, T expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(sql))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    Assert.Equal(expected, reader.GetFieldValue<T>(0));
                }
            }
        }

        [Fact]
        public void GetFieldValue_of_byteArray_works()
            => GetFieldValue_works(
                "SELECT X'7E57';",
                new byte[] { 0x7e, 0x57 });

        [Fact]
        public void GetFieldValue_of_byteArray_empty()
            => GetFieldValue_works(
                "SELECT X'';",
                new byte[0]);

        [Fact]
        public void GetFieldValue_of_byteArray_throws_when_null()
            => GetX_throws_when_null(
                r => r.GetFieldValue<byte[]>(0));

        [Fact]
        public void GetFieldValue_of_DateTime_works()
            => GetFieldValue_works(
                "SELECT '2014-04-15 11:58:13';",
                new DateTime(2014, 4, 15, 11, 58, 13));

        [Fact]
        public void GetFieldValue_of_DateTimeOffset_works()
            => GetFieldValue_works(
                "SELECT '2014-04-15 11:58:13-08:00';",
                new DateTimeOffset(2014, 4, 15, 11, 58, 13, new TimeSpan(-8, 0, 0)));

        [Fact]
        public void GetFieldValue_of_DBNull_works()
            => GetFieldValue_works(
                "SELECT NULL;",
                DBNull.Value);

        [Fact]
        public void GetFieldValue_of_DBNull_throws_when_not_null()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    Assert.Throws<InvalidCastException>(() => reader.GetFieldValue<DBNull>(0));
                }
            }
        }

        [Fact]
        public void GetFieldValue_of_decimal_works()
            => GetFieldValue_works(
                "SELECT '3.14';",
                3.14m);

        [Fact]
        public void GetFieldValue_of_Enum_works()
            => GetFieldValue_works(
                "SELECT 1;",
                MyEnum.One);

        [Fact]
        public void GetFieldValue_of_Guid_works()
            => GetFieldValue_works(
                "SELECT X'0E7E0DDC5D364849AB9B8CA8056BF93A';",
                new Guid("dc0d7e0e-365d-4948-ab9b-8ca8056bf93a"));

        [Fact]
        public void GetFieldValue_of_Nullable_works()
            => GetFieldValue_works(
                "SELECT 1;",
                (int?)1);

        [Fact]
        public void GetFieldValue_of_Stream_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT x'7E57';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var stream = reader.GetFieldValue<Stream>(0);
                    Assert.Equal(0x7E, stream.ReadByte());
                    Assert.Equal(0x57, stream.ReadByte());
                }
            }
        }

        [Fact]
        public void GetFieldValue_of_TextReader_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 'test';"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    using (var textReader = reader.GetFieldValue<TextReader>(0))
                    {
                        Assert.Equal("test", textReader.ReadToEnd());
                    }
                }
            }
        }

        [Fact]
        public void GetFieldValue_of_TimeSpan_works()
            => GetFieldValue_works(
                "SELECT '12:06:29';",
                new TimeSpan(12, 6, 29));

        [Fact]
        public void GetFieldValue_of_TimeSpan_throws_when_null()
            => GetX_throws_when_null(r => r.GetFieldValue<TimeSpan>(0));

        [Fact]
        public void GetFieldValue_throws_before_read()
            => X_throws_before_read(r => r.GetFieldValue<DBNull>(0));

        [Fact]
        public void GetFieldValue_throws_when_done()
            => X_throws_when_done(r => r.GetFieldValue<DBNull>(0));

        [Fact]
        public void GetFieldValue_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetFieldValue<long>(0), nameof(SqliteDataReader.GetFieldValue));
        }

        [Fact]
        public void GetFieldValue_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetFieldValue<long>(0));

        [Theory]
        [InlineData(byte.MinValue)]
        [InlineData(char.MinValue)]
        [InlineData(int.MinValue)]
        [InlineData(sbyte.MinValue)]
        [InlineData(short.MinValue)]
        [InlineData(uint.MinValue)]
        [InlineData(ushort.MinValue)]
        public void GetFieldValue_throws_on_overflow<T>(T minValue)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(
                    "SELECT $minValue - 1;",
                    new SqliteParameter("$minValue", minValue)))
                {
                    reader.Read();

                    Assert.Throws<OverflowException>(() => reader.GetFieldValue<T>(0));
                }
            }
        }

        [Theory]
        [InlineData("SELECT 1;", typeof(long))]
        [InlineData("SELECT 3.14;", typeof(double))]
        [InlineData("SELECT 'test';", typeof(string))]
        [InlineData("SELECT X'7E57';", typeof(byte[]))]
        [InlineData("SELECT NULL;", typeof(byte[]))]
        public void GetFieldType_works(string sql, Type expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(sql))
                {
                    Assert.Equal(expected, reader.GetFieldType(0));
                }
            }
        }

        [Theory]
        [InlineData("TEXT", typeof(string))]
        [InlineData("CHARACTER(20)", typeof(string))]
        [InlineData("NVARCHAR(100)", typeof(string))]
        [InlineData("CLOB", typeof(string))]
        [InlineData("INTEGER", typeof(long))]
        [InlineData("BIGINT", typeof(long))]
        [InlineData("UNSIGNED BIG INT", typeof(long))]
        [InlineData("REAL", typeof(double))]
        [InlineData("DOUBLE", typeof(double))]
        [InlineData("FLOAT", typeof(double))]
        [InlineData("BLOB", typeof(byte[]))]
        [InlineData("", typeof(byte[]))]
        [InlineData("NUMERIC", typeof(string))]
        [InlineData("DATETIME", typeof(string))]
        public void GetFieldType_works_on_NULL(string type, Type expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery($"CREATE TABLE Test(Value {type});");

                using (var reader = connection.ExecuteReader("SELECT Value FROM Test;"))
                {
                    Assert.Equal(expected, reader.GetFieldType(0));
                }
            }
        }

        [Fact]
        public void GetFieldType_works_on_NULL_cached()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Test(Value FOOBAR);");
                connection.ExecuteNonQuery("INSERT INTO Test (Value) VALUES ('test'), (NULL);");

                using (var reader = connection.ExecuteReader("SELECT Value FROM Test;"))
                {
                    Assert.True(reader.Read());
                    Assert.Equal(typeof(string), reader.GetFieldType(0));
                    Assert.Equal("test", reader.GetValue(0));
                    Assert.True(reader.Read());
                    Assert.Equal(typeof(string), reader.GetFieldType(0));
                    Assert.Equal(DBNull.Value, reader.GetValue(0));
                }
            }
        }

        [Fact]
        public void GetFieldType_throws_when_ordinal_out_of_range()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var ex = Assert.Throws<ArgumentOutOfRangeException>(() => reader.GetFieldType(1));

                    Assert.Equal("ordinal", ex.ParamName);
                    Assert.Equal(1, ex.ActualValue);
                }
            }
        }

        [Fact]
        public void GetFieldType_throws_when_closed()
            => X_throws_when_closed(r => r.GetFieldType(0), "GetFieldType");

        [Fact]
        public void GetFieldType_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetFieldType(0));

        [Theory]
        [InlineData("3", 3f)]
        [InlineData("9e999", float.PositiveInfinity)]
        [InlineData("-9e999", float.NegativeInfinity)]
        public void GetFloat_works(string val, float result)
            => GetX_works(
                "SELECT " + val,
                r => r.GetFloat(0),
                result);

        [Fact]
        public void GetFloat_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetFloat(0), nameof(SqliteDataReader.GetFloat));
        }

        [Fact]
        public void GetFloat_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetFloat(0));

        [Theory]
        [InlineData("2.0", 2.0)]
        [InlineData("9e999", double.PositiveInfinity)]
        [InlineData("-9e999", double.NegativeInfinity)]
        [InlineData("'3.14'", 3.14)]
        [InlineData("'1.2e-03'", 0.0012)]
        public void GetDouble_works(string val, double result)
            => GetX_works(
                "SELECT " + val,
                r => r.GetDouble(0),
                result);

        [Fact]
        public void GetGuid_works_when_blob()
            => GetX_works(
                "SELECT X'0E7E0DDC5D364849AB9B8CA8056BF93A';",
                r => r.GetGuid(0),
                new Guid("dc0d7e0e-365d-4948-ab9b-8ca8056bf93a"));

        [Fact]
        public void GetGuid_works_when_text_blob()
            => GetX_works(
                "SELECT CAST('dc0d7e0e-365d-4948-ab9b-8ca8056bf93a' AS BLOB);",
                r => r.GetGuid(0),
                new Guid("dc0d7e0e-365d-4948-ab9b-8ca8056bf93a"));

        [Fact]
        public void GetGuid_works_when_text()
            => GetX_works(
                "SELECT 'dc0d7e0e-365d-4948-ab9b-8ca8056bf93a';",
                r => r.GetGuid(0),
                new Guid("dc0d7e0e-365d-4948-ab9b-8ca8056bf93a"));

        [Fact]
        public void GetGuid_throws_when_null()
            => GetX_throws_when_null(r => r.GetGuid(0));

        [Fact]
        public void GetGuid_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetGuid(0), nameof(SqliteDataReader.GetGuid));
        }

        [Fact]
        public void GetGuid_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetGuid(0));

        [Fact]
        public void GetInt16_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetInt16(0),
                (short)1);

        [Fact]
        public void GetInt16_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetInt16(0), nameof(SqliteDataReader.GetInt16));
        }

        [Fact]
        public void GetInt16_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetInt16(0));

        [Fact]
        public void GetInt32_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetInt32(0),
                1);

        [Fact]
        public void GetInt32_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetInt32(0), nameof(SqliteDataReader.GetInt32));
        }

        [Fact]
        public void GetInt32_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetInt32(0));

        [Fact]
        public void GetInt64_works()
            => GetX_works(
                "SELECT 1;",
                r => r.GetInt64(0),
                1L);

        [Fact]
        public void GetInt64_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetInt64(0), nameof(SqliteDataReader.GetInt64));
        }

        [Fact]
        public void GetInt64_throws_when_null()
            => GetX_throws_when_null(
                r => r.GetInt64(0));

        [Fact]
        public void GetInt64_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetInt64(0));

        [Fact]
        public void GetName_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 AS Id;"))
                {
                    Assert.Equal("Id", reader.GetName(0));
                }
            }
        }

        [Fact]
        public void GetName_throws_when_ordinal_out_of_range()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var ex = Assert.Throws<ArgumentOutOfRangeException>(() => reader.GetName(1));

                    Assert.Equal("ordinal", ex.ParamName);
                    Assert.Equal(1, ex.ActualValue);
                }
            }
        }

        [Fact]
        public void GetName_throws_when_closed()
            => X_throws_when_closed(r => r.GetName(0), "GetName");

        [Fact]
        public void GetName_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetName(0));

        [Fact]
        public void GetOrdinal_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 AS Id;"))
                {
                    Assert.Equal(0, reader.GetOrdinal("Id"));
                }
            }
        }

        [Fact]
        public void GetOrdinal_throws_when_out_of_range()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var ex = Assert.Throws<ArgumentOutOfRangeException>(() => reader.GetOrdinal("Name"));
                    Assert.NotNull(ex.Message);
                    Assert.Equal("name", ex.ParamName);
                    Assert.Equal("Name", ex.ActualValue);
                }
            }
        }

        [Fact]
        public void GetOrdinal_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetOrdinal(null!), nameof(SqliteDataReader.GetOrdinal));
        }

        [Fact]
        public void GetOrdinal_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetOrdinal("dummy"));

        [Fact]
        public void GetString_works_utf8()
            => GetX_works(
                "SELECT '测试测试测试';",
                r => r.GetString(0),
                "测试测试测试");

        [Fact]
        public void GetFieldValue_works_utf8()
            => GetX_works(
                "SELECT '测试测试测试';",
                r => r.GetFieldValue<string>(0),
                "测试测试测试");

        [Fact]
        public void GetValue_to_string_works_utf8()
            => GetX_works(
                "SELECT '测试测试测试';",
                r => r.GetValue(0) as string,
                "测试测试测试");

        [Fact]
        public void GetString_works()
            => GetX_works(
                "SELECT 'test';",
                r => r.GetString(0),
                "test");

        [Fact]
        public void GetString_throws_when_null()
            => GetX_throws_when_null(
                r => r.GetString(0));

        [Fact]
        public void GetString_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetString(0), nameof(SqliteDataReader.GetString));
        }

        [Fact]
        public void GetString_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetString(0));

        [Theory]
        [InlineData("SELECT 1;", 1L)]
        [InlineData("SELECT 3.14;", 3.14)]
        [InlineData("SELECT 'test';", "test")]
        public void GetValue_works(string sql, object expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(sql))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    Assert.Equal(expected, reader.GetValue(0));
                }
            }
        }

        [Fact]
        public void GetValue_works_when_blob()
            => GetValue_works(
                "SELECT X'7E57';",
                new byte[] { 0x7e, 0x57 });

        [Fact]
        public void GetValue_works_when_null()
            => GetValue_works(
                "SELECT NULL;",
                DBNull.Value);

        [Fact]
        public void GetValue_throws_before_read()
            => X_throws_before_read(r => r.GetValue(0));

        [Fact]
        public void GetValue_throws_when_done()
            => X_throws_when_done(r => r.GetValue(0));

        [Fact]
        public void GetValue_throws_when_closed()
            => X_throws_when_closed(r => r.GetValue(0), "GetValue");

        [Fact]
        public void GetValue_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetValue(0));

        [Fact]
        public void GetValues_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    // Array may be wider than row
                    var values = new object[2];
                    var result = reader.GetValues(values);

                    Assert.Equal(1, result);
                    Assert.Equal(1L, values[0]);
                }
            }
        }

        [Fact]
        public void GetValues_throws_when_too_narrow()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    var values = new object[0];
                    Assert.Throws<IndexOutOfRangeException>(() => reader.GetValues(values));
                }
            }
        }

        [Fact]
        public void GetValues_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetValues(null!), nameof(SqliteDataReader.GetValues));
        }

        [Fact]
        public void GetValues_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetValues(null!));

        [Fact]
        public void HasRows_returns_true_when_rows()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    Assert.True(reader.HasRows);
                }
            }
        }

        [Fact]
        public void HasRows_returns_false_when_no_rows()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 WHERE 0 = 1;"))
                {
                    Assert.False(reader.HasRows);
                }
            }
        }

        [Fact]
        public void HasRows_works_when_batching()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 WHERE 0 = 1; SELECT 1;"))
                {
                    Assert.False(reader.HasRows);

                    reader.NextResult();

                    Assert.True(reader.HasRows);
                }
            }
        }

        [Fact]
        public void IsClosed_returns_false_when_active()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    Assert.False(reader.IsClosed);
                }
            }
        }

        [Fact]
        public void IsClosed_returns_true_when_closed()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                var reader = connection.ExecuteReader("SELECT 1;");
                reader.Close();

                Assert.True(reader.IsClosed);
            }
        }

        [Fact]
        public void IsDBNull_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT NULL;"))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    Assert.True(reader.IsDBNull(0));
                }
            }
        }

        [Fact]
        public void IsDBNull_throws_before_read()
            => X_throws_before_read(r => r.IsDBNull(0));

        [Fact]
        public void IsDBNull_throws_when_done()
            => X_throws_when_done(r => r.IsDBNull(0));

        [Fact]
        public void IsDBNull_throws_when_closed()
            => X_throws_when_closed(r => r.IsDBNull(0), "IsDBNull");

        [Fact]
        public void IsDBNull_throws_when_non_query()
            => X_throws_when_non_query(r => r.IsDBNull(0));

        [Fact]
        public void Item_by_ordinal_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    Assert.Equal(1L, reader[0]);
                }
            }
        }

        [Fact]
        public void Item_by_ordinal_throws_when_non_query()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("CREATE TABLE dual(dummy);"))
                {
                    var ex = Assert.Throws<InvalidOperationException>(() => reader[0]);
                    Assert.Equal(Resources.NoData, ex.Message);
                }
            }
        }

        [Fact]
        public void Item_by_name_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 AS Id;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    Assert.Equal(1L, reader["Id"]);
                }
            }
        }

        [Fact]
        public void Item_by_name_throws_when_non_query()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("CREATE TABLE dual(dummy);"))
                {
                    var ex = Assert.Throws<InvalidOperationException>(() => reader["dummy"]);
                    Assert.Equal(Resources.NoData, ex.Message);
                }
            }
        }

        [Fact]
        public void NextResult_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1; SELECT 2;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);
                    Assert.Equal(1L, reader.GetInt64(0));

                    var hasResults = reader.NextResult();
                    Assert.True(hasResults);

                    hasData = reader.Read();
                    Assert.True(hasData);
                    Assert.Equal(2L, reader.GetInt64(0));

                    hasResults = reader.NextResult();
                    Assert.False(hasResults);
                }
            }
        }

        [Fact]
        public void NextResult_can_be_called_more_than_once()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1;"))
                {
                    var hasResults = reader.NextResult();
                    Assert.False(hasResults);

                    hasResults = reader.NextResult();
                    Assert.False(hasResults);
                }
            }
        }

        [Fact]
        public void NextResult_skips_DML_statements()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");

                var sql = @"
                    SELECT 1;
                    INSERT INTO Test VALUES(1);
                    SELECT 2;";
                using (var reader = connection.ExecuteReader(sql))
                {
                    var hasResults = reader.NextResult();
                    Assert.True(hasResults);

                    var hasData = reader.Read();
                    Assert.True(hasData);

                    Assert.Equal(2L, reader.GetInt64(0));
                }
            }
        }

        [Fact]
        public void NextResult_throws_on_error()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");
                connection.CreateFunction<string, long>("throw", message => throw new Exception(message));

                var sql = @"
                    SELECT 1;
                    SELECT throw('An error');
                    INSERT INTO Test VALUES (1);";
                using (var reader = connection.ExecuteReader(sql))
                {
                    var ex = Assert.Throws<SqliteException>(() => reader.NextResult());
                    Assert.Contains("An error", ex.Message);
                }

                Assert.Equal(0L, connection.ExecuteScalar<long>("SELECT count() FROM Test;"));
            }
        }

        [Fact]
        public void NextResult_throws_when_closed()
        {
            X_throws_when_closed(r => r.NextResult(), nameof(SqliteDataReader.NextResult));
        }

        [Fact]
        public void Read_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT 1 UNION SELECT 2;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);
                    Assert.Equal(1L, reader.GetInt64(0));

                    hasData = reader.Read();
                    Assert.True(hasData);
                    Assert.Equal(2L, reader.GetInt64(0));

                    hasData = reader.Read();
                    Assert.False(hasData);

                    hasData = reader.Read();
                    Assert.False(hasData);
                }
            }
        }

        [Fact]
        public void Read_throws_when_closed()
            => X_throws_when_closed(r => r.Read(), "Read");

        [Fact]
        public void Read_returns_false_when_non_query()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("CREATE TABLE dual(dummy);"))
                {
                    Assert.False(reader.Read());
                }
            }
        }

        [Fact]
        public void RecordsAffected_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");

                var reader = connection.ExecuteReader("INSERT INTO Test VALUES(1);");
                ((IDisposable)reader).Dispose();

                Assert.Equal(1, reader.RecordsAffected);
            }
        }

        [Fact]
        public void RecordsAffected_works_when_no_DDL()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                var reader = connection.ExecuteReader("SELECT 1;");
                ((IDisposable)reader).Dispose();

                Assert.Equal(-1, reader.RecordsAffected);
            }
        }

        [Fact]
        public void RecordsAffected_works_during_enumeration()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");

                var reader = connection.ExecuteReader(
                    @"
                    SELECT 1;
                    INSERT INTO Test VALUES(1);
                    SELECT 1;
                    INSERT INTO Test VALUES(2);");
                using (reader)
                {
                    Assert.Equal(-1, reader.RecordsAffected);
                    reader.NextResult();
                    Assert.Equal(1, reader.RecordsAffected);
                }

                Assert.Equal(2, reader.RecordsAffected);
            }
        }

        [Fact]
        public void GetSchemaTable_works()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery(
                    "CREATE TABLE Person (ID INTEGER PRIMARY KEY, FirstName TEXT, LastName TEXT NOT NULL, Code INT UNIQUE);");
                connection.ExecuteNonQuery("INSERT INTO Person VALUES(101, 'John', 'Dee', 123);");
                connection.ExecuteNonQuery("INSERT INTO Person VALUES(105, 'Jane', 'Doe', 456);");

                using (var reader = connection.ExecuteReader("SELECT LastName, ID, Code, ID+1 AS IncID FROM Person;"))
                {
                    var schema = reader.GetSchemaTable();
                    Assert.True(schema.Columns.Contains("ColumnName"));
                    Assert.True(schema.Columns.Contains("ColumnOrdinal"));
                    Assert.True(schema.Columns.Contains("ColumnSize"));
                    Assert.True(schema.Columns.Contains("NumericPrecision"));
                    Assert.True(schema.Columns.Contains("NumericScale"));
                    Assert.True(schema.Columns.Contains("IsUnique"));
                    Assert.True(schema.Columns.Contains("IsKey"));
                    Assert.True(schema.Columns.Contains("BaseServerName"));
                    Assert.True(schema.Columns.Contains("BaseCatalogName"));
                    Assert.True(schema.Columns.Contains("BaseColumnName"));
                    Assert.True(schema.Columns.Contains("BaseSchemaName"));
                    Assert.True(schema.Columns.Contains("BaseTableName"));
                    Assert.True(schema.Columns.Contains("DataType"));
                    Assert.True(schema.Columns.Contains("DataTypeName"));
                    Assert.True(schema.Columns.Contains("AllowDBNull"));
                    Assert.True(schema.Columns.Contains("IsAliased"));
                    Assert.True(schema.Columns.Contains("IsExpression"));
                    Assert.True(schema.Columns.Contains("IsAutoIncrement"));
                    Assert.True(schema.Columns.Contains("IsLong"));

                    Assert.Equal(4, schema.Rows.Count);

                    Assert.Equal("LastName", schema.Rows[0]["ColumnName"]);
                    Assert.Equal(0, schema.Rows[0]["ColumnOrdinal"]);
                    Assert.Equal(-1, schema.Rows[0]["ColumnSize"]);
                    Assert.Equal(DBNull.Value, schema.Rows[0]["NumericPrecision"]);
                    Assert.Equal(DBNull.Value, schema.Rows[0]["NumericScale"]);
                    Assert.False((bool)schema.Rows[0]["IsUnique"]);
                    Assert.False((bool)schema.Rows[0]["IsKey"]);
                    Assert.Equal("", schema.Rows[0]["BaseServerName"]);
                    Assert.Equal("main", schema.Rows[0]["BaseCatalogName"]);
                    Assert.Equal("LastName", schema.Rows[0]["BaseColumnName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[0]["BaseSchemaName"]);
                    Assert.Equal("Person", schema.Rows[0]["BaseTableName"]);
                    Assert.Equal(typeof(string), schema.Rows[0]["DataType"]);
                    Assert.Equal("TEXT", schema.Rows[0]["DataTypeName"]);
                    Assert.False((bool)schema.Rows[0]["AllowDBNull"]);
                    Assert.False((bool)schema.Rows[0]["IsAliased"]);
                    Assert.False((bool)schema.Rows[0]["IsExpression"]);
                    Assert.False((bool)schema.Rows[0]["IsAutoIncrement"]);
                    Assert.Equal(DBNull.Value, schema.Rows[0]["IsLong"]);

                    Assert.Equal("ID", schema.Rows[1]["ColumnName"]);
                    Assert.Equal(1, schema.Rows[1]["ColumnOrdinal"]);
                    Assert.Equal(-1, schema.Rows[1]["ColumnSize"]);
                    Assert.Equal(DBNull.Value, schema.Rows[1]["NumericPrecision"]);
                    Assert.Equal(DBNull.Value, schema.Rows[1]["NumericScale"]);
                    Assert.False((bool)schema.Rows[1]["IsUnique"]);
                    Assert.True((bool)schema.Rows[1]["IsKey"]);
                    Assert.Equal("", schema.Rows[1]["BaseServerName"]);
                    Assert.Equal("main", schema.Rows[1]["BaseCatalogName"]);
                    Assert.Equal("ID", schema.Rows[1]["BaseColumnName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[1]["BaseSchemaName"]);
                    Assert.Equal("Person", schema.Rows[1]["BaseTableName"]);
                    Assert.Equal(typeof(long), schema.Rows[1]["DataType"]);
                    Assert.Equal("INTEGER", schema.Rows[1]["DataTypeName"]);
                    Assert.True((bool)schema.Rows[1]["AllowDBNull"]);
                    Assert.False((bool)schema.Rows[1]["IsAliased"]);
                    Assert.False((bool)schema.Rows[1]["IsExpression"]);
                    Assert.False((bool)schema.Rows[1]["IsAutoIncrement"]);
                    Assert.Equal(DBNull.Value, schema.Rows[1]["IsLong"]);

                    Assert.Equal("Code", schema.Rows[2]["ColumnName"]);
                    Assert.Equal(2, schema.Rows[2]["ColumnOrdinal"]);
                    Assert.Equal(-1, schema.Rows[2]["ColumnSize"]);
                    Assert.Equal(DBNull.Value, schema.Rows[2]["NumericPrecision"]);
                    Assert.Equal(DBNull.Value, schema.Rows[2]["NumericScale"]);
                    Assert.True((bool)schema.Rows[2]["IsUnique"]);
                    Assert.False((bool)schema.Rows[2]["IsKey"]);
                    Assert.Equal("", schema.Rows[2]["BaseServerName"]);
                    Assert.Equal("main", schema.Rows[2]["BaseCatalogName"]);
                    Assert.Equal("Code", schema.Rows[2]["BaseColumnName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[2]["BaseSchemaName"]);
                    Assert.Equal("Person", schema.Rows[2]["BaseTableName"]);
                    Assert.Equal(typeof(long), schema.Rows[2]["DataType"]);
                    Assert.Equal("INT", schema.Rows[2]["DataTypeName"]);
                    Assert.True((bool)schema.Rows[2]["AllowDBNull"]);
                    Assert.False((bool)schema.Rows[2]["IsAliased"]);
                    Assert.False((bool)schema.Rows[2]["IsExpression"]);
                    Assert.False((bool)schema.Rows[2]["IsAutoIncrement"]);
                    Assert.Equal(DBNull.Value, schema.Rows[2]["IsLong"]);

                    Assert.Equal("IncID", schema.Rows[3]["ColumnName"]);
                    Assert.Equal(3, schema.Rows[3]["ColumnOrdinal"]);
                    Assert.Equal(-1, schema.Rows[3]["ColumnSize"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["NumericPrecision"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["NumericScale"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["IsUnique"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["IsKey"]);
                    Assert.Equal("", schema.Rows[3]["BaseServerName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["BaseCatalogName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["BaseColumnName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["BaseSchemaName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["BaseTableName"]);
                    Assert.Equal(typeof(long), schema.Rows[3]["DataType"]);
                    Assert.Equal("INTEGER", schema.Rows[3]["DataTypeName"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["AllowDBNull"]);
                    Assert.True((bool)schema.Rows[3]["IsAliased"]);
                    Assert.True((bool)schema.Rows[3]["IsExpression"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["IsAutoIncrement"]);
                    Assert.Equal(DBNull.Value, schema.Rows[3]["IsLong"]);
                }
            }
        }

        [Fact]
        public void GetSchemaTable_works_when_view()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery(
                    @"CREATE VIEW dual AS SELECT 'X' AS dummy;");

                using (var reader = connection.ExecuteReader("SELECT * FROM dual;"))
                {
                    var schemaTable = reader.GetSchemaTable();
                    Assert.Equal(1, schemaTable.Rows.Count);
                    Assert.Equal("dummy", schemaTable.Rows[0][SchemaTableColumn.ColumnName]);
                }
            }
        }

        [Fact]
        public void GetSchemaTable_works_when_virtual_table()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE VIRTUAL TABLE dual USING fts3(dummy);");

                using (var reader = connection.ExecuteReader("SELECT * FROM dual;"))
                {
                    var schemaTable = reader.GetSchemaTable();
                    Assert.Equal(1, schemaTable.Rows.Count);
                    Assert.Equal("dummy", schemaTable.Rows[0][SchemaTableColumn.ColumnName]);
                }
            }
        }

        [Fact]
        public void GetSchemaTable_works_when_pragma()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("PRAGMA table_info('sqlite_master');"))
                {
                    var schemaTable = reader.GetSchemaTable();
                    Assert.Equal(6, schemaTable.Rows.Count);
                    Assert.Equal("cid", schemaTable.Rows[0][SchemaTableColumn.ColumnName]);
                    Assert.Equal("name", schemaTable.Rows[1][SchemaTableColumn.ColumnName]);
                    Assert.Equal("type", schemaTable.Rows[2][SchemaTableColumn.ColumnName]);
                    Assert.Equal("notnull", schemaTable.Rows[3][SchemaTableColumn.ColumnName]);
                    Assert.Equal("dflt_value", schemaTable.Rows[4][SchemaTableColumn.ColumnName]);
                    Assert.Equal("pk", schemaTable.Rows[5][SchemaTableColumn.ColumnName]);
                }
            }
        }

        [Fact]
        public void GetSchemaTable_works_when_eponymous_virtual_table()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT * FROM pragma_table_info('sqlite_master');"))
                {
                    var schemaTable = reader.GetSchemaTable();
                    Assert.Equal(6, schemaTable.Rows.Count);
                    Assert.Equal("cid", schemaTable.Rows[0][SchemaTableColumn.ColumnName]);
                    Assert.Equal("name", schemaTable.Rows[1][SchemaTableColumn.ColumnName]);
                    Assert.Equal("type", schemaTable.Rows[2][SchemaTableColumn.ColumnName]);
                    Assert.Equal("notnull", schemaTable.Rows[3][SchemaTableColumn.ColumnName]);
                    Assert.Equal("dflt_value", schemaTable.Rows[4][SchemaTableColumn.ColumnName]);
                    Assert.Equal("pk", schemaTable.Rows[5][SchemaTableColumn.ColumnName]);
                }
            }
        }

        [Theory]
        [InlineData("(0), (1), ('A')", typeof(long))]
        [InlineData("('Z'), (1), ('A')", typeof(string))]
        [InlineData("(0.1), (0.01), ('A')", typeof(double))]
        [InlineData("(X'7E57'), (X'577E'), ('A')", typeof(byte[]))]
        [InlineData("(NULL), (NULL), (NULL)", typeof(byte[]))]
        [InlineData("(NULL), ('A'), ('B')", typeof(string))]
        public void GetSchemaTable_DataType_works(string values, Type expectedType)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");
                connection.ExecuteNonQuery($"INSERT INTO Test VALUES {values};");

                using (var reader = connection.ExecuteReader("SELECT Value FROM Test;"))
                {
                    var schema = reader.GetSchemaTable();
                    Assert.True(schema.Columns.Contains("DataType"));
                    Assert.Equal(expectedType, schema.Rows[0]["DataType"]);
                }
            }
        }

        [Theory]
        [InlineData("TEXT", typeof(string))]
        [InlineData("CHARACTER(20)", typeof(string))]
        [InlineData("NVARCHAR(100)", typeof(string))]
        [InlineData("CLOB", typeof(string))]
        [InlineData("INTEGER", typeof(long))]
        [InlineData("BIGINT", typeof(long))]
        [InlineData("UNSIGNED BIG INT", typeof(long))]
        [InlineData("REAL", typeof(double))]
        [InlineData("DOUBLE", typeof(double))]
        [InlineData("FLOAT", typeof(double))]
        [InlineData("BLOB", typeof(byte[]))]
        [InlineData("", typeof(byte[]))]
        [InlineData("NUMERIC", typeof(string))]
        [InlineData("DATETIME", typeof(string))]
        public void GetSchemaTable_DataType_works_on_empty_table(string type, Type expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();
                connection.ExecuteNonQuery($"CREATE TABLE Test(Value {type});");

                using (var reader = connection.ExecuteReader("SELECT Value FROM Test;"))
                {
                    var schema = reader.GetSchemaTable();
                    Assert.True(schema.Columns.Contains("DataType"));
                    Assert.Equal(expected, schema.Rows[0]["DataType"]);
                }
            }
        }

        [Fact]
        public void GetSchemaTable_throws_when_closed()
        {
            X_throws_when_closed(r => r.GetSchemaTable(), nameof(SqliteDataReader.GetSchemaTable));
        }

        [Fact]
        public void GetSchemaTable_throws_when_non_query()
            => X_throws_when_non_query(r => r.GetSchemaTable());

        [Fact]
        public void Dispose_executes_remaining_statements()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");
                connection.CreateFunction<string, long>("throw", message => throw new Exception(message));

                var reader = connection.ExecuteReader(
                    @"
                    SELECT 1;
                    INSERT INTO Test VALUES (1);");
                ((IDisposable)reader).Dispose();

                Assert.Equal(1L, connection.ExecuteScalar<long>("SELECT count() FROM Test;"));
            }
        }

        [Fact]
        public void Dispose_doesnt_throw_but_stops_on_error()
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                connection.ExecuteNonQuery("CREATE TABLE Test(Value);");
                connection.CreateFunction<string, long>("throw", message => throw new Exception(message));

                var reader = connection.ExecuteReader(
                    @"
                    SELECT 1;
                    SELECT throw('An error');
                    INSERT INTO Test VALUES (1);");
                ((IDisposable)reader).Dispose();

                Assert.Equal(0L, connection.ExecuteScalar<long>("SELECT count() FROM Test;"));
            }
        }

        private static void GetX_works<T>(string sql, Func<DbDataReader, T> action, T expected)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader(sql))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    Assert.Equal(expected, action(reader));
                }
            }
        }

        private static void GetX_throws_when_null(Action<DbDataReader> action)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT NULL;"))
                {
                    var hasData = reader.Read();

                    Assert.True(hasData);
                    var ex = Assert.Throws<InvalidOperationException>(() => action(reader));
                    Assert.Equal(Resources.CalledOnNullValue(0), ex.Message);
                }
            }
        }

        private static void X_throws_before_read(Action<DbDataReader> action)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT NULL;"))
                {
                    var ex = Assert.Throws<InvalidOperationException>(() => action(reader));

                    Assert.Equal(Resources.NoData, ex.Message);
                }
            }
        }

        private static void X_throws_when_done(Action<DbDataReader> action)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("SELECT NULL;"))
                {
                    var hasData = reader.Read();
                    Assert.True(hasData);

                    hasData = reader.Read();
                    Assert.False(hasData);

                    var ex = Assert.Throws<InvalidOperationException>(() => action(reader));
                    Assert.Equal(Resources.NoData, ex.Message);
                }
            }
        }

        private static void X_throws_when_closed(Action<SqliteDataReader> action, string operation)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                var reader = connection.ExecuteReader("SELECT 1;");
                ((IDisposable)reader).Dispose();

                var ex = Assert.Throws<InvalidOperationException>(() => action(reader));
                Assert.Equal(Resources.DataReaderClosed(operation), ex.Message);
            }
        }

        private static void X_throws_when_non_query(Action<SqliteDataReader> action)
        {
            using (var connection = new SqliteConnection("Data Source=:memory:"))
            {
                connection.Open();

                using (var reader = connection.ExecuteReader("CREATE TABLE dual(dummy);"))
                {
                    var ex = Assert.Throws<InvalidOperationException>(() => action(reader));
                    Assert.Equal(Resources.NoData, ex.Message);
                }
            }
        }

        private enum MyEnum
        {
            One = 1
        }
    }
}