/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="name"></param> /// <param name="table"></param> /// <param name="expressions"></param> /// <returns></returns> public IBdoDbModelBuilder AddTable <T>(DbTable table, params Expression <Func <T, object> >[] expressions) where T : class { Type type = typeof(T); var tableName = type.Name; if (table == null) { table = new DbTable { Name = tableName }; if (type.GetCustomAttribute(typeof(BdoDbTableAttribute)) is BdoDbTableAttribute tableAttribute) { table.Name = tableAttribute.Name; table.Schema = tableAttribute.Schema; table.DataModule = tableAttribute.DataModule; } } List <DbField> fields = new List <DbField>(); foreach (var expression in expressions) { fields.Add(DbFluent.Field(expression.GetProperty().Name)); } AddTable(tableName, table, fields.ToArray()); return(this); }
/// <summary> /// Delete the specified employee. /// </summary> /// <param name="code">The code to consider.</param> /// <returns>Returns the generated query.</returns> internal IDbQuery DeleteEmployee5(string code) { var query = DbFluent.DeleteQuery(Table <DbEmployee>()) .Where(q => DbFluent.Eq(DbFluent.Field("code"), code)); return(query); }
// Join conditions --------------------------------------- /// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="table1Alias"></param> /// <param name="table2Alias"></param> /// <returns></returns> public DataExpression JoinCondition( string name, string table1Alias = null, string table2Alias = null) { DbTableRelationship relationship = Relationship(name); if (!string.IsNullOrEmpty(table1Alias)) { relationship.Table1.Alias = table1Alias; } if (!string.IsNullOrEmpty(table2Alias)) { relationship.Table2.Alias = table2Alias; } List <object> queryConditions = new List <object>(); foreach (var mapping in relationship.FieldMappingDictionary.Values) { queryConditions.Add( DbFluent.Eq( DbFluent.Field(mapping.Key, relationship.Table1), DbFluent.Field(mapping.Content, relationship.Table2))); } return(DbFluent.And(queryConditions.ToArray())); }
public void TestInterprete_Fun_SqlEq() { var log = new BdoLog(); string value = null; string fluentScript = DbFluent.Eq( DbFluent.Field("RegionalDirectorateId"), DbFluent.IfNull(value, DbFluent.Field("RegionalDirectorateId"))); string expectedScript = "$sqlEq($sqlField('RegionalDirectorateId'), $sqlIfNull($sqlNull(), $sqlField('RegionalDirectorateId')))"; string xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(expectedScript.Equals(fluentScript, StringComparison.OrdinalIgnoreCase), "Bad fluent interpretation. Result was '" + xml); var scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); string result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(fluentScript, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); string expectedResult = @"""RegionalDirectorateId""=COALESCE(NULL, ""RegionalDirectorateId"")"; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
/// <summary> /// Delete the specified employee. /// </summary> /// <param name="code">The code to consider.</param> /// <returns>Returns the generated query.</returns> internal IDbQuery DeleteEmployee4(string code) { var query = DbFluent.DeleteQuery(Table <DbEmployee>()) .Where(q => DbFluent.Eq(DbFluent.Field("code"), q.UseParameter("code", DataValueTypes.Text))) .WithParameters( ElementFactory.CreateScalar("code", code)); return(query); }
/// <summary> /// Delete the specified employee. /// </summary> /// <param name="code">The code to consider.</param> /// <returns>Returns the generated query.</returns> internal IDbQuery DeleteEmployee6(string code) { var query = DbFluent.DeleteQuery(Table <DbEmployee>()) .From( DbFluent.TableAsJoin( DbQueryJoinKind.Left, Table("RegionalDirectorate").WithAlias("directorate"), JoinCondition("Employee_RegionalDirectorate", null, "directorate"))) .Where(q => DbFluent.Eq(DbFluent.Field("code"), code)); return(query); }
/// <summary> /// /// </summary> /// <param name="code"></param> /// <param name="isPartialUpdate"></param> /// <param name="employee"></param> /// <returns></returns> internal IDbQuery UpdateEmployee1(string code, bool isPartialUpdate, EmployeeDto employee) { return(this.UseQuery("UpdateEmployee1", p => { var query = DbFluent.UpdateQuery(Table <DbEmployee>()) .From( DbFluent.TableAsJoin( DbQueryJoinKind.Left, Table("RegionalDirectorate"), JoinCondition("Employee_RegionalDirectorate"))) .WithReturnedIdFields(Field("Code", "DbEmployee")); query.AddField( !isPartialUpdate || employee?.Code?.Length > 0, q => DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text))); query.AddField( !isPartialUpdate || employee?.ByteArrayField?.Length > 0, q => DbFluent.FieldAsParameter(nameof(DbEmployee.ByteArrayField), q.UseParameter("byteArrayField", DataValueTypes.ByteArray))); query.AddField( !isPartialUpdate || employee?.DateTimeField != null, q => DbFluent.FieldAsParameter(nameof(DbEmployee.DoubleField), q.UseParameter("doubleField", DataValueTypes.Number))); query.AddField( !isPartialUpdate || employee?.DoubleField != null, q => DbFluent.FieldAsParameter(nameof(DbEmployee.DateTimeField), q.UseParameter("dateTimeField", DataValueTypes.Date))); query.AddField( true, q => DbFluent.FieldAsParameter(nameof(DbEmployee.LongField), q.UseParameter("longField", DataValueTypes.Long))); query.AddField( !isPartialUpdate || employee?.RegionalDirectorateCode?.Length > 0, q => DbFluent.FieldAsQuery(nameof(DbEmployee.RegionalDirectorateId), DbFluent.SelectQuery(Table("RegionalDirectorate")) .AddField(DbFluent.Field(nameof(DbRegionalDirectorate.RegionalDirectorateId))) .WithIdFields( DbFluent.FieldAsParameter(nameof(DbRegionalDirectorate.Code), q.UseParameter("directorateCode", DataValueTypes.Text))))); return query; }) .WithParameters( ElementFactory.CreateScalar("code", code), ElementFactory.CreateScalar("byteArrayField", employee.ByteArrayField), ElementFactory.CreateScalar("doubleField", employee.DoubleField), ElementFactory.CreateScalar("dateTimeField", employee.DateTimeField), ElementFactory.CreateScalar("directorateCode", null), ElementFactory.CreateScalar("longField", employee.LongField))); }
/// <summary> /// Delete the specified employee. /// </summary> /// <param name="code">The code to consider.</param> /// <returns>Returns the generated query.</returns> internal IDbQuery DeleteEmployee9(string code) { var query = DbFluent.DeleteQuery(Table <DbEmployee>()) .From( DbFluent.TableAsJoin(DbQueryJoinKind.Left, Table("RegionalDirectorate").WithAlias("directorate"), JoinCondition("Employee_RegionalDirectorate"))) .Where(q => DbFluent.Eq(DbFluent.Field("code"), q.UseParameter("code", DataValueTypes.Text))) .AddIdField(q => DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text))) .WithParameters( ElementFactory.CreateScalar("code", code)); return(query); }
public void AddFields() { var log = new BdoLog(); var tuple = DbFluent.Tuple( DbFluent.Field("field1", DbFluent.Table("Table1")), DbFluent.Field("field2", DbFluent.Table("Table1")), DbFluent.Field("field3", DbFluent.Table("Table1")).WithAlias("f3")) .AddFields( DbFluent.FieldAsLiteral("field1", 1), DbFluent.FieldAsLiteral("field2", DbFluent.Table("Table2"), 2).WithAlias("f3")); Assert.That(tuple.Fields.Count == 3, "Bad script interpretation"); }
/// <summary> /// /// </summary> /// <param name="code"></param> /// <returns></returns> internal IDbQuery SelectEmployeeWithCode2(string code) { return(this.UseQuery("SelectEmployeeWithCode2", p => DbFluent.SelectQuery(Table <DbEmployee>()) .From( DbFluent.TableAsJoin( DbQueryJoinKind.Left, Table("RegionalDirectorate"), JoinCondition("Employee_RegionalDirectorate"))) .WithFields(Tuple("Fields_SelectEmployee")) .WithLimit(100) .AddIdField(q => DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("code", DataValueTypes.Text))) .Where(DbFluent.Eq(DbFluent.Field("field1"), DbFluent.Field("field2")))) .WithParameters( ElementFactory.CreateScalar("code", code))); }
/// <summary> /// /// </summary> /// <param name="employee"></param> /// <returns></returns> internal IDbQuery InsertEmployee3(EmployeeDto employee) { return(DbFluent.InsertQuery(Table <DbEmployee>()) .WithFields(q => new[] { DbFluent.Field(nameof(DbEmployee.Code)), DbFluent.Field(nameof(DbEmployee.ByteArrayField)), DbFluent.Field(nameof(DbEmployee.DoubleField)), DbFluent.Field(nameof(DbEmployee.DateTimeField)), DbFluent.Field(nameof(DbEmployee.LongField)) }) .WithReturnedIdFields(new[] { Field <DbEmployee>(p => p.EmployeeId) }) .From(p => p.UseSubQuery( DbFluent.SelectQuery(Table <DbEmployee>()) .WithFields(q => new[] { DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("newCode", DataValueTypes.Text)), DbFluent.FieldAsParameter(nameof(DbEmployee.ByteArrayField), q.UseParameter("ByteArrayField", DataValueTypes.Text)), DbFluent.FieldAsParameter(nameof(DbEmployee.DoubleField), q.UseParameter("DoubleField", DataValueTypes.Text)), DbFluent.FieldAsParameter(nameof(DbEmployee.DateTimeField), q.UseParameter("DateTimeField", DataValueTypes.Text)), DbFluent.FieldAsParameter(nameof(DbEmployee.LongField), q.UseParameter("LongField", DataValueTypes.Date)), DbFluent.FieldAsQuery <DbContact>(p => p.ContactId, DbFluent.SelectQuery(Table <DbContact>()) .WithLimit(1) .AddField(Field <DbContact>(f => f.ContactId)) .AddIdField( DbFluent.FieldAsParameter <DbContact>(f => f.Code, q.UseParameter("contactCode", DataValueTypes.Text)))), }) .WithIdFields(q => new[] { DbFluent.FieldAsParameter(nameof(DbEmployee.Code), q.UseParameter("oldCode", DataValueTypes.Text)) }) .WithParameters( ElementFactory.CreateScalar("newCode", employee.Code), ElementFactory.CreateScalar("contactCode", "contactCodeA"), ElementFactory.CreateScalar("oldCode", "oldCode"), ElementFactory.CreateScalar("ByteArrayField", employee.ByteArrayField), ElementFactory.CreateScalar("DoubleField", employee.DoubleField), ElementFactory.CreateScalar("DateTimeField", employee.DateTimeField), ElementFactory.CreateScalar("LongField", employee.LongField))))); }
/// <summary> /// /// </summary> /// <param name="q"></param> /// <param name="orderBy"></param> /// <param name="pageSize"></param> /// <param name="pageToken"></param> /// <param name="log"></param> /// <returns></returns> internal IDbQuery ListEmployees1( string q, string orderBy, int?pageSize = null, string pageToken = null, IBdoLog log = null) => DbFluent.SelectQuery("GetMyTables", DbFluent.Table()) .WithLimit(100) .AsDistinct() .WithFields( DbFluent.FieldAsAll(DbFluent.Table("table")), DbFluent.Field("Field1", DbFluent.Table("table")), DbFluent.Field("Field2", DbFluent.Table("table"))) .From( DbFluent.Table(nameof(DbRegionalDirectorate).Substring(2), "schema1").WithAlias("table"), DbFluent.TableAsJoin( DbQueryJoinKind.Left, DbFluent.Table("DbTable1".Substring(2), "schema2").WithAlias("table1"), DbFluent.And( DbFluent.Eq( DbFluent.Field("table1key", DbFluent.Table("table1")), DbFluent.Field(nameof(DbRegionalDirectorate.Code), DbFluent.Table("table"))), DbFluent.Eq( DbFluent.Field("table2key", DbFluent.Table("table2")), DbFluent.Field(nameof(DbRegionalDirectorate.LabelEN), DbFluent.Table("table"))))), DbFluent.TableAsJoin( DbQueryJoinKind.Left, DbFluent.Table("DbTable1".Substring(2), "schema2").WithAlias("table2"), DbFluent.Eq( DbFluent.Field("table1key", DbFluent.Table("table2")), DbFluent.Field("Field1", DbFluent.Table("table")))) ) .Filter( q, DbApiFluent.CreateFilterDefinition( DbApiFluent.CreateFilterClause("startDate", DbFluent.Field("CreationDate", DbFluent.Table("table")), DataOperators.GreaterOrEqual), DbApiFluent.CreateFilterClause("endDate", DbFluent.Field("LastModificationDate", DbFluent.Table("table")), DataOperators.LesserOrEqual), DbApiFluent.CreateFilterClause("code", DbFluent.Field("Code", DbFluent.Table("table")), DataOperators.Equal)), log) .Sort( orderBy, DbApiFluent.CreateSortDefinition( DbApiFluent.CreateSortClause("startDate", DbFluent.Field("CreationDate", DbFluent.Table("table"))), DbApiFluent.CreateSortClause("endDate", DbFluent.Field("LastModificationDate", DbFluent.Table("table"))), DbApiFluent.CreateSortClause("code", DbFluent.Field("Code", DbFluent.Table("table")))), log);
public void TestInterprete_Fun_SqlEq_Null() { var log = new BdoLog(); // Case: value, null string value = null; string fluentScript1 = DbFluent.Eq( null, DbFluent.IfNull(value, DbFluent.Field("RegionalDirectorateId", DbFluent.Table("Table1", "Schema1")))); var scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); string result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(fluentScript1, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); string expectedResult = @"COALESCE(NULL, ""Schema1"".""Table1"".""RegionalDirectorateId"") is null"; string xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); // Case: null, value string fluentScript2 = DbFluent.Eq( DbFluent.IfNull(value, DbFluent.Field("RegionalDirectorateId", DbFluent.Table("Table1", "Schema1"))), null); result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(fluentScript2, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); expectedResult = @"COALESCE(NULL, ""Schema1"".""Table1"".""RegionalDirectorateId"") is null"; xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
/// <summary> /// Updates the regional directorate of the specified Fidal employee. /// </summary> /// <param name="regionalDirectorateCode">The code of the regional directorate to consider.</param> /// <returns>Returns the query.</returns> internal IDbQuery UpdateEmployee2(string regionalDirectorateCode) { return(this.UseQuery("UpdateEmployee2", p => DbFluent.UpdateQuery(Table("DbEmployee", "employee")) .AddField(q => DbFluent.Field <DbEmployee>(q => q.RegionalDirectorateId).AsNull()) .From(Table("RegionalDirectorate", "regionalDirectorate")) .AddIdField(q => DbFluent.FieldAsOther <DbEmployee>( t => t.RegionalDirectorateId, Table("DbEmployee", "employee"), DbFluent.Field <DbRegionalDirectorate>( t => t.RegionalDirectorateId, Table("RegionalDirectorate").WithAlias("regionalDirectorate")))) .AddIdField(q => DbFluent.FieldAsParameter <DbEmployee>( t => t.Code, DbFluent.Table("employee"), q.UseParameter("regionalDirectorateCode", DataValueTypes.Text))) .WithReturnedIdFields(Field("Code", "DbEmployee", "employee")) ) .WithParameters( ElementFactory.CreateScalar("regionalDirectorateCode", regionalDirectorateCode))); }
public void TestInterprete_Fun_SqlULPad() { var log = new BdoLog(); string fluentScript = DbFluent.LeftPadding(DbFluent.Field("RegionalDirectorateId"), 10, DbFluent.Text("A")); var scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); string result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(fluentScript, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); string expectedResult = @"lpad(""RegionalDirectorateId"", 10, 'A')"; string xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
public void TestInterprete_Fun_SqlIf() { string value = null; string script1 = DbFluent.If(DbFluent.IsNull(value), DbFluent.Field("RegionalDirectorateId"), DbFluent.Field("RegionalDirectorateId2")); string expectedResult = @"case when (null is null) then ""RegionalDirectorateId"" else ""RegionalDirectorateId2"" end"; var log = new BdoLog(); var scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); string result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(script1, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); string xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
public void TestInterprete_Fun_SqlEncode() { string script = DbFluent.EncodeBase64(DbFluent.Text("ABCDE")); string expectedResult = @"encode('ABCDE', 'base64')"; var log = new BdoLog(); var scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); string result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(script, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); string xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); script = DbFluent.DecodeBase64(DbFluent.Field("ABCDE")); expectedResult = @"decode(""ABCDE"", 'base64')"; log = new BdoLog(); scriptVariableSet = new ScriptVariableSet(); scriptVariableSet.SetValue(VarSetDb.__DbBuilder, DbQueryFactory.CreateQueryBuilder <DbQueryBuilder_PostgreSql>(GlobalVariables.AppHost)); result = GlobalVariables.AppHost.Scope.Interpreter.Evaluate(script, DataExpressionKind.Script, scriptVariableSet, log: log)?.ToString(); xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
/// <summary> /// /// </summary> /// <param name="builder"></param> public void OnCreating_Test1() { AddTable <DbEmployee>(DbFluent.Table(nameof(DbEmployee).Substring(2), "Mdm")) .AddTable("RegionalDirectorate", DbFluent.Table(nameof(DbRegionalDirectorate).Substring(2), "Mdm")) .AddTable <DbContact>(DbFluent.Table(nameof(DbContact).Substring(2), "Mdm")) .AddRelationship("Employee_RegionalDirectorate", Table <DbEmployee>(), Table("RegionalDirectorate"), (nameof(DbEmployee.EmployeeId), nameof(DbRegionalDirectorate.RegionalDirectorateId))) .AddRelationship <DbEmployee, DbContact>((p => p.MainContactId, q => q.ContactId)) .AddRelationship <DbEmployee, DbContact>("secondary", (p => p.MainContactId, q => q.ContactId)) .AddTuple("Fields_SelectEmployee", DbFluent.FieldAsAll(Table <DbEmployee>()), DbFluent.Field(nameof(DbRegionalDirectorate.RegionalDirectorateId), Table("RegionalDirectorate")), DbFluent.Field(nameof(DbRegionalDirectorate.Code), Table("RegionalDirectorate"))) .AddTuple("Fields_SelectEmployee2", DbFluent.FieldAsAll(Table <DbEmployee>("employee")), DbFluent.Field <DbContact>(p => p.Code, Table <DbContact>("contact")).WithAlias("contactCode"), DbFluent.Field(nameof(DbRegionalDirectorate.RegionalDirectorateId), Table("RegionalDirectorate", "regionalDirectorate")), DbFluent.Field(nameof(DbRegionalDirectorate.Code), Table("RegionalDirectorate", "regionalDirectorate"))) .AddQuery( DbFluent.StoredQuery( DbFluent.SelectQuery(Table <DbEmployee>()) .From( Table <DbEmployee>(), DbFluent.TableAsJoin( DbQueryJoinKind.Left, Table("RegionalDirectorate"), JoinCondition("Employee_RegionalDirectorate"))) .WithFields(Tuple("Fields_SelectEmployee")) .AddIdField(p => DbFluent.FieldAsParameter(nameof(DbEmployee.Code), p.UseParameter("code"))))); }
public void TestSqlIfNull() { var expression = DbFluent.Eq( DbFluent.Field("fieldA"), DbFluent.IfNull( DbFluent.Parameter("myText"), DbFluent.Field("fieldA"))); var log = new BdoLog(); string expectedResult = @"""fieldA""=coalesce(|*|p:myText|*|, ""fieldA"")"; var result = _appHost.Interpreter.Evaluate <string>( expression, new ScriptVariableSet().SetDbBuilder(new DbQueryBuilder_PostgreSql()), log: log); var xml = ""; if (log.HasErrorsOrExceptions()) { xml = ". Result was '" + log.ToXml(); } Assert.That(result.Trim().Equals(expectedResult.Trim(), StringComparison.OrdinalIgnoreCase), "Bad script interpretation" + xml); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="expression"></param> /// <param name="tableAlias"></param> /// <returns></returns> public DbField Field <T>(Expression <Func <T, object> > expression, string tableAlias = null) { return(DbFluent.Field(expression.GetProperty().Name, Table <T>(tableAlias))); }
/// <summary> /// /// </summary> /// <param name="name"></param> /// <param name="tableName"></param> /// <param name="tableAlias"></param> /// <returns></returns> public DbField Field(string name, string tableName, string tableAlias = null) { return(DbFluent.Field(name, Table(tableName, tableAlias))); }
/// <summary> /// /// </summary> public void OnCreating_Test2() { // Community AddTable <DbCommunity>( DbFluent.Table(nameof(DbCommunity).Substring(2), DbSchemas.Test2.ToString()), q => q.CommunityId, q => q.Code, q => q.CreationDate, q => q.LabelEN, q => q.LabelFR, q => q.LastModificationDate) .AddTuple( "SelectCommunity", AllFields <DbCommunity>().ToArray() ) .AddTuple( "UpdateCommunity", DbFluent.Field(nameof(DbCommunity.Code), Table <DbCommunity>()), Field <DbCommunity>(q => q.LabelEN), Field(nameof(DbCommunity.LabelFR), "DbCommunity"), DbFluent.Field(nameof(DbCommunity.LastModificationDate), Table <DbCommunity>()) ); // Country AddTable <DbCountry>( DbFluent.Table(nameof(DbCountry).Substring(2), DbSchemas.Test2.ToString()), q => q.CountryId, q => q.Code, q => q.CreationDate, q => q.LabelEN, q => q.LabelFR, q => q.LastModificationDate) .AddTuple( "SelectCountry", Field <DbCountry>(q => q.CountryId), DbFluent.Field(nameof(DbCountry.Code), Table <DbCountry>()), DbFluent.Field(nameof(DbCountry.CreationDate)), DbFluent.Field(nameof(DbCountry.LabelEN)), DbFluent.Field(nameof(DbCountry.LabelFR)), DbFluent.Field(nameof(DbCountry.LastModificationDate))) .AddTuple( "UpdateCountry", DbFluent.Field(nameof(DbCountry.Code)), DbFluent.Field(nameof(DbCountry.LabelEN)), DbFluent.Field(nameof(DbCountry.LabelFR)), DbFluent.Field(nameof(DbCountry.LastModificationDate))); // Country_Community AddTable("Country_Community", DbFluent.Table(nameof(DbCountry_Community).Substring(2), DbSchemas.Test2.ToString())) .AddTuple( "SelectCountry_Community", DbFluent.Field(nameof(DbCountry_Community.CountryId), Table("Country_Community")), DbFluent.Field(nameof(DbCountry_Community.CommunityId), Table("Country_Community"))) .AddTuple( "UpdateCountry", DbFluent.Field(nameof(DbCountry_Community.CountryId), Table("Country_Community")), DbFluent.Field(nameof(DbCountry_Community.CommunityId), Table("Country_Community"))); // CountryInformation AddTable <DbCountryInformation>( DbFluent.Table(nameof(DbCountryInformation).Substring(2), DbSchemas.Test2.ToString())) .AddTuple( "SelectCountryInformation", DbFluent.Field(nameof(DbCountryInformation.CountryId)), DbFluent.Field(nameof(DbCountryInformation.CreationDate)), DbFluent.Field(nameof(DbCountryInformation.LastModificationDate)), DbFluent.Field(nameof(DbCountryInformation.StartDate))) .AddTuple( "UpdateCountryInformation", DbFluent.Field(nameof(DbCountryInformation.LastModificationDate)), DbFluent.Field(nameof(DbCountryInformation.StartDate))); // Relationships AddRelationship( "Community_Country_Community", Table <DbCommunity>(), Table("Country_Community"), (nameof(DbCommunity.CommunityId), nameof(DbCountry_Community.CommunityId))) .AddRelationship( "Community_Country_Community", Table <DbCountry>(), Table("Country_Community"), (nameof(DbCountry.CountryId), nameof(DbCountry_Community.CountryId))) .AddRelationship <DbCountryInformation, DbCountry>( (q => q.CountryId, q => q.CountryId)); }