using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Data.Common;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.Data.Sqlite.Properties;
using Microsoft.Data.Sqlite.Utilities;
using SQLitePCL;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Microsoft.Data.Sqlite.e_sqlcipher.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: InternalsVisibleTo("Microsoft.Data.Sqlite.e_sqlite3mc.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: InternalsVisibleTo("Microsoft.Data.Sqlite.sqlite3.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: InternalsVisibleTo("Microsoft.Data.Sqlite.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: InternalsVisibleTo("Microsoft.Data.Sqlite.winsqlite3.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("CommitHash", "a612c2a1056fe3265387ae3ff7c94eba1505caf9")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Microsoft.Data.Sqlite is a lightweight ADO.NET provider for SQLite. This package does not include a copy of the native SQLite library.\r\n\r\nCommonly Used Types:\r\nMicrosoft.Data.Sqlite.SqliteCommand\r\nMicrosoft.Data.Sqlite.SqliteConnection\r\nMicrosoft.Data.Sqlite.SqliteConnectionStringBuilder\r\nMicrosoft.Data.Sqlite.SqliteDataReader\r\nMicrosoft.Data.Sqlite.SqliteException\r\nMicrosoft.Data.Sqlite.SqliteFactory\r\nMicrosoft.Data.Sqlite.SqliteParameter\r\nMicrosoft.Data.Sqlite.SqliteTransaction")]
[assembly: AssemblyFileVersion("10.0.526.15411")]
[assembly: AssemblyInformationalVersion("10.0.5")]
[assembly: AssemblyProduct("Microsoft Entity Framework Core")]
[assembly: AssemblyTitle("Microsoft.Data.Sqlite")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/dotnet")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("10.0.5.0")]
[module: RefSafetyRules(11)]
[module: System.Runtime.CompilerServices.NullablePublicOnly(true)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System
{
	internal static class TypeExtensions
	{
		public static Type UnwrapEnumType(this Type type)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		public static Type UnwrapNullableType(this Type type)
		{
			return Nullable.GetUnderlyingType(type) ?? type;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
}
namespace SQLitePCL
{
	internal static class SQLitePCLExtensions
	{
		private static readonly Dictionary<string, bool> _knownLibraries = new Dictionary<string, bool>
		{
			{ "e_sqlcipher", true },
			{ "e_sqlite3", false },
			{ "e_sqlite3mc", true },
			{ "sqlcipher", true },
			{ "sqlite3mc", true },
			{ "winsqlite3", false }
		};

		public static bool? EncryptionSupported()
		{
			string libraryName;
			return EncryptionSupported(out libraryName);
		}

		public static bool? EncryptionSupported(out string libraryName)
		{
			libraryName = raw.GetNativeLibraryName();
			if (!_knownLibraries.TryGetValue(libraryName, out var value))
			{
				return null;
			}
			return value;
		}
	}
}
namespace Microsoft.Data.Sqlite
{
	internal static class SqliteConnectionExtensions
	{
		public static int ExecuteNonQuery(this SqliteConnection connection, string commandText, params SqliteParameter[] parameters)
		{
			using SqliteCommand sqliteCommand = connection.CreateCommand();
			sqliteCommand.CommandText = commandText;
			sqliteCommand.Parameters.AddRange(parameters);
			return sqliteCommand.ExecuteNonQuery();
		}

		public static T ExecuteScalar<T>(this SqliteConnection connection, string commandText, params SqliteParameter[] parameters)
		{
			return (T)connection.ExecuteScalar(commandText, parameters);
		}

		private static object ExecuteScalar(this SqliteConnection connection, string commandText, params SqliteParameter[] parameters)
		{
			using SqliteCommand sqliteCommand = connection.CreateCommand();
			sqliteCommand.CommandText = commandText;
			sqliteCommand.Parameters.AddRange(parameters);
			return sqliteCommand.ExecuteScalar();
		}
	}
	public class SqliteBlob : Stream
	{
		private sqlite3_blob _blob;

		private readonly SqliteConnection _connection;

		private long _position;

		public override bool CanRead => true;

		public override bool CanWrite { get; }

		public override bool CanSeek => true;

		public override long Length { get; }

		public override long Position
		{
			get
			{
				return _position;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException("value", value, null);
				}
				_position = value;
			}
		}

		public SqliteBlob(SqliteConnection connection, string tableName, string columnName, long rowid, bool readOnly = false)
			: this(connection, "main", tableName, columnName, rowid, readOnly)
		{
		}

		public SqliteBlob(SqliteConnection connection, string databaseName, string tableName, string columnName, long rowid, bool readOnly = false)
		{
			if (connection == null || connection.State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.SqlBlobRequiresOpenConnection);
			}
			if (tableName == null)
			{
				throw new ArgumentNullException("tableName");
			}
			if (columnName == null)
			{
				throw new ArgumentNullException("columnName");
			}
			_connection = connection;
			CanWrite = !readOnly;
			SqliteException.ThrowExceptionForRC(raw.sqlite3_blob_open(_connection.Handle, databaseName, tableName, columnName, rowid, (!readOnly) ? 1 : 0, ref _blob), _connection.Handle);
			Length = raw.sqlite3_blob_bytes(_blob);
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", offset, null);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", count, null);
			}
			if (offset + count > buffer.Length)
			{
				throw new ArgumentException(Resources.InvalidOffsetAndCount);
			}
			return Read(buffer.AsSpan(offset, count));
		}

		public new virtual int Read(Span<byte> buffer)
		{
			if (_blob == null)
			{
				throw new ObjectDisposedException(null);
			}
			long num = _position;
			if (num > Length)
			{
				num = Length;
			}
			int num2 = buffer.Length;
			if (num + num2 > Length)
			{
				num2 = (int)(Length - num);
			}
			if (num2 > 0)
			{
				SqliteException.ThrowExceptionForRC(raw.sqlite3_blob_read(_blob, buffer.Slice(0, num2), (int)num), _connection.Handle);
			}
			_position += num2;
			return num2;
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", offset, null);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", count, null);
			}
			if (offset + count > buffer.Length)
			{
				throw new ArgumentException(Resources.InvalidOffsetAndCount);
			}
			if (_blob == null)
			{
				throw new ObjectDisposedException(null);
			}
			Write(buffer.AsSpan(offset, count));
		}

		public new virtual void Write(ReadOnlySpan<byte> buffer)
		{
			if (!CanWrite)
			{
				throw new NotSupportedException(Resources.WriteNotSupported);
			}
			long num = _position;
			if (num > Length)
			{
				num = Length;
			}
			int length = buffer.Length;
			if (num + length > Length)
			{
				throw new NotSupportedException(Resources.ResizeNotSupported);
			}
			if (length > 0)
			{
				SqliteException.ThrowExceptionForRC(raw.sqlite3_blob_write(_blob, buffer.Slice(0, length), (int)num), _connection.Handle);
			}
			_position += length;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			long num = origin switch
			{
				SeekOrigin.Begin => offset, 
				SeekOrigin.Current => _position + offset, 
				SeekOrigin.End => Length + offset, 
				_ => throw new ArgumentException(Resources.InvalidEnumValue(typeof(SeekOrigin), origin), "origin"), 
			};
			if (num < 0)
			{
				throw new IOException(Resources.SeekBeforeBegin);
			}
			return _position = num;
		}

		protected override void Dispose(bool disposing)
		{
			if (_blob != null)
			{
				((SafeHandle)(object)_blob).Dispose();
				_blob = null;
			}
		}

		public override void Flush()
		{
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException(Resources.ResizeNotSupported);
		}
	}
	public enum SqliteCacheMode
	{
		Default,
		Private,
		Shared
	}
	public class SqliteCommand : DbCommand
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass54_0
		{
			public string name;

			internal bool <GetStatements>b__0(SqliteParameter p)
			{
				return p.ParameterName == name;
			}
		}

		[CompilerGenerated]
		private sealed class <GetStatements>d__54 : IEnumerable<sqlite3_stmt>, IEnumerable, IEnumerator<sqlite3_stmt>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private sqlite3_stmt <>2__current;

			private int <>l__initialThreadId;

			public SqliteCommand <>4__this;

			private IEnumerator<(sqlite3_stmt Statement, int ParamCount)> <>7__wrap1;

			sqlite3_stmt IEnumerator<sqlite3_stmt>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetStatements>d__54(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					SqliteCommand sqliteCommand = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<(sqlite3_stmt Statement, int ParamCount)> enumerable;
						if (sqliteCommand._prepared)
						{
							IEnumerable<(sqlite3_stmt, int)> preparedStatements = sqliteCommand._preparedStatements;
							enumerable = preparedStatements;
						}
						else
						{
							enumerable = sqliteCommand.PrepareAndEnumerateStatements();
						}
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						(sqlite3_stmt Statement, int ParamCount) current = <>7__wrap1.Current;
						sqlite3_stmt item = current.Statement;
						int item2 = current.ParamCount;
						int num2 = sqliteCommand._parameters?.Bind(item, sqliteCommand.Connection.Handle) ?? 0;
						if (item2 != num2)
						{
							List<string> list = new List<string>();
							for (int i = 1; i <= item2; i++)
							{
								<>c__DisplayClass54_0 CS$<>8__locals0 = new <>c__DisplayClass54_0();
								utf8z val = raw.sqlite3_bind_parameter_name(item, i);
								CS$<>8__locals0.name = ((utf8z)(ref val)).utf8_to_string();
								if (sqliteCommand._parameters != null && !sqliteCommand._parameters.Cast<SqliteParameter>().Any((SqliteParameter p) => p.ParameterName == CS$<>8__locals0.name))
								{
									list.Add(CS$<>8__locals0.name);
								}
							}
							if (raw.sqlite3_libversion_number() < 3028000 || raw.sqlite3_stmt_isexplain(item) == 0)
							{
								throw new InvalidOperationException(Resources.MissingParameters(string.Join(", ", list)));
							}
						}
						<>2__current = item;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<sqlite3_stmt> IEnumerable<sqlite3_stmt>.GetEnumerator()
			{
				<GetStatements>d__54 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetStatements>d__54(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<sqlite3_stmt>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <PrepareAndEnumerateStatements>d__64 : IEnumerable<(sqlite3_stmt Statement, int ParamCount)>, IEnumerable, IEnumerator<(sqlite3_stmt Statement, int ParamCount)>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private (sqlite3_stmt Statement, int ParamCount) <>2__current;

			private int <>l__initialThreadId;

			public SqliteCommand <>4__this;

			private int <byteCount>5__2;

			private byte[] <sql>5__3;

			private TimeSpan <totalElapsedTime>5__4;

			private int <start>5__5;

			(sqlite3_stmt, int) IEnumerator<(sqlite3_stmt, int)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PrepareAndEnumerateStatements>d__64(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sql>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				SqliteCommand sqliteCommand = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_018f;
				}
				<>1__state = -1;
				sqliteCommand.DisposePreparedStatements(disposing: false);
				<byteCount>5__2 = Encoding.UTF8.GetByteCount(sqliteCommand._commandText);
				<sql>5__3 = new byte[<byteCount>5__2 + 1];
				Encoding.UTF8.GetBytes(sqliteCommand._commandText, 0, sqliteCommand._commandText.Length, <sql>5__3, 0);
				<totalElapsedTime>5__4 = TimeSpan.Zero;
				<start>5__5 = 0;
				goto IL_0087;
				IL_0087:
				SharedStopwatch sharedStopwatch = SharedStopwatch.StartNew();
				int rc;
				sqlite3_stmt val = default(sqlite3_stmt);
				ReadOnlySpan<byte> readOnlySpan = default(ReadOnlySpan<byte>);
				while (IsBusy(rc = raw.sqlite3_prepare_v2(sqliteCommand._connection.Handle, (ReadOnlySpan<byte>)<sql>5__3.AsSpan(<start>5__5), ref val, ref readOnlySpan)) && (sqliteCommand.CommandTimeout == 0 || !((<totalElapsedTime>5__4 + sharedStopwatch.Elapsed).TotalMilliseconds >= (double)((long)sqliteCommand.CommandTimeout * 1000L))))
				{
					Thread.Sleep(150);
				}
				<totalElapsedTime>5__4 += sharedStopwatch.Elapsed;
				<start>5__5 = <sql>5__3.Length - readOnlySpan.Length;
				SqliteException.ThrowExceptionForRC(rc, sqliteCommand._connection.Handle);
				if (((SafeHandle)(object)val).IsInvalid)
				{
					if (<start>5__5 < <byteCount>5__2)
					{
						goto IL_018f;
					}
					goto IL_01a0;
				}
				int item = raw.sqlite3_bind_parameter_count(val);
				(sqlite3_stmt, int) item2 = (val, item);
				sqliteCommand._preparedStatements.Add(item2);
				<>2__current = item2;
				<>1__state = 1;
				return true;
				IL_018f:
				if (<start>5__5 < <byteCount>5__2)
				{
					goto IL_0087;
				}
				goto IL_01a0;
				IL_01a0:
				sqliteCommand._prepared = true;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<(sqlite3_stmt Statement, int ParamCount)> IEnumerable<(sqlite3_stmt, int)>.GetEnumerator()
			{
				<PrepareAndEnumerateStatements>d__64 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <PrepareAndEnumerateStatements>d__64(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<(sqlite3_stmt, int)>)this).GetEnumerator();
			}
		}

		private SqliteParameterCollection _parameters;

		private readonly List<(sqlite3_stmt Statement, int ParamCount)> _preparedStatements = new List<(sqlite3_stmt, int)>(1);

		private SqliteConnection _connection;

		private string _commandText = string.Empty;

		private bool _prepared;

		private int? _commandTimeout;

		public override CommandType CommandType
		{
			get
			{
				return CommandType.Text;
			}
			set
			{
				if (value != CommandType.Text)
				{
					throw new ArgumentException(Resources.InvalidCommandType(value));
				}
			}
		}

		public override string CommandText
		{
			get
			{
				return _commandText;
			}
			[param: AllowNull]
			set
			{
				if (DataReader != null)
				{
					throw new InvalidOperationException(Resources.SetRequiresNoOpenReader("CommandText"));
				}
				if (value != _commandText)
				{
					DisposePreparedStatements();
					_commandText = value ?? string.Empty;
				}
			}
		}

		public new virtual SqliteConnection? Connection
		{
			get
			{
				return _connection;
			}
			set
			{
				if (DataReader != null)
				{
					throw new InvalidOperationException(Resources.SetRequiresNoOpenReader("Connection"));
				}
				if (value != _connection)
				{
					DisposePreparedStatements();
					_connection?.RemoveCommand(this);
					_connection = value;
					value?.AddCommand(this);
				}
			}
		}

		protected override DbConnection? DbConnection
		{
			get
			{
				return Connection;
			}
			set
			{
				Connection = (SqliteConnection)value;
			}
		}

		public new virtual SqliteTransaction? Transaction { get; set; }

		protected override DbTransaction? DbTransaction
		{
			get
			{
				return Transaction;
			}
			set
			{
				Transaction = (SqliteTransaction)value;
			}
		}

		public new virtual SqliteParameterCollection Parameters => _parameters ?? (_parameters = new SqliteParameterCollection());

		protected override DbParameterCollection DbParameterCollection => Parameters;

		public override int CommandTimeout
		{
			get
			{
				return _commandTimeout ?? _connection?.DefaultTimeout ?? 30;
			}
			set
			{
				_commandTimeout = value;
			}
		}

		public override bool DesignTimeVisible { get; set; }

		public override UpdateRowSource UpdatedRowSource { get; set; }

		protected internal virtual SqliteDataReader? DataReader { get; set; }

		public SqliteCommand()
		{
		}

		public SqliteCommand(string? commandText)
		{
			CommandText = commandText;
		}

		public SqliteCommand(string? commandText, SqliteConnection? connection)
			: this(commandText)
		{
			Connection = connection;
		}

		public SqliteCommand(string? commandText, SqliteConnection? connection, SqliteTransaction? transaction)
			: this(commandText, connection)
		{
			Transaction = transaction;
		}

		protected override void Dispose(bool disposing)
		{
			DisposePreparedStatements(disposing);
			if (disposing)
			{
				_connection?.RemoveCommand(this);
			}
			base.Dispose(disposing);
		}

		public new virtual SqliteParameter CreateParameter()
		{
			return new SqliteParameter();
		}

		protected override DbParameter CreateDbParameter()
		{
			return CreateParameter();
		}

		public override void Prepare()
		{
			SqliteConnection connection = _connection;
			if (connection == null || connection.State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.CallRequiresOpenConnection("Prepare"));
			}
			if (_prepared)
			{
				return;
			}
			using IEnumerator<(sqlite3_stmt, int)> enumerator = PrepareAndEnumerateStatements().GetEnumerator();
			while (enumerator.MoveNext())
			{
			}
		}

		public new virtual SqliteDataReader ExecuteReader()
		{
			return ExecuteReader(CommandBehavior.Default);
		}

		public new virtual SqliteDataReader ExecuteReader(CommandBehavior behavior)
		{
			if (DataReader != null)
			{
				throw new InvalidOperationException(Resources.DataReaderOpen);
			}
			SqliteConnection connection = _connection;
			if (connection == null || connection.State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.CallRequiresOpenConnection("ExecuteReader"));
			}
			if (Transaction != _connection.Transaction)
			{
				throw new InvalidOperationException((Transaction == null) ? Resources.TransactionRequired : Resources.TransactionConnectionMismatch);
			}
			SqliteTransaction? transaction = _connection.Transaction;
			if (transaction != null && transaction.ExternalRollback)
			{
				throw new InvalidOperationException(Resources.TransactionCompleted);
			}
			bool closeConnection = behavior.HasFlag(CommandBehavior.CloseConnection);
			SqliteDataReader sqliteDataReader = new SqliteDataReader(this, GetStatements(), closeConnection);
			sqliteDataReader.NextResult();
			return DataReader = sqliteDataReader;
		}

		[IteratorStateMachine(typeof(<GetStatements>d__54))]
		private IEnumerable<sqlite3_stmt> GetStatements()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetStatements>d__54(-2)
			{
				<>4__this = this
			};
		}

		protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
		{
			return ExecuteReader(behavior);
		}

		public new virtual Task<SqliteDataReader> ExecuteReaderAsync()
		{
			return ExecuteReaderAsync(CommandBehavior.Default, CancellationToken.None);
		}

		public new virtual Task<SqliteDataReader> ExecuteReaderAsync(CancellationToken cancellationToken)
		{
			return ExecuteReaderAsync(CommandBehavior.Default, cancellationToken);
		}

		public new virtual Task<SqliteDataReader> ExecuteReaderAsync(CommandBehavior behavior)
		{
			return ExecuteReaderAsync(behavior, CancellationToken.None);
		}

		public new virtual Task<SqliteDataReader> ExecuteReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			return Task.FromResult(ExecuteReader(behavior));
		}

		protected override async Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
		{
			return await ExecuteReaderAsync(behavior, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		public override int ExecuteNonQuery()
		{
			SqliteConnection connection = _connection;
			if (connection == null || connection.State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.CallRequiresOpenConnection("ExecuteNonQuery"));
			}
			SqliteDataReader sqliteDataReader = ExecuteReader();
			sqliteDataReader.Dispose();
			return sqliteDataReader.RecordsAffected;
		}

		public override object? ExecuteScalar()
		{
			SqliteConnection connection = _connection;
			if (connection == null || connection.State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.CallRequiresOpenConnection("ExecuteScalar"));
			}
			using SqliteDataReader sqliteDataReader = ExecuteReader();
			return sqliteDataReader.Read() ? sqliteDataReader.GetValue(0) : null;
		}

		public override void Cancel()
		{
		}

		[IteratorStateMachine(typeof(<PrepareAndEnumerateStatements>d__64))]
		private IEnumerable<(sqlite3_stmt Statement, int ParamCount)> PrepareAndEnumerateStatements()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PrepareAndEnumerateStatements>d__64(-2)
			{
				<>4__this = this
			};
		}

		private void DisposePreparedStatements(bool disposing = true)
		{
			if (disposing && DataReader != null)
			{
				DataReader.Dispose();
				DataReader = null;
			}
			if (_preparedStatements != null)
			{
				foreach (var preparedStatement in _preparedStatements)
				{
					((SafeHandle)(object)preparedStatement.Statement).Dispose();
				}
				_preparedStatements.Clear();
			}
			_prepared = false;
		}

		private static bool IsBusy(int rc)
		{
			if ((uint)(rc - 5) <= 1u || rc == 262)
			{
				return true;
			}
			return false;
		}
	}
	public class SqliteConnection : DbConnection
	{
		private sealed class AggregateDefinition<TAccumulate, TResult>
		{
			public string Name { get; }

			public TAccumulate Seed { get; }

			public Func<TAccumulate, SqliteValueReader, TAccumulate> Func { get; }

			public Func<TAccumulate, TResult> ResultSelector { get; }

			public AggregateDefinition(string name, TAccumulate seed, Func<TAccumulate, SqliteValueReader, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
			{
				Name = name;
				Seed = seed;
				Func = func;
				ResultSelector = resultSelector;
				base..ctor();
			}
		}

		private sealed class AggregateContext<T>
		{
			public T Accumulate { get; set; }

			public Exception Exception { get; set; }

			public AggregateContext(T seed)
			{
				Accumulate = seed;
				base..ctor();
			}
		}

		private sealed class FunctionsKeyComparer : IEqualityComparer<(string name, int arity)>
		{
			public static readonly FunctionsKeyComparer Instance = new FunctionsKeyComparer();

			public bool Equals((string name, int arity) x, (string name, int arity) y)
			{
				if (StringComparer.OrdinalIgnoreCase.Equals(x.name, y.name))
				{
					return x.arity == y.arity;
				}
				return false;
			}

			public int GetHashCode((string name, int arity) obj)
			{
				int hashCode = StringComparer.OrdinalIgnoreCase.GetHashCode(obj.name);
				int hashCode2 = obj.arity.GetHashCode();
				return (((hashCode << 5) | (hashCode >>> 27)) + hashCode) ^ hashCode2;
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c__162<TAccumulate, TResult>
		{
			public static readonly <>c__162<TAccumulate, TResult> <>9 = new <>c__162<TAccumulate, TResult>();

			public static delegate_function_aggregate_step <>9__162_0;

			public static delegate_function_aggregate_final <>9__162_1;

			internal void <CreateAggregateCore>b__162_0(sqlite3_context ctx, object user_data, sqlite3_value[] args)
			{
				AggregateDefinition<TAccumulate, TResult> aggregateDefinition = (AggregateDefinition<TAccumulate, TResult>)user_data;
				if (ctx.state == null)
				{
					ctx.state = new AggregateContext<TAccumulate>(aggregateDefinition.Seed);
				}
				AggregateContext<TAccumulate> aggregateContext = (AggregateContext<TAccumulate>)ctx.state;
				if (aggregateContext.Exception != null)
				{
					return;
				}
				SqliteParameterReader arg = new SqliteParameterReader(aggregateDefinition.Name, args);
				try
				{
					aggregateContext.Accumulate = aggregateDefinition.Func(aggregateContext.Accumulate, arg);
				}
				catch (Exception exception)
				{
					aggregateContext.Exception = exception;
				}
			}

			internal void <CreateAggregateCore>b__162_1(sqlite3_context ctx, object user_data)
			{
				AggregateDefinition<TAccumulate, TResult> aggregateDefinition = (AggregateDefinition<TAccumulate, TResult>)user_data;
				if (ctx.state == null)
				{
					ctx.state = new AggregateContext<TAccumulate>(aggregateDefinition.Seed);
				}
				AggregateContext<TAccumulate> aggregateContext = (AggregateContext<TAccumulate>)ctx.state;
				if (aggregateContext.Exception == null)
				{
					try
					{
						TResult val = aggregateDefinition.ResultSelector(aggregateContext.Accumulate);
						new SqliteResultBinder(ctx, val).Bind();
					}
					catch (Exception exception)
					{
						aggregateContext.Exception = exception;
					}
				}
				if (aggregateContext.Exception != null)
				{
					raw.sqlite3_result_error(ctx, aggregateContext.Exception.Message);
					if (aggregateContext.Exception is SqliteException ex)
					{
						raw.sqlite3_result_error_code(ctx, ex.SqliteErrorCode);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <GetLoadExtensionPaths>d__154 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string file;

			public string <>3__file;

			private bool <shouldTryAddingLibPrefix>5__2;

			private string[] <>7__wrap2;

			private int <>7__wrap3;

			private string <dir>5__5;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetLoadExtensionPaths>d__154(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap2 = null;
				<dir>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = file;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!string.IsNullOrEmpty(Path.GetDirectoryName(file)))
					{
						return false;
					}
					<shouldTryAddingLibPrefix>5__2 = !file.StartsWith("lib", StringComparison.Ordinal) && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
					if (<shouldTryAddingLibPrefix>5__2)
					{
						<>2__current = "lib" + file;
						<>1__state = 2;
						return true;
					}
					goto IL_00b1;
				case 2:
					<>1__state = -1;
					goto IL_00b1;
				case 3:
					<>1__state = -1;
					if (<shouldTryAddingLibPrefix>5__2)
					{
						<>2__current = Path.Combine(<dir>5__5, "lib" + file);
						<>1__state = 4;
						return true;
					}
					goto IL_014c;
				case 4:
					{
						<>1__state = -1;
						goto IL_014c;
					}
					IL_00b1:
					if (NativeDllSearchDirectories == null)
					{
						NativeDllSearchDirectories = GetNativeDllSearchDirectories();
					}
					<>7__wrap2 = NativeDllSearchDirectories;
					<>7__wrap3 = 0;
					break;
					IL_014c:
					<dir>5__5 = null;
					<>7__wrap3++;
					break;
				}
				if (<>7__wrap3 < <>7__wrap2.Length)
				{
					<dir>5__5 = <>7__wrap2[<>7__wrap3];
					<>2__current = Path.Combine(<dir>5__5, file);
					<>1__state = 3;
					return true;
				}
				<>7__wrap2 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				<GetLoadExtensionPaths>d__154 <GetLoadExtensionPaths>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetLoadExtensionPaths>d__ = this;
				}
				else
				{
					<GetLoadExtensionPaths>d__ = new <GetLoadExtensionPaths>d__154(0);
				}
				<GetLoadExtensionPaths>d__.file = <>3__file;
				return <GetLoadExtensionPaths>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		internal const string MainDatabaseName = "main";

		private const int SQLITE_WIN32_DATA_DIRECTORY_TYPE = 1;

		private const int SQLITE_WIN32_TEMP_DIRECTORY_TYPE = 2;

		private readonly List<WeakReference<SqliteCommand>> _commands = new List<WeakReference<SqliteCommand>>();

		private Dictionary<string, (object state, strdelegate_collation collation)> _collations;

		private Dictionary<(string name, int arity), (int flags, object state, delegate_function_scalar func)> _functions;

		private Dictionary<(string name, int arity), (int flags, object state, delegate_function_aggregate_step func_step, delegate_function_aggregate_final func_final)> _aggregates;

		private HashSet<(string file, string proc)> _extensions;

		private string _connectionString;

		private ConnectionState _state;

		private SqliteConnectionInternal _innerConnection;

		private bool _extensionsEnabled;

		private int? _defaultTimeout;

		private static readonly StateChangeEventArgs _fromClosedToOpenEventArgs;

		private static readonly StateChangeEventArgs _fromOpenToClosedEventArgs;

		private static string[] NativeDllSearchDirectories;

		public virtual sqlite3? Handle => _innerConnection?.Handle;

		public override string ConnectionString
		{
			get
			{
				return _connectionString;
			}
			[MemberNotNull(new string[] { "_connectionString", "PoolGroup" })]
			[param: AllowNull]
			set
			{
				if (State != 0)
				{
					throw new InvalidOperationException(Resources.ConnectionStringRequiresClosedConnection);
				}
				_connectionString = value ?? string.Empty;
				PoolGroup = SqliteConnectionFactory.Instance.GetPoolGroup(_connectionString);
			}
		}

		internal SqliteConnectionPoolGroup PoolGroup { get; set; }

		internal SqliteConnectionStringBuilder ConnectionOptions => PoolGroup.ConnectionOptions;

		public override string Database => "main";

		public override string DataSource
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				string text = null;
				if (State == ConnectionState.Open)
				{
					utf8z val = raw.sqlite3_db_filename(Handle, "main");
					text = ((utf8z)(ref val)).utf8_to_string();
				}
				return text ?? ConnectionOptions.DataSource;
			}
		}

		public virtual int DefaultTimeout
		{
			get
			{
				return _defaultTimeout ?? ConnectionOptions.DefaultTimeout;
			}
			set
			{
				_defaultTimeout = value;
			}
		}

		public override string ServerVersion
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				utf8z val = raw.sqlite3_libversion();
				return ((utf8z)(ref val)).utf8_to_string();
			}
		}

		public override ConnectionState State => _state;

		protected override DbProviderFactory DbProviderFactory => SqliteFactory.Instance;

		protected internal virtual SqliteTransaction? Transaction { get; set; }

		public virtual void CreateAggregate<TAccumulate>(string name, Func<TAccumulate?, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, TAccumulate> func2 = func;
			CreateAggregateCore(name, 0, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a)), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, TAccumulate>(string name, Func<TAccumulate?, T1, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, TAccumulate> func2 = func;
			CreateAggregateCore(name, 1, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, TAccumulate>(string name, Func<TAccumulate?, T1, T2, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, TAccumulate> func2 = func;
			CreateAggregateCore(name, 2, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, TAccumulate> func2 = func;
			CreateAggregateCore(name, 3, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, TAccumulate> func2 = func;
			CreateAggregateCore(name, 4, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, TAccumulate> func2 = func;
			CreateAggregateCore(name, 5, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, TAccumulate> func2 = func;
			CreateAggregateCore(name, 6, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, TAccumulate> func2 = func;
			CreateAggregateCore(name, 7, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate> func2 = func;
			CreateAggregateCore(name, 8, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate> func2 = func;
			CreateAggregateCore(name, 9, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate> func2 = func;
			CreateAggregateCore(name, 10, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate> func2 = func;
			CreateAggregateCore(name, 11, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate> func2 = func;
			CreateAggregateCore(name, 12, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate> func2 = func;
			CreateAggregateCore(name, 13, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate> func2 = func;
			CreateAggregateCore(name, 14, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate>(string name, Func<TAccumulate?, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate> func2 = func;
			CreateAggregateCore(name, 15, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<TAccumulate>(string name, Func<TAccumulate?, object?[], TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, object[], TAccumulate> func2 = func;
			CreateAggregateCore(name, -1, default(TAccumulate), IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, GetValues(r))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, TAccumulate> func2 = func;
			CreateAggregateCore(name, 0, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a)), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, TAccumulate> func2 = func;
			CreateAggregateCore(name, 1, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, TAccumulate> func2 = func;
			CreateAggregateCore(name, 2, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, TAccumulate> func2 = func;
			CreateAggregateCore(name, 3, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, TAccumulate> func2 = func;
			CreateAggregateCore(name, 4, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, TAccumulate> func2 = func;
			CreateAggregateCore(name, 5, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, TAccumulate> func2 = func;
			CreateAggregateCore(name, 6, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, TAccumulate> func2 = func;
			CreateAggregateCore(name, 7, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate> func2 = func;
			CreateAggregateCore(name, 8, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate> func2 = func;
			CreateAggregateCore(name, 9, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate> func2 = func;
			CreateAggregateCore(name, 10, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate> func2 = func;
			CreateAggregateCore(name, 11, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate> func2 = func;
			CreateAggregateCore(name, 12, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate> func2 = func;
			CreateAggregateCore(name, 13, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate> func2 = func;
			CreateAggregateCore(name, 14, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate> func2 = func;
			CreateAggregateCore(name, 15, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<TAccumulate>(string name, TAccumulate seed, Func<TAccumulate, object?[], TAccumulate>? func, bool isDeterministic = false)
		{
			Func<TAccumulate, object[], TAccumulate> func2 = func;
			CreateAggregateCore(name, -1, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, GetValues(r))), (TAccumulate a) => a, isDeterministic);
		}

		public virtual void CreateAggregate<TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 0, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a)), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 1, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 2, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 3, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 4, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 5, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 6, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 7, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 8, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 9, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 10, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 11, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 12, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 13, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 14, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, 15, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14))), resultSelector, isDeterministic);
		}

		public virtual void CreateAggregate<TAccumulate, TResult>(string name, TAccumulate seed, Func<TAccumulate, object?[], TAccumulate>? func, Func<TAccumulate, TResult>? resultSelector, bool isDeterministic = false)
		{
			Func<TAccumulate, object[], TAccumulate> func2 = func;
			CreateAggregateCore<TAccumulate, TResult>(name, -1, seed, IfNotNull(func2, (TAccumulate a, SqliteValueReader r) => func2(a, GetValues(r))), resultSelector, isDeterministic);
		}

		public virtual void CreateFunction<TResult>(string name, Func<TResult>? function, bool isDeterministic = false)
		{
			Func<TResult> function2 = function;
			CreateFunctionCore(name, 0, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2()), isDeterministic);
		}

		public virtual void CreateFunction<T1, TResult>(string name, Func<T1, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, TResult> function2 = function;
			CreateFunctionCore(name, 1, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, TResult>(string name, Func<T1, T2, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, TResult> function2 = function;
			CreateFunctionCore(name, 2, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, TResult> function2 = function;
			CreateFunctionCore(name, 3, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, TResult> function2 = function;
			CreateFunctionCore(name, 4, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, TResult>(string name, Func<T1, T2, T3, T4, T5, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, TResult> function2 = function;
			CreateFunctionCore(name, 5, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, TResult> function2 = function;
			CreateFunctionCore(name, 6, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, TResult> function2 = function;
			CreateFunctionCore(name, 7, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> function2 = function;
			CreateFunctionCore(name, 8, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function2 = function;
			CreateFunctionCore(name, 9, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function2 = function;
			CreateFunctionCore(name, 10, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function2 = function;
			CreateFunctionCore(name, 11, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function2 = function;
			CreateFunctionCore(name, 12, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function2 = function;
			CreateFunctionCore(name, 13, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function2 = function;
			CreateFunctionCore(name, 14, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function2 = function;
			CreateFunctionCore(name, 15, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14))), isDeterministic);
		}

		public virtual void CreateFunction<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(string name, Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>? function, bool isDeterministic = false)
		{
			Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> function2 = function;
			CreateFunctionCore(name, 16, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14), r.GetFieldValue<T16>(15))), isDeterministic);
		}

		public virtual void CreateFunction<TResult>(string name, Func<object?[], TResult>? function, bool isDeterministic = false)
		{
			Func<object[], TResult> function2 = function;
			CreateFunctionCore(name, -1, null, IfNotNull(function2, (object s, SqliteValueReader r) => function2(GetValues(r))), isDeterministic);
		}

		public virtual void CreateFunction<TState, TResult>(string name, TState state, Func<TState, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, TResult> function2 = function;
			CreateFunctionCore(name, 0, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s)), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, TResult>(string name, TState state, Func<TState, T1, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, TResult> function2 = function;
			CreateFunctionCore(name, 1, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, TResult>(string name, TState state, Func<TState, T1, T2, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, TResult> function2 = function;
			CreateFunctionCore(name, 2, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, TResult>(string name, TState state, Func<TState, T1, T2, T3, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, TResult> function2 = function;
			CreateFunctionCore(name, 3, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, TResult> function2 = function;
			CreateFunctionCore(name, 4, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, TResult> function2 = function;
			CreateFunctionCore(name, 5, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, TResult> function2 = function;
			CreateFunctionCore(name, 6, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, TResult> function2 = function;
			CreateFunctionCore(name, 7, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, TResult> function2 = function;
			CreateFunctionCore(name, 8, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> function2 = function;
			CreateFunctionCore(name, 9, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> function2 = function;
			CreateFunctionCore(name, 10, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> function2 = function;
			CreateFunctionCore(name, 11, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> function2 = function;
			CreateFunctionCore(name, 12, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> function2 = function;
			CreateFunctionCore(name, 13, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> function2 = function;
			CreateFunctionCore(name, 14, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13))), isDeterministic);
		}

		public virtual void CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(string name, TState state, Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>? function, bool isDeterministic = false)
		{
			Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> function2 = function;
			CreateFunctionCore(name, 15, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, r.GetFieldValue<T1>(0), r.GetFieldValue<T2>(1), r.GetFieldValue<T3>(2), r.GetFieldValue<T4>(3), r.GetFieldValue<T5>(4), r.GetFieldValue<T6>(5), r.GetFieldValue<T7>(6), r.GetFieldValue<T8>(7), r.GetFieldValue<T9>(8), r.GetFieldValue<T10>(9), r.GetFieldValue<T11>(10), r.GetFieldValue<T12>(11), r.GetFieldValue<T13>(12), r.GetFieldValue<T14>(13), r.GetFieldValue<T15>(14))), isDeterministic);
		}

		public virtual void CreateFunction<TState, TResult>(string name, TState state, Func<TState, object?[], TResult>? function, bool isDeterministic = false)
		{
			Func<TState, object[], TResult> function2 = function;
			CreateFunctionCore(name, -1, state, IfNotNull(function2, (TState s, SqliteValueReader r) => function2(s, GetValues(r))), isDeterministic);
		}

		static SqliteConnection()
		{
			_fromClosedToOpenEventArgs = new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open);
			_fromOpenToClosedEventArgs = new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed);
			Type.GetType("SQLitePCL.Batteries_V2, SQLitePCLRaw.batteries_v2")?.GetRuntimeMethod("Init", Type.EmptyTypes)?.Invoke(null, null);
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				return;
			}
			Type type = null;
			Type type2 = null;
			try
			{
				type = Type.GetType("Windows.Storage.ApplicationData, Windows, ContentType=WindowsRuntime") ?? Type.GetType("Windows.Storage.ApplicationData, Microsoft.Windows.SDK.NET");
				type2 = Type.GetType("Windows.Storage.StorageFolder, Windows, ContentType=WindowsRuntime") ?? Type.GetType("Windows.Storage.StorageFolder, Microsoft.Windows.SDK.NET");
			}
			catch
			{
			}
			object obj2 = null;
			try
			{
				obj2 = type?.GetRuntimeProperty("Current")?.GetValue(null);
			}
			catch (TargetInvocationException)
			{
			}
			if (obj2 != null)
			{
				object obj3 = type?.GetRuntimeProperty("LocalFolder")?.GetValue(obj2);
				string text = (string)type2?.GetRuntimeProperty("Path")?.GetValue(obj3);
				if (text != null)
				{
					raw.sqlite3_win32_set_directory(1, text);
				}
				object obj4 = type?.GetRuntimeProperty("TemporaryFolder")?.GetValue(obj2);
				string text2 = (string)type2?.GetRuntimeProperty("Path")?.GetValue(obj4);
				if (text2 != null)
				{
					raw.sqlite3_win32_set_directory(2, text2);
				}
			}
		}

		public SqliteConnection()
			: this(null)
		{
		}

		public SqliteConnection(string? connectionString)
		{
			ConnectionString = connectionString;
		}

		public static void ClearAllPools()
		{
			SqliteConnectionFactory.Instance.ClearPools();
		}

		public static void ClearPool(SqliteConnection connection)
		{
			connection.PoolGroup.Clear();
		}

		public override void Open()
		{
			if (State == ConnectionState.Open)
			{
				return;
			}
			_innerConnection = SqliteConnectionFactory.Instance.GetConnection(this);
			_state = ConnectionState.Open;
			try
			{
				if (ConnectionOptions.ForeignKeys.HasValue)
				{
					this.ExecuteNonQuery("PRAGMA foreign_keys = " + (ConnectionOptions.ForeignKeys.Value ? "1" : "0") + ";");
				}
				if (ConnectionOptions.RecursiveTriggers)
				{
					this.ExecuteNonQuery("PRAGMA recursive_triggers = 1;");
				}
				if (_collations != null)
				{
					foreach (KeyValuePair<string, (object, strdelegate_collation)> collation in _collations)
					{
						SqliteException.ThrowExceptionForRC(raw.sqlite3_create_collation(Handle, collation.Key, collation.Value.Item1, collation.Value.Item2), Handle);
					}
				}
				if (_functions != null)
				{
					foreach (KeyValuePair<(string, int), (int, object, delegate_function_scalar)> function in _functions)
					{
						SqliteException.ThrowExceptionForRC(raw.sqlite3_create_function(Handle, function.Key.Item1, function.Key.Item2, function.Value.Item2, function.Value.Item3), Handle);
					}
				}
				if (_aggregates != null)
				{
					foreach (KeyValuePair<(string, int), (int, object, delegate_function_aggregate_step, delegate_function_aggregate_final)> aggregate in _aggregates)
					{
						SqliteException.ThrowExceptionForRC(raw.sqlite3_create_function(Handle, aggregate.Key.Item1, aggregate.Key.Item2, aggregate.Value.Item2, aggregate.Value.Item3, aggregate.Value.Item4), Handle);
					}
				}
				if (_extensions != null && _extensions.Count != 0)
				{
					int num = default(int);
					SqliteException.ThrowExceptionForRC(raw.sqlite3_db_config(Handle, 1005, 1, ref num), Handle);
					foreach (var extension in _extensions)
					{
						LoadExtensionCore(extension.file, extension.proc);
					}
				}
				if (_extensionsEnabled)
				{
					SqliteException.ThrowExceptionForRC(raw.sqlite3_enable_load_extension(Handle, _extensionsEnabled ? 1 : 0), Handle);
				}
			}
			catch
			{
				_innerConnection.Close();
				_innerConnection = null;
				_state = ConnectionState.Closed;
				throw;
			}
			OnStateChange(_fromClosedToOpenEventArgs);
		}

		public override void Close()
		{
			if (State != ConnectionState.Open)
			{
				return;
			}
			Transaction?.Dispose();
			List<WeakReference<SqliteCommand>> commands = _commands;
			for (int num = commands.Count - 1; num >= 0; num--)
			{
				if (commands[num].TryGetTarget(out var target))
				{
					target.Dispose();
				}
			}
			_commands.Clear();
			_innerConnection.Close();
			_innerConnection = null;
			_state = ConnectionState.Closed;
			OnStateChange(_fromOpenToClosedEventArgs);
		}

		internal void Deactivate()
		{
			if (_collations != null)
			{
				foreach (string key in _collations.Keys)
				{
					SqliteException.ThrowExceptionForRC(raw.sqlite3_create_collation(Handle, key, (object)null, (strdelegate_collation)null), Handle);
				}
			}
			if (_functions != null)
			{
				foreach (var (text, num) in _functions.Keys)
				{
					SqliteException.ThrowExceptionForRC(raw.sqlite3_create_function(Handle, text, num, (object)null, (delegate_function_scalar)null), Handle);
				}
			}
			if (_aggregates != null)
			{
				foreach (var (text2, num2) in _aggregates.Keys)
				{
					SqliteException.ThrowExceptionForRC(raw.sqlite3_create_function(Handle, text2, num2, (object)null, (delegate_function_aggregate_step)null, (delegate_function_aggregate_final)null), Handle);
				}
			}
			if (_extensionsEnabled)
			{
				SqliteException.ThrowExceptionForRC(raw.sqlite3_enable_load_extension(Handle, 0), Handle);
			}
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				Close();
			}
			base.Dispose(disposing);
		}

		public new virtual SqliteCommand CreateCommand()
		{
			return new SqliteCommand
			{
				Connection = this,
				CommandTimeout = DefaultTimeout,
				Transaction = Transaction
			};
		}

		protected override DbCommand CreateDbCommand()
		{
			return CreateCommand();
		}

		internal void AddCommand(SqliteCommand command)
		{
			_commands.Add(new WeakReference<SqliteCommand>(command));
		}

		internal void RemoveCommand(SqliteCommand command)
		{
			for (int num = _commands.Count - 1; num >= 0; num--)
			{
				WeakReference<SqliteCommand> weakReference = _commands[num];
				if (weakReference != null && weakReference.TryGetTarget(out var target) && target == command)
				{
					_commands.RemoveAt(num);
				}
			}
		}

		public virtual void CreateCollation(string name, Comparison<string>? comparison)
		{
			Comparison<string> comparison2 = comparison;
			CreateCollation(name, null, (comparison2 != null) ? ((Func<object, string, string, int>)((object _, string s1, string s2) => comparison2(s1, s2))) : null);
		}

		public virtual void CreateCollation<T>(string name, T state, Func<T, string, string, int>? comparison)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Func<T, string, string, int> comparison2 = comparison;
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			strdelegate_collation val = ((comparison2 == null) ? ((strdelegate_collation)null) : ((strdelegate_collation)((object v, string s1, string s2) => comparison2((T)v, s1, s2))));
			if (State == ConnectionState.Open)
			{
				SqliteException.ThrowExceptionForRC(raw.sqlite3_create_collation(Handle, name, (object)state, val), Handle);
			}
			if (_collations == null)
			{
				_collations = new Dictionary<string, (object, strdelegate_collation)>(StringComparer.OrdinalIgnoreCase);
			}
			_collations[name] = (state, val);
		}

		public new virtual SqliteTransaction BeginTransaction()
		{
			return BeginTransaction(IsolationLevel.Unspecified);
		}

		public virtual SqliteTransaction BeginTransaction(bool deferred)
		{
			return BeginTransaction(IsolationLevel.Unspecified, deferred);
		}

		protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel)
		{
			return BeginTransaction(isolationLevel);
		}

		public new virtual SqliteTransaction BeginTransaction(IsolationLevel isolationLevel)
		{
			return BeginTransaction(isolationLevel, isolationLevel == IsolationLevel.ReadUncommitted);
		}

		public virtual SqliteTransaction BeginTransaction(IsolationLevel isolationLevel, bool deferred)
		{
			if (State != ConnectionState.Open)
			{
				throw new InvalidOperationException(Resources.CallRequiresOpenConnection("BeginTransaction"));
			}
			if (Transaction != null)
			{
				throw new InvalidOperationException(Resources.ParallelTransactionsNotSupported);
			}
			return Transaction = new SqliteTransaction(this, isolationLevel, deferred);
		}

		public override void ChangeDatabase(string databaseName)
		{
			throw new NotSupportedException();
		}

		public virtual void EnableExtensions(bool enable = true)
		{
			if (State == ConnectionState.Open)
			{
				SqliteException.ThrowExceptionForRC(raw.sqlite3_enable_load_extension(Handle, enable ? 1 : 0), Handle);
			}
			_extensionsEnabled = enable;
		}

		public virtual void LoadExtension(string file, string? proc = null)
		{
			if (State == ConnectionState.Open)
			{
				if (!_extensionsEnabled)
				{
					int num = default(int);
					SqliteException.ThrowExceptionForRC(raw.sqlite3_db_config(Handle, 1005, 1, ref num), Handle);
				}
				LoadExtensionCore(file, proc);
			}
			if (_extensions == null)
			{
				_extensions = new HashSet<(string, string)>();
			}
			_extensions.Add((file, proc));
		}

		private void LoadExtensionCore(string file, string proc)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			SqliteException ex = null;
			utf8z val = default(utf8z);
			foreach (string loadExtensionPath in GetLoadExtensionPaths(file))
			{
				int num = raw.sqlite3_load_extension(Handle, utf8z.FromString(loadExtensionPath), utf8z.FromString(proc), ref val);
				if (num == 0)
				{
					return;
				}
				if (ex == null)
				{
					ex = new SqliteException(Resources.SqliteNativeError(num, ((utf8z)(ref val)).utf8_to_string()), num, num);
				}
			}
			if (ex != null