private static IDbConnection GetDatabaseConnectionSDS(string cs)
{
var rv = new Microsoft.Data.Sqlite.SqliteConnection(cs);
if (rv == null)
{
throw new ArgumentException("no connection");
}
rv.Open();
try {
/* rv.SetChunkSize(GROW_SIZE); */
}
catch (Exception ex) {
LogManager.GetLogger(typeof(Sqlite)).Error(
"Failed to sqlite control", ex);
}
if (clearPool == null)
{
clearPool = conn =>
{
/* SQLiteConnection.ClearPool(
* conn as SqliteConnection); */
};
}
return(rv);
}
static BaseDataSQLite()
{
#if DEBUG
_sqliteFile = Paths.DebugSQLitePath;
#else
_sqliteFile = Paths.ReleaseSQLitePath;
#endif
//_connectionString = String.Format("Data Source=:memory:");
//_connectionString = String.Format("Data Source={0};Version=3;Pooling=True;Max Pool Size=100;Synchronous=Normal;Journal Mode=WAL", _sqliteFile);
_connectionString = String.Format("Data Source={0}", _sqliteFile);
if (!File.Exists(_sqliteFile))
{
if (!File.Exists(Paths.SqlPath))
throw new FileNotFoundException("Cannot find SQL file: " + Paths.SqlPath);
else {
// Generate database
var conn = new SqliteConnection(_connectionString);
conn.Open();
var sql = File.ReadAllText(Paths.SqlPath);
conn.Execute(sql);
conn.Dispose();
}
}
}
private async Task<IEnumerable<IPRangeInfo>> LocateIPv6Async(IPAddress ip)
{
var flatIP = new FlatIPAddress(ip);
using (var connection = new SqliteConnection(_connectionString))
{
connection.Open();
return await connection.ExecuteReaderAsync(dataReader =>
{
return new IPRangeInfo
{
IPRange = new IPRange
{
Start = new FlatIPAddress { Low = (long)dataReader["StartLow"], High = (long)dataReader["StartHigh"] }.ToIPAddress(),
End = new FlatIPAddress { Low = (long)dataReader["EndLow"], High = (long)dataReader["EndHigh"] }.ToIPAddress(),
},
AreaId = Convert.ToInt32(dataReader["AreaId"]),
ProviderId = Convert.ToInt32(dataReader["ProviderId"]),
};
}, @"
SELECT * FROM IPRangeInfos
WHERE (StartHigh < {1} OR (StartHigh = {1} AND StartLow <= {0}))
AND (EndHigh > {1} OR (EndHigh = {1} AND EndLow >= {0}));",
flatIP.Low, flatIP.High);
}
}
internal SqliteTransaction(SqliteConnection connection, IsolationLevel isolationLevel)
{
_connection = connection;
_isolationLevel = isolationLevel;
if (isolationLevel == IsolationLevel.ReadUncommitted)
{
if (connection.ConnectionStringBuilder.CacheMode != CacheMode.Shared)
{
throw new ArgumentException(Strings.FormatInvalidIsolationLevelForUnsharedCache(isolationLevel));
}
connection.ExecuteNonQuery("PRAGMA read_uncommitted = 1;");
}
else if (isolationLevel == IsolationLevel.Serializable)
{
connection.ExecuteNonQuery("PRAGMA read_uncommitted = 0;");
}
else if (isolationLevel != IsolationLevel.Unspecified)
{
throw new ArgumentException(Strings.FormatInvalidIsolationLevel(isolationLevel));
}
// TODO: Register transaction hooks to detect when a user manually completes a transaction created using this API
connection.ExecuteNonQuery("BEGIN;");
}
public void SimpleReader_TypedDictionary()
{
using var sqlite = new Microsoft.Data.Sqlite.SqliteConnection("Data Source=:memory:");
using var conn = new DataConnection(sqlite, new DataSqlDialect());
conn.Open();
assert.Equal(ConnectionState.Open, conn.State);
var parameters = new Dictionary <string, object>()
{
{ "first", "one" },
};
var query = conn.SqlDialect.CreateBuilder();
var reader = conn.ExecuteReader(
query.Append("SELECT @first AS first"), parameters);
bool read = false;
while (reader.Read())
{
var v = reader.GetString("first");
assert.Equal("one", v);
read = true;
}
assert.Ok(read);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual DatabaseModel Create(string connectionString, TableSelectionSet tableSelectionSet)
{
Check.NotEmpty(connectionString, nameof(connectionString));
Check.NotNull(tableSelectionSet, nameof(tableSelectionSet));
ResetState();
using (_connection = new SqliteConnection(connectionString))
{
_connection.Open();
_tableSelectionSet = tableSelectionSet;
string databaseName = null;
try
{
databaseName = Path.GetFileNameWithoutExtension(_connection.DataSource);
}
catch (ArgumentException)
{
// graceful fallback
}
_databaseModel.DatabaseName = !string.IsNullOrEmpty(databaseName)
? databaseName
: _connection.DataSource;
GetTables();
GetColumns();
GetIndexes();
GetForeignKeys();
return _databaseModel;
}
}
private static void AddHistoricMessage(Message message)
{
var sql = string.Format("INSERT INTO {0} (MessageId, MessageType, Topic, Timestamp, HeaderBag, Body) VALUES (@MessageId, @MessageType, @Topic, @Timestamp, @HeaderBag, @Body)", _sqliteTestHelper.TableName_Messages);
var parameters = new[]
{
new SqliteParameter("MessageId", message.Id.ToString()),
new SqliteParameter("MessageType", message.Header.MessageType.ToString()),
new SqliteParameter("Topic", message.Header.Topic),
new SqliteParameter("Timestamp", SqliteType.Text) { Value =message.Header.TimeStamp.ToString("s")},
new SqliteParameter("HeaderBag",SqliteType.Text) { Value = JsonConvert.SerializeObject(message.Header.Bag)},
new SqliteParameter("Body", message.Body.Value),
};
using (var connection = new SqliteConnection(_sqliteTestHelper.ConnectionString))
using (var command = connection.CreateCommand())
{
connection.Open();
command.CommandText = sql;
//command.Parameters.AddRange(parameters); used to work... but can't with current Sqlite lib. Iterator issue
for (var index = 0; index < parameters.Length; index++)
{
command.Parameters.Add(parameters[index]);
}
command.ExecuteNonQuery();
}
}
public void RunSqlite()
{
using (var connection = new SqliteConnection("Data Source=:memory:"))
{
connection.Open();
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "CREATE TABLE Test(Value);";
cmd.ExecuteNonQuery();
cmd.CommandText = "INSERT INTO Test VALUES(1);";
cmd.ExecuteNonQuery();
}
using (var cmd = connection.CreateCommand())
{
cmd.CommandText =
"SELECT [type], [name], [tbl_name], [rootpage], [sql], [rowid] FROM [main].[sqlite_master] WHERE [type] LIKE 'table'";
using (var dr = cmd.ExecuteReader())
{
while (dr.Read())
{
System.Console.WriteLine(dr[2].ToString());
}
}
}
var databaseReader = new DatabaseSchemaReader.DatabaseReader(connection);
var schema = databaseReader.ReadAll();
var tableList = databaseReader.TableList();
var tables = databaseReader.AllTables();
var views = databaseReader.AllViews();
Assert.NotEmpty(tableList);
}
}
public void CreateDatabase()
{
using (Microsoft.Data.Sqlite.SqliteConnection connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString))
{
connection.Open();
}
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = DATABASE_NAME };
var connectionString = connectionStringBuilder.ToString();
var connection = new SqliteConnection(connectionString);
optionsBuilder.UseSqlite(connection);
}
public void Dispose()
{
if (_conn != null)
{
_conn.Dispose();
_conn = null;
}
}
private SqliteTestStore CreateTransient(bool sharedCache)
{
_connection = new SqliteConnection(CreateConnectionString(_name, sharedCache));
_connection.Open();
return this.AsTransient();
}
// This method connects the context with the database
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = "ef6NotesManagerV3.sqlite" };
var connectionString = connectionStringBuilder.ToString();
var connection = new SqliteConnection(connectionString);
optionsBuilder.UseSqlite(connection);
}
private SqliteConnection Open(string connectionString)
{
var connection = new SqliteConnection(connectionString);
connection.Open();
connection.EnableExtensions();
connection.LoadExtension(_spatialiteExtensionName);
return connection;
}
public void Ctor_sets_connection_string()
{
var connectionSring = "Data Source=test.db";
var connection = new SqliteConnection(connectionSring);
Assert.Equal(connectionSring, connection.ConnectionString);
}
public void ServerVersion_returns_value()
{
var connection = new SqliteConnection();
var version = connection.ServerVersion;
Assert.StartsWith("3.", version);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = "WeatherDressing.db" };
var connectionString = connectionStringBuilder.ToString();
var connection = new SqliteConnection(connectionString);
//optionsBuilder.UseSqlite(connection);
}
public InspectionTest()
{
var logConn = new Microsoft.Data.Sqlite.SqliteConnection("Data Source=:memory:");
logConn.Open();
_insp = new JobLogDB(new FMSSettings(), logConn);
_insp.CreateTables(firstSerialOnEmpty: null);
}
public void TestLite()
{
using (SqliteConnection conn = new SqliteConnection(_connectionString))
{
conn.Open();
//var d = conn.Query("SELECT * FROM User;");
}
}
private void ResetState()
{
_connection = null;
_tableSelectionSet = null;
_databaseModel = new DatabaseModel();
_tables = new Dictionary<string, TableModel>(StringComparer.OrdinalIgnoreCase);
_tableColumns = new Dictionary<string, ColumnModel>(StringComparer.OrdinalIgnoreCase);
}
public void Dispose()
{
if (_sqlCon != null)
{
_sqlCon.Dispose();
_sqlConForDelete.Dispose();
_sqlCon = null;
}
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = "MQTTRawData.db" };
var connectionString = connectionStringBuilder.ToString();
var connection = new SqliteConnection(connectionString);
Debug.WriteLine($"Connecting to:{connection.ConnectionString}");
optionsBuilder.UseSqlite(connection);
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connStringBuilder = new SqliteConnectionStringBuilder
{ DataSource = Path.Combine(_appEnv.ApplicationBasePath, _data.Configuration["App:DbFile"]) };
var connString = connStringBuilder.ToString();
var conn = new SqliteConnection(connString);
optionsBuilder.UseSqlite(conn);
}
public void ConnectionString_gets_and_sets_value()
{
var connection = new SqliteConnection();
var connectionSring = "Data Source=test.db";
connection.ConnectionString = connectionSring;
Assert.Equal(connectionSring, connection.ConnectionString);
}
public void ExecuteReader_throws_when_connection_closed()
{
using (var connection = new SqliteConnection("Data Source=:memory:"))
{
var ex = Assert.Throws<InvalidOperationException>(() => connection.CreateCommand().ExecuteReader());
Assert.Equal(Strings.FormatCallRequiresOpenConnection("ExecuteReader"), ex.Message);
}
}
private SqliteTestStore CreateTransient()
{
_connection = new SqliteConnection(CreateConnectionString(_name));
_connection.Open();
_deleteDatabase = true;
return this;
}
private void CreateAndOpenConnection(bool sharedCache = false)
{
_connection = new SqliteConnection(CreateConnectionString(_name, sharedCache));
_connection.Open();
var command = _connection.CreateCommand();
command.CommandText = "PRAGMA foreign_keys=ON;";
command.ExecuteNonQuery();
}
protected override bool CanShowOverlay(string path, FILE_ATTRIBUTE attributes)
{
// Return true if the file is read only, meaning we'll show the overlay.
try
{
string app = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
string dbPath = Path.Combine(app, @"yliyun\db\file_status.db");
using (SqliteConnection conn = new SqliteConnection("Data Source =" + dbPath))
{
string rootDir = @"D:\一粒云盘";
conn.Open();
SqliteCommand cmd1 = new SqliteCommand("SELECT syncRoot FROM yliyun_conf", conn);
SqliteDataReader reader1 = cmd1.ExecuteReader();
if (reader1.Read())
{
rootDir = reader1.GetString(0);
}
if (path.StartsWith(Path.Combine(rootDir, @"个人空间\"))
|| path.StartsWith(Path.Combine(rootDir, @"群组空间\"))
|| path.StartsWith(Path.Combine(rootDir, @"部门空间\"))
|| path.StartsWith(Path.Combine(rootDir, @"共享空间\")))
{
string sql = "SELECT lastModified FROM file_status WHERE filePath = @fp";
SqliteCommand cmd = new SqliteCommand(sql, conn);
cmd.Parameters.AddRange(new[]
{
new SqliteParameter("@fp", path)
});
SqliteDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
return false;
}
else
{
return true;
}
}
else
{
return false;
}
}
}
catch (Exception)
{
return false;
}
}
public void CreateTable()
{
using (Microsoft.Data.Sqlite.SqliteConnection connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString))
{
connection.Open();
SqliteCommand cmd = connection.CreateCommand();
cmd.CommandText = "CREATE TABLE IF NOT EXISTS favorite_beers(name VARCHAR(50))";
cmd.ExecuteNonQuery();
}
}
private SqliteTestStore CreateShared(Action initializeDatabase)
{
CreateShared(typeof(SqliteTestStore).Name + _name, initializeDatabase);
_connection = new SqliteConnection(CreateConnectionString(_name));
_connection.Open();
_transaction = _connection.BeginTransaction();
return this;
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
// Visual Studio 2015 | Use the LocalDb 12 instance created by Visual Studio
//optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=EFGetStarted.ConsoleApp.NewDb;Trusted_Connection=True;");
var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = "test254.sqlite" };
var connectionString = connectionStringBuilder.ToString();
var connection = new SqliteConnection(connectionString);
optionsBuilder.UseSqlite(connection);
}
public override IModel ConstructRelationalModel([NotNull] string connectionString)
{
Check.NotEmpty(connectionString, nameof(connectionString));
var modelBuilder = new ModelBuilder(new ConventionSet());
using (var connection = new SqliteConnection(connectionString))
{
connection.Open();
var tables = new Dictionary<string, string>();
var indexes = new List<SqliteIndexInfo>();
var master = connection.CreateCommand();
master.CommandText = "SELECT type, name, sql, tbl_name FROM sqlite_master";
using (var reader = master.ExecuteReader())
{
while (reader.Read())
{
var type = reader.GetString(0);
var name = reader.GetString(1);
var sql = reader.GetValue(2) as string; // can be null
var tableName = reader.GetString(3);
if (type == "table"
&& name != "sqlite_sequence"
&& _tableSelectionSet.Allows(TableSelection.Any, name))
{
tables.Add(name, sql);
}
else if (type == "index")
{
indexes.Add(new SqliteIndexInfo
{
Name = name,
TableName = tableName,
Sql = sql
});
}
}
}
LoadTablesAndColumns(connection, modelBuilder, tables.Keys);
LoadIndexes(connection, modelBuilder, indexes);
foreach (var item in tables)
{
SqliteDmlParser.ParseTableDefinition(modelBuilder, item.Key, item.Value);
}
AddAlternateKeys(modelBuilder);
LoadForeignKeys(connection, modelBuilder, tables.Keys);
}
return modelBuilder.Model;
}
public void DropTable()
{
using (Microsoft.Data.Sqlite.SqliteConnection connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString))
{
SqliteCommand cmd = connection.CreateCommand();
cmd.CommandText = "DROP TABLE IF EXISTS favorite_beers";
connection.Open();
cmd.ExecuteNonQuery();
}
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var path = FileSystem.Current.LocalStorage.Path;
var connection = new Microsoft.Data.Sqlite.SqliteConnection($"Data Source= {path}/{filename}");
connection.Open();
var command = connection.CreateCommand();
command.CommandText = "PRAGMA key = 'password';";
command.ExecuteNonQuery();
optionsBuilder.UseSqlite(connection);
// optionsBuilder.UseSqlite($"Filename= {path}/{filename}");
base.OnConfiguring(optionsBuilder);
}
public StorageDB(string filepath, PropertyInfo property)
{
_pro = property;
if (System.IO.Directory.Exists(Path.GetDirectoryName(filepath)) == false)
{
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(filepath));
}
_sqlCon = new SQLiteConnection($"Data Source=\"{filepath}\"");
_sqlCon.Open();
FixFileSize();
if (isTableExist("main") == false)
{
CreateTable(_pro.PropertyType);
}
_sqlConForDelete = new SQLiteConnection($"Data Source=\"{filepath}\"");
_sqlConForDelete.Open();
}
public void GetSchemaTable_works()
{
using (var connection = new SqliteConnection("Data Source=:memory:"))
{
connection.Open();
connection.ExecuteNonQuery(
"CREATE TABLE Person (ID INTEGER PRIMARY KEY, FirstName TEXT, LastName TEXT NOT NULL, Code INT UNIQUE);");
connection.ExecuteNonQuery("INSERT INTO Person VALUES(101, 'John', 'Dee', 123);");
connection.ExecuteNonQuery("INSERT INTO Person VALUES(105, 'Jane', 'Doe', 456);");
using (var reader = connection.ExecuteReader("SELECT LastName, ID, Code, ID+1 AS IncID FROM Person;"))
{
var schema = reader.GetSchemaTable();
Assert.True(schema.Columns.Contains("ColumnName"));
Assert.True(schema.Columns.Contains("ColumnOrdinal"));
Assert.True(schema.Columns.Contains("ColumnSize"));
Assert.True(schema.Columns.Contains("NumericPrecision"));
Assert.True(schema.Columns.Contains("NumericScale"));
Assert.True(schema.Columns.Contains("IsUnique"));
Assert.True(schema.Columns.Contains("IsKey"));
Assert.True(schema.Columns.Contains("BaseServerName"));
Assert.True(schema.Columns.Contains("BaseCatalogName"));
Assert.True(schema.Columns.Contains("BaseColumnName"));
Assert.True(schema.Columns.Contains("BaseSchemaName"));
Assert.True(schema.Columns.Contains("BaseTableName"));
Assert.True(schema.Columns.Contains("DataType"));
Assert.True(schema.Columns.Contains("DataTypeName"));
Assert.True(schema.Columns.Contains("AllowDBNull"));
Assert.True(schema.Columns.Contains("IsAliased"));
Assert.True(schema.Columns.Contains("IsExpression"));
Assert.True(schema.Columns.Contains("IsAutoIncrement"));
Assert.True(schema.Columns.Contains("IsLong"));
Assert.Equal(4, schema.Rows.Count);
Assert.Equal("LastName", schema.Rows[0]["ColumnName"]);
Assert.Equal(0, schema.Rows[0]["ColumnOrdinal"]);
Assert.Equal(DBNull.Value, schema.Rows[0]["ColumnSize"]);
Assert.Equal(DBNull.Value, schema.Rows[0]["NumericPrecision"]);
Assert.Equal(DBNull.Value, schema.Rows[0]["NumericScale"]);
Assert.False((bool)schema.Rows[0]["IsUnique"]);
Assert.False((bool)schema.Rows[0]["IsKey"]);
Assert.Equal("", schema.Rows[0]["BaseServerName"]);
Assert.Equal("main", schema.Rows[0]["BaseCatalogName"]);
Assert.Equal("LastName", schema.Rows[0]["BaseColumnName"]);
Assert.Equal(DBNull.Value, schema.Rows[0]["BaseSchemaName"]);
Assert.Equal("Person", schema.Rows[0]["BaseTableName"]);
Assert.Equal(typeof(string), schema.Rows[0]["DataType"]);
Assert.Equal("TEXT", schema.Rows[0]["DataTypeName"]);
Assert.False((bool)schema.Rows[0]["AllowDBNull"]);
Assert.False((bool)schema.Rows[0]["IsAliased"]);
Assert.False((bool)schema.Rows[0]["IsExpression"]);
Assert.False((bool)schema.Rows[0]["IsAutoIncrement"]);
Assert.Equal(DBNull.Value, schema.Rows[0]["IsLong"]);
Assert.Equal("ID", schema.Rows[1]["ColumnName"]);
Assert.Equal(1, schema.Rows[1]["ColumnOrdinal"]);
Assert.Equal(DBNull.Value, schema.Rows[1]["ColumnSize"]);
Assert.Equal(DBNull.Value, schema.Rows[1]["NumericPrecision"]);
Assert.Equal(DBNull.Value, schema.Rows[1]["NumericScale"]);
Assert.False((bool)schema.Rows[1]["IsUnique"]);
Assert.True((bool)schema.Rows[1]["IsKey"]);
Assert.Equal("", schema.Rows[1]["BaseServerName"]);
Assert.Equal("main", schema.Rows[1]["BaseCatalogName"]);
Assert.Equal("ID", schema.Rows[1]["BaseColumnName"]);
Assert.Equal(DBNull.Value, schema.Rows[1]["BaseSchemaName"]);
Assert.Equal("Person", schema.Rows[1]["BaseTableName"]);
Assert.Equal(typeof(long), schema.Rows[1]["DataType"]);
Assert.Equal("INTEGER", schema.Rows[1]["DataTypeName"]);
Assert.True((bool)schema.Rows[1]["AllowDBNull"]);
Assert.False((bool)schema.Rows[1]["IsAliased"]);
Assert.False((bool)schema.Rows[1]["IsExpression"]);
Assert.False((bool)schema.Rows[1]["IsAutoIncrement"]);
Assert.Equal(DBNull.Value, schema.Rows[1]["IsLong"]);
Assert.Equal("Code", schema.Rows[2]["ColumnName"]);
Assert.Equal(2, schema.Rows[2]["ColumnOrdinal"]);
Assert.Equal(DBNull.Value, schema.Rows[2]["ColumnSize"]);
Assert.Equal(DBNull.Value, schema.Rows[2]["NumericPrecision"]);
Assert.Equal(DBNull.Value, schema.Rows[2]["NumericScale"]);
Assert.True((bool)schema.Rows[2]["IsUnique"]);
Assert.False((bool)schema.Rows[2]["IsKey"]);
Assert.Equal("", schema.Rows[2]["BaseServerName"]);
Assert.Equal("main", schema.Rows[2]["BaseCatalogName"]);
Assert.Equal("Code", schema.Rows[2]["BaseColumnName"]);
Assert.Equal(DBNull.Value, schema.Rows[2]["BaseSchemaName"]);
Assert.Equal("Person", schema.Rows[2]["BaseTableName"]);
Assert.Equal(typeof(long), schema.Rows[2]["DataType"]);
Assert.Equal("INT", schema.Rows[2]["DataTypeName"]);
Assert.True((bool)schema.Rows[2]["AllowDBNull"]);
Assert.False((bool)schema.Rows[2]["IsAliased"]);
Assert.False((bool)schema.Rows[2]["IsExpression"]);
Assert.False((bool)schema.Rows[2]["IsAutoIncrement"]);
Assert.Equal(DBNull.Value, schema.Rows[2]["IsLong"]);
Assert.Equal("IncID", schema.Rows[3]["ColumnName"]);
Assert.Equal(3, schema.Rows[3]["ColumnOrdinal"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["ColumnSize"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["NumericPrecision"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["NumericScale"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["IsUnique"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["IsKey"]);
Assert.Equal("", schema.Rows[3]["BaseServerName"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["BaseCatalogName"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["BaseColumnName"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["BaseSchemaName"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["BaseTableName"]);
Assert.Equal(typeof(long), schema.Rows[3]["DataType"]);
Assert.Equal("INTEGER", schema.Rows[3]["DataTypeName"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["AllowDBNull"]);
Assert.True((bool)schema.Rows[3]["IsAliased"]);
Assert.True((bool)schema.Rows[3]["IsExpression"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["IsAutoIncrement"]);
Assert.Equal(DBNull.Value, schema.Rows[3]["IsLong"]);
}
}
}
private void Complete()
{
_connection.Transaction = null;
_connection = null;
_completed = true;
}
//Add-Migration vyzva-sqlite-001 -c NewData.Vyzva57Context_Sqlite
//Update-Database vyzva-sqlite-001 -c NewData.Vyzva57Context_Sqlite
protected override void OnConfiguring(DbContextOptionsBuilder options) {
base.OnConfiguring(options);
var config = ConfigurationManager.ConnectionStrings["Vyzva57-sqlite"];
var conn = new SqliteConnection(config.ConnectionString);
//var conn = new SqliteConnection("Data Source=" + MachinesLow.rootDir + config.ConnectionString);
options.UseSqlite(conn);
}
public void Ctor_throws_when_invalid_isolation_level()
{
using (var connection = new SqliteConnection("Data Source=:memory:"))
{
connection.Open();
var ex = Assert.Throws<ArgumentException>(() => connection.BeginTransaction(IsolationLevel.Snapshot));
Assert.Equal(Strings.FormatInvalidIsolationLevel(IsolationLevel.Snapshot), ex.Message);
}
}
public void ConnectionString_setter_throws_when_open()
{
using (var connection = new SqliteConnection("Data Source=:memory:"))
{
connection.Open();
var ex = Assert.Throws<InvalidOperationException>(() => connection.ConnectionString = "Data Source=test.db");
Assert.Equal(Strings.ConnectionStringRequiresClosedConnection, ex.Message);
}
}
public void Can_add_extension_with_connection_using_generic_options()
{
var optionsBuilder = new EntityOptionsBuilder<DbContext>();
var connection = new SqliteConnection();
optionsBuilder.UseSqlite(connection);
var extension = optionsBuilder.Options.Extensions.OfType<SqliteOptionsExtension>().Single();
Assert.Same(connection, extension.Connection);
Assert.Null(extension.ConnectionString);
}
