static PreKeyring() { try { log.Debug("Opening SQL connection..."); PreKeyring.conn = new SqliteConnection(); SqliteConnectionStringBuilder connStr = new SqliteConnectionStringBuilder(); connStr.DataSource = Config.PrekeyringFile_Path; //connStr.Password = Config.PrekeyringFile_Password; PreKeyring.conn.ConnectionString = connStr.ToString(); connectString = connStr.ToString(); if ( Directory.Exists( Config.PrekeyringFile_Dir ) == false ) Directory.CreateDirectory( Config.PrekeyringFile_Dir ); if ( File.Exists( Config.PrekeyringFile_Path ) == false ) { SqliteConnection.CreateFile( Config.PrekeyringFile_Path ); CreateTablesByStructures( PreKeyring.TableName ); } conn.Open(); } catch ( SqliteException ex ) { SecuruStikException sex = new SecuruStikException( SecuruStikExceptionType.Init_Database,"SQLite - Create/Connect Failed." , ex ); throw sex; } finally { PreKeyring.conn.Close(); } }
public void Open(string filePath) { if (_command != null) _command.Dispose(); if (_conn != null) _conn.Close(); try { ConnectionStringBuilder connstr = new ConnectionStringBuilder(); _conn = new Connection(); connstr.DataSource = (filePath.EndsWith("/") || filePath.EndsWith("\\")) ? filePath + "sys.db" : filePath + "/sys.db"; _conn.ConnectionString = connstr.ToString(); _conn.Open(); _command = new Command(_conn); _command.CommandText = "SELECT Content FROM [Text] WHERE [Name]=:name AND [Language]=:language"; _command.Parameters.Add(new Parameter(":name", DbType.Binary)); _command.Parameters.Add(new Parameter(":language", DbType.Binary)); } catch { if (_command != null) _command.Dispose(); if (_conn != null) _conn.Dispose(); _command = null; _conn = null; throw new DatabaseException("Cannot Open System Database"); } }
public void TestGetColumnInfoFromMeta() { String path = Environment.CurrentDirectory + string.Format ("{0}Resources{0}test.db", Path.DirectorySeparatorChar); SqliteConnectionStringBuilder constrBuilder = new SqliteConnectionStringBuilder (); constrBuilder.DataSource = path; IDbServerConnection serverCon = new SqliteDbServerConnection ("test.db", constrBuilder.ConnectionString); var con = serverCon.CreateConnection (); List<ColumnInfo> colInfos; try { con.Open(); using (IDbCommand cmd = con.CreateCommand ()) { cmd.CommandText = "select * from testtable"; using (var reader = cmd.ExecuteReader ()) { colInfos = serverCon.GetColumnInfosFromMeta( reader.GetSchemaTable () ); } } } finally { if (con.State == ConnectionState.Open) con.Close (); } Assert.Greater (colInfos.Count, 1); }
protected SqlHelper(String tableName) { Directory.CreateDirectory(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "SolderHelper")); String databaseName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "SolderHelper", "SolderHelper.db"); try { if (!File.Exists(databaseName)) { if (IsUnix()) { SqliteConnection.CreateFile(databaseName); } else { SQLiteConnection.CreateFile(databaseName); } } } catch (Exception) { // ignored } if (IsUnix()) { SqliteConnectionStringBuilder c = new SqliteConnectionStringBuilder { DataSource = databaseName }; ConnectionString = c.ConnectionString; } else { SQLiteConnectionStringBuilder c = new SQLiteConnectionStringBuilder { DataSource = databaseName }; ConnectionString = c.ConnectionString; } TableName = tableName; }
public void TestSqliteStatePersistanceProvider() { IDbServerConnection session = new SqliteDbServerConnection ("testdb", "someconnectionstring"); SqliteStatePersistanceProvider prov = new SqliteStatePersistanceProvider (); SqliteConnectionStringBuilder conStrBuilder = new SqliteConnectionStringBuilder (); conStrBuilder.DataSource = ":memory:"; using (SqliteConnection con = new SqliteConnection (conStrBuilder.ConnectionString)) { con.Open (); // Start calling RestoreSessions method even though no session is saved. This triggers the initialization logic // in the SqliteStatePersistanceProvider. var providersShouldBeEmpty = prov.RestoreSessions (con); Assert.AreEqual (0, providersShouldBeEmpty.Length); // Save session prov.SaveSessions (new IDbServerConnection[] { session }, con); // restore saved session IDbServerConnection[] restoredSessions = prov.RestoreSessions (con); Assert.AreEqual (1, restoredSessions.Length); Assert.AreEqual (session, restoredSessions [0]); } }
static SQLiteLinker() { SqliteConnectionStringBuilder connectionBuilder = new SqliteConnectionStringBuilder(); connectionBuilder.JournalMode = SQLiteJournalModeEnum.Persist; connectionBuilder.DataSource = DBEnviroment.DATABASE_FILE_PATH; CONNECTION_STRING = connectionBuilder.ConnectionString; __connection = new SqliteConnection(CONNECTION_STRING); }
public void CollationTest() { var builder = new SqliteConnectionStringBuilder(); builder.DataSource = uri; var connectionString = builder.ToString(); using (var connection = new SqliteConnection (connectionString)) { connection.Open (); connection.Close (); } }
/// <summary> /// 连接SQLITE数据库 /// </summary> public void BeginConnection() { if (m_connection == null) { SqliteConnectionStringBuilder builder = new SqliteConnectionStringBuilder(); builder.DataSource = Application.persistentDataPath + "/" + GetDatabaseName(); Debug.Log(String.Format("Database Path: {0}", builder.DataSource)); m_connection = new SqliteConnection(builder.ConnectionString); m_connection.Open(); } }
public DbUtils.Core.Api.IDbServerConnection[] RestoreSessions() { SqliteConnectionStringBuilder constrBuilder = new SqliteConnectionStringBuilder (); constrBuilder.DataSource = StateDbDataSource; constrBuilder.FailIfMissing = false; using (SqliteConnection connection = new SqliteConnection (constrBuilder.ConnectionString)) { connection.Open (); return this.RestoreSessions (connection); } }
public void TestSqliteSessionStateProvider() { SqliteConnectionStringBuilder conStrBuilder = new SqliteConnectionStringBuilder (); SqliteDbServerConnection serverCon = new SqliteDbServerConnection ("test", conStrBuilder.ConnectionString); ISessionStateProvider sessionStateProvider = new SqliteSessionStateProvider(serverCon); String state = sessionStateProvider.getSerializedState (); IDbServerConnection restoredCon = sessionStateProvider.restoreSessionFromState (state); Assert.AreEqual (restoredCon, serverCon); }
void Start() { //SqliteConnectionStringBuilder conn_builder = new SqliteConnectionStringBuilder (); SqliteConnectionStringBuilder conn_build; conn_build = new SqliteConnectionStringBuilder (); conn_build.Version = 3; conn_build.Uri = "file:" + @DatabaseName; connectionString = conn_build.ToString (); //sql_connection = new SqliteConnection ("Uri=file:" + @DatabaseName); //sql_connection = new SqliteConnection (); //sql_connection.ConnectionString = conn_build.ToString (); }
public SqliteMonoSqlDatabaseContext(DataAccessModel model, SqliteSqlDatabaseContextInfo contextInfo, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager) : base(model, contextInfo, sqlDataTypeProvider, sqlQueryFormatterManager) { var connectionStringBuilder = new SqliteConnectionStringBuilder { Enlist = false, DataSource = contextInfo.FileName }; connectionStringBuilder.Add("foreign keys", 1); this.ConnectionString = connectionStringBuilder.ConnectionString; this.ServerConnectionString = this.ConnectionString; this.SchemaManager = new SqliteMonoSqlDatabaseSchemaManager(this); }
/// <summary> /// Initializes a new instance of the <see cref="InMemorySQLiteDatabase"/> class. /// </summary> public InMemorySQLiteDatabase() { var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = ":memory:", Version = 3, DefaultTimeout = 5, JournalMode = SQLiteJournalModeEnum.Off, UseUTF16Encoding = true }; ConnectionString = connectionStringBuilder.ToString(); connectionManager = new SQLiteConnectionManager(connectionStringBuilder.ConnectionString); sharedConnection = new SqliteConnection(connectionStringBuilder.ConnectionString); sharedConnection.Open(); sqlRunner = new AdHocSqlRunner(() => sharedConnection.CreateCommand(), null, () => true); }
/// <summary> /// Initializes a new instance of the <see cref="TemporarySQLiteDatabase"/> class. /// </summary> /// <param name="name">The name.</param> public TemporarySQLiteDatabase(string name) { dataSourcePath = Path.Combine(Environment.CurrentDirectory, name); var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = name, Version = 3, DefaultTimeout = 5, JournalMode = SQLiteJournalModeEnum.Delete, UseUTF16Encoding = true }; sqLiteConnection = new SqliteConnection(connectionStringBuilder.ConnectionString); sqLiteConnection.Open(); sharedConnection = new SharedConnection(sqLiteConnection); sqlRunner = new AdHocSqlRunner(() => sqLiteConnection.CreateCommand(), null, () => true); }
/// <summary> /// 连接数据库,数据库文件在工程目录下 /// </summary> /// <returns>The conn.</returns> /// <param name="dbName">Db name.</param> /// <param name="pwd">Pwd.</param> public static SqliteConnection CreateConn(string datasource, string pwd) { try { //连接数据库 SqliteConnection conn = new SqliteConnection (); SqliteConnectionStringBuilder connstr = new SqliteConnectionStringBuilder (); connstr.DataSource = datasource; if (pwd != null) { connstr.Password = pwd; } conn.ConnectionString = connstr.ToString(); conn.Open (); return conn; } catch (Exception exp) { HttpContext.Current.Response.Write ("===CONN CREATE ERR===\r\n{0}" + exp.ToString ()); return null; } }
private static IDictionary<string, string> GetFromQch(string docsPath) { string dataSource = Path.Combine(docsPath, "qch", "qt.qch"); if (!File.Exists(dataSource)) { return new Dictionary<string, string>(); } SqliteConnectionStringBuilder sqliteConnectionStringBuilder = new SqliteConnectionStringBuilder(); sqliteConnectionStringBuilder.DataSource = dataSource; using (SqliteConnection sqliteConnection = new SqliteConnection(sqliteConnectionStringBuilder.ConnectionString)) { sqliteConnection.Open(); using (SqliteCommand sqliteCommand = new SqliteCommand( "SELECT Name, Data FROM FileNameTable INNER JOIN FileDataTable ON FileNameTable.FileId = FileDataTable.Id " + "WHERE Name LIKE '%.html' " + "ORDER BY Name", sqliteConnection)) { using (SqliteDataReader sqliteDataReader = sqliteCommand.ExecuteReader()) { Dictionary<string, string> documentation = new Dictionary<string, string>(); while (sqliteDataReader.Read()) { byte[] blob = new byte[ushort.MaxValue]; int length = (int) sqliteDataReader.GetBytes(1, 0, blob, 0, blob.Length); using (MemoryStream output = new MemoryStream(length - 4)) { using (ZOutputStream zOutputStream = new ZOutputStream(output)) { zOutputStream.Write(blob, 4, length - 4); zOutputStream.Flush(); documentation.Add(sqliteDataReader.GetString(0), Encoding.UTF8.GetString(output.ToArray()).Replace(@"\", @"\\")); } } } return documentation; } } } }
public IDbServerConnection getConnection(Window parentWindow) { FileChooserDialog chooseFileDialog = new FileChooserDialog ( openNew ? "New SQLite database" : "Open existing SQLite database", parentWindow, openNew ? FileChooserAction.Save : FileChooserAction.Open, "Cancel", ResponseType.Cancel, openNew ? "Create" : "Open", ResponseType.Accept ); try { if (chooseFileDialog.Run () != (int)ResponseType.Accept) return null; SqliteConnectionStringBuilder conStrBuilder = new SqliteConnectionStringBuilder (); conStrBuilder.DataSource = chooseFileDialog.Filename; conStrBuilder.FailIfMissing = !openNew; return new SqliteDbServerConnection (chooseFileDialog.Filename, conStrBuilder.ConnectionString); } finally { chooseFileDialog.Destroy (); } }
static IDbConnection CreateConnection (string fileName) { if (fileName == null) throw new ArgumentNullException ("fileName"); if (fileName.Length == 0) throw new ArgumentException ("The file name cannot be empty.", "fileName"); #if !__MOBILE__ var builder = Activator.CreateInstance (sqliteConnectionStringBuilderClass); sqliteConnectionStringBuilderClass.GetProperty ("DateTimeFormat").SetValue (builder, 0, null); sqliteConnectionStringBuilderClass.GetProperty ("DataSource").SetValue (builder, fileName, null); if (!File.Exists (fileName)) sqliteConnectionClass.GetMethod ("CreateFile").Invoke (null, new [] {fileName}); var connectionString = (string) sqliteConnectionStringBuilderClass.GetProperty ("ConnectionString").GetValue (builder, null); return (IDbConnection) Activator.CreateInstance (sqliteConnectionClass, new [] { connectionString }); #else var builder = new SqliteConnectionStringBuilder (); builder.DateTimeFormat = SQLiteDateFormats.Ticks; builder.DataSource = fileName; if (!File.Exists (fileName)) SqliteConnection.CreateFile (fileName); return new SqliteConnection (builder.ConnectionString); #endif }
public void SaveSessions(DbUtils.Core.Api.IDbServerConnection[] sessions) { SqliteConnectionStringBuilder sbuilder = new SqliteConnectionStringBuilder (); sbuilder.DataSource = StateDbDataSource; using (SqliteConnection con = new SqliteConnection (sbuilder.ConnectionString)) { con.Open (); SaveSessions (sessions, con); } }
public override bool Open (String path) { var connectionString = new SqliteConnectionStringBuilder { DataSource = path, Version = 3, SyncMode = SynchronizationModes.Full }; var result = true; try { shouldCommit = false; Connection = new SqliteConnection (connectionString.ToString ()); Connection.Open(); } catch (Exception ex) { Log.E(Tag, "Error opening the Sqlite connection using connection String: {0}".Fmt(connectionString.ToString()), ex); result = false; } return result; }
/// <summary> /// Connects to db. /// </summary> /// <param name="dbPath">The db path.</param> /// <param name="logger">The logger.</param> /// <returns>Task{IDbConnection}.</returns> /// <exception cref="System.ArgumentNullException">dbPath</exception> public static async Task<IDbConnection> ConnectToDb(string dbPath, ILogger logger) { if (string.IsNullOrEmpty(dbPath)) { throw new ArgumentNullException("dbPath"); } logger.Info("Opening {0}", dbPath); #if __MonoCS__ var connectionstr = new SqliteConnectionStringBuilder { PageSize = 4096, CacheSize = 4096, SyncMode = SynchronizationModes.Normal, DataSource = dbPath, JournalMode = SQLiteJournalModeEnum.Off }; var connection = new SqliteConnection(connectionstr.ConnectionString); #else var connectionstr = new SQLiteConnectionStringBuilder { PageSize = 4096, CacheSize = 4096, SyncMode = SynchronizationModes.Normal, DataSource = dbPath, JournalMode = SQLiteJournalModeEnum.Wal }; var connection = new SQLiteConnection(connectionstr.ConnectionString); #endif await connection.OpenAsync().ConfigureAwait(false); return connection; }
/// <summary> /// Initializes a new instance of the <see cref="MimeKit.Cryptography.X509CertificateDatabase"/> class. /// </summary> /// <param name="fileName">The file name.</param> /// <param name="password">The password.</param> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="fileName"/> is <c>null</c>.</para> /// <para>-or-</para> /// <para><paramref name="password"/> is <c>null</c>.</para> /// </exception> /// <exception cref="System.ArgumentException"> /// The specified file path is empty. /// </exception> /// <exception cref="System.UnauthorizedAccessException"> /// The user does not have access to read the specified file. /// </exception> /// <exception cref="System.IO.IOException"> /// An error occurred reading the file. /// </exception> public X509CertificateDatabase(string fileName, string password) { if (fileName == null) throw new ArgumentNullException ("fileName"); var builder = new SqliteConnectionStringBuilder (); builder.DateTimeFormat = SQLiteDateFormats.Ticks; builder.DataSource = fileName; //builder.Password = password; if (!File.Exists (fileName)) SqliteConnection.CreateFile (fileName); sqlite = new SqliteConnection (builder.ConnectionString); sqlite.Open (); passwd = password.ToCharArray (); CreateCertificatesTable (); CreateCrlsTable (); }
private static IDictionary<string, string> GetFromQch(string docsPath, string module) { var dataSource = Path.Combine(docsPath, string.Format("qt{0}.qch", module.ToLowerInvariant())); if (!File.Exists(dataSource)) { return new Dictionary<string, string>(); } var sqliteConnectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = dataSource }; using (var sqliteConnection = new SqliteConnection(sqliteConnectionStringBuilder.ConnectionString)) { sqliteConnection.Open(); using (var sqliteCommand = new SqliteCommand( "SELECT Name, Data FROM FileNameTable INNER JOIN FileDataTable ON FileNameTable.FileId = FileDataTable.Id " + "WHERE Name LIKE '%.html' " + "ORDER BY Name", sqliteConnection)) { using (var sqliteDataReader = sqliteCommand.ExecuteReader()) { var documentation = new Dictionary<string, string>(); while (sqliteDataReader.Read()) { byte[] blob = new byte[ushort.MaxValue]; var length = (int) sqliteDataReader.GetBytes(1, 0, blob, 0, blob.Length); using (var output = new MemoryStream(length - 4)) { using (var zOutputStream = new ZOutputStream(output)) { zOutputStream.Write(blob, 4, length - 4); zOutputStream.Flush(); documentation.Add(sqliteDataReader.GetString(0), Encoding.UTF8.GetString(output.ToArray())); } } } return documentation; } } } }
static DbConnection CreateConnection (string fileName) { if (fileName == null) throw new ArgumentNullException (nameof (fileName)); if (fileName.Length == 0) throw new ArgumentException ("The file name cannot be empty.", nameof (fileName)); #if !__MOBILE__ var dateTimeFormat = sqliteConnectionStringBuilderClass.GetProperty ("DateTimeFormat"); var builder = Activator.CreateInstance (sqliteConnectionStringBuilderClass); sqliteConnectionStringBuilderClass.GetProperty ("DataSource").SetValue (builder, fileName, null); if (dateTimeFormat != null) dateTimeFormat.SetValue (builder, 0, null); if (!File.Exists (fileName)) { var dir = Path.GetDirectoryName (fileName); if (!string.IsNullOrEmpty (dir) && !Directory.Exists (dir)) Directory.CreateDirectory (dir); File.Create (fileName).Dispose (); } var connectionString = (string) sqliteConnectionStringBuilderClass.GetProperty ("ConnectionString").GetValue (builder, null); return (DbConnection) Activator.CreateInstance (sqliteConnectionClass, new [] { connectionString }); #else var builder = new SqliteConnectionStringBuilder (); builder.DateTimeFormat = SQLiteDateFormats.Ticks; builder.DataSource = fileName; if (!File.Exists (fileName)) { var dir = Path.GetDirectoryName (fileName); if (!string.IsNullOrEmpty (dir) && !Directory.Exists (dir)) Directory.CreateDirectory (dir); SqliteConnection.CreateFile (fileName); } return new SqliteConnection (builder.ConnectionString); #endif }