public static InstanceInfo ResolveInstance(
DbConnectionStringBuilder builder,
bool isOdbc,
QuerySource dbType
)
{
InstanceInfo instance;
if (dbType == QuerySource.SQLite || dbType == QuerySource.NetworkInformation)
{
instance = ResolveNonDatabase(
builder.ConnectionString,
dbType
);
}
else
{
instance = ResolveDatabase(
builder,
dbType,
isOdbc
);
}
return(instance);
}
private static AuthenticationInfo GetAuthentication(
DbConnectionStringBuilder cnnBuilder,
QuerySource sourceType
)
{
switch (sourceType)
{
case QuerySource.MSSQL:
case QuerySource.TDSQL:
return(new AuthenticationInfo
{
IsWindows = ReadBoolProp(cnnBuilder, "Integrated Security"),
Username = ReadProp(cnnBuilder, "uid", "User ID") as string ?? string.Empty,
Password = ReadProp(cnnBuilder, "pwd", "Password") as string ?? string.Empty
});
default:
return(new AuthenticationInfo
{
IsWindows = true,
Username = string.Empty,
Password = string.Empty
});
}
}
private static InstanceInfo ResolveNonDatabase(
string connection,
QuerySource sourceType,
bool isDynamicConnection = false
)
{
InstanceInfo instanceInfo = new InstanceInfo(isDynamicConnection)
{
Instance = connection,
IsEnabled = true,
IsODBC = false,
Name = connection,
Authentication = new AuthenticationInfo
{
IsWindows = false,
Password = string.Empty,
Username = string.Empty
},
DbType = sourceType.ToString()
};
return(instanceInfo);
}
public void VBStringComparison()
{
var parameterExpression = Expression.Parameter(typeof(Cook), "c");
var vbCompareStringExpression =
Expression.Equal(
Expression.Call(
typeof(Operators).GetMethod("CompareString"),
Expression.Constant("string1"),
Expression.MakeMemberAccess(parameterExpression, typeof(Cook).GetProperty("Name")),
Expression.Constant(true)),
Expression.Constant(0));
var query = QuerySource
.Where(Expression.Lambda <Func <Cook, bool> > (vbCompareStringExpression, parameterExpression))
.Select(c => c.Name);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var whereClause = (WhereClause)queryModel.BodyClauses[0];
var expectedExpression = new VBStringComparisonExpression(
Expression.Equal(
Expression.Constant("string1"),
Expression.MakeMemberAccess(new QuerySourceReferenceExpression(queryModel.MainFromClause), typeof(Cook).GetProperty("Name"))),
true);
ExpressionTreeComparer.CheckAreEqualTrees(expectedExpression, whereClause.Predicate);
}
/// <summary>
/// Gets CRUD schema from MySqlReader per particular QuerySource.
/// If source is null then all columns from reader are copied.
/// Note: this code was purposely made provider specific because other providers may treat some nuances differently
/// </summary>
public static Schema GetSchemaFromReader(string name, QuerySource source, MySqlDataReader reader)
{
var table = name;
var fdefs = new List <Schema.FieldDef>();
for (int i = 0; i < reader.FieldCount; i++)
{
var fname = reader.GetName(i);
var ftype = reader.GetFieldType(i);
var def = new Schema.FieldDef(fname, ftype, source != null ? (source.HasPragma ? source.ColumnDefs[fname] : null) : null);
fdefs.Add(def);
}
if (source != null)
{
if (source.HasPragma && source.ModifyTarget.IsNotNullOrWhiteSpace())
{
table = source.ModifyTarget;
}
}
if (table.IsNullOrWhiteSpace())
{
table = Guid.NewGuid().ToString();
}
return(new Schema(table, source != null ? source.ReadOnly : true, fdefs));
}
private static InstanceInfo ResolveDatabase(
DbConnectionStringBuilder cnn,
QuerySource sourceType,
bool isOdbcConnection,
bool isDynamicConnection = false
)
{
AuthenticationInfo authentication = GetAuthentication(cnn, sourceType);
log.InfoFormat("IsWindows:'{0}';Username:'******';Password:'******'",
authentication.IsWindows,
authentication.Username,
authentication.Password
);
string instanceName = ReadProp(cnn, "Dsn", "Data Source") as string;
InstanceInfo instance = new InstanceInfo(isDynamicConnection)
{
Authentication = authentication,
Instance = instanceName,
IsEnabled = true,
Name = instanceName,
IsODBC = isOdbcConnection,
DbType = sourceType.ToString()
};
if (isOdbcConnection)
{
instance.InnerOdbcConnectionString = cnn.ConnectionString;
}
return(instance);
}
private static InstanceInfo ResolveNonDatabase(
string connection,
QuerySource sourceType,
bool isDynamicConnection = false
)
{
InstanceInfo instanceInfo = new InstanceInfo(isDynamicConnection)
{
Instance = connection,
IsEnabled = true,
IsODBC = false,
Name = connection,
Authentication = new AuthenticationInfo
{
IsWindows = false,
Password = string.Empty,
Username = string.Empty
},
DbType = sourceType.ToString()
};
return instanceInfo;
}
private void btnOk_Click(object sender, EventArgs e)
{
if (!ValidateConnections())
{
return;
}
if (this._updatesMade)
{
if (this._connectionGroup.Connections.Any())
{
QuerySource dbType = this._connectionGroup.Connections.First().Type;
List <InstanceInfo> instances = this.lstConnectionStrings.Items
.OfType <InstanceInfo>().Where(i => i.Type == dbType).ToList();
this._connectionGroup.Connections = instances;
foreach (InstanceInfo instanceInfo in instances)
{
instanceInfo.ConnectionGroup = this._connectionGroup;
}
this._connectionsManager.UpdateGroupInstances(
this._connectionGroup, dbType.ToString()
);
}
DialogResult = DialogResult.OK;
}
else
{
DialogResult = DialogResult.Cancel;
}
}
public override IQueryConnection CreateQueryConnection(
QuerySource sourceType,
InstanceInfo instance
)
{
IQueryConnection connection;
lock (this._connectionPoolLock)
{
if (!this._connectionCache.ContainsKey(instance))
{
connection = base.CreateQueryConnection(sourceType, instance);
this._connectionCache.Add(instance, connection);
}
connection = this._connectionCache[instance];
}
if (connection != null)
{
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
return connection;
}
public void GroupJoin_WithoutSelect()
{
var query = QuerySource.GroupJoin(DetailQuerySource, s => s.ID, sd => sd.RoomNumber, (s, sds) => Tuple.Create(s, sds));
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Tuple <Cook, IEnumerable <Kitchen> > >)));
var mainFromClause = queryModel.MainFromClause;
CheckConstantQuerySource(mainFromClause.FromExpression, QuerySource);
Assert.That(mainFromClause.ItemType, Is.SameAs(typeof(Cook)));
Assert.That(mainFromClause.ItemName, Is.EqualTo("s"));
var groupJoinClause = ((GroupJoinClause)queryModel.BodyClauses[0]);
Assert.That(groupJoinClause.ItemName, Is.SameAs("sds"));
Assert.That(groupJoinClause.ItemType, Is.SameAs(typeof(IEnumerable <Kitchen>)));
CheckConstantQuerySource(groupJoinClause.JoinClause.InnerSequence, DetailQuerySource);
Assert.That(groupJoinClause.JoinClause.ItemType, Is.SameAs(typeof(Kitchen)));
Assert.That(groupJoinClause.JoinClause.ItemName, Is.EqualTo("sd"));
CheckResolvedExpression <Cook, int> (groupJoinClause.JoinClause.OuterKeySelector, mainFromClause, s => s.ID);
CheckResolvedExpression <Kitchen, int> (groupJoinClause.JoinClause.InnerKeySelector, groupJoinClause.JoinClause, sd => sd.RoomNumber);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, IEnumerable <Kitchen>, Tuple <Cook, IEnumerable <Kitchen> > > (
selectClause.Selector,
mainFromClause,
groupJoinClause,
(s, sds) => Tuple.Create(s, sds));
}
public override IQueryConnection CreateQueryConnection(
QuerySource sourceType,
InstanceInfo instance
)
{
IQueryConnection connection;
lock (this._connectionPoolLock)
{
if (!this._connectionCache.ContainsKey(instance))
{
connection = base.CreateQueryConnection(sourceType, instance);
this._connectionCache.Add(instance, connection);
}
connection = this._connectionCache[instance];
}
if (connection != null)
{
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
return(connection);
}
protected static DbConnectionStringBuilder GetConnectionStringBuilder(
QuerySource source,
string connectionString,
bool isOdbc
)
{
if (isOdbc)
{
return(new OdbcConnectionStringBuilder(connectionString));
}
DbConnectionStringBuilder builder;
switch (source)
{
case QuerySource.MSSQL:
builder = new SqlConnectionStringBuilder();
break;
case QuerySource.SQLite:
// ODBC connection string builder is used
// for SQLite internal connection
// since it handles special connection string adequately
builder = new OdbcConnectionStringBuilder();
break;
default:
builder = new DbConnectionStringBuilder();
break;
}
builder.ConnectionString = connectionString;
return(builder);
}
private string Process(T state, StringBuilder builder, QuerySource query, string alias)
{
string name;
if (query.TableName != null)
{
EscapeName(builder, query.TableName, true);
name = alias ?? query.TableName;
}
else
{
builder.Append("(");
var subName = Process(state, builder, query.TableQuery);
builder.Append(")");
alias = alias ?? subName;
name = alias;
}
if (!StencilUtils.IsNullOrWhiteSpace(alias))
{
builder.Append(" AS ");
EscapeName(builder, alias, false);
}
return(name);
}
public void Join_WithoutSelect()
{
var query = QuerySource.Join(DetailQuerySource, s => s, sd => sd.Cook, (s, sd) => Tuple.Create(s, sd));
var queryModel = QueryParser.GetParsedQuery(query.Expression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <Tuple <Cook, Kitchen> >)));
var mainFromClause = queryModel.MainFromClause;
CheckConstantQuerySource(mainFromClause.FromExpression, QuerySource);
Assert.That(mainFromClause.ItemType, Is.SameAs(typeof(Cook)));
Assert.That(mainFromClause.ItemName, Is.EqualTo("s"));
var joinClause = (JoinClause)queryModel.BodyClauses[0];
CheckConstantQuerySource(joinClause.InnerSequence, DetailQuerySource);
Assert.That(joinClause.ItemType, Is.SameAs(typeof(Kitchen)));
Assert.That(joinClause.ItemName, Is.EqualTo("sd"));
CheckResolvedExpression <Cook, Cook> (joinClause.OuterKeySelector, mainFromClause, s => s);
CheckResolvedExpression <Kitchen, Cook> (joinClause.InnerKeySelector, joinClause, sd => sd.Cook);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, Kitchen, Tuple <Cook, Kitchen> > (
selectClause.Selector,
mainFromClause,
joinClause,
(s, sd) => Tuple.Create(s, sd));
}
public void DelegateAsSelector()
{
Func <Cook, string> expression = c => c.FirstName;
var query = QuerySource.Select(c => c.Assistants.Select(expression));
QueryParser.GetParsedQuery(query.Expression);
}
public void CovariantSubqueryTest()
{
IQueryable <object> subQueryable = (QuerySource.Select(c => c)).Distinct();
var queryExpression = ExpressionHelper.MakeExpression(() => (
from o in subQueryable
select o));
var queryModel = QueryParser.GetParsedQuery(queryExpression);
Assert.That(queryModel.GetOutputDataInfo().DataType, Is.SameAs(typeof(IQueryable <object>)));
var subQuery = ((SubQueryExpression)queryModel.MainFromClause.FromExpression).QueryModel;
var selectOutputInfo = subQuery.SelectClause.GetOutputDataInfo();
Assert.That(selectOutputInfo.ItemExpression.Type, Is.SameAs(typeof(Cook)));
Assert.That(selectOutputInfo.ResultItemType, Is.SameAs(typeof(Cook)));
Assert.That(selectOutputInfo.DataType, Is.SameAs(typeof(IQueryable <Cook>)));
var distinctOperator = (DistinctResultOperator)subQuery.ResultOperators.Single();
var distinctOperatorOutputInfo = (StreamedSequenceInfo)distinctOperator.GetOutputDataInfo(selectOutputInfo);
Assert.That(distinctOperatorOutputInfo.ItemExpression.Type, Is.SameAs(typeof(Cook)));
Assert.That(distinctOperatorOutputInfo.ResultItemType, Is.SameAs(typeof(Cook)));
Assert.That(distinctOperatorOutputInfo.DataType, Is.SameAs(typeof(IQueryable <Cook>)));
var queryOutputInfo = (StreamedSequenceInfo)subQuery.GetOutputDataInfo();
Assert.That(queryOutputInfo.ItemExpression.Type, Is.SameAs(typeof(Cook)));
Assert.That(queryOutputInfo.ResultItemType, Is.SameAs(typeof(Cook)));
Assert.That(queryOutputInfo.DataType, Is.SameAs(typeof(IQueryable <Cook>)));
}
private QuerySource GetCompanyNotices(int ID, int page)
{
const int PageSize = 15;
QuerySource model = new QuerySource();
var query = CompanyNoticeService.GetALL()
.Where(x => x.MemberID == ID &&
x.Status >= (int)CompanyNoticeStatus.ShowOnLine)
.OrderByDescending(x => x.AddTime)
.Skip((page - 1) * PageSize)
.Take(PageSize)
.ToList().Select(x => new LinkItem()
{
Name = x.Title,
Description = x.Content,
ID = x.ID,
MemberID = x.MemberID,
AddTime = x.AddTime
}).ToList();
int totalCount = CompanyNoticeService.GetALL()
.Count(x => x.MemberID == ID);
model.Items = query;
model.CurrentPage = page;
model.PageSize = PageSize;
model.TotalCount = totalCount;
return(model);
}
public static InstanceInfo ResolveInstance(
DbConnectionStringBuilder builder,
bool isOdbc,
QuerySource dbType
)
{
InstanceInfo instance;
if (dbType == QuerySource.SQLite || dbType == QuerySource.NetworkInformation)
{
instance = ResolveNonDatabase(
builder.ConnectionString,
dbType
);
}
else
{
instance = ResolveDatabase(
builder,
dbType,
isOdbc
);
}
return instance;
}
public QuerySource GetCompanyCredentials(int ID, int page)
{
const int PageSize = 15;
QuerySource model = new QuerySource();
var query = CompanyCredentialsImgService.GetALL()
.Where(x => x.MemberID == ID)
.OrderByDescending(x => x.ID)
.Skip((page - 1) * PageSize)
.Take(PageSize)
.ToList().Select(x => new LinkItem()
{
Name = x.Title,
ID = x.ID,
MemberID = x.MemberID,
FocusImgUrl = x.ImgUrl
}).ToList();
int totalCount = CompanyNoticeService.GetALL()
.Count(x => x.MemberID == ID);
model.Items = query;
model.CurrentPage = page;
model.PageSize = PageSize;
model.TotalCount = totalCount;
return(model);
}
public CountPerzons(MongoDBDataStore store) : base(store, null)
{
m_Source = new QuerySource(GetType().FullName,
@"#pragma
modify=MyPerzon
{'Age': {'$gt': '$$fromAge', '$lt': '$$toAge'}}");
}
public void PRAGMA_2_nonModifiable()
{
var src =
@"#pragma
key=counter,ssn
ignore=marker
load=counter
@last_name=lname
@first_name=fname
.last_name=This is description of last name
select
1 as marker,
t1.counter,
t1.ssn,
t1.lname as last_name,
t1.fname as first_name,
t1.c_doctor,
t2.phone as doctor_phone,
t2.NPI as doctor_id
from
tbl_patient t1
left outer join tbl_doctor t2 on t1.c_doctor = t2.counter
where
t1.lname like ?LN";
var qs = new QuerySource("1", src);
Assert.IsTrue(qs.HasPragma);
Assert.IsTrue(qs.ReadOnly);
Assert.AreEqual(string.Empty, qs.ModifyTarget);
Assert.AreEqual(true, qs.ColumnDefs["counter"].Key);
Assert.AreEqual(true, qs.ColumnDefs["ssn"].Key);
Assert.AreEqual("lname", qs.ColumnDefs["last_name"].BackendName);
Assert.AreEqual("fname", qs.ColumnDefs["first_name"].BackendName);
Assert.AreEqual("This is description of last name", qs.ColumnDefs["last_name"].Description);
Assert.AreEqual(StoreFlag.OnlyLoad, qs.ColumnDefs["counter"].StoreFlag);
Assert.AreEqual(StoreFlag.None, qs.ColumnDefs["marker"].StoreFlag);
Assert.AreEqual(StoreFlag.LoadAndStore, qs.ColumnDefs["ssn"].StoreFlag);
Assert.AreEqual(
@"select
1 as marker,
t1.counter,
t1.ssn,
t1.lname as last_name,
t1.fname as first_name,
t1.c_doctor,
t2.phone as doctor_phone,
t2.NPI as doctor_id
from
tbl_patient t1
left outer join tbl_doctor t2 on t1.c_doctor = t2.counter
where
t1.lname like ?LN
", qs.StatementSource);
}
public static InstanceInfo Create(string connection, QuerySource sourceType, bool isOdbcConnection)
{
if (IsDatabaseSource(sourceType))
{
return CreateDatabaseSelectConnection(connection, sourceType, isOdbcConnection);
}
return CreateNonDatabaseSelectConnection(connection, sourceType);
}
public void InvocationExpression_AppliedToInlineLambdaExpression()
{
var query = QuerySource.Where(c => ((Func <Cook, bool>)(c1 => c1.Name != null))(c)).Select(c => c.FirstName);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var predicate = ((WhereClause)queryModel.BodyClauses[0]).Predicate;
CheckResolvedExpression <Cook, bool> (predicate, queryModel.MainFromClause, c => c.Name != null);
}
/// <summary>
/// Returns a hash code for this object.
/// </summary>
/// <returns>
/// A hash code for this object.
/// </returns>
public override int GetHashCode()
{
unchecked
{
var hashCode = Alias?.GetHashCode() ?? 0;
hashCode = (hashCode * 397) ^ (QuerySource?.GetHashCode() ?? 0);
return(hashCode);
}
}
public Connector.Query MakeQuery(Query query, QuerySource source)
{
var args = query.Select(p =>
{
var elm = Converter.ConvertCLRtoBSON(p.Name, p.Value, Store.TargetName);
return(new TemplateArg(p.Name, elm.ElementType, elm.ObjectValue));
}).ToArray();
return(new Connector.Query(source.StatementSource, true, args));
}
public void Transformation_ViaAttributedInstanceMethod()
{
var query = QuerySource.Select(c => c.GetFullName());
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, string> (selectClause.Selector, queryModel.MainFromClause, c => c.FirstName + " " + c.Name);
}
public void Transformation_ViaAttributedInstanceProperty()
{
var query = QuerySource.Select(c => c.WeightInLbs);
var queryModel = QueryParser.GetParsedQuery(query.Expression);
var selectClause = queryModel.SelectClause;
CheckResolvedExpression <Cook, double> (selectClause.Selector, queryModel.MainFromClause, c => c.Weight * 2.20462262);
}
public void WithoutPRAGMA_1()
{
var src = "abc";
var qs = new QuerySource("1", src);
Assert.IsFalse(qs.HasPragma);
Assert.IsTrue(qs.ReadOnly);
Assert.AreEqual("abc", qs.OriginalSource);
Assert.AreEqual("abc", qs.StatementSource);
}
public Connector.Query MakeQuery(Connector.Database db, Query query, QuerySource source, out Connector.Collection collection)
{
if (source.ModifyTarget.IsNullOrWhiteSpace())
{
throw new MongoDbDataAccessException(StringConsts.QUERY_MODIFY_TARGET_MISSING_ERROR + "\n" + Source.OriginalSource);
}
collection = db[source.ModifyTarget];
return(MakeQuery(query, source));
}
public void CovariantQueryTest()
{
IQueryable <object> queryable = QuerySource.Where(c => c.Name != "john");
var queryExpression = ExpressionHelper.MakeExpression(() => (queryable.Distinct()));
var queryModel = QueryParser.GetParsedQuery(queryExpression);
var outputDataInfo = (StreamedSequenceInfo)queryModel.GetOutputDataInfo();
Assert.That(outputDataInfo.DataType, Is.SameAs(typeof(IQueryable <object>)));
Assert.That(outputDataInfo.ItemExpression.Type, Is.SameAs(typeof(Cook)));
}
private static string Translate(QuerySource source, string queryText, DateTime runTimestamp)
{
var db = new PostgreeSqlDatabase(source.ConnectionString);
var schemeStore = new PostgreeSqlSchemaStore(db);
var translator = new QueryToSqlTranslator(schemeStore, source.Areas)
{
CurrentDate = runTimestamp
};
return(translator.Translate(queryText));
}
private static IEnumerable <QueryInfo> GetQueries(LoaderRootWrapper wrapper, QuerySource querySource)
{
List <QueryInfo> queryInfos = wrapper.GetQueriesOfType(querySource).SelectMany(w => w.Infos).ToList();
queryInfos.ForEach(q =>
{
q.OnDesialized();
q.Source = querySource;
});
return(queryInfos);
}
private static bool IsDatabaseSource(QuerySource sourceType)
{
switch (sourceType)
{
case QuerySource.MSSQL:
case QuerySource.SQLite:
case QuerySource.TDSQL:
return(true);
}
return(false);
}
private static bool IsDatabaseSource(QuerySource sourceType)
{
switch (sourceType)
{
case QuerySource.MSSQL:
case QuerySource.SQLite:
case QuerySource.TDSQL:
return true;
}
return false;
}
public static IConnectionStringDialog CreateDialog(QuerySource querySource, MsSqlAuditorModel model)
{
switch (querySource)
{
case QuerySource.MSSQL:
return new CommonConnectionStringDialog();
case QuerySource.SQLite:
return new InternalSqliteConnectionDialog(model);
case QuerySource.NetworkInformation:
return new NetworkInformationConnectionDialog();
default:
return new NonSqlDataConnectionDialog();
}
}
public static List<InstanceInfo> ResolveInstances(
List<Tuple<DbConnectionStringBuilder, bool>> connectionProperties,
QuerySource dbType
)
{
List<InstanceInfo> instances = new List<InstanceInfo>();
foreach (Tuple<DbConnectionStringBuilder, bool> properties in connectionProperties)
{
DbConnectionStringBuilder cnn = properties.Item1;
bool isOdbc = properties.Item2;
InstanceInfo instance = ResolveInstance(cnn, isOdbc, dbType);
instances.Add(instance);
}
return instances;
}
private static InstanceInfo CreateNonDatabaseSelectConnection(string connection, QuerySource sourceType)
{
var instanceInfo = new InstanceInfo(true)
{
Instance = connection,
IsEnabled = true,
IsODBC = false,
Name = connection,
Authentication = new AuthenticationInfo
{
IsWindows = false,
Password = string.Empty,
Username = string.Empty
},
DbType = sourceType.ToString()
};
return instanceInfo;
}
/// <summary>
/// The create trial connection group.
/// </summary>
/// <param name="propertiesList">The properties list.</param>
/// <param name="templateFile">Path to temlate file</param>
/// <param name="dbType">Type DB</param>
/// <param name="connectionGroupName">Name connection group</param>
/// <param name="isExternalTemplate">Is opened from user file template </param>
/// <returns>
/// The <see cref="ConnectionGroupInfo" />.
/// </returns>
public static ConnectionGroupInfo CreateTrialConnectionGroup(
List<Tuple<DbConnectionStringBuilder, bool>> propertiesList,
string templateFile,
QuerySource dbType,
string connectionGroupName,
bool isExternalTemplate
)
{
ConnectionGroupInfo connectionGroup = new ConnectionGroupInfo
{
Connections = InstanceInfoResolver.ResolveInstances(propertiesList, dbType),
IsExternal = isExternalTemplate,
TemplateDir = Path.GetDirectoryName(templateFile),
TemplateFileName = Path.GetFileName(templateFile),
Name = connectionGroupName
};
return connectionGroup;
}
public static InstanceInfo ResolveDynamicInstance(
string connection,
QuerySource sourceType,
bool isOdbcConnection
)
{
if (IsDatabaseSource(sourceType))
{
return ResolveDatabase(
connection,
sourceType,
isOdbcConnection,
true
);
}
return ResolveNonDatabase(
connection,
sourceType,
true
);
}
public IQueryConnection CreateQueryConnection(QuerySource sourceType, InstanceInfo instance)
{
bool isOdbc = instance.IsODBC;
QuerySource queryType = instance.Type;
instance.SetSettings(this._model.Settings);
if (sourceType == QuerySource.SQLite)
{
IStorageManager storageManager = this._model.GetVaultProcessor(
instance.ConnectionGroup ?? new ConnectionGroupInfo()
);
AttachingSqliteQueryConnection sqliteQueryConnection;
string connectionString = instance.GetConnectionString();
SqliteConnectionParameters connectionParameters = SqliteConnectionParameters.Parse(connectionString);
if (connectionParameters.IsValid)
{
sqliteQueryConnection = new SqliteInnerQueryConnection(
storageManager.CurrentStorage,
connectionParameters
);
}
else
{
sqliteQueryConnection = new SqliteInternalQueryConnection(
storageManager.CurrentStorage,
instance
);
}
if (storageManager.HistoryStorage != null)
{
foreach (var historyStorage in storageManager.HistoryStorage)
{
sqliteQueryConnection.AddDatabaseToAttach(
historyStorage.Alias,
historyStorage.FileName
);
}
}
if (storageManager.ReportStorage != null)
{
sqliteQueryConnection.AddDatabaseToAttach(
"report",
storageManager.ReportStorage.FileName
);
}
return sqliteQueryConnection;
}
if (isOdbc)
{
OdbcConnection odbcConnection = ConnectionFactory.CreateOdbcConnection(instance, true);
return new OdbcQueryConnection(odbcConnection);
}
if (sourceType == queryType)
{
switch (sourceType)
{
case QuerySource.MSSQL:
SqlConnection sqlConnection =
ConnectionFactory.CreateSqlConnection(instance, true);
return new MsSqlQueryConnection(sqlConnection);
case QuerySource.TDSQL:
TdConnection tdConnection =
ConnectionFactory.CreateTdConnection(instance, true);
return new TeradataSqlQueryConnection(tdConnection);
case QuerySource.SQLiteExternal:
SQLiteConnection sqliteConnection =
ConnectionFactory.CreateSQLiteExternalConnection(instance);
return new SqliteExternalQueryConnection(sqliteConnection);
case QuerySource.ActiveDirectory:
ActiveDirectoryConnection activeDirectoryConnection =
ConnectionFactory.CreateActiveDirectoryConnection(instance);
return new ActiveDirectoryQueryConnection(activeDirectoryConnection);
case QuerySource.EventLog:
EventLogConnection eventLogConnection =
ConnectionFactory.CreateEventLogConnection(instance);
return new EventLogQueryConnection(eventLogConnection);
case QuerySource.NetworkInformation:
NetworkInformationConnection networkInfoConnection =
ConnectionFactory.CreateNetworkInformationConnection(instance);
return new NetworkInformationQueryConnection(networkInfoConnection);
}
}
string errorMessage = String.Format(
"There is no QueryConnection defined. QuerySource: {0}, QueryType: {1}",
sourceType,
queryType
);
Log.ErrorFormat(errorMessage);
throw new ArgumentException(errorMessage);
}
private static InstanceInfo ResolveDatabase(
string connection,
QuerySource sourceType,
bool isOdbcConnection,
bool isDynamicConnection = false
)
{
DbConnectionStringBuilder connectionBuilder = new DbConnectionStringBuilder
{
ConnectionString = connection
};
return ResolveDatabase(
connectionBuilder,
sourceType,
isOdbcConnection,
isDynamicConnection
);
}
private static InstanceInfo ResolveDatabase(
DbConnectionStringBuilder cnn,
QuerySource sourceType,
bool isOdbcConnection,
bool isDynamicConnection = false
)
{
AuthenticationInfo authentication = GetAuthentication(cnn, sourceType);
log.InfoFormat("IsWindows:'{0}';Username:'******';Password:'******'",
authentication.IsWindows,
authentication.Username,
authentication.Password
);
string instanceName = ReadProp(cnn, "Dsn", "Data Source") as string;
InstanceInfo instance = new InstanceInfo(isDynamicConnection)
{
Authentication = authentication,
Instance = instanceName,
IsEnabled = true,
Name = instanceName,
IsODBC = isOdbcConnection,
DbType = sourceType.ToString()
};
if (isOdbcConnection)
{
instance.InnerOdbcConnectionString = cnn.ConnectionString;
}
return instance;
}
protected static DbConnectionStringBuilder GetConnectionStringBuilder(
QuerySource source,
string connectionString,
bool isOdbc
)
{
if (isOdbc)
{
return new OdbcConnectionStringBuilder(connectionString);
}
DbConnectionStringBuilder builder;
switch (source)
{
case QuerySource.MSSQL:
builder = new SqlConnectionStringBuilder();
break;
case QuerySource.SQLite:
// ODBC connection string builder is used
// for SQLite internal connection
// since it handles special connection string adequately
builder = new OdbcConnectionStringBuilder();
break;
default:
builder = new DbConnectionStringBuilder();
break;
}
builder.ConnectionString = connectionString;
return builder;
}
ISqlPredicate MakeIsPredicate(IParseContext context, QuerySource.Table table, Type typeOperand)
{
if (typeOperand == table.ObjectType && table.InheritanceMapping.Count(m => m.Type == typeOperand) == 0)
return Convert(context, new SqlQuery.Predicate.Expr(new SqlValue(true)));
var mapping = table.InheritanceMapping.Select((m,i) => new { m, i }).Where(m => m.m.Type == typeOperand && !m.m.IsDefault).ToList();
switch (mapping.Count)
{
case 0:
{
var cond = new SqlQuery.SearchCondition();
foreach (var m in table.InheritanceMapping.Select((m,i) => new { m, i }).Where(m => !m.m.IsDefault))
{
cond.Conditions.Add(
new SqlQuery.Condition(
false,
Convert(context,
new SqlQuery.Predicate.ExprExpr(
table.Columns[table.InheritanceDiscriminators[m.i]].Field,
SqlQuery.Predicate.Operator.NotEqual,
new SqlValue(m.m.Code)))));
}
return cond;
}
case 1:
return Convert(context,
new SqlQuery.Predicate.ExprExpr(
table.Columns[table.InheritanceDiscriminators[mapping[0].i]].Field,
SqlQuery.Predicate.Operator.Equal,
new SqlValue(mapping[0].m.Code)));
default:
{
var cond = new SqlQuery.SearchCondition();
foreach (var m in mapping)
{
cond.Conditions.Add(
new SqlQuery.Condition(
false,
Convert(context,
new SqlQuery.Predicate.ExprExpr(
table.Columns[table.InheritanceDiscriminators[m.i]].Field,
SqlQuery.Predicate.Operator.Equal,
new SqlValue(m.m.Code))),
true));
}
return cond;
}
}
}
private static LoaderMSSQLQueryWrapper ReadLoaderQueryWrapper(List<QueryInfo> queries, QuerySource querySource)
{
LoaderMSSQLQueryWrapper queryWrapper = new LoaderMSSQLQueryWrapper
{
Infos = queries.Where(query => query.Source == querySource).ToList(),
Type = querySource.ToString()
};
return queryWrapper;
}
/// <summary>
/// Check template database type.
/// </summary>
/// <param name="model">Model mssql auditor.</param>
/// <param name="template">Template.</param>
/// <param name="selectedSource">Selected db source.</param>
/// <returns>If template available.</returns>
public static bool CheckFromXml(MsSqlAuditorModel model, Template template, QuerySource selectedSource)
{
return template.DBType == selectedSource;
}
[Conditional("TRACE_PARSING")] public static void WriteLine(string prefix, QuerySource source) { WriteLineInternal(prefix, source); }
public virtual IQueryConnection CreateQueryConnection(QuerySource sourceType, InstanceInfo instance)
{
return this._connectionFactory.CreateQueryConnection(sourceType, instance);
}
private static AuthenticationInfo GetAuthentication(
DbConnectionStringBuilder cnnBuilder,
QuerySource sourceType
)
{
switch (sourceType)
{
case QuerySource.MSSQL:
case QuerySource.TDSQL:
return new AuthenticationInfo
{
IsWindows = ReadBoolProp(cnnBuilder, "Integrated Security"),
Username = ReadProp(cnnBuilder, "uid", "User ID") as string ?? string.Empty,
Password = ReadProp(cnnBuilder, "pwd", "Password") as string ?? string.Empty
};
default:
return new AuthenticationInfo
{
IsWindows = true,
Username = string.Empty,
Password = string.Empty
};
}
}
public BindingWrapper<ConnectionType> GetConnectionType(QuerySource dbType)
{
ConnectionType[] connectionTypes = Settings.SystemSettings.ConnectionTypes;
if (connectionTypes != null)
{
foreach (ConnectionType connectionType in connectionTypes)
{
QuerySource querySource;
if (Enum.TryParse(connectionType.Id, true, out querySource))
{
if (querySource == dbType)
{
return new BindingWrapper<ConnectionType>(
connectionType,
ct =>
{
i18n localeItem = ct.Locales.FirstOrDefault(
l => l.Language == Settings.InterfaceLanguage
);
string displayName = localeItem != null
? localeItem.Text
: ct.Id;
return displayName.RemoveWhitespaces();
}
);
}
}
}
}
return null;
}
private static IEnumerable<QueryInfo> GetQueries(LoaderRootWrapper wrapper, QuerySource querySource)
{
List<QueryInfo> queryInfos = wrapper.GetQueriesOfType(querySource).SelectMany(w => w.Infos).ToList();
queryInfos.ForEach(q =>
{
q.OnDesialized();
q.Source = querySource;
});
return queryInfos;
}
private static InstanceInfo CreateDatabaseSelectConnection(string connection, QuerySource sourceType, bool isOdbcConnection)
{
bool AuthenticationInfoIsWindows = false;
string AuthenticationInfoUsername = string.Empty;
string AuthenticationInfoPassword = string.Empty;
var connectionDialog = new DataConnectionDialog();
connectionDialog.DataSources.Add(DataSource.OdbcDataSource);
connectionDialog.DataSources.Add(DataSource.SqlDataSource);
connectionDialog.SelectedDataSource = isOdbcConnection ? DataSource.OdbcDataSource : DataSource.SqlDataSource;
connectionDialog.UnspecifiedDataSource.Providers.Add(DataProvider.SqlDataProvider);
connectionDialog.ConnectionString = connection;
var properties = connectionDialog.ConnectionProperties;
if (sourceType == QuerySource.MSSQL)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.TDSQL)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.SQLite)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.SQLiteExternal)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.ActiveDirectory)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.EventLog)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else if (sourceType == QuerySource.NetworkInformation)
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
else
{
AuthenticationInfoIsWindows = true;
AuthenticationInfoUsername = string.Empty;
AuthenticationInfoPassword = string.Empty;
}
if (properties["Integrated Security"] != null)
{
if (properties["Integrated Security"] as bool)
{
AuthenticationInfoIsWindows = true;
}
else
{
AuthenticationInfoIsWindows = false;
}
}
if (properties["uid"] != null)
{
if (!string.IsNullOrEmpty(properties["uid"] as string))
{
AuthenticationInfoIsWindows = false;
AuthenticationInfoUsername = properties["uid"] as string;
}
}
if (properties["User ID"] != null)
{
if (!string.IsNullOrEmpty(properties["User ID"] as string))
{
AuthenticationInfoIsWindows = false;
AuthenticationInfoUsername = properties["User ID"] as string;
}
}
if (properties["pwd"] != null)
{
if (!string.IsNullOrEmpty(properties["pwd"] as string))
{
AuthenticationInfoIsWindows = false;
AuthenticationInfoPassword = properties["pwd"] as string;
}
}
if (properties["Password"] != null)
{
if (!string.IsNullOrEmpty(properties["Password"] as string))
{
AuthenticationInfoIsWindows = false;
AuthenticationInfoPassword = properties["Password"] as string;
}
}
log.InforFormat("IsWindows:'{0}';Username:'******';Password:'******',
AuthenticationInfoIsWindows
AuthenticationInfoUsername,
AuthenticationInfoPassword,
);
var instance = new InstanceInfo(true)
{
Authentication = new AuthenticationInfo
{
// IsWindows = properties["Integrated Security"] as bool? ?? false,
// Username = (properties["uid"] as string) ?? (properties["User ID"] as string) ?? string.Empty,
// Password = (properties["pwd"] as string) ?? (properties["Password"] as string) ?? string.Empty
IsWindows = AuthenticationInfoIsWindows,
Username = AuthenticationInfoUsername,
Password = AuthenticationInfoPassword
},
Instance = (properties["Dsn"] as string) ?? (properties["Data Source"] as string),
IsEnabled = true,
Name = (properties["Dsn"] as string) ?? (properties["Data Source"] as string),
IsODBC = isOdbcConnection,
DbType = sourceType.ToString()
};
if (instance.IsODBC)
{
instance.SetInnerODBCCOnnectionString(connection);
}
return instance;
}
public List<LoaderMSSQLQueryWrapper> GetQueriesOfType(QuerySource querySource)
{
return _sqlInfos.Where(x => x.DBType == querySource).ToList();
}
