{
public override IPooledDbConnection CreateConnection (IConnectionPool pool, DatabaseConnectionSettings settings, out string error)
{
SqlConnectionStringBuilder builder = null;
try {
if (settings.UseConnectionString) {
builder = new SqlConnectionStringBuilder (settings.ConnectionString);
} else {
builder = new SqlConnectionStringBuilder ();
builder.InitialCatalog = settings.Database;
builder.UserID = settings.Username;
builder.Password = settings.Password;
builder.DataSource = String.Concat (settings.Server, ",", settings.Port);
//builder.NetworkLibrary = "DBMSSOCN";
}
builder.Pooling = false;
SqlConnection connection = new SqlConnection (builder.ToString ());
connection.Open ();
error = null;
return new SqlServerPooledDbConnection (pool, connection);
} catch (Exception e) {
error = e.Message;
return null;
}
public static IDbFactory GetDbFactory (DatabaseConnectionSettings settings)
{
if (settings == null)
throw new ArgumentNullException ("settings");
return GetDbFactory (settings.ProviderIdentifier);
}
public static bool DatabaseConnectionContextExist (DatabaseConnectionSettings settings)
{
var existsContext = from c in contexts
where c.ConnectionSettings.Name.ToLower () == settings.Name.ToLower ()
select c;
return existsContext.Count () > 0;
}
public DatabaseConnectionContext (DatabaseConnectionSettings connectionSettings, bool temp)
{
if (connectionSettings == null)
throw new ArgumentNullException ("connectionSettings");
this.connectionSettings = connectionSettings;
this.temp = temp;
}
public DatabaseConnectionSettings GetDefaultConnectionSettings ()
{
DatabaseConnectionSettings settings = new DatabaseConnectionSettings ();
settings.ProviderIdentifier = Identifier;
settings.MaxPoolSize = 5;
return settings;
public DatabaseConnectionSettingsDialog (IDbFactory factory, DatabaseConnectionSettings settings)
: this (factory, true)
{
if (settings == null)
throw new ArgumentNullException ("settings");
settingsWidget.ShowSettings (settings);
settingsWidget.AppendDatabase (settings);
}
public static DatabaseConnectionContext AddDatabaseConnectionContext (DatabaseConnectionSettings settings)
{
if (settings == null)
throw new ArgumentNullException ("settings");
DatabaseConnectionContext context = new DatabaseConnectionContext (settings);
AddDatabaseConnectionContext (context);
return context;
}
private void Initialize (IDbFactory factory)
{
if (DatabaseConnection != null)
DatabaseConnection.ConnectionPool.Close ();
DatabaseConnectionSettings settings = new DatabaseConnectionSettings(connectionWidget.ConnectionSettings);
settings.Database = "mysql";
// Create Context, Pool, Connection
DatabaseConnectionContext ctx = new DatabaseConnectionContext (settings, true);
ctx.ConnectionPool.Initialize ();
this.DatabaseConnection = ctx;
}
public override DatabaseConnectionSettings GetDefaultConnectionSettings ()
{
DatabaseConnectionSettings settings = new DatabaseConnectionSettings ();
settings.ProviderIdentifier = Identifier;
settings.Server = "localhost";
settings.Port = 5432;
settings.Username = "******";
settings.MaxPoolSize = 5;
return settings;
protected override ConnectionSettingsWidget CreateConnectionSettingsWidget (IDbFactory factory)
{
connectionWidget = new SqliteConnectionSettingsWidget (factory);
connectionWidget.ShowSettings (factory.GetDefaultConnectionSettings ());
connectionWidget.EnableOpenButton = true;
connectionWidget.EnableTestButton = false;
DatabaseConnectionSettings settings = new DatabaseConnectionSettings(connectionWidget.ConnectionSettings);
// Set a temp database to avoid exception of the default connection pool.
settings.Database = System.IO.Path.GetTempFileName ();
// Create Context, Pool, Connection
DatabaseConnectionContext ctx = new DatabaseConnectionContext (settings, true);
ctx.ConnectionPool.Initialize ();
this.DatabaseConnection = ctx;
return connectionWidget;
}
public DatabaseConnectionSettings GetDefaultConnectionSettings ()
{
DatabaseConnectionSettings settings = new DatabaseConnectionSettings ();
settings.ProviderIdentifier = Identifier;
settings.Server = "localhost";
settings.Port = 1433;
settings.Username = "******";
settings.MaxPoolSize = 5;
settings.CanUseIntegratedSecurity = true;
int p = (int) Environment.OSVersion.Platform;
if ((p == 4) || (p == 6) || (p == 128))
settings.UseIntegratedSecurity = false;
else
settings.UseIntegratedSecurity = true;
return settings;
public virtual bool CheckConnection (IPooledDbConnection connection, DatabaseConnectionSettings settings)
{
if (connection.IsOpen) {
IDbConnection conn = connection.DbConnection;
if (conn.Database == settings.Database) {
return true;
} else {
try {
conn.ChangeDatabase (settings.Database);
return true;
} catch {
return false;
}
}
}
return false;
}
public DatabaseConnectionSettings (DatabaseConnectionSettings copy)
{
name = copy.Name;
providerIdentifier = copy.ProviderIdentifier;
server = copy.Server;
port = copy.Port;
database = copy.Database;
username = copy.Username;
password = copy.Password;
savePassword = copy.SavePassword;
minPoolSize = copy.MinPoolSize;
maxPoolSize = copy.MaxPoolSize;
useConnectionString = copy.UseConnectionString;
connectionString = copy.ConnectionString;
useIntegratedSecurity = copy.UseIntegratedSecurity;
canUseIntegratedSecurity = copy.canUseIntegratedSecurity;
}
protected virtual void OkClicked (object sender, System.EventArgs e)
{
context = comboConnections.DatabaseConnection;
if (context.IsTemporary) {
//make it a real connection context and fill in the database
context.ConnectionSettings.Database = entryDatabase.Text;
context.ConnectionSettings.Name = entryName.Text;
context.IsTemporary = false;
} else {
//create a copy of the settings and create a new context
DatabaseConnectionSettings settings = new DatabaseConnectionSettings (context.ConnectionSettings);
settings.Database = entryDatabase.Text;
settings.Name = entryName.Text;
context = new DatabaseConnectionContext (settings);
}
Respond (ResponseType.Ok);
Destroy ();
}
public override IPooledDbConnection CreateConnection (IConnectionPool pool, DatabaseConnectionSettings settings, out string error)
{
string connStr = null;
try {
if (settings.UseConnectionString) {
connStr = settings.ConnectionString;
} else {
connStr = String.Concat ("URI=file:", settings.Database);
}
SqliteConnection connection = new SqliteConnection (connStr);
connection.Open ();
error = null;
return new SqlitePooledDbConnection (pool, connection);
} catch (Exception e) {
error = e.Message;
return null;
}
}
{
public override IPooledDbConnection CreateConnection (IConnectionPool pool, DatabaseConnectionSettings settings, out string error)
{
string connStr = null;
try {
if (settings.UseConnectionString) {
connStr = settings.ConnectionString;
} else {
//User ID=root;Password=myPassword;Host=localhost;Port=5432;Database=myDataBase;Pooling=true;Min Pool Size=0;Max Pool Size=100;Connection Lifetime=0;
connStr = String.Format ("User ID={0};Password={1};Host={2};Port={3};Database={4};",
settings.Username, settings.Password, settings.Server, settings.Port, settings.Database);
}
connStr = SetConnectionStringParameter (connStr, String.Empty, "Pooling", "false");
NpgsqlConnection connection = new NpgsqlConnection (connStr);
connection.Open ();
error = null;
return new NpgsqlPooledDbConnection (pool, connection);
} catch (Exception e) {
error = e.Message;
return null;
}
{
public override IPooledDbConnection CreateConnection (IConnectionPool pool, DatabaseConnectionSettings settings, out string error)
{
string connStr = null;
try {
if (settings.UseConnectionString) {
connStr = settings.ConnectionString;
} else {
//"Server=Server;Port=1234;Database=Test;Uid=UserName;Pwd=asdasd;"
//Default port is 3306. Enter value -1 to use a named pipe connection.
connStr = String.Format ("Server={0};Port={1};Database={2};Uid={3};Pwd={4};",
settings.Server, settings.Port, settings.Database, settings.Username, settings.Password);
}
connStr = SetConnectionStringParameter (connStr, String.Empty, "Pooling", "false");
MySqlConnection connection = new MySqlConnection (connStr);
connection.Open ();
error = null;
return new MySqlPooledDbConnection (pool, connection);
} catch (Exception e) {
error = e.Message;
return null;
}
#region IDbLinq implementation
public bool Generate (DatabaseConnectionSettings connection, string outputType, string outputFile, string language,
string style, string defaultNamespace, string entityBase, string entityAttr,
string membersAttr, string generateTypes, string culture, bool generateSchema,
bool generateTimestamp, bool overrideEqualAndHash, bool extractProcedures, bool pluralize)
{
return SqlMetalServices.Generate (Provider, connection, outputType, outputFile, language, style, defaultNamespace,
entityBase, entityAttr, membersAttr, generateTypes, culture, generateSchema,
generateTimestamp, overrideEqualAndHash, extractProcedures, pluralize);
public DatabaseConnectionSettingsDialog (bool isCreateDbMode)
: this (false, isCreateDbMode)
{
settings = new DatabaseConnectionSettings ();
isDefaultSettings = true;
if (!isCreateDbMode) {
storeDatabases.AppendValues (GettextCatalog.GetString ("No databases found!"));
isDatabaseListEmpty = true;
}
}
public DatabaseConnectionSettingsDialog (DatabaseConnectionSettings settings)
: this (true, false)
{
if (settings == null)
throw new ArgumentNullException ("settings");
this.settings = settings;
ShowSettings (settings, true);
storeDatabases.AppendValues (settings.Database);
isDatabaseListEmpty = false;
}
public abstract IPooledDbConnection CreateConnection (IConnectionPool pool, DatabaseConnectionSettings settings, out string error);
protected virtual DatabaseConnectionSettings CreateDatabaseConnectionSettings ()
{
DatabaseConnectionSettings settings = new DatabaseConnectionSettings ();
FillDatabaseConnectionSettings (settings);
return settings;
}
protected virtual void FillDatabaseConnectionSettings (DatabaseConnectionSettings settings)
{
settings.ConnectionString = textConnectionString.Buffer.Text;
settings.UseConnectionString = checkCustom.Active;
settings.MinPoolSize = (int)spinMinPoolSize.Value;
settings.MaxPoolSize = (int)spinMaxPoolSize.Value;
settings.Name = entryName.Text;
settings.Username = entryUsername.Text;
settings.Password = entryPassword.Text;
settings.Server = entryServer.Text;
settings.Port = (int)spinPort.Value;
settings.Database = comboDatabase.Entry.Text;
settings.SavePassword = checkSavePassword.Active;
TreeIter iter;
if (comboProvider.GetActiveIter (out iter)) {
IDbFactory fac = storeProviders.GetValue (iter, 1) as IDbFactory;
settings.ProviderIdentifier = fac.Identifier;
}
}
public SqliteDatabaseConnectionSettingsDialog (IDbFactory factory, DatabaseConnectionSettings settings)
: base (factory, settings)
{
}
public static bool Generate (string provider, DatabaseConnectionSettings connection, string outputType,
string outputFile, string defaultNamespace, string entityBase, string entityAttr,
string membersAttr, string generateTypes, string culture, bool generateSchema,
bool generateTimestamp, bool overrideEqualAndHash, bool extractProcedures,
bool pluralize)
{
return Generate (provider, connection, outputType, outputFile, "", "", defaultNamespace, entityBase, entityAttr,
membersAttr, generateTypes, culture, generateSchema, generateTimestamp, overrideEqualAndHash,
extractProcedures, pluralize);
}
protected virtual void ShowSettings (DatabaseConnectionSettings settings, bool updateProviderCombo)
{
checkCustom.Active = settings.UseConnectionString;
entryName.Text = String.IsNullOrEmpty (settings.Name) ? String.Empty : settings.Name;
entryPassword.Text = String.IsNullOrEmpty (settings.Password) ? String.Empty : settings.Password;
spinPort.Value = settings.Port > 0 ? settings.Port : spinPort.Value;
entryServer.Text = String.IsNullOrEmpty (settings.Server) ? String.Empty : settings.Server;
entryUsername.Text = String.IsNullOrEmpty (settings.Username) ? String.Empty : settings.Username;
textConnectionString.Buffer.Text = String.IsNullOrEmpty (settings.ConnectionString) ? String.Empty : settings.ConnectionString;
comboDatabase.Entry.Text = String.IsNullOrEmpty (settings.Database) ? String.Empty : settings.Database;
spinMinPoolSize.Value = settings.MinPoolSize;
spinMaxPoolSize.Value = settings.MaxPoolSize;
if (updateProviderCombo) {
TreeIter iter;
if (storeProviders.GetIterFirst (out iter)) {
do {
IDbFactory fac = storeProviders.GetValue (iter, 1) as IDbFactory;
if (settings.ProviderIdentifier == fac.Identifier) {
comboProvider.SetActiveIter (iter);
return;
}
} while (storeProviders.IterNext (ref iter));
}
}
}
public static bool Generate (string provider, DatabaseConnectionSettings connection, string outputType,
string outputFile, string language, string outputStyle, string defaultNamespace,
string entityBase, string entityAttr, string membersAttr, string generateTypes,
string culture, bool generateSchema, bool generateTimestamp,
bool overrideEqualAndHash, bool extractProcedures, bool pluralize)
{
StringBuilder parameters = new StringBuilder ();
if (provider.Equals ("sqlite", StringComparison.InvariantCultureIgnoreCase)) {
parameters.AppendFormat ("/provider:{0} ", provider);
parameters.AppendFormat ("/conn:Uri=file:{0} ", connection.Database);
} else {
parameters.AppendFormat ("/server:{0} ", connection.Server);
parameters.AppendFormat ("/provider:{0} ", provider);
parameters.AppendFormat ("/user:{0} ", connection.Username);
parameters.AppendFormat ("/password:{0} ", connection.Password);
parameters.AppendFormat ("/database:{0} ", connection.Database);
}
if (outputType.Equals (AddinCatalog.GetString ("code"), StringComparison.InvariantCultureIgnoreCase)
|| outputType.Equals (AddinCatalog.GetString ("Code & DBML"),
StringComparison.InvariantCultureIgnoreCase)) {
parameters.AppendFormat ("/code:{0} ", outputFile);
parameters.AppendFormat ("/case:{0} ", outputStyle);
parameters.AppendFormat ("/language:{0} ", language.Replace ("#", @"\#"));
}
if (outputType.Equals (AddinCatalog.GetString ("DBML"), StringComparison.InvariantCultureIgnoreCase)
|| outputType.Equals (AddinCatalog.GetString ("Code & DBML"),
StringComparison.InvariantCultureIgnoreCase)) {
string dbmlFile = string.Concat (Path.GetFileNameWithoutExtension (outputFile), ".dbml");
parameters.AppendFormat ("/dbml:{0} ", dbmlFile);
}
if (!string.IsNullOrEmpty (defaultNamespace))
parameters.AppendFormat ("/namespace:{0} ", defaultNamespace);
if (!string.IsNullOrEmpty (entityBase))
parameters.AppendFormat ("/entityBase:{0} ", entityBase);
if (!string.IsNullOrEmpty (entityAttr))
parameters.AppendFormat ("/entityAttributes:{0} ", entityAttr);
if (!string.IsNullOrEmpty (membersAttr))
parameters.AppendFormat ("/memberAttributes:{0} ", membersAttr);
if (!string.IsNullOrEmpty (generateTypes))
parameters.AppendFormat ("/generate-type:{0} ", generateTimestamp);
if (!string.IsNullOrEmpty (culture))
parameters.AppendFormat ("/culture:{0} ", culture);
if (!generateSchema)
parameters.Append ("/schema:false");
if (!generateTimestamp)
parameters.Append ("/generate-timestamps:false");
if (overrideEqualAndHash)
parameters.Append ("/generateEqualsAndHash");
if (extractProcedures)
parameters.Append ("/sprocs");
if (pluralize)
parameters.Append ("/pluralize");
Console.WriteLine (parameters);
ProcessStartInfo info = new ProcessStartInfo (metal, parameters.ToString ());
info.UseShellExecute = false;
info.RedirectStandardError = true;
info.RedirectStandardOutput = true;
StringWriter outWriter = new StringWriter ();
StringWriter errorWriter = new StringWriter ();
MonoDevelop.Core.Execution.ProcessWrapper p = Runtime.ProcessService.StartProcess (info, outWriter, errorWriter, null);
p.WaitForExit ();
if (errorWriter.ToString () != "") {
QueryService.RaiseException ("Cannot create Linq Class",
new SqlMetalExecException (errorWriter.ToString ()));
return false;
}
// Process.Start (metal, parameters.ToString ());
return true;
}
protected virtual void OnOkClicked (object sender, System.EventArgs e)
{
if (!isEditMode)
ConnectionContextService.AddDatabaseConnectionContext (ConnectionSettings);
settings = settingsWidget.ConnectionSettings;
Respond (ResponseType.Ok);
Hide ();
}
public DatabaseConnectionContext (DatabaseConnectionSettings connectionSettings)
: this (connectionSettings, false)
{
}
public static bool Generate(string provider, DatabaseConnectionSettings connection, string outputType,
string outputFile, string language, string outputStyle, string defaultNamespace,
string entityBase, string entityAttr, string membersAttr, string generateTypes,
string culture, bool generateSchema, bool generateTimestamp,
bool overrideEqualAndHash, bool extractProcedures, bool pluralize)
{
StringBuilder parameters = new StringBuilder();
if (provider.Equals("sqlite", StringComparison.InvariantCultureIgnoreCase))
{
parameters.AppendFormat("/provider:{0} ", provider);
parameters.AppendFormat("/conn:Uri=file:{0} ", connection.Database);
}
else
{
parameters.AppendFormat("/server:{0} ", connection.Server);
parameters.AppendFormat("/provider:{0} ", provider);
parameters.AppendFormat("/user:{0} ", connection.Username);
parameters.AppendFormat("/password:{0} ", connection.Password);
parameters.AppendFormat("/database:{0} ", connection.Database);
}
if (outputType.Equals(AddinCatalog.GetString("code"), StringComparison.InvariantCultureIgnoreCase) ||
outputType.Equals(AddinCatalog.GetString("Code & DBML"),
StringComparison.InvariantCultureIgnoreCase))
{
parameters.AppendFormat("/code:{0} ", outputFile);
parameters.AppendFormat("/case:{0} ", outputStyle);
parameters.AppendFormat("/language:{0} ", language.Replace("#", @"\#"));
}
if (outputType.Equals(AddinCatalog.GetString("DBML"), StringComparison.InvariantCultureIgnoreCase) ||
outputType.Equals(AddinCatalog.GetString("Code & DBML"),
StringComparison.InvariantCultureIgnoreCase))
{
string dbmlFile = string.Concat(Path.GetFileNameWithoutExtension(outputFile), ".dbml");
parameters.AppendFormat("/dbml:{0} ", dbmlFile);
}
if (!string.IsNullOrEmpty(defaultNamespace))
{
parameters.AppendFormat("/namespace:{0} ", defaultNamespace);
}
if (!string.IsNullOrEmpty(entityBase))
{
parameters.AppendFormat("/entityBase:{0} ", entityBase);
}
if (!string.IsNullOrEmpty(entityAttr))
{
parameters.AppendFormat("/entityAttributes:{0} ", entityAttr);
}
if (!string.IsNullOrEmpty(membersAttr))
{
parameters.AppendFormat("/memberAttributes:{0} ", membersAttr);
}
if (!string.IsNullOrEmpty(generateTypes))
{
parameters.AppendFormat("/generate-type:{0} ", generateTimestamp);
}
if (!string.IsNullOrEmpty(culture))
{
parameters.AppendFormat("/culture:{0} ", culture);
}
if (!generateSchema)
{
parameters.Append("/schema:false");
}
if (!generateTimestamp)
{
parameters.Append("/generate-timestamps:false");
}
if (overrideEqualAndHash)
{
parameters.Append("/generateEqualsAndHash");
}
if (extractProcedures)
{
parameters.Append("/sprocs");
}
if (pluralize)
{
parameters.Append("/pluralize");
}
Console.WriteLine(parameters);
ProcessStartInfo info = new ProcessStartInfo(metal, parameters.ToString());
info.UseShellExecute = false;
info.RedirectStandardError = true;
info.RedirectStandardOutput = true;
StringWriter outWriter = new StringWriter();
StringWriter errorWriter = new StringWriter();
MonoDevelop.Core.Execution.ProcessWrapper p = Runtime.ProcessService.StartProcess(info, outWriter, errorWriter, null);
p.WaitForExit();
if (errorWriter.ToString() != "")
{
QueryService.RaiseException("Cannot create Linq Class",
new SqlMetalExecException(errorWriter.ToString()));
return(false);
}
// Process.Start (metal, parameters.ToString ());
return(true);
}
public MongoDbDatabaseConnectionSettingsDialog(IDbFactory factory, DatabaseConnectionSettings settings)
: base(factory, settings)
{
}
