public void InitializeTree(dbRoot myMeta, string error)
{
this.MyTree.BeginUpdate();
this.MyTree.Nodes.Clear();
this.myMeta = myMeta;
string nodeText = error == "" ? myMeta.DriverString : error;
TreeNode rootNode = new TreeNode("MyMeta (" + nodeText + ")");
rootNode.Tag = new NodeData(NodeType.MYMETA, myMeta);
rootNode.SelectedImageIndex = rootNode.ImageIndex = 21;
this.MyTree.Nodes.Add(rootNode);
if (error != "")
{
// There's an error when trying to connect, let's bail with the error
// text in the node
rootNode.Expand();
this.MyTree.EndUpdate();
return;
}
// This is true for dbDriver = NONE
if (myMeta.Databases == null)
{
this.MyTree.EndUpdate();
return;
}
try
{
TreeNode databasesNode = new TreeNode("Databases");
databasesNode.Tag = new NodeData(NodeType.DATABASES, myMeta.Databases);
databasesNode.SelectedImageIndex = databasesNode.ImageIndex = 0;
rootNode.Nodes.Add(databasesNode);
foreach (IDatabase database in myMeta.Databases)
{
TreeNode dbNode = new TreeNode(database.Name);
dbNode.Tag = new NodeData(NodeType.DATABASE, database);
dbNode.SelectedImageIndex = dbNode.ImageIndex = 1;
dbNode.Nodes.Add(this.BlankNode);
databasesNode.Nodes.Add(dbNode);
}
rootNode.Expand();
databasesNode.Expand();
this.MyTree.EndUpdate();
}
catch (Exception ex)
{
if (rootNode != null)
{
rootNode.Text = "MyMeta (" + ex.Message + " )";
}
}
}
public static void Test(IMyMetaTestContext criteria)
{
dbRoot root = null;
if (!criteria.HasErrors)
{
root = new dbRoot();
try
{
root.Connect(criteria.ProviderType, criteria.ConnectionString);
root.ShowDefaultDatabaseOnly = true;
criteria.AppendLog("MyMeta dbRoot Connection Successful.");
}
catch (Exception ex)
{
criteria.AppendLog("Error connecting to dbRoot", ex);
}
}
TestDatabases(criteria, root);
TestTables(criteria, root);
TestViews(criteria, root);
TestProcedures(criteria, root);
TestSQL(criteria, root);
}
private void OpenDataLinkDialog(string connection, dbDriver driver, string caption)
{
DataLinksClass dl = new MSDASC.DataLinksClass();
ADODB.Connection conn = new ADODB.ConnectionClass();
conn.ConnectionString = connection;
object objCn = (object)conn;
// dl.PromptNew();
if (dl.PromptEdit(ref objCn))
{
this.Text = "MyMeta Browser " + caption;
string error = "";
try
{
myMeta = new dbRoot();
myMeta.Connect(driver, conn.ConnectionString);
}
catch (Exception ex)
{
error = ex.Message;
}
this.InitializeTree(myMeta, error);
}
}
private void PopulateComboBox(DefaultSettings settings)
{
this.cboxLanguage.Items.Clear();
// Populate the ComboBox
dbRoot myMeta = new dbRoot();
myMeta.LanguageMappingFileName = settings.LanguageMappingFile;
myMeta.Language = settings.Language;
string[] languages = myMeta.GetLanguageMappings(settings.DbDriver);
if (null != languages)
{
for (int i = 0; i < languages.Length; i++)
{
this.cboxLanguage.Items.Add(languages[i]);
}
this.cboxLanguage.SelectedItem = myMeta.Language;
if (this.cboxLanguage.SelectedIndex == -1)
{
// The default doesn't exist, set it to the first in the list
this.cboxLanguage.SelectedIndex = 0;
}
}
}
private void PopulateComboBox(DefaultSettings settings)
{
this.cboxDbTarget.Items.Clear();
// Populate the ComboBox
dbRoot myMeta = new dbRoot();
myMeta.DbTargetMappingFileName = settings.DbTargetMappingFile;
myMeta.DbTarget = settings.DbTarget;
string[] targets = myMeta.GetDbTargetMappings(settings.DbDriver);
if (null != targets)
{
for (int i = 0; i < targets.Length; i++)
{
this.cboxDbTarget.Items.Add(targets[i]);
}
this.cboxDbTarget.SelectedItem = myMeta.DbTarget;
if (this.cboxDbTarget.SelectedIndex == -1)
{
// The default doesn't exist, set it to the first in the list
this.cboxDbTarget.SelectedIndex = 0;
}
}
}
private static void Code1()
{
string basePath = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
dbRoot = new dbRoot();
dbRoot.DbTarget = "SqlClient";
dbRoot.DbTargetMappingFileName = Path.Combine(basePath, @"cfg\DbTargets.xml");
dbRoot.Language = "C#";
dbRoot.LanguageMappingFileName = Path.Combine(basePath, @"cfg\Languages.xml");
//dbRoot.UserMetaDataFileName = @"C:\Program Files\MyGeneration\Settings\UserMetaData.xml";
dbRoot.Connect(dbDriver.SQL,
"Provider=sqloledb;Data Source=(local);Initial Catalog=Northwind;Integrated Security = SSPI; ");
var database = dbRoot.DefaultDatabase;
var sps = database.Procedures.ToList();
var sps1 = sps.FindAll(p => p.Alias.StartsWith("sp"));
var sps2 = sps.FindAll(p => p.Alias.StartsWith("dm_"));
var sps3 = sps.FindAll(p =>
!p.Alias.StartsWith("dm_") && !p.Alias.StartsWith("sp_") && !p.Alias.StartsWith("xp_") &&
!p.Alias.StartsWith("fn_"));
Console.WriteLine(sps.Count);
}
private static void TestSQL(IMyMetaTestContext criteria, dbRoot root)
{
IDbConnection conn = root.PluginSpecificData(root.DriverString, "internalconnection") as IDbConnection;
if (conn != null)
{
IDbCommand cmd = conn.CreateCommand();
cmd.CommandText = "select * from TEST_DATATYPES";
IDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
for (int i = 0; i < reader.FieldCount; i++)
{
try
{
string name = reader.GetName(i);
string dtname = reader.GetDataTypeName(i);
string dtname2 = reader.GetFieldType(i).Name;
criteria.AppendLog(name + "\t=\t" + dtname + "\t=\t" + dtname2);
}
catch { }
}
}
}
}
protected void InitForm(dbRoot myMeta, IZeusInput input)
{
this.myMeta = myMeta;
this.zeusInput = input;
InitializeComponent();
this.GetSetting();
}
virtual public object Reconstitute(string source)
{
string[] items = source.Split(';');
dbRoot myMeta = new dbRoot();
if (items.Length >= 7)
{
// DriverString, ConnectionString
myMeta.Connect(
ReadableDeserialize(items[3]),
ReadableDeserialize(items[0])
);
// DbTargetMappingFileName
myMeta.DbTargetMappingFileName = ReadableDeserialize(items[1]);
// DomainOverride
myMeta.DomainOverride = Convert.ToBoolean(items[2]);
// Language
myMeta.Language = ReadableDeserialize(items[4]);
// LanguageMappingFileName
myMeta.LanguageMappingFileName = ReadableDeserialize(items[5]);
// UserMetaDataFileName
myMeta.UserMetaDataFileName = ReadableDeserialize(items[6]);
}
return(myMeta);
}
public void RefreshConnectionInfo()
{
_dbDriver = null;
_connString = null;
dbRoot mymeta = CurrentDbRoot();
_databaseNames.Clear();
if (mymeta.Databases != null)
{
foreach (IDatabase db in mymeta.Databases)
{
_databaseNames.Add(db.Name);
}
if (mymeta.Databases.Count >= 1)
{
try
{
//show databases dropdown - select current
if (mymeta.DefaultDatabase != null && (string.IsNullOrEmpty(_databaseName)) || (!_databaseNames.Contains(_databaseName)))
{
this._databaseName = mymeta.DefaultDatabase.Name;
}
}
catch (Exception)
{
this._databaseName = mymeta.Databases[0].Name;
}
}
}
}
private void MyMetaPluginUtility_Load(object sender, EventArgs e)
{
//dbRoot root = new dbRoot();
foreach (IMyMetaPlugin plugin in dbRoot.Plugins.Values)
{
IMyMetaPlugin pluginTest = dbRoot.Plugins[plugin.ProviderUniqueKey] as IMyMetaPlugin;
if (pluginTest == plugin)
{
this.comboBoxPlugins.Items.Add(plugin.ProviderUniqueKey);
}
}
dbRoot root = new dbRoot();
foreach (string dbd in Enum.GetNames(typeof(dbDriver)))
{
if (!dbd.Equals("Plugin", StringComparison.CurrentCultureIgnoreCase))
{
this.comboBoxPlugins.Items.Add(dbd.ToUpper());
}
}
if (ConfigFile.Exists)
{
string[] lines = File.ReadAllLines(ConfigFile.FullName);
if (lines.Length > 1)
{
int idx = this.comboBoxPlugins.FindStringExact(lines[0]);
if (idx >= 0)
{
this.comboBoxPlugins.SelectedIndex = idx;
}
this.textBoxConnectionString.Text = lines[1];
}
}
}
//
// static public NpgsqlConnection CreateConnection(MyMeta.dbRoot dbRoot, string database)
// {
// string cnstr = dbRoot.ConnectionString + "Database=" + database + ";";
// NpgsqlConnection cn = new Npgsql.NpgsqlConnection(cnstr);
// return cn;
// }
static public NpgsqlConnection CreateConnection(dbRoot dbRoot, string database)
{
NpgsqlConnection cn = new Npgsql.NpgsqlConnection(dbRoot.ConnectionString);
cn.Open();
cn.ChangeDatabase(database);
return(cn);
}
//
static public SQLiteConnection CreateConnection(dbRoot dbRoot)
{
SQLiteConnection cn = new SQLiteConnection(dbRoot.ConnectionString);
cn.Open();
//cn.ChangeDatabase(database);
return(cn);
}
public List <ITable> GetAllExportTablesOrders()
{
dbRoot db = new dbRoot();
db.Connect(dbDriver.SQL, this.Connstring);
List <ITable> tables = TableGenerationHelper.GetAllExportDataOrderTables(db.DefaultDatabase);
return(tables);
}
static void Main()
{
OMeta = new dbRoot();
//连接到SqlServer数据库，注意必须使用oledb连接字符串
OMeta.Connect(dbDriver.SQL, "Provider=sqloledb;Data Source=(local);Initial Catalog=Northwind;Integrated Security = SSPI; ");
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new frmMain());
}
private void Setup(DefaultSettings settings)
{
string error = string.Empty;
try
{
myMeta = new dbRoot();
this.Text = "MyMeta Browser (" + settings.DbDriver + ")";
if (settings.DbDriver.ToUpper() != "NONE")
{
#if !DEBUG
TestConnectionForm tcf = new TestConnectionForm(settings.DbDriver, settings.ConnectionString, true);
if (isFirstRun)
{
tcf.StartPosition = FormStartPosition.CenterScreen;
isFirstRun = false;
}
tcf.ShowDialog(this.MdiParent);
if (TestConnectionForm.State == ConnectionTestState.Error)
{
if (TestConnectionForm.LastErrorMsg != null)
{
error = TestConnectionForm.LastErrorMsg;
}
else
{
error = "Connection Error...";
}
}
tcf = null;
#endif
}
if (error == string.Empty)
{
myMeta.Connect(settings.DbDriver, settings.ConnectionString);
myMeta.LanguageMappingFileName = settings.LanguageMappingFile;
myMeta.Language = settings.Language;
myMeta.DbTargetMappingFileName = settings.DbTargetMappingFile;
myMeta.DbTarget = settings.DbTarget;
myMeta.UserMetaDataFileName = settings.UserMetaDataFileName;
myMeta.DomainOverride = settings.DomainOverride;
myMeta.ShowSystemData = chkSystem.Checked;
}
}
catch (Exception ex)
{
error = ex.Message;
}
this.InitializeTree(myMeta, error);
}
public static void BindDataBaseToComboBox(dbRoot myMeta, ComboBox cmbSelectDataBase)
{
cmbSelectDataBase.DataSource = myMeta.Databases;
cmbSelectDataBase.DisplayMember = "Name";
if (myMeta.DefaultDatabase != null)
{
cmbSelectDataBase.SelectedIndex =
cmbSelectDataBase.FindStringExact(myMeta.DefaultDatabase.Name);
}
}
public void TestConnection(IHost host)
{
var myMeta = new dbRoot();
if (myMeta.Connect(dbDriver.SQL, ConnectionString))
{
MessageBox.Show("Connection was successful");
}
else
{
MessageBox.Show("Connection failed");
}
}
public OMetaMSSQLTests()
{
string basePath = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
dbRoot = new dbRoot();
dbRoot.DbTarget = "SqlClient";
dbRoot.DbTargetMappingFileName = Path.Combine(basePath, @"cfg\DbTargets.xml");
dbRoot.Language = "C#";
dbRoot.LanguageMappingFileName = Path.Combine(basePath, @"cfg\Languages.xml");
//dbRoot.UserMetaDataFileName = @"C:\Program Files\MyGeneration\Settings\UserMetaData.xml";
dbRoot.Connect(dbDriver.SQL, "Provider=sqloledb;Data Source=(local);Initial Catalog=Northwind;Integrated Security = SSPI; ");
}
override public object Reconstitute(string source)
{
string[] items = source.Split('|');
IDatabase database = null;
if (items.Length >= 2)
{
dbRoot myMeta = base.Reconstitute(items[0]) as dbRoot;
database = myMeta.Databases[ReadableDeserialize(items[1])];
}
return(database);
}
public List <ITable> GetAllTables()
{
dbRoot db = new dbRoot();
db.Connect(dbDriver.SQL, this.Connstring);
List <ITable> tables = new List <ITable>();
foreach (ITable table in db.DefaultDatabase.Tables)
{
tables.Add(table);
}
return(tables);
}
private void PopulateConnectionSettings()
{
_myMeta = new dbRoot();
_myMeta.ShowDefaultDatabaseOnly = DefaultSettings.Instance.ShowDefaultDatabaseOnly;
_myMeta.LanguageMappingFileName = DefaultSettings.Instance.LanguageMappingFile;
_myMeta.DbTargetMappingFileName = DefaultSettings.Instance.DbTargetMappingFile;
ReloadSavedDbConnections();
PopulateConnectionStringSettings();
PopulateDbTargetSettings();
PopulateLanguageSettings();
DbUserMetaMappingsTextBox.Text = DefaultSettings.Instance.DatabaseUserDataXmlMappingsString;
UserMetaDataFileTextBox.Text = DefaultSettings.Instance.UserMetaDataFileName;
}
public UIGenerationForm(dbRoot myMeta, IZeusInput zeusInput)
{
this.myMeta = myMeta;
this.zeusInput = zeusInput;
InitializeComponent();
UICodeGenerationConfig cg = this.Uiconfig;
ArrayList al = new ArrayList();
foreach (InputUIControl inputUIControl in cg.UIControlConfigs)
{
al.Add(inputUIControl.Name);
}
this.colInputType.Items.AddRange(al.ToArray());
this.GetSetting();
}
private void tsbAddDataBase_Click(object sender, EventArgs e)
{
DataBaseItem dataBase = new DataBaseItem();
dataBase.Name = "1";
dataBase.Connstring = "Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;User ID=sa;Initial Catalog=BackhaulDB;Data Source=192.168.1.8";
dbRoot db = new dbRoot();
db.Connect(dbDriver.SQL, dataBase.Connstring);
dataBase.DefaultDatabaseName = db.DefaultDatabase.Name;
DatabaseAccess.Repository.Add(dataBase);
RefreshDbTreeView();
}
public IDbConnection OpenConnection(string database)
{
//dbRoot mymeta = new dbRoot();
dbRoot mymeta = CurrentDbRoot();
IDbConnection _connection = null;
try
{
// special code to handle databases that cannot have multiple open connections.
object v = mymeta.PluginSpecificData(DbDriver, "requiresinternalconnection");
if (v != null && v.GetType() == typeof(bool))
{
if ((bool)v)
{
_connection = mymeta.PluginSpecificData(DbDriver, "internalconnection") as IDbConnection;
}
}
// The standard connection code.
if (_connection == null)
{
_connection = mymeta.BuildConnection(DbDriver, ConnectionString);
}
if (_connection != null)
{
if (_connection.State != ConnectionState.Open)
{
_connection.Open();
}
if (!string.IsNullOrEmpty(database))
{
mymeta.ChangeDatabase(_connection, database);
}
}
}
catch (Exception ex)
{
this._mdi.ErrorList.AddErrors(ex);
}
return(_connection);
}
private void _ProcessMyMeta()
{
if (_argmgr.MergeMetaFiles)
{
try
{
dbRoot.MergeUserMetaDataFiles(_argmgr.MetaFile1, _argmgr.MetaDatabase1, _argmgr.MetaFile2, _argmgr.MetaDatabase2, _argmgr.MetaFileMerged);
}
catch (Exception ex)
{
this._log.Write(ex);
this._log.Write("Merge UserMetaData files failed.");
}
}
else
{
IDbConnection connection = null;
try
{
dbRoot mymeta = new dbRoot();
connection = mymeta.BuildConnection(_argmgr.ConnectionType, _argmgr.ConnectionString);
_log.Write("Beginning test for {0}: {1}", connection.GetType().ToString(), _argmgr.ConnectionString);
connection.Open();
connection.Close();
_log.Write("Test Successful");
}
catch (Exception ex)
{
_log.Write("Test Failed");
if (_log != null)
{
_log.Write(ex);
}
_returnValue = -1;
}
if (connection != null)
{
connection.Close();
connection = null;
}
}
}
public static IDatabase CreateDbConnection(IConnectionSettings connectionInfo)
{
dbRoot server = new dbRoot();
if (!server.Connect(connectionInfo.DriverType, connectionInfo.ConnectionString))
{
throw new SqlMigrationException("Could not connect to database server.");
}
IDatabase db = server.Databases[connectionInfo.Database];
if (db == null)
{
throw new SqlMigrationException(
string.Format("Unable to find the database {0} on server.",
connectionInfo.Database));
}
return(db);
}
protected void InitForm(dbRoot myMeta, IZeusInput input)
{
try
{
this.myMeta = myMeta;
zeusInput = input;
InitializeComponent();
GetSetting();
InitInputType();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public dbRoot CurrentDbRoot()
{
dbRoot mymeta = null;
try
{
mymeta = _mdi.PerformMdiFunction(this.Parent as IMyGenContent, "getstaticdbroot") as dbRoot;
_isUsingCurrentConnection = true;
if (!(mymeta is dbRoot))
{
mymeta = new dbRoot();
mymeta.Connect(DbDriver, ConnectionString);
_isUsingCurrentConnection = false;
}
}
catch (Exception ex)
{
this._mdi.ErrorList.AddErrors(ex);
}
return(mymeta);
}
private static void TestDatabases(IMyMetaTestContext criteria, dbRoot root)
{
string garbage;
if (!criteria.HasErrors)
{
try
{
foreach (IDatabase db in root.Databases)
{
garbage = db.Name;
garbage = db.SchemaName;
garbage = db.SchemaOwner;
}
criteria.AppendLog(root.Databases.Count + " databases traversed successfully through MyMeta.");
}
catch (Exception ex)
{
criteria.AppendLog("Error traversing databases through MyMeta", ex);
}
}
}
