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
}
