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 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()) }; }