static AuthDatabase()
{
var config = Config.Instance.AuthDatabase;
DataAccessModelConfiguration dbConfig;
switch (Config.Instance.AuthDatabase.Engine)
{
case DatabaseEngine.MySQL:
dbConfig = MySqlConfiguration.Create(config.Database, config.Host, config.Username, config.Password, true);
break;
case DatabaseEngine.SQLite:
dbConfig = SqliteConfiguration.Create(config.Filename, null);
break;
default:
Logger.Error()
.Message("Invalid database engine {0}", Config.Instance.AuthDatabase.Engine)
.Write();
Environment.Exit(0);
return;
}
Instance = DataAccessModel.BuildDataAccessModel <Database.Auth.AuthDatabase>(dbConfig);
}
protected SqliteSqlDatabaseContext(DataAccessModel model, SqliteSqlDatabaseContextInfo contextInfo, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager)
: base(model, SqliteSqlDialect.Default, sqlDataTypeProvider, sqlQueryFormatterManager, Path.GetFileNameWithoutExtension(contextInfo.FileName), contextInfo)
{
this.FileName = contextInfo.FileName;
this.IsSharedCacheConnection = IsSharedConnectionRegex.IsMatch(this.FileName);
this.IsInMemoryConnection = IsMemoryConnectionRegex.IsMatch(this.FileName);
}
public static int ExecuteNonQueryEx(this IDbCommand command, DataAccessModel dataAccessModel, bool suppressAnalytics = false)
{
var marsDbCommand = command as MarsDbCommand;
if (marsDbCommand != null)
{
if (!suppressAnalytics)
{
dataAccessModel.queryAnalytics.IncrementQueryCount();
}
return(marsDbCommand.ExecuteNonQuery());
}
var dbCommand = command as DbCommand;
if (dbCommand != null)
{
if (!suppressAnalytics)
{
dataAccessModel.queryAnalytics.IncrementQueryCount();
}
return(dbCommand.ExecuteNonQuery());
}
return(command.ExecuteNonQuery());
}
public IdentityModelTests()
{
this.model = DataAccessModel.BuildDataAccessModel <IdentityModel>(SqliteConfiguration.Create(":memory:", null, BaseTests <IdentityModel> .useMonoData));
this.model.Create(DatabaseCreationOptions.IfDatabaseNotExist);
this.userStore = new ShaolinqIdentityUserStore <ShaolinqIdentityUser <Guid>, IdentityModel, Guid, DbUser, DbUserLogin, DbUserClaim, DbUserRole>(this.model);
}
public void Test_Distributed_Transaction_TransactionScope_CreateFlushComplete_Calls_DataModelHook(bool flush, bool complete)
{
var config2 = this.CreateSqliteClassicInMemoryConfiguration(null);
var model2 = DataAccessModel.BuildDataAccessModel <ComplexPrimaryKeyDataAccessModel>(config2);
var hook2 = new TestDataModelHook();
model2.AddHook(hook2);
model2.Create(DatabaseCreationOptions.IfDatabaseNotExist);
using (var scope = new TransactionScope())
{
var cat = this.model.Cats.Create();
var coord = model2.Coordinates.Create(1);
Console.WriteLine("===");
if (flush)
{
scope.Flush();
}
if (complete)
{
scope.Complete();
}
}
Assert.AreEqual(complete ? 1 : 0, this.testDataModelHook.CommitCount);
Assert.AreEqual(complete || !flush ? 0 : 1, this.testDataModelHook.RollbackCount);
Assert.AreEqual(complete ? 1 : 0, hook2.CommitCount);
Assert.AreEqual(complete || !flush ? 0 : 1, hook2.RollbackCount);
}
public BaseTests(string providerName)
{
this.ProviderName = providerName;
XmlConfigurator.Configure();
try
{
if (providerName == "default")
{
model = DataAccessModel.BuildDataAccessModel <T>();
}
else
{
configuration = this.Create(providerName, this.GetType().Name);
model = DataAccessModel.BuildDataAccessModel <T>(configuration);
}
model.Create(DatabaseCreationOptions.DeleteExisting);
}
catch (Exception e)
{
Console.WriteLine("Exception while configuring provider: " + providerName);
Console.WriteLine(e);
Console.WriteLine(e.StackTrace);
throw;
}
}
private static void RegisterDataModelSingleton <TInterface, TImpl>(this IdentityServerServiceFactory factory, ShaolinqServiceOptions options)
where TImpl : DataAccessModel, TInterface
where TInterface : class
{
options = options ?? new ShaolinqServiceOptions();
var configSection = options.DataAccessModelConfigSection;
if (string.IsNullOrEmpty(configSection))
{
configSection = typeof(TImpl).Name;
}
var dictionaryKey = GetDataAccessModelDictionaryKey(typeof(TImpl), configSection);
lock (LockObj)
{
DataAccessModel dataModel;
if (!DataAccessModels.TryGetValue(dictionaryKey, out dataModel))
{
dataModel = DataAccessModel.BuildDataAccessModel <TImpl>();
//dataModel.Create(DatabaseCreationOptions.DeleteExistingDatabase);
DataAccessModels.Add(dictionaryKey, dataModel);
factory.Register(new Registration <TImpl>((TImpl)dataModel));
}
factory.Register(new Registration <TInterface>((TImpl)dataModel));
}
}
public TrinityMysqlDatabaseProvider()
{
string Database = TrinityMySqlDatabaseModule.DbAccess.DB;
string User = TrinityMySqlDatabaseModule.DbAccess.User;
string Password = TrinityMySqlDatabaseModule.DbAccess.Password;
string Host = TrinityMySqlDatabaseModule.DbAccess.Host;
try
{
var config = MySqlConfiguration.Create(Database, Host, User, Password);
model = DataAccessModel.BuildDataAccessModel <TrinityDatabase>(config);
try
{
model.Create(DatabaseCreationOptions.IfDatabaseNotExist);
}
catch (Exception)
{
// already exists, its ok
}
var temp = GetCreatureTemplates();
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(Host))
{
MessageBox.Show($"Cannot connect to MySql database: {e.Message} Check your settings.");
}
model = null;
}
}
public ObjectProjector(SqlQueryProvider queryProvider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult)
{
this.QueryProvider = queryProvider;
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
this.formatResult = formatResult;
}
public MysqlDatabaseProvider()
{
try
{
string Database = MySqlDatabaseModule.DbAccess.DB;
string User = MySqlDatabaseModule.DbAccess.User;
string Password = MySqlDatabaseModule.DbAccess.Password;
string Host = MySqlDatabaseModule.DbAccess.Host;
var config = MySqlConfiguration.Create(Database, Host, User, Password);
model = DataAccessModel.BuildDataAccessModel <TrinityDatabase>(config);
try
{
model.Create(DatabaseCreationOptions.IfDatabaseNotExist);
}
catch (Exception e)
{
// already exists, its ok
}
var temp = GetCreatureTemplates();
}
catch (Exception e)
{
Console.WriteLine("Cannot connect to MySql database. Check your settings.");
model = null;
}
}
protected SqlTransactionalCommandsContext(SqlDatabaseContext sqlDatabaseContext, IDbConnection dbConnection, TransactionContext transactionContext)
{
this.TransactionContext = transactionContext;
try
{
this.DbConnection = dbConnection;
this.SqlDatabaseContext = sqlDatabaseContext;
this.DataAccessModel = sqlDatabaseContext.DataAccessModel;
this.parameterIndicatorPrefix = this.SqlDatabaseContext.SqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.ParameterPrefix);
this.emulateMultipleActiveResultSets = !sqlDatabaseContext.SqlDialect.SupportsCapability(SqlCapability.MultipleActiveResultSets);
if (transactionContext?.DataAccessTransaction != null)
{
this.dbTransaction = dbConnection.BeginTransaction(ConvertIsolationLevel(transactionContext.DataAccessTransaction.IsolationLevel));
}
}
catch
{
this.Dispose(true);
throw;
}
}
public static void UpdateListModelBL(ModelBL oldItemBL, ModelBL itemBL, string listName, string url, string fileName)
{
DataAccessModel outPutData = new DataAccessModel();
using (SPSite oSiteCollection = new SPSite(url))
{
using (SPWeb oWeb = oSiteCollection.OpenWeb())
{
SPList oList = oWeb.Lists[listName];
SPListItem oListItem = oList.GetItemById(Convert.ToInt32(oldItemBL.Id));
oListItem["BL_CATEGORY"] = itemBL.BL_CATEGORY;
oListItem["BRAND"] = itemBL.BRAND;
oListItem["BL_PRODUCT_TYPE"] = itemBL.BL_PRODUCT_TYPE;
oListItem["BL_PRODUCT_SIZE"] = itemBL.BL_PRODUCT_SIZE;
oListItem["REFRIGERANT"] = itemBL.REFRIGERANT;
oListItem["INDOOR"] = itemBL.INDOOR;
oListItem["OUTDOOR"] = itemBL.OUTDOOR;
oListItem["INSTALLATION"] = itemBL.INSTALLATION;
oListItem["OWNER"] = itemBL.OWNER;
oListItem["DISC"] = itemBL.DISC;
oListItem["SPECIFICATION"] = itemBL.SPECIFICATION;
oListItem["BULLETIN"] = itemBL.BULLETIN;
oListItem["DATABOOK"] = itemBL.DATABOOK;
oListItem["VDO"] = itemBL.VDO;
oListItem["PRESENTATION"] = itemBL.PRESENTATION;
oListItem["IMAGE_LOW"] = itemBL.IMAGE_LOW;
oListItem["CATALOGUE"] = itemBL.CATALOGUE;
oListItem["IMPORT_FILE"] = fileName;
oListItem.Update();
}
}
}
public ObjectProjector(SqlQueryProvider queryProvider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult)
{
this.QueryProvider = queryProvider;
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
this.formatResult = formatResult;
}
public static int ExecuteNonQueryEx(this IDbCommand command, DataAccessModel dataAccessModel, bool suppressAnalytics = false)
{
if (command is MarsDbCommand marsDbCommand)
{
if (!suppressAnalytics)
{
dataAccessModel.queryAnalytics.IncrementQueryCount();
}
return(marsDbCommand.ExecuteNonQuery());
}
if (command is DbCommand dbCommand)
{
if (!suppressAnalytics)
{
dataAccessModel.queryAnalytics.IncrementQueryCount();
}
return(dbCommand.ExecuteNonQuery());
}
return(command.ExecuteNonQuery());
}
protected SqliteSqlDatabaseContext(DataAccessModel model, SqliteSqlDatabaseContextInfo contextInfo, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager)
: base(model, new SqliteSqlDialect(), sqlDataTypeProvider, sqlQueryFormatterManager, Path.GetFileNameWithoutExtension(contextInfo.FileName), contextInfo)
{
this.FileName = contextInfo.FileName;
this.IsSharedCacheConnection = IsSharedConnectionRegex.IsMatch(this.FileName);
this.IsInMemoryConnection = IsMemoryConnectionRegex.IsMatch(this.FileName);
}
public SqliteMonoSqlDatabaseContext(DataAccessModel model, SqliteSqlDatabaseContextInfo contextInfo, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager)
: base(model, contextInfo, sqlDataTypeProvider, sqlQueryFormatterManager)
{
if (this.FileName != null)
{
var connectionStringBuilder = new SqliteConnectionStringBuilder
{
Enlist = false,
DataSource = contextInfo.FileName
};
connectionStringBuilder.Add("DateTimeKind", contextInfo.DateTimeKind);
connectionStringBuilder.Add("foreign keys", 1);
this.ConnectionString = connectionStringBuilder.ConnectionString;
}
else
{
this.ConnectionString = contextInfo.ConnectionString;
}
this.ServerConnectionString = this.ConnectionString;
this.SchemaManager = new SqliteMonoSqlDatabaseSchemaManager(this);
}
internal static void SetInheritenceOfClass(DataAccessModel obj)
{
if (offerBaseEntity.Intersect(obj.Params.Select(x => x.Key)).Count() == offerBaseEntity.Count())
{
obj.Inheritence = "OfferBaseEntity";
obj.Params = obj.Params.Where(x => !offerBaseEntity.Contains(x.Key)).AsEnumerable();
}
if (commonBaseEntity.Intersect(obj.Params.Select(x => x.Key)).Count() == commonBaseEntity.Count())
{
obj.Inheritence = "CommonBaseEntity";
obj.Params = obj.Params.Where(x => !commonBaseEntity.Contains(x.Key)).AsEnumerable();
}
if (hotelBaseEntity.Intersect(obj.Params.Select(x => x.Key)).Count() == hotelBaseEntity.Count())
{
obj.Inheritence = "HotelBossBaseEntity";
obj.Params = obj.Params.Where(x => !hotelBaseEntity.Contains(x.Key)).AsEnumerable();
}
if (baseEntity.Intersect(obj.Params.Select(x => x.Key)).Count() == baseEntity.Count())
{
obj.Inheritence = "BaseEntity";
obj.Params = obj.Params.Where(x => !baseEntity.Contains(x.Key)).AsEnumerable();
}
}
public static Expression Optimize(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression)
{
expression = SqlGroupByCollator.Collate(expression);
expression = SqlAggregateSubqueryRewriter.Rewrite(expression);
expression = SqlUnusedColumnRemover.Remove(expression);
expression = SqlRedundantColumnRemover.Remove(expression);
expression = SqlRedundantSubqueryRemover.Remove(expression);
expression = SqlFunctionCoalescer.Coalesce(expression);
expression = SqlExistsSubqueryOptimizer.Optimize(expression);
expression = SqlRedundantBinaryExpressionsRemover.Remove(expression);
expression = SqlCrossJoinRewriter.Rewrite(expression);
expression = SqlConditionalEliminator.Eliminate(expression);
expression = SqlExpressionCollectionOperationsExpander.Expand(expression);
expression = SqlSubCollectionOrderByAmender.Amend(dataAccessModel.TypeDescriptorProvider, expression);
expression = SqlOrderByRewriter.Rewrite(expression);
var rewritten = SqlCrossApplyRewriter.Rewrite(expression);
if (rewritten != expression)
{
expression = rewritten;
expression = SqlUnusedColumnRemover.Remove(expression);
expression = SqlRedundantColumnRemover.Remove(expression);
expression = SqlRedundantSubqueryRemover.Remove(expression);
expression = SqlOrderByRewriter.Rewrite(expression);
}
expression = SqlDeleteNormalizer.Normalize(expression);
expression = SqlUpdateNormalizer.Normalize(expression);
expression = SqlInsertIntoNormalizer.Normalize(expression);
return(expression);
}
public static DataAccessModel GetListModelBLData(string listName, string url)
{
DataAccessModel outPutData = new DataAccessModel();
try
{
using (SPSite oSite = new SPSite(url))
{
using (SPWeb oWeb = oSite.OpenWeb())
{
List <string> camlQuery = new List <string>();
camlQuery = GetModelBLCAML();
SPQuery query = new SPQuery();
query.Query = camlQuery[0].ToString();
query.ViewFields = camlQuery[1].ToString();
SPList oList = oWeb.Lists[listName];
SPListItemCollection items = oList.GetItems(query);
var dt = items.GetDataTable();
var list = (from table in dt.AsEnumerable()
select new ModelBL
{
Id = table["Id"].ToString(),
Title = table["Title"].ToString(),
BL_CATEGORY = table["BL_CATEGORY"].ToString(),
BRAND = table["BRAND"].ToString(),
BL_PRODUCT_TYPE = table["BL_PRODUCT_TYPE"].ToString(),
BL_PRODUCT_SIZE = table["BL_PRODUCT_SIZE"].ToString(),
REFRIGERANT = table["REFRIGERANT"].ToString(),
INDOOR = table["INDOOR"].ToString(),
OUTDOOR = table["OUTDOOR"].ToString(),
INSTALLATION = table["INSTALLATION"].ToString(),
OWNER = table["OWNER"].ToString(),
DISC = table["DISC"].ToString(),
SPECIFICATION = table["SPECIFICATION"].ToString(),
BULLETIN = table["BULLETIN"].ToString(),
DATABOOK = table["DATABOOK"].ToString(),
VDO = table["VDO"].ToString(),
PRESENTATION = table["PRESENTATION"].ToString(),
IMAGE_LOW = table["IMAGE_LOW"].ToString(),
IMAGE_HD = table["IMAGE_HD"].ToString(),
CATALOGUE = table["CATALOGUE"].ToString()
}).ToList();
outPutData.listModelBLData = list;
outPutData.Status = true;
outPutData.Reason = "Success";
}
}
return(outPutData);
}
catch (Exception ex)
{
outPutData.listModelBLData = new List <ModelBL>();
outPutData.Status = false;
outPutData.Reason = ex.Message.ToString();
return(outPutData);
}
}
public void CreatDataBase()
{
var configuration = Shaolinq.Sqlite.SqliteConfiguration.Create(":memory:");
model = DataAccessModel.BuildDataAccessModel <ExampleModel>(configuration);
//如果不存在则创建
model.Create(DatabaseCreationOptions.IfDatabaseNotExist);
}
public static Expression Build(DataAccessModel dataAccessModel, SqlQueryFormatterManager formatterManager, SqlDataTypeProvider sqlDataTypeProvider, SqlDialect sqlDialect, DataAccessModel model, DatabaseCreationOptions options, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
var builder = new SqlDataDefinitionExpressionBuilder(dataAccessModel, formatterManager, sqlDialect, sqlDataTypeProvider, model, options, tableNamePrefix, flags);
var retval = builder.Build();
return(retval);
}
public static Expression Build(SqlDataTypeProvider sqlDataTypeProvider, SqlDialect sqlDialect, DataAccessModel model, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
var builder = new SqlDataDefinitionExpressionBuilder(sqlDialect, sqlDataTypeProvider, model, tableNamePrefix, flags);
var retval = builder.Build();
return retval;
}
public IActionResult Summary(bool created, long id)
{
Product model = DataAccessModel.GetProduct(id);
ViewData["Category"] = DataAccessModel.GetCategory(model.CategoryId);
ViewData["Created"] = created;
return(View(model));
}
public ObjectProjector(SqlQueryProvider queryProvider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, string commandText, IReadOnlyList <TypedValue> parameterValues)
{
this.QueryProvider = queryProvider;
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
this.CommandText = commandText;
this.ParameterValues = parameterValues;
}
public static SqliteSqlDatabaseContext Create(SqliteSqlDatabaseContextInfo contextInfo, DataAccessModel model)
{
var constraintDefaults = model.Configuration.ConstraintDefaults;
var sqlDataTypeProvider = new SqliteSqlDataTypeProvider(constraintDefaults);
var sqlQueryFormatterManager = new DefaultSqlQueryFormatterManager(SqliteSqlDialect.Default, sqlDataTypeProvider, typeof(SqliteSqlQueryFormatter));
return new SqliteMonoSqlDatabaseContext(model, contextInfo, sqlDataTypeProvider, sqlQueryFormatterManager);
}
/// <summary>
/// Builds the lambda expression that will perform the projection
/// </summary>
/// <param name="dataAccessModel">The related data access model</param>
/// <param name="sqlDatabaseContext">The related <see cref="SqlDatabaseContext"/></param>
/// <param name="expression">
/// The expression that performs the projection (can be any expression but usually is a MemberInit expression)
/// </param>
/// <returns>
/// A <see cref="LambdaExpression"/> that takes two parameters: an <see cref="ObjectProjector"/>
/// and an <see cref="IDataReader"/>. The lambda expression will construct a single
/// object for return from the current row in the given <see cref="IDataReader"/>.
/// </returns>
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression, IEnumerable<string> columns)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, columns);
var body = projectionBuilder.Visit(expression);
return Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.dynamicParameters);
}
/// <summary>
/// Builds the lambda expression that will perform the projection
/// </summary>
/// <param name="dataAccessModel">The related data access model</param>
/// <param name="sqlDatabaseContext">The related <see cref="SqlDatabaseContext"/></param>
/// <param name="expression">
/// The expression that performs the projection (can be any expression but usually is a MemberInit expression)
/// </param>
/// <returns>
/// A <see cref="LambdaExpression"/> that takes two parameters: an <see cref="ObjectProjector"/>
/// and an <see cref="IDataReader"/>. The lambda expression will construct a single
/// object for return from the current row in the given <see cref="IDataReader"/>.
/// </returns>
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression, IEnumerable <string> columns)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, columns);
var body = projectionBuilder.Visit(expression);
return(Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.dynamicParameters));
}
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, Expression expression, ProjectionBuilderScope scope)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, queryProvider, scope);
var body = projectionBuilder.Visit(expression);
return(Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.versionParameter, projectionBuilder.dynamicParameters));
}
public static PostgresSqlDatabaseContext Create(PostgresSqlDatabaseContextInfo contextInfo, DataAccessModel model)
{
var constraintDefaults = model.Configuration.ConstraintDefaultsConfiguration;
var sqlDialect = new PostgresSqlDialect();
var sqlDataTypeProvider = new PostgresSqlDataTypeProvider(model.TypeDescriptorProvider, constraintDefaults, contextInfo.NativeUuids, contextInfo.NativeEnums);
var sqlQueryFormatterManager = new DefaultSqlQueryFormatterManager(sqlDialect, sqlDataTypeProvider, (options, sqlDataTypeProviderArg, sqlDialectArg) => new PostgresSqlQueryFormatter(options, sqlDataTypeProviderArg, sqlDialectArg, contextInfo.SchemaName, true));
return new PostgresSqlDatabaseContext(model, sqlDialect, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo);
}
public TransactionContext(DataAccessModel dataAccessModel, Transaction transaction)
{
this.DataAccessModel = dataAccessModel;
this.Transaction = transaction;
this.DatabaseContextCategoriesKey = ".";
this.ResourceManagerIdentifier = Guid.NewGuid();
this.persistenceTransactionContextsBySqlDatabaseContexts = new Dictionary<SqlDatabaseContext, TransactionEntry>(PrimeNumbers.Prime7);
}
public static Models.Category CreateFrom(DataAccessModel.Category category)
{
return new Models.Category
{
ID = category.ID,
Name = category.Name,
Description = category.Description
};
}
public InjectionContext(DataAccessModel model, SqlDatabaseContextInfo contextInfo, Func <SqlDataTypeProvider> defaultProviderFactoryMethod, Func <string, Tuple <bool, object> > parameterNameToValue = null)
{
this.model = model;
this.contextInfo = contextInfo;
this.defaultProviderFactoryMethod = defaultProviderFactoryMethod;
this.parameterNameToValue = parameterNameToValue;
this.typeDescriptorProvider = this.model.TypeDescriptorProvider;
this.constraintsDefaultConfiguration = this.model.Configuration.ConstraintDefaultsConfiguration;
}
private SqlDataDefinitionExpressionBuilder(SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, DataAccessModel model, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
this.model = model;
this.sqlDialect = sqlDialect;
this.tableNamePrefix = tableNamePrefix;
this.flags = flags;
this.sqlDataTypeProvider = sqlDataTypeProvider;
this.currentTableConstraints = new List<Expression>();
}
public static SqlServerSqlDatabaseContext Create(SqlServerSqlDatabaseContextInfo contextInfo, DataAccessModel model)
{
var constraintDefaults = model.Configuration.ConstraintDefaultsConfiguration;
var sqlDataTypeProvider = new SqlServerSqlDataTypeProvider(constraintDefaults);
var sqlDialect = new SqlServerSqlDialect(contextInfo);
var typeDescriptorProvider = model.TypeDescriptorProvider;
var sqlQueryFormatterManager = new DefaultSqlQueryFormatterManager(sqlDialect, options => new SqlServerSqlQueryFormatter(options, sqlDialect, sqlDataTypeProvider, typeDescriptorProvider));
return new SqlServerSqlDatabaseContext(model, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo);
}
private SqlDataDefinitionExpressionBuilder(DataAccessModel dataAccessModel, SqlQueryFormatterManager formatterManager, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, DataAccessModel model, DatabaseCreationOptions options, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
this.dataAccessModel = dataAccessModel;
this.formatterManager = formatterManager;
this.model = model;
this.sqlDialect = sqlDialect;
this.flags = flags;
this.sqlDataTypeProvider = sqlDataTypeProvider;
this.currentTableConstraints = new List <SqlConstraintExpression>();
}
public static TransactionContext GetCurrentContext(DataAccessModel dataAccessModel, bool forWrite)
{
TransactionContext context;
var dataAccessTransaction = DataAccessTransaction.Current;
if (dataAccessTransaction == null && Transaction.Current != null)
{
dataAccessTransaction = DataAccessTransaction.Current = new DataAccessTransaction(DataAccessIsolationLevel.Unspecified);
}
if (dataAccessTransaction == null)
{
if (forWrite)
{
throw new InvalidOperationException("Write operation must be performed inside a scope");
}
context = dataAccessModel.AsyncLocalTransactionContext;
if (context == null || context.disposed)
{
context = new TransactionContext(null, dataAccessModel);
dataAccessModel.AsyncLocalTransactionContext = context;
}
return context;
}
if (dataAccessTransaction.SystemTransaction?.TransactionInformation.Status == TransactionStatus.Aborted)
{
throw new TransactionAbortedException();
}
var contexts = dataAccessTransaction.transactionContextsByDataAccessModel;
var skipTest = false;
if (contexts == null)
{
skipTest = true;
contexts = dataAccessTransaction.transactionContextsByDataAccessModel = new Dictionary<DataAccessModel, TransactionContext>();
}
if (skipTest || !contexts.TryGetValue(dataAccessModel, out context))
{
context = new TransactionContext(dataAccessTransaction, dataAccessModel);
contexts[dataAccessModel] = context;
dataAccessModel.AsyncLocalTransactionContext = context;
dataAccessTransaction.AddTransactionContext(context);
}
return context;
}
public ObjectProjector(IQueryProvider provider, DataAccessModel dataAccessModel, SqlQueryFormatResult formatResult, SqlDatabaseContext sqlDatabaseContext, IRelatedDataAccessObjectContext relatedDataAccessObjectContext, SelectFirstType selectFirstType, SqlAggregateType?sqlAggregateType, bool isDefaultIfEmpty)
{
this.sqlAggregateType = sqlAggregateType;
this.isDefaultIfEmpty = isDefaultIfEmpty;
this.provider = provider;
this.DataAccessModel = dataAccessModel;
this.FormatResult = formatResult;
this.SqlDatabaseContext = sqlDatabaseContext;
this.selectFirstType = selectFirstType;
this.relatedDataAccessObjectContext = relatedDataAccessObjectContext;
}
private SqlDataDefinitionExpressionBuilder(SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, DataAccessModel model, DatabaseCreationOptions options, string tableNamePrefix, SqlDataDefinitionBuilderFlags flags)
{
this.model = model;
this.options = options;
this.sqlDialect = sqlDialect;
this.tableNamePrefix = tableNamePrefix;
this.flags = flags;
this.sqlDataTypeProvider = sqlDataTypeProvider;
this.currentTableConstraints = new List <Expression>();
}
public static Models.Company CreateFrom(DataAccessModel.Company company,
List<Models.Category> categories)
{
return new Models.Company
{
ID = company.ID,
Name = company.Name,
Description = company.Description,
Categories = categories
};
}
/// <summary>
/// Method of creating a View role model
/// </summary>
/// <param name="role">Role</param>
/// <returns></returns>
public static RoleVm Create(Role role) => new RoleVm
{
Id = role.Id,
Name = role.Name,
Description = role.Description,
AccessToSystemFunctions = role.AccessToSystemFunctionsArray,
StandardDataAccess = DataAccessModel.FromPermissions(role.StandardDataAccessArray),
ActiveUsers = role.ActiveUsers,
Status = role.Status,
SqlWalletUser = role.SqlWalletUser
};
public override SqlDatabaseContext CreateSqlDatabaseContext(DataAccessModel model)
{
if (this.UseMonoData)
{
return SqliteMonoSqlDatabaseContext.Create(this, model);
}
else
{
return SqliteOfficialsSqlDatabaseContext.Create(this, model);
}
}
public override SqlDatabaseContext CreateSqlDatabaseContext(DataAccessModel model)
{
if (this.UseMonoData)
{
return(SqliteMonoSqlDatabaseContext.Create(this, model));
}
else
{
return(SqliteOfficialsSqlDatabaseContext.Create(this, model));
}
}
public void Test_Backup()
{
using (var scope = NewTransactionScope())
{
var school = this.model.Schools.Create();
school.Name = "School1";
scope.Complete();
}
var backupFileModel = DataAccessModel.BuildDataAccessModel <TestDataAccessModel>(CreateSqliteConfiguration("backup.sql3"));
this.model.Backup(backupFileModel);
var backupModel = DataAccessModel.BuildDataAccessModel <TestDataAccessModel>(CreateSqliteClassicInMemoryConfiguration(null));
backupFileModel.Backup(backupModel);
Assert.AreEqual("School1", this.model.Schools.Select(c => c.Name).Single());
using (var scope = NewTransactionScope())
{
var school = this.model.Schools.Create();
school.Name = "School2";
scope.Complete();
}
Assert.AreEqual("School2", this.model.Schools.Select(c => c.Name).Single(c => c == "School2"));
using (var scope = NewTransactionScope())
{
var school = backupModel.Schools.Create();
school.Name = "School3";
school = backupModel.Schools.Create();
school.Name = "School4";
scope.Complete();
}
Assert.IsNull(this.model.Schools.Select(c => c.Name).FirstOrDefault(c => c == "School3"));
Assert.IsNull(this.model.Schools.Select(c => c.Name).FirstOrDefault(c => c == "School4"));
Assert.AreEqual("School3", backupModel.Schools.Select(c => c.Name).Single(c => c == "School3"));
Assert.AreEqual("School4", backupModel.Schools.Select(c => c.Name).Single(c => c == "School4"));
Assert.AreEqual(2, this.model.Schools.Count());
Assert.AreEqual(3, backupModel.Schools.Count());
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, IEnumerable<string> columns)
{
var x = 0;
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.columnIndexes = columns.ToDictionary(c => c, c => x++);
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof (object[]), "dynamicParameters");
}
private MySqlSqlDatabaseContext(DataAccessModel model, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, MySqlSqlDatabaseContextInfo contextInfo)
: base(model, MySqlSqlDialect.Default, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo.DatabaseName, contextInfo)
{
this.ServerName = contextInfo.ServerName;
this.Username = contextInfo.UserName;
this.Password = contextInfo.Password;
this.ConnectionString = String.Format("Server={0}; Database={1}; Uid={2}; Pwd={3}; Pooling={4}; AutoEnlist=false; charset=utf8; Convert Zero Datetime={5}; Allow Zero Datetime={6};", this.ServerName, this.DatabaseName, this.Username, this.Password, contextInfo.PoolConnections, contextInfo.ConvertZeroDateTime ? "true" : "false", contextInfo.AllowConvertZeroDateTime ? "true" : "false");
this.ServerConnectionString = Regex.Replace(this.ConnectionString, @"Database\s*\=[^;$]+[;$]", "");
this.SchemaManager = new MySqlSqlDatabaseSchemaManager(this);
}
protected SqlDatabaseContext(DataAccessModel model, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, string databaseName, SqlDatabaseContextInfo contextInfo)
{
this.DatabaseName = databaseName;
this.DataAccessModel = model;
this.CommandTimeout = contextInfo.CommandTimeout == null ? null : (TimeSpan?)TimeSpan.FromSeconds(contextInfo.CommandTimeout.Value);
var categories = contextInfo.Categories ?? "";
this.ContextCategories = categories.Trim().Length == 0 ? new string[0] : categories.Split(',').Select(c => c.Trim()).ToArray();
this.SqlDialect = sqlDialect;
this.SqlDataTypeProvider = sqlDataTypeProvider;
this.SqlQueryFormatterManager = sqlQueryFormatterManager;
this.SchemaName = EnvironmentSubstitutor.Substitute(contextInfo.SchemaName);
this.TableNamePrefix = EnvironmentSubstitutor.Substitute(contextInfo.TableNamePrefix);
}
public static Models.Product CreateFrom(DataAccessModel.Product product)
{
return new Models.Product
{
ID = product.ID,
Name = product.Name,
Description = product.Description,
ImageURL = product.ImageURL,
Price = product.Price,
IsFrontProduct = product.IsFrontProduct,
IsHotProduct = product.IsHotProduct
};
}
protected PostgresSqlDatabaseContext(DataAccessModel model, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, PostgresSqlDatabaseContextInfo contextInfo)
: base(model, sqlDialect, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo.DatabaseName, contextInfo)
{
this.SupportsPreparedTransactions = contextInfo.EnablePreparedTransactions;
this.Host = contextInfo.ServerName;
this.UserId = contextInfo.UserId;
this.Password = contextInfo.Password;
this.Port = contextInfo.Port;
var connectionStringBuilder = new NpgsqlConnectionStringBuilder
{
Host = contextInfo.ServerName,
Username = contextInfo.UserId,
Password = contextInfo.Password,
Port = contextInfo.Port,
Pooling = contextInfo.Pooling,
Enlist = false,
MinPoolSize = contextInfo.MinPoolSize,
MaxPoolSize = contextInfo.MaxPoolSize,
KeepAlive = contextInfo.KeepAlive,
ConnectionIdleLifetime = contextInfo.ConnectionIdleLifetime,
ConvertInfinityDateTime = contextInfo.ConvertInfinityDateTime
};
if (contextInfo.Timeout != null)
{
connectionStringBuilder.Timeout = contextInfo.Timeout.Value;
}
if (contextInfo.ConnectionTimeout.HasValue)
{
connectionStringBuilder.Timeout = contextInfo.ConnectionTimeout.Value;
}
if (contextInfo.ConnectionCommandTimeout.HasValue)
{
connectionStringBuilder.CommandTimeout = contextInfo.ConnectionCommandTimeout.Value;
}
connectionStringBuilder.Database = contextInfo.DatabaseName;
this.ConnectionString = connectionStringBuilder.ToString();
connectionStringBuilder.Database = "postgres";
this.ServerConnectionString = connectionStringBuilder.ToString();
this.SchemaManager = new PostgresSqlDatabaseSchemaManager(this);
}
protected PostgresSqlDatabaseContext(DataAccessModel model, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, PostgresSqlDatabaseContextInfo contextInfo)
: base(model, sqlDialect, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo.DatabaseName, contextInfo)
{
this.Host = contextInfo.ServerName;
this.UserId = contextInfo.UserId;
this.Password = contextInfo.Password;
this.Port = contextInfo.Port;
this.CommandTimeout = TimeSpan.FromSeconds(contextInfo.CommandTimeout);
this.ConnectionString = String.Format("Host={0};User Id={1};Password={2};Database={3};Port={4};Pooling={5};MinPoolSize={6};MaxPoolSize={7};Enlist=false;Timeout={8};CommandTimeout={9}", contextInfo.ServerName, contextInfo.UserId, contextInfo.Password, contextInfo.DatabaseName, contextInfo.Port, contextInfo.Pooling, contextInfo.MinPoolSize, contextInfo.MaxPoolSize, contextInfo.ConnectionTimeout, contextInfo.CommandTimeout);
this.ServerConnectionString = Regex.Replace(this.ConnectionString, @"Database\s*\=[^;]+[;$]", "Database=postgres;");
this.SchemaManager = new PostgresSharedSqlDatabaseSchemaManager(this);
}
/// <summary>
/// Gets the <see cref="DataAccessModelTransactionManager "/> for the current <see cref="Shaolinq.DataAccessModel"/> for the current thread.
/// </summary>
/// <remarks>
/// The framework does not support accessing objects created within different transactions
/// from other transactions. For each Transaction there may be more than one attached
/// <see cref="TransactionContext"/> (one for each thread that participates in the transaction).
/// </remarks>
public static DataAccessModelTransactionManager GetAmbientTransactionManager(DataAccessModel dataAccessModel)
{
DataAccessModelTransactionManager retval;
var transactionManagers = ambientTransactionManagers.Value;
if (!transactionManagers.TryGetValue(dataAccessModel, out retval))
{
retval = new DataAccessModelTransactionManager(dataAccessModel);
transactionManagers[dataAccessModel] = retval;
}
return retval;
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, ProjectionBuilderScope scope)
{
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.queryProvider = queryProvider;
this.scope = scope;
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof (object[]), "dynamicParameters");
this.versionParameter = Expression.Parameter(typeof(int), "version");
this.filterParameter = Expression.Parameter(typeof(Func<DataAccessObject, DataAccessObject>), "filter");
}
public static RelatedPropertiesJoinExpanderResults Expand(DataAccessModel model, Expression expression)
{
expression = SqlProjectionSelectExpander.Expand(expression);
var visitor = new RelatedPropertiesJoinExpander(model);
var processedExpression = visitor.Visit(expression);
return new RelatedPropertiesJoinExpanderResults(visitor.replacementExpressionForPropertyPathsByJoin)
{
ProcessedExpression = processedExpression,
IncludedPropertyInfos = visitor.includedPropertyInfos
};
}
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);
}
protected PostgresDotConnectSqlDatabaseContext(DataAccessModel model, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, PostgresDotConnectSqlDatabaseContextInfo contextInfo)
: base(model, sqlDialect, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo.DatabaseName, contextInfo)
{
if (!string.IsNullOrEmpty(contextInfo.ConnectionString))
{
this.ConnectionString = contextInfo.ConnectionString;
this.ServerConnectionString = Regex.Replace(this.ConnectionString, @"Database\s*\=[^;$]+[;$]", "");
}
else
{
this.Host = contextInfo.ServerName;
this.UserId = contextInfo.UserId;
this.Password = contextInfo.Password;
this.Port = contextInfo.Port;
var connectionStringBuilder = new PgSqlConnectionStringBuilder
{
Host = contextInfo.ServerName,
UserId = contextInfo.UserId,
Password = contextInfo.Password,
Port = contextInfo.Port,
Pooling = contextInfo.Pooling,
Enlist = false,
Charset = "UTF8",
Unicode = true,
MaxPoolSize = contextInfo.MaxPoolSize,
UnpreparedExecute = contextInfo.UnpreparedExecute
};
if (contextInfo.ConnectionTimeout != null)
{
connectionStringBuilder.ConnectionTimeout = contextInfo.ConnectionTimeout.Value;
}
if (contextInfo.ConnectionCommandTimeout != null)
{
connectionStringBuilder.DefaultCommandTimeout = contextInfo.ConnectionCommandTimeout.Value;
}
this.ServerConnectionString = connectionStringBuilder.ConnectionString;
connectionStringBuilder.Database = contextInfo.DatabaseName;
this.ConnectionString = connectionStringBuilder.ConnectionString;
}
this.SchemaManager = new PostgresSqlDatabaseSchemaManager(this);
}
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, Expression expression, ProjectionBuilderScope scope, out Expression<Func<IDataReader, object[]>> rootKeys)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, queryProvider, scope);
var body = projectionBuilder.Visit(expression);
if (projectionBuilder.scope.rootPrimaryKeys.Count > 0)
{
rootKeys = Expression.Lambda<Func<IDataReader, object[]>>(Expression.NewArrayInit(typeof(object), projectionBuilder.scope.rootPrimaryKeys), projectionBuilder.dataReader);
}
else
{
rootKeys = null;
}
return Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.versionParameter, projectionBuilder.dynamicParameters, projectionBuilder.filterParameter);
}
public static ReferencedRelatedObjectPropertyGathererResults Gather(DataAccessModel model, Expression[] expressions, ParameterExpression sourceParameterExpression, bool forProjection)
{
var gatherer = new ReferencedRelatedObjectPropertyGatherer(model, sourceParameterExpression, forProjection);
var reducedExpressions = expressions.Select(gatherer.Visit).ToArray();
return new ReferencedRelatedObjectPropertyGathererResults
{
ReducedExpressions = reducedExpressions,
ReferencedRelatedObjectByPath = gatherer.results,
RootExpressionsByPath = gatherer.rootExpressionsByPath,
IncludedPropertyInfoByExpression = gatherer
.includedPropertyInfos
.GroupBy(c => c.RootExpression)
.ToDictionary(c => c.Key, c => c.ToList())
};
}
internal static TransactionExecutionContext Acquire(DataAccessModel dataAccessModel, bool forWrite)
{
var context = GetOrCreateCurrent(dataAccessModel, forWrite, true);
if (context == null)
{
throw new InvalidOperationException("No Current TransactionContext");
}
if (context.disposed)
{
throw new ObjectDisposedException(nameof(TransactionContext));
}
var retval = new TransactionExecutionContext(context);
retval.Finished += context.OnVersionContextFinished;
return retval;
}
protected PostgresSqlDatabaseContext(DataAccessModel model, SqlDialect sqlDialect, SqlDataTypeProvider sqlDataTypeProvider, SqlQueryFormatterManager sqlQueryFormatterManager, PostgresSqlDatabaseContextInfo contextInfo)
: base(model, sqlDialect, sqlDataTypeProvider, sqlQueryFormatterManager, contextInfo.DatabaseName, contextInfo)
{
this.Host = contextInfo.ServerName;
this.UserId = contextInfo.UserId;
this.Password = contextInfo.Password;
this.Port = contextInfo.Port;
var connectionStringBuilder = new NpgsqlConnectionStringBuilder
{
Host = contextInfo.ServerName,
Username = contextInfo.UserId,
Password = contextInfo.Password,
Port = contextInfo.Port,
Pooling = contextInfo.Pooling,
Enlist = false,
BackendTimeouts = contextInfo.BackendTimeouts,
MinPoolSize = contextInfo.MinPoolSize,
MaxPoolSize = contextInfo.MaxPoolSize
};
if (contextInfo.ConnectionTimeout.HasValue)
{
connectionStringBuilder.Timeout = contextInfo.ConnectionTimeout.Value;
}
if (contextInfo.ConnectionCommandTimeout.HasValue)
{
connectionStringBuilder.CommandTimeout = contextInfo.ConnectionCommandTimeout.Value;
}
connectionStringBuilder.Database = contextInfo.DatabaseName;
this.ConnectionString = connectionStringBuilder.ToString();
connectionStringBuilder.Database = "postgres";
this.ServerConnectionString = connectionStringBuilder.ToString();
this.SchemaManager = new PostgresSqlDatabaseSchemaManager(this);
}
/// <summary>
/// Gets the <see cref="DataAccessModelTransactionManager "/> for the current <see cref="Shaolinq.DataAccessModel"/> for the current thread.
/// </summary>
/// <remarks>
/// The framework does not support accessing objects created within different transactions
/// from other transactions. For each Transaction there may be more than one attached
/// <see cref="TransactionContext"/> (one for each thread that participates in the transaction).
/// </remarks>
public static DataAccessModelTransactionManager GetAmbientTransactionManager(DataAccessModel dataAccessModel)
{
DataAccessModelTransactionManager retval;
var transactionManagers = AmbientTransactionManagers;
if (transactionManagers == null)
{
transactionManagers = new Dictionary<DataAccessModel, DataAccessModelTransactionManager>();
DataAccessModelTransactionManager.AmbientTransactionManagers = transactionManagers;
}
if (!transactionManagers.TryGetValue(dataAccessModel, out retval))
{
retval = new DataAccessModelTransactionManager(dataAccessModel);
transactionManagers[dataAccessModel] = retval;
}
return retval;
}
public static ReferencedRelatedObjectPropertyGathererResults Gather(DataAccessModel model, IList<Tuple<ParameterExpression, Expression>> expressions, bool forProjection)
{
var gatherer = new ReferencedRelatedObjectPropertyGatherer(model, null, forProjection);
var reducedExpressions = expressions.Select(c =>
{
gatherer.sourceParameterExpression = c.Item1;
return SqlExpressionReplacer.Replace(gatherer.Visit(c.Item2), d => d.StripForIncludeScanning());
}).ToArray();
return new ReferencedRelatedObjectPropertyGathererResults
{
ReducedExpressions = reducedExpressions,
ReferencedRelatedObjects = gatherer.results.Values.ToList(),
RootExpressionsByPath = gatherer.rootExpressionsByPath,
IncludedPropertyInfoByExpression = gatherer
.includedPropertyInfos
.GroupBy(c => c.RootExpression)
.ToDictionary(c => c.Key, c => c.ToList())
};
}
