public OleDbTabularData(IPhysicalConnection conn, Guid collectionGuid, string collectionName, string dbname)
: base(conn)
{
m_collectionName = collectionName;
m_collectionGuid = collectionGuid;
m_dbname = dbname;
}
public bool Accept(IPhysicalConnection conn, string dbname, NameWithSchema table, string[] columns)
{
var props = new Dictionary <string, string>();
string srv = null;
if (conn != null && conn.StoredConnection != null)
{
srv = conn.StoredConnection.GetDataSource();
}
props["server"] = srv;
props["database"] = dbname;
string schema = null, tbl = null;
if (table != null)
{
schema = table.Schema;
tbl = table.Name;
}
props["dbobjname"] = tbl;
props["dbobjschema"] = schema;
props["columns"] = columns.CreateDelimitedText("|");
return(base.Accept(props));
}
public static void CallChangeConnection(IPhysicalConnection conn)
{
if (ChangeConnection != null)
{
ChangeConnection(conn);
}
}
public static void Close(IPhysicalConnection conn)
{
IAsyncResult res = conn.BeginClose(null);
Async.WaitFor(res);
conn.EndClose(res);
}
private static void Open(IPhysicalConnection conn)
{
IAsyncResult res = conn.BeginOpen(null);
Async.WaitFor(res);
conn.EndOpen(res);
}
public static void SafeReconnect(IPhysicalConnection conn)
{
IAsyncResult res = conn.BeginInvoke((Action)conn.Reconnect, null);
Async.WaitFor(res);
conn.EndInvoke(res);
}
public IPhysicalConnection CloneConnection()
{
IPhysicalConnection conn = m_conn.Clone();
conn.SetOnOpenDatabase(m_dbname);
return(conn);
}
public static ITableStructure CGetStructure(this ITableSource table, PriorityLevel priority, bool behaveAsStack, Action guiCallback)
{
IPhysicalConnection conn = table.Connection;
string key = CGetStructureKey(table);
return((ITableStructure)conn.CacheGet(priority, behaveAsStack, key, () => table.LoadTableStructure(TableStructureMembers.All), guiCallback));
}
public static void CallAddConnection(IPhysicalConnection conn)
{
if (AddConnection != null)
{
AddConnection(conn);
}
}
public static void CallRemoveConnection(IPhysicalConnection conn)
{
if (RemoveConnection != null)
{
RemoveConnection(conn);
}
}
public DataGridWidgetControl(AppPageInstance pagei, DataGridWidget widget)
{
m_widget = widget;
m_pagei = pagei;
m_conn = m_pagei.Database.Connection.Clone();
ReloadData();
}
public static void SetOnOpenDatabase(this IPhysicalConnection conn, ObjectPath objpath)
{
if (objpath != null)
{
conn.SetOnOpenDatabase(objpath.DbName);
}
}
public static bool CStructureAvailable(this ITableSource table)
{
string key = CGetStructureKey(table);
IPhysicalConnection conn = table.Connection;
return(conn.CacheAvailable(key));
}
//public static void ClearCache(this IPhysicalConnection conn)
//{
// lock (conn.CachedData) conn.CachedData.Clear();
//}
public static void SetOnOpenDatabase(this IPhysicalConnection conn, string dbname)
{
if (!String.IsNullOrEmpty(dbname))
{
conn.AfterOpen += ConnTools.ChangeDatabaseCallback(dbname);
}
}
public void CreateNewObject()
{
if (m_conn.DatabaseCaps.ExecuteSql)
{
OpenQueryParameters pars = new OpenQueryParameters();
IPhysicalConnection newconn = GetConnection().Clone();
string dbname = TreeNodeExtension.GetDatabaseName(this);
if (dbname != null)
{
newconn.AfterOpen += ConnTools.ChangeDatabaseCallback(dbname);
}
pars.GenerateSql = delegate(IPhysicalConnection conn)
{
return(m_dbtype.GenerateCreateNew(conn.SystemConnection, TreeNodeExtension.GetAnyObjectPath(this)));
};
pars.HideDesign = true;
pars.ExecutedCallback = this.CompleteRefresh;
MainWindow.Instance.OpenContent(new QueryFrame(newconn, pars));
}
else
{
string sql = m_dbtype.GenerateCreateNew(m_conn.Connection.SystemConnection, TreeNodeExtension.GetAnyObjectPath(this));
var pars = new ObjectEditorPars {
SavedCallback = this.CompleteRefresh
};
var frm = new SpecificObjectFrame(m_conn, m_repr.ObjectType, sql, pars);
MainWindow.Instance.OpenContent(frm);
}
}
public static ITableStructure CPeekStructure(this ITableSource table)
{
IPhysicalConnection conn = table.Connection;
string key = CGetStructureKey(table);
return((ITableStructure)conn.CachePeek(key));
}
public override string CreateText(AppObject appobj, ConnectionPack connpack)
{
ObjectPath objpath = appobj.GetObjectPath();
IDatabaseSource db = appobj.FindDatabaseConnection(connpack);
IPhysicalConnection conn = appobj.FindPhysicalConnection(connpack);
if (conn != null && objpath != null && conn.SystemConnection != null)
{
string text = conn.InvokeR <string>((Func <string>) delegate()
{
conn.SystemConnection.SafeChangeDatabase(objpath);
string sql = GetSelect(objpath);
using (var cmd = conn.SystemConnection.CreateCommand())
{
cmd.CommandText = sql;
using (var reader = cmd.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.Read())
{
return(reader[m_colnumber].SafeToString());
}
}
}
return("");
});
return(text);
}
return("");
}
private void DoOpenWindow()
{
OpenQueryParameters pars = new OpenQueryParameters();
pars.GeneratingSql = true;
var appobj = ContainerInfo.RelatedObject;
IPhysicalConnection newconn = null;
if (ContainerInfo.RelatedConnection != null)
{
newconn = ContainerInfo.RelatedConnection.CreateConnection();
}
if (newconn != null && ContainerInfo.RelatedDatabase != null)
{
newconn.SetOnOpenDatabase(ContainerInfo.RelatedDatabase);
}
pars.GeneratingSql = true;
m_frame = new QueryFrame(newconn, pars);
MainWindow.Instance.OpenContent(m_frame);
MainWindow.Instance.Window.BringToFront();
if (!m_shownGenereratedSql)
{
m_frame.GenerateSqlFinished(m_sqltext);
m_shownGenereratedSql = true;
}
}
public static void RunScript(this IPhysicalConnection conn, Action <ISqlDumper> script, DbTransaction trans, IProgressInfo progress)
{
ConnectionSqlOutputStream sqlo = new ConnectionSqlOutputStream(conn.SystemConnection, trans, conn.Dialect);
ISqlDumper fmt = conn.Dialect.CreateDumper(sqlo, SqlFormatProperties.Default);
fmt.ProgressInfo = progress;
script(fmt);
}
public static void RemoveConnection(IPhysicalConnection conn)
{
lock (Connections)
{
Connections.Remove(conn);
HConnection.CallRemoveConnection(conn);
}
}
public GenericViewAsTableSource(IDatabaseSource database, IPhysicalConnection conn, string dbname, string schema, string viewname)
: base(conn)
{
m_dbname = dbname;
m_viewname = viewname;
m_schema = schema;
m_database = database;
}
public GenericTableSource(IDatabaseSource database, IPhysicalConnection conn, string dbname, string schema, string tblname)
: base(conn)
{
m_dbname = dbname;
m_tblname = tblname;
m_schema = schema;
m_database = database;
}
public static void AddConnection(IPhysicalConnection conn)
{
lock (Connections)
{
Connections.Add(conn);
HConnection.CallAddConnection(conn);
}
}
public IDatabaseSource MergeToConnection(IPhysicalConnection conn)
{
if (conn.GetConnKey() != m_conn.GetConnKey())
{
throw new InternalError("DAE-00193 Cannot merge connections with different groups");
}
return(new DataArchiveReader((DataArchiveConnection)conn));
}
//public void CreateConstraints(IEnumerable<IConstraint> constraints)
//{
// foreach (IConstraint cnt in constraints)
// {
// m_table.Constraints.Add(Constraint.CreateCopy(cnt));
// }
//}
public ITableSource MergeToConnection(IPhysicalConnection conn)
{
if (conn.GetConnKey() != m_conn.GetConnKey())
{
throw new InternalError("DAE-00018 Cannot merge connections with different groups");
}
return(new DataArchiveTable(Database.MergeToConnection(conn), (DataArchiveConnection)conn, m_table));
}
public GenericTabularDataStore(IPhysicalConnection conn, string dbname, string schema, string tblname)
: base(conn)
{
m_dbname = dbname;
m_tblname = tblname;
//m_catalog = catalog;
m_schema = schema;
m_builder = m_conn.DbFactory.CreateCommandBuilder();
}
public virtual void GetPopupMenu(MenuBuilder mb, IPhysicalConnection conn, ObjectPath fullName)
{
var cmd = CreateMenu();
cmd.Connection = conn;
cmd.FullName = fullName;
cmd.Parent = this;
mb.AddObject(cmd);
}
public static void InvokeScript(this IPhysicalConnection conn, Action <ISqlDumper> script, string dbname)
{
conn.Invoke(
(Action) delegate()
{
conn.SystemConnection.SafeChangeDatabase(dbname);
conn.RunScript(script);
});
}
//public static void EnsureValid(this IPhysicalConnection conn)
//{
// if (conn.Dialect != null && conn.SystemConnection != null)
// {
// string ping = conn.Dialect.GeneratePing();
// try
// {
// conn.SystemConnection.ExecuteNonQuery(ping);
// }
// catch
// {
// try
// {
// conn.ReconnectIfBroken();
// }
// }
// }
//}
public static void SafeChangeConnection <T>(ref T m_conn, IPhysicalConnection value)
where T : IPhysicalConnection
{
if (m_conn.GetConnKey() != value.GetConnKey())
{
throw new InternalError("DAE-00011 Invalid connection, connection key differs");
}
m_conn = (T)value;
}
//public static List<NameWithSchema> InvokeLoadFullTableNames(this IPhysicalConnection conn, string dbname)
//{
// DatabaseStructureMembers dbmem = new DatabaseStructureMembers { TableList = true };
// IDatabaseStructure dbs = conn.InvokeLoadStructure(dbname, dbmem);
// return dbs.GetTableNames();
//}
public static IDatabaseStructure InvokeLoadStructure(this IPhysicalConnection conn, string dbname, DatabaseStructureMembers members, IProgressInfo progress)
{
IAsyncResult async = conn.BeginInvoke(
(Func <IDatabaseStructure>) delegate() { return(conn.Dialect.AnalyseDatabase(conn, dbname, members, progress)); },
null);
Async.WaitFor(async);
return((IDatabaseStructure)conn.EndInvoke(async));
}
