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(); } } }
/// <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 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); }
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); } }
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); } }
public void CreateDatabase() { using (Microsoft.Data.Sqlite.SqliteConnection connection = new Microsoft.Data.Sqlite.SqliteConnection(connectionString)) { connection.Open(); } }
private SqliteTestStore CreateTransient(bool sharedCache) { _connection = new SqliteConnection(CreateConnectionString(_name, sharedCache)); _connection.Open(); return this.AsTransient(); }
public InspectionTest() { var logConn = new Microsoft.Data.Sqlite.SqliteConnection("Data Source=:memory:"); logConn.Open(); _insp = new JobLogDB(new FMSSettings(), logConn); _insp.CreateTables(firstSerialOnEmpty: null); }
private SqliteConnection Open(string connectionString) { var connection = new SqliteConnection(connectionString); connection.Open(); connection.EnableExtensions(); connection.LoadExtension(_spatialiteExtensionName); return connection; }
public void TestLite() { using (SqliteConnection conn = new SqliteConnection(_connectionString)) { conn.Open(); //var d = conn.Query("SELECT * FROM User;"); } }
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; } }
private SqliteTestStore CreateShared(Action initializeDatabase) { CreateShared(typeof(SqliteTestStore).Name + _name, initializeDatabase); _connection = new SqliteConnection(CreateConnectionString(_name)); _connection.Open(); _transaction = _connection.BeginTransaction(); return this; }
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 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(); } }
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(); } }
public void Ctor_unsets_read_uncommitted_when_serializable() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); using (connection.BeginTransaction(IsolationLevel.Serializable)) { Assert.Equal(0L, connection.ExecuteScalar<long>("PRAGMA read_uncommitted;")); } } }
public void Ctor_sets_read_uncommitted() { using (var connection = new SqliteConnection("Data Source=:memory:;Cache=Shared")) { connection.Open(); using (connection.BeginTransaction(IsolationLevel.ReadUncommitted)) { Assert.Equal(1L, connection.ExecuteScalar<long>("PRAGMA read_uncommitted;")); } } }
public void DataSource_returns_actual_filename_when_open() { using (var connection = new SqliteConnection("Data Source=test.db")) { connection.Open(); var result = connection.DataSource; Assert.True(Path.IsPathRooted(result)); Assert.Equal("test.db", Path.GetFileName(result)); } }
private SqliteConnection CreateDatabaseWithTable(string dataSourceTestDb, string createTableScript) { _sqlConnection = new SqliteConnection(dataSourceTestDb); _sqlConnection.Open(); using (var command = _sqlConnection.CreateCommand()) { command.CommandText = createTableScript; command.ExecuteNonQuery(); } return _sqlConnection; }
public void IsolationLevel_throws_when_completed() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); var transaction = connection.BeginTransaction(); transaction.Dispose(); var ex = Assert.Throws<InvalidOperationException>(() => transaction.IsolationLevel); Assert.Equal(Strings.TransactionCompleted, ex.Message); } }
public void Ctor_throws_when_invalid_isolation_level_without_cache() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); var ex = Assert.Throws<ArgumentException>(() => connection.BeginTransaction(IsolationLevel.ReadUncommitted)); Assert.Equal(Strings.FormatInvalidIsolationLevelForUnsharedCache(IsolationLevel.ReadUncommitted), ex.Message); } using (var connection = new SqliteConnection("Data Source=:memory:;Cache=Shared")) { connection.Open(); connection.BeginTransaction(IsolationLevel.ReadUncommitted); } }
public void Ctor_sets_values() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var command = new SqliteCommand("SELECT 1;", connection, transaction); Assert.Equal("SELECT 1;", command.CommandText); Assert.Same(connection, command.Connection); Assert.Same(transaction, command.Transaction); } } }
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(); }
protected void Execute(Action<SqliteCommand> action) { try { using (SqliteConnection connection = new SqliteConnection(this.connectionString)) { connection.Open(); using (SqliteCommand command = new SqliteCommand()) { command.Connection = connection; action.Invoke(command); } } } catch (Exception) { throw; } }
public void CharTest2() { using (var connection = new SqliteConnection(@"Data Source=Database\TestData.sqlite")) { connection.Open(); var command = connection.CreateCommand(); command.CommandText = "SELECT @p"; var p = command.CreateParameter(); p.Value = '1'; p.ParameterName = "@p"; command.Parameters.Add(p); var r = command.ExecuteReader(); r.Read(); var value = r.GetValue(0); Assert.AreNotEqual((long)49, value, $"{value.GetType().FullName}"); } }
public void UInt32Test() { using (var connection = new SqliteConnection(@"Data Source=Database\TestData.sqlite")) { connection.Open(); var command = connection.CreateCommand(); command.CommandText = "SELECT @p"; var p = command.CreateParameter(); p.Value = UInt32.MaxValue; p.DbType = System.Data.DbType.UInt32; p.ParameterName = "@p"; command.Parameters.Add(p); var r = command.ExecuteReader(); r.Read(); var value = r.GetValue(0); Assert.AreEqual(UInt32.MaxValue, value, $"{value.GetType().FullName} {value}"); } }
public virtual DatabaseModel Create( [NotNull] string connectionString, [NotNull] 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; GetSqliteMaster(); GetColumns(); GetIndexes(); foreach (var table in _databaseModel.Tables) { SqliteDmlParser.ParseTableDefinition(table, _tableDefinitions[table.Name]); } GetForeignKeys(); return _databaseModel; } }
public void ExecuteReader_throws_when_transaction_mismatched() { using (var connection = new SqliteConnection("Data Source=:memory:")) { var command = connection.CreateCommand(); command.CommandText = "SELECT 1;"; connection.Open(); using (var otherConnection = new SqliteConnection("Data Source=:memory:")) { otherConnection.Open(); using (var transction = otherConnection.BeginTransaction()) { command.Transaction = transction; var ex = Assert.Throws <InvalidOperationException>(() => command.ExecuteReader()); Assert.Equal(Strings.TransactionConnectionMismatch, ex.Message); } } } }
public void NextResult_skips_DML_statements() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); connection.ExecuteNonQuery("CREATE TABLE Test(Value);"); var sql = @" SELECT 1; INSERT INTO Test VALUES(1); SELECT 2;"; using (var reader = connection.ExecuteReader(sql)) { var hasResults = reader.NextResult(); Assert.True(hasResults); var hasData = reader.Read(); Assert.True(hasData); Assert.Equal(2L, reader.GetInt64(0)); } } }
public void ReadUncommitted_allows_dirty_reads() { const string connectionString = "Data Source=read-uncommitted;Mode=Memory;Cache=Shared"; using (var connection1 = new SqliteConnection(connectionString)) using (var connection2 = new SqliteConnection(connectionString)) { connection1.Open(); connection2.Open(); connection1.ExecuteNonQuery("CREATE TABLE Data (Value); INSERT INTO Data VALUES (0);"); using (connection1.BeginTransaction()) using (connection2.BeginTransaction(IsolationLevel.ReadUncommitted)) { connection1.ExecuteNonQuery("UPDATE Data SET Value = 1;"); var value = connection2.ExecuteScalar <long>("SELECT * FROM Data;"); Assert.Equal(1, value); } } }
public void EnsureDatabase() { try { if (sqliteFilePath.Length > 0) { //sqlite will automatically create the db when it tries to connect but the folder must exist string folderPath = Path.GetDirectoryName(sqliteFilePath); if (!Directory.Exists(folderPath)) { Directory.CreateDirectory(folderPath); } if (!File.Exists(sqliteFilePath)) { using (SqliteConnection conn = new SqliteConnection(connectionString)) { conn.Open(); } //this closes it } } } catch (Exception ex) { log.LogError("SqlCe database file is not present, tried to create it but this error occurred.", ex); } }
public void NextResult_works() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); using (var reader = connection.ExecuteReader("SELECT 1; SELECT 2;")) { var hasData = reader.Read(); Assert.True(hasData); Assert.Equal(1L, reader.GetInt64(0)); var hasResults = reader.NextResult(); Assert.True(hasResults); hasData = reader.Read(); Assert.True(hasData); Assert.Equal(2L, reader.GetInt64(0)); hasResults = reader.NextResult(); Assert.False(hasResults); } } }
public void Open_decrypts_lazily_when_no_password() { try { using var connection1 = new SqliteConnection("Data Source=encrypted2.db;Password=password"); connection1.Open(); // NB: The file is only encrypted after writing connection1.ExecuteNonQuery( "CREATE TABLE IF NOT EXISTS data (value); INSERT INTO data (value) VALUES (1);"); using var connection2 = new SqliteConnection("Data Source=encrypted2.db"); connection2.Open(); connection2.ExecuteNonQuery("PRAGMA key = 'password';"); var value = connection2.ExecuteScalar <long>("SELECT value FROM data;"); Assert.Equal(1L, value); } finally { File.Delete("encrypted2.db"); } }
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(Int64), 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(Int64), 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(Int64), 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"]); } } }
public void Open_throws_when_no_connection_string() { var connection = new SqliteConnection(); var ex = Assert.Throws<InvalidOperationException>(() => connection.Open()); Assert.Equal(Strings.OpenRequiresSetConnectionString, ex.Message); }
public void Open_works_when_no_connection_string() { using var connection = new SqliteConnection(); connection.Open(); }
public void Mars_works() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); var command1 = connection.CreateCommand(); command1.CommandText = "SELECT '1A' UNION SELECT '1B';"; using (var reader1 = command1.ExecuteReader()) { reader1.Read(); Assert.Equal("1A", reader1.GetString(0)); var command2 = connection.CreateCommand(); command2.CommandText = "SELECT '2A' UNION SELECT '2B';"; using (var reader2 = command2.ExecuteReader()) { reader2.Read(); Assert.Equal("2A", reader2.GetString(0)); reader1.Read(); Assert.Equal("1B", reader1.GetString(0)); reader2.Read(); Assert.Equal("2B", reader2.GetString(0)); } } } }
public void BeginTransaction_works() { using (var connection = new SqliteConnection("Data Source=:memory:")) { connection.Open(); using (var transaction = connection.BeginTransaction(IsolationLevel.Serializable)) { Assert.NotNull(transaction); Assert.Equal(connection, transaction.Connection); Assert.Equal(IsolationLevel.Serializable, transaction.IsolationLevel); } } }
private void Open_works_when_password_might_be_supported() { using var connection = new SqliteConnection("Data Source=encrypted.db;Password=password"); connection.Open(); }
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 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); } }