public override void DoSecondPass(IDictionary <string, PersistentClass> persistentClasses)
{
if (value is ManyToOne)
{
ManyToOne manyToOne = (ManyToOne)value;
PersistentClass @ref;
persistentClasses.TryGetValue(manyToOne.ReferencedEntityName, out @ref);
if (@ref == null)
{
throw new AnnotationException(
"@OneToOne or @ManyToOne on "
+ StringHelper.Qualify(entityClassName, path)
+ " references an unknown entity: "
+ manyToOne.ReferencedEntityName);
}
BinderHelper.CreateSyntheticPropertyReference(columns, @ref, null, manyToOne, false, mappings);
TableBinder.BindFk(@ref, null, columns, manyToOne, unique, mappings);
//HbmBinder does this only when property-ref != null, but IMO, it makes sense event if it is null
if (!manyToOne.IsIgnoreNotFound)
{
manyToOne.CreatePropertyRefConstraints(persistentClasses);
}
}
else if (value is OneToOne)
{
value.CreateForeignKey();
}
else
{
throw new AssertionFailure("FkSecondPass for a wrong value type: " + value.GetType().Name);
}
}
private static Ejb3Column[] BuildImplicitColumn(IPropertyData inferredData,
IDictionary <string, Join> secondaryTables,
IPropertyHolder propertyHolder, Nullability nullability,
ExtendedMappings mappings)
{
Ejb3Column[] columns;
columns = new Ejb3Column[1];
Ejb3Column column = new Ejb3Column();
column.SetImplicit(false);
//not following the spec but more clean
if (nullability != Nullability.ForcedNull && inferredData.ClassOrElement.IsPrimitive &&
!inferredData.Property.GetType().IsArray) //TODO: IsArray in this way ???
{
column.SetNullable(false);
}
column.SetLength(DEFAULT_COLUMN_LENGTH);
column.PropertyName = BinderHelper.GetRelativePath(propertyHolder, inferredData.PropertyName);
column.PropertyHolder = propertyHolder;
column.SetJoins(secondaryTables);
column.Mappings = mappings;
column.Bind();
columns[0] = column;
return(columns);
}
public object GetValue(NameValueCollection data)
{
object value = null;
bool succeed = false;
if (Binder != null)
{
value = Binder.GetConvert().Parse(data, Info.Name, Binder.Prefix, out succeed);
if (!succeed && Binder.Fungible != null)
{
value = Activator.CreateInstance(Binder.Fungible);
}
return(value);
}
else
{
IConvert convert = BindUtils.GetConvert(Info.PropertyType);
if (convert != null)
{
value = convert.Parse(data, Info.Name, null, out succeed);
}
else
{
if (Info.PropertyType.IsValueType)
{
value = BinderHelper.GetValue(Info.PropertyType, Info.Name);
}
else
{
value = GetObject(data);
}
}
}
return(value);
}
private object GetObject(NameValueCollection data)
{
if (Info.PropertyType.GetInterface(typeof(IList <>).Name) != null || Info.PropertyType.Name == "IList`1")
{
if (Binder == null)
{
return(BinderHelper.GetList(Info.PropertyType, data, null));
}
else
{
return(BinderHelper.GetList(Info.PropertyType, data, Binder.Prefix));
}
}
else
{
if (Binder == null)
{
return(BinderHelper.GetObject(Info.PropertyType, null));
}
else
{
return(BinderHelper.GetObject(Info.PropertyType, Binder.Prefix));
}
}
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
var serializer = bindingContext.GetSerializer(node.Type, null);
var accumulator = new AccumulatorExpression(
node.Type,
"__result",
serializer,
AccumulatorType.Sum,
Expression.Constant(1));
source = new GroupByExpression(
node.Type,
source,
Expression.Constant(1),
new[] { accumulator });
return(new PipelineExpression(
source,
new FieldExpression(accumulator.FieldName, accumulator.Serializer),
new CountResultOperator(
node.Type,
bindingContext.GetSerializer(node.Type, node))));
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
{
bsonWriter.WriteNull();
return;
}
var metaObject = ((IDynamicMetaObjectProvider)value).GetMetaObject(Expression.Constant(value));
var memberNames = metaObject.GetDynamicMemberNames().ToList();
if (memberNames.Count == 0)
{
bsonWriter.WriteNull();
return;
}
bsonWriter.WriteStartDocument();
foreach (var memberName in memberNames)
{
bsonWriter.WriteName(memberName);
var memberValue = BinderHelper.GetMemberValue(value, memberName);
if (memberValue == null)
{
bsonWriter.WriteNull();
}
else
{
var serializer = BsonSerializer.LookupSerializer(memberValue.GetType());
serializer.Serialize(bsonWriter, nominalType, memberValue, options);
}
}
bsonWriter.WriteEndDocument();
}
private static IEnumerable <Assembly> GetReferencedAssemblyNames(DXCompileParameter parameter)
{
// 확장 모듈에서 생성된 객체인경우 어셈블리 가져옴
List <Assembly> assemblies = parameter.Screens.Select(s => s.GetType().Assembly).ToList();
foreach (PBinderHost comp in parameter.Components)
{
foreach (IBinderHost host in BinderHelper.FindHostNodes(comp))
{
if (host is PFunction func)
{
assemblies.Add(func.FunctionInfo.DeclaringType.Assembly);
}
else if (host is PTrigger trigger)
{
assemblies.Add(trigger.EventInfo.DeclaringType.Assembly);
}
}
}
return(assemblies
.Where(ass => !ass.GetName().Name.AnyEquals("DeXign.Core"))
.Distinct());
}
public SimpleValue FillSimpleValue(SimpleValue simpleValue)
{
string type = BinderHelper.IsDefault(explicitType) ? returnedClassName : explicitType;
TypeDef typeDef = mappings.GetTypeDef(type);
if (typeDef != null)
{
type = typeDef.TypeClass;
simpleValue.TypeParameters = typeDef.Parameters;
}
if (typeParameters != null && typeParameters.Count != 0)
{
//explicit type params takes precedence over type def params
simpleValue.TypeParameters = typeParameters;
}
simpleValue.TypeName = type;
if (persistentClassName != null)
{
simpleValue.SetTypeUsingReflection(persistentClassName, propertyName, "");
}
foreach (Ejb3Column column in columns)
{
column.linkWithValue(simpleValue);
}
return(simpleValue);
}
/// <summary>
/// Get a application from the service collection.
/// This method builds the <see cref="ServiceProvider" /> collection. Because of this behavior, the options must be registered in the
/// <see cref="IServiceCollection" /> prior to calling this method.
/// </summary>
/// <param name="services"></param>
/// <param name="settingsSection"></param>
/// <typeparam name="TOptions"></typeparam>
/// <returns></returns>
public static TOptions GetOptions <TOptions>(this IServiceCollection services, string settingsSection)
where TOptions : class, new()
{
using ServiceProvider serviceProvider = services.BuildServiceProvider();
var configuration = serviceProvider.GetService <IConfiguration>();
return(BinderHelper.BindOptions <TOptions>(configuration.GetSection(settingsSection)));
}
private void SetFKNameIfDefined(Join join)
{
TableAttribute matchingTable = FindMatchingComplimentTableAnnotation(join);
if (matchingTable != null && !BinderHelper.IsDefault(matchingTable.ForeignKey.Name))
{
((SimpleValue)join.Key).ForeignKeyName = matchingTable.ForeignKey.Name;
}
}
public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
return(new PipelineExpression(
source,
pipeline.Projector));
}
private static Ejb3Column[] BuildColumnFromAnnotation(ColumnAttribute[] anns, Nullability nullability,
IPropertyHolder propertyHolder, IPropertyData inferredData,
IDictionary <string, Join> secondaryTables,
ExtendedMappings mappings)
{
ColumnAttribute[] actualCols = anns;
ColumnAttribute[] overriddenCols = propertyHolder.GetOverriddenColumn(StringHelper.Qualify(propertyHolder.Path, inferredData.PropertyName));
if (overriddenCols != null)
{
//check for overridden first
if (anns != null && overriddenCols.Length != anns.Length)
{
throw new AnnotationException("AttributeOverride.column() should override all columns for now");
}
actualCols = overriddenCols.Length == 0 ? null : overriddenCols;
log.DebugFormat("Column(s) overridden for property {0}", inferredData.PropertyName);
}
if (actualCols == null)
{
return(BuildImplicitColumn(inferredData, secondaryTables, propertyHolder, nullability, mappings));
}
int length = actualCols.Length;
Ejb3Column[] columns = new Ejb3Column[length];
for (int index = 0; index < length; index++)
{
ColumnAttribute col = actualCols[index];
String sqlType = col.ColumnDefinition.Equals("") ? null : col.ColumnDefinition;
Ejb3Column column = new Ejb3Column();
column.SetImplicit(false);
column.SetSqlType(sqlType);
column.SetLength(col.Length);
column.SetPrecision(col.Precision);
column.SetScale(col.Scale);
column.SetLogicalColumnName(col.Name);
column.PropertyName = BinderHelper.GetRelativePath(propertyHolder, inferredData.PropertyName);
column.SetNullable(col.Nullable); //TODO force to not null if available? This is a (bad) user choice.
column.SetUnique(col.Unique);
column.SetInsertable(col.Insertable);
column.SetUpdatable(col.Updatable);
column.SetSecondaryTableName(col.Table);
column.PropertyHolder = propertyHolder;
column.SetJoins(secondaryTables);
column.Mappings = mappings;
column.Bind();
columns[index] = column;
}
return(columns);
}
public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = BinderHelper.BindSelect(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
var serializer = bindingContext.GetSerializer(source.Selector.Type, source.Selector);
return(new PipelineExpression(
source,
new DocumentExpression(serializer)));
}
private void SetNodeOpacity(BindOptions option, double opacity)
{
this.Opacity = opacity;
foreach (var node in BinderHelper.FindHostNodes(this.Model, option))
{
var element = node.GetView <FrameworkElement>();
if (element != null)
{
element.Opacity = opacity;
}
}
}
private void Binder_Binded(object sender, IBinder e)
{
var expression = BinderHelper.GetPairBinder(this.Binder, e);
var output = (expression.Output as PBinder).GetView <BindThumb>();
var input = (expression.Input as PBinder).GetView <BindThumb>();
if (output == null || input == null)
{
return;
}
// Propagate
output.PropagateBind(output, input);
}
public WPFCodeBuilder(DXCompileParameter parameter, CSharpGenerator generator)
{
this.Parameter = parameter;
this.NativeGenerator = generator;
sdkNamespaces =
parameter.Components
.SelectMany(c => BinderHelper.FindHostNodes(c))
.Where(host => host is PFunction)
.Select(host => (host as PFunction).FunctionInfo.DeclaringType.Namespace)
.Distinct()
.ToList();
definedNamespaces = new List <string>();
logicCodes = new List <string>();
}
public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindSelect(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
return(new PipelineExpression(
source,
pipeline.Projector,
new MinResultOperator(node.Type)));
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
source = new TakeExpression(source, Expression.Constant(1));
return(new PipelineExpression(
source,
pipeline.Projector,
new AnyResultOperator()));
}
public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindSelect(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
return(new PipelineExpression(
source,
pipeline.Projector,
new StandardDeviationResultOperator(
node.Type,
bindingContext.GetSerializer(node.Type, node),
node.Method.Name == nameof(MongoEnumerable.StandardDeviationSample))));
}
public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
return(new PipelineExpression(
source,
pipeline.Projector,
new FirstResultOperator(
node.Type,
pipeline.Projector.Serializer,
node.Method.Name == nameof(Enumerable.FirstOrDefault))));
}
// CreateScope (Recursive)
internal static string CreateScope(DXMapper <CSharpCodeMapAttribute> mapper, CodeComponent <CSharpCodeMapAttribute>[] scopeComponents, NameContainer localVariableContainer, bool isCodeBlock = false)
{
var scopeBuilder = new IndentStringBuilder();
var stack = new Stack <CodeComponent <CSharpCodeMapAttribute> >(scopeComponents.Reverse());
if (!isCodeBlock)
{
scopeBuilder.AppendLine();
scopeBuilder.AppendLine("{");
}
while (stack.Count > 0)
{
var cc = stack.Pop();
var mappingResult = mapper.Build(cc.Element, cc.Attribute.MappingCode);
var sourceBuilder = new IndentStringBuilder(mappingResult.Source);
if (cc.Element is PBinderHost host)
{
foreach (DXToken token in mappingResult.Errors)
{
switch (token.Token)
{
case "Scope":
{
if (!token.IsIndexed)
{
continue;
}
int index = int.Parse(token.Parameters[0]) - 1;
if (host is PFunction)
{
index++;
}
var scopeBinder = host[BindOptions.Output].ElementAt(index) as PBinder;
var scopeZeroHosts = scopeBinder.Items.Select(b => b.GetBinderHost());
var childScopeComponents = BinderHelper.FindZeroLevelNodes(scopeZeroHosts, withRoot: true)
.Distinct()
.Select(childHost => new CodeComponent <CSharpCodeMapAttribute>(
childHost, childHost.GetAttribute <CSharpCodeMapAttribute>()))
.ToArray();
sourceBuilder.Replace(
token.OriginalSource,
CreateScope(mapper, childScopeComponents, localVariableContainer));
break;
}
case "Line":
{
if (!token.IsIndexed)
{
continue;
}
int index = int.Parse(token.Parameters[0]) - 1;
var paramBinder = host[BindOptions.Parameter].ElementAt(index) as PBinder;
ProcessBinderValue(mapper, sourceBuilder, token, paramBinder);
break;
}
default:
break;
}
}
}
scopeBuilder.AppendBlock(sourceBuilder.ToString(), 1);
scopeBuilder.AppendLine();
}
if (!isCodeBlock)
{
scopeBuilder.AppendLine("}");
}
return(scopeBuilder.ToString());
}
public void BindEntity()
{
persistentClass.IsAbstract = annotatedClass.IsAbstract;
persistentClass.ClassName = annotatedClass.Name;
persistentClass.NodeName = name;
//TODO:review this
//persistentClass.setDynamic(false); //no longer needed with the Entity name refactoring?
persistentClass.EntityName = (annotatedClass.Name);
BindDiscriminatorValue();
persistentClass.IsLazy = lazy;
if (proxyClass != null)
{
persistentClass.ProxyInterfaceName = proxyClass.Name;
}
persistentClass.DynamicInsert = dynamicInsert;
persistentClass.DynamicUpdate = dynamicUpdate;
if (persistentClass is RootClass)
{
RootClass rootClass = (RootClass)persistentClass;
bool mutable = true;
//priority on @Immutable, then @Entity.mutable()
if (annotatedClass.IsAttributePresent <ImmutableAttribute>())
{
mutable = false;
}
else
{
var entityAnn = annotatedClass.GetAttribute <EntityAttribute>();
if (entityAnn != null)
{
mutable = entityAnn.IsMutable;
}
}
rootClass.IsMutable = mutable;
rootClass.IsExplicitPolymorphism = ExplicitPolymorphismConverter.Convert(polymorphismType);
if (StringHelper.IsNotEmpty(where))
{
rootClass.Where = where;
}
if (cacheConcurrentStrategy != null)
{
rootClass.CacheConcurrencyStrategy = cacheConcurrentStrategy;
rootClass.CacheRegionName = cacheRegion;
//TODO: LazyPropertiesCacheable
//rootClass.LazyPropertiesCacheable = cacheLazyProperty ;
}
rootClass.IsForceDiscriminator = annotatedClass.IsAttributePresent <ForceDiscriminatorAttribute>();
}
else
{
if (explicitHibernateEntityAnnotation)
{
log.WarnFormat("[NHibernate.Annotations.Entity] used on a non root entity: ignored for {0}", annotatedClass.Name);
}
if (annotatedClass.IsAttributePresent <ImmutableAttribute>())
{
log.WarnFormat("[Immutable] used on a non root entity: ignored for {0}", annotatedClass.Name);
}
}
persistentClass.OptimisticLockMode = OptimisticLockModeConverter.Convert(optimisticLockType);
persistentClass.SelectBeforeUpdate = selectBeforeUpdate;
//set persister if needed
//[Persister] has precedence over [Entity.persister]
var persisterAnn = annotatedClass.GetAttribute <PersisterAttribute>();
System.Type persister = null;
if (persisterAnn != null)
{
persister = persisterAnn.Implementation;
}
else
{
var entityAnn = annotatedClass.GetAttribute <EntityAttribute>();
if (entityAnn != null && !BinderHelper.IsDefault(entityAnn.Persister))
{
try
{
persister = ReflectHelper.ClassForName(entityAnn.Persister);
}
catch (TypeLoadException tle)
{
throw new AnnotationException("Could not find persister class: " + persister, tle);
}
}
}
if (persister != null)
{
persistentClass.EntityPersisterClass = persister;
}
persistentClass.BatchSize = batchSize;
//SQL overriding
var sqlInsert = annotatedClass.GetAttribute <SQLInsertAttribute>();
var sqlUpdate = annotatedClass.GetAttribute <SQLUpdateAttribute>();
var sqlDelete = annotatedClass.GetAttribute <SQLDeleteAttribute>();
var sqlDeleteAll = annotatedClass.GetAttribute <SQLDeleteAllAttribute>();
var loader = annotatedClass.GetAttribute <LoaderAttribute>();
if (sqlInsert != null)
{
persistentClass.SetCustomSQLInsert(sqlInsert.Sql.Trim(), sqlInsert.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlInsert.Check));
}
if (sqlUpdate != null)
{
persistentClass.SetCustomSQLUpdate(sqlUpdate.Sql.Trim(), sqlUpdate.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlUpdate.Check));
}
if (sqlDelete != null)
{
persistentClass.SetCustomSQLDelete(sqlDelete.Sql, sqlDelete.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlDelete.Check));
}
if (sqlDeleteAll != null)
{
persistentClass.SetCustomSQLDelete(sqlDeleteAll.Sql, sqlDeleteAll.Callable,
ExecuteUpdateResultCheckStyleConverter.Convert(sqlDeleteAll.Check));
}
if (loader != null)
{
persistentClass.LoaderName = loader.NamedQuery;
}
//tuplizers
if (annotatedClass.IsAttributePresent <TuplizerAttribute>())
{
foreach (TuplizerAttribute tuplizer in annotatedClass.GetAttributes <TuplizerAttribute>())
{
var mode = EntityModeConverter.Convert(tuplizer.EntityMode);
persistentClass.AddTuplizer(mode, tuplizer.Implementation.Name);
}
}
if (annotatedClass.IsAttributePresent <TuplizerAttribute>())
{
var tuplizer = annotatedClass.GetAttribute <TuplizerAttribute>();
var mode = EntityModeConverter.Convert(tuplizer.EntityMode);
persistentClass.AddTuplizer(mode, tuplizer.Implementation.Name);
}
if (!inheritanceState.HasParents)
{
var iter = filters.GetEnumerator();
while (iter.MoveNext())
{
var filter = iter.Current;
String filterName = filter.Key;
String cond = filter.Value;
if (BinderHelper.IsDefault(cond))
{
FilterDefinition definition = mappings.GetFilterDefinition(filterName);
cond = definition == null ? null : definition.DefaultFilterCondition;
if (StringHelper.IsEmpty(cond))
{
throw new AnnotationException("no filter condition found for filter " + filterName + " in " + name);
}
}
persistentClass.AddFilter(filterName, cond);
}
}
else
{
if (filters.Count > 0)
{
log.WarnFormat("@Filter not allowed on subclasses (ignored): {0}", persistentClass.EntityName);
}
}
log.DebugFormat("Import with entity name {0}", name);
try
{
mappings.AddImport(persistentClass.EntityName, name);
String entityName = persistentClass.EntityName;
if (!entityName.Equals(name))
{
mappings.AddImport(entityName, entityName);
}
}
catch (MappingException me)
{
throw new AnnotationException("Use of the same entity name twice: " + name, me);
}
}
/// <summary>
/// Gets an section of the json configuration and binds to an object.
/// </summary>
/// <param name="configuration">
/// <see cref="IConfiguration" />
/// </param>
/// <param name="section">Configuration section name</param>
/// <typeparam name="TOptions">Resulting object</typeparam>
/// <returns>Instance of TOptions</returns>
public static TOptions GetOptions <TOptions>(this IConfiguration configuration, string section)
where TOptions : class, new()
{
return(BinderHelper.BindOptions <TOptions>(configuration.GetSection(section)));
}
/// <summary>
/// Gets an section of the json configuration and binds to an object.
/// </summary>
/// <param name="configuration">
/// <see cref="IConfiguration" />
/// </param>
/// <param name="section">Configuration section name</param>
/// <typeparam name="TOptions">Resulting object</typeparam>
/// <returns>Instance of TOptions</returns>
public static TOptions GetOptions <TOptions>(this IConfigurationSection section)
where TOptions : class, new()
{
return(BinderHelper.BindOptions <TOptions>(section));
}
/// <summary>
/// A non null propertyHolder means than we process the Pk creation without delay
/// </summary>
/// <param name="secondaryTable"></param>
/// <param name="joinTable"></param>
/// <param name="propertyHolder"></param>
/// <param name="noDelayInPkColumnCreation"></param>
/// <returns></returns>
private Join AddJoin(SecondaryTableAttribute secondaryTable,
JoinTableAttribute joinTable,
IPropertyHolder propertyHolder,
bool noDelayInPkColumnCreation)
{
Join join = new Join();
join.PersistentClass = persistentClass;
string schema;
string catalog;
string table;
string realTable;
System.Persistence.UniqueConstraintAttribute[] uniqueConstraintsAnn;
if (secondaryTable != null)
{
schema = secondaryTable.Schema;
catalog = secondaryTable.Catalog;
table = secondaryTable.Name;
realTable = mappings.NamingStrategy.TableName(table); //always an explicit table name
uniqueConstraintsAnn = secondaryTable.UniqueConstraints;
}
else if (joinTable != null)
{
schema = joinTable.Schema;
catalog = joinTable.Catalog;
table = joinTable.Name;
realTable = mappings.NamingStrategy.TableName(table); //always an explicit table name
uniqueConstraintsAnn = joinTable.UniqueConstraints;
}
else
{
throw new AssertionFailure("Both JoinTable and SecondaryTable are null");
}
var uniqueConstraints = new List <string[]>(uniqueConstraintsAnn == null ? 0 : uniqueConstraintsAnn.Length);
if (uniqueConstraintsAnn != null && uniqueConstraintsAnn.Length != 0)
{
foreach (UniqueConstraintAttribute uc in uniqueConstraintsAnn)
{
uniqueConstraints.Add(uc.ColumnNames);
}
}
Table tableMapping = TableBinder.FillTable(
schema,
catalog,
realTable,
table, false, uniqueConstraints, null, null, mappings);
//no check constraints available on joins
join.Table = tableMapping;
//somehow keep joins() for later.
//Has to do the work later because it needs persistentClass id!
object joinColumns = null;
//get the appropriate pk columns
if (secondaryTable != null)
{
joinColumns = secondaryTable.PkJoinColumns;
}
else if (joinTable != null)
{
joinColumns = joinTable.JoinColumns;
}
log.InfoFormat("Adding secondary table to entity {0} -> {1}", persistentClass.EntityName, join.Table.Name);
TableAttribute matchingTable = FindMatchingComplimentTableAnnotation(join);
if (matchingTable != null)
{
join.IsSequentialSelect = FetchMode.Join != matchingTable.Fetch;
join.IsInverse = matchingTable.IsInverse;
join.IsOptional = matchingTable.IsOptional;
if (!BinderHelper.IsDefault(matchingTable.SqlInsert.Sql))
{
join.SetCustomSQLInsert(matchingTable.SqlInsert.Sql.Trim(),
matchingTable.SqlInsert.Callable,
ExecuteUpdateResultCheckStyle.Parse(matchingTable.SqlInsert.Check.ToString().ToLower()));
}
if (!BinderHelper.IsDefault(matchingTable.SqlUpdate.Sql))
{
join.SetCustomSQLUpdate(matchingTable.SqlUpdate.Sql.Trim(),
matchingTable.SqlUpdate.Callable,
ExecuteUpdateResultCheckStyle.Parse(matchingTable.SqlUpdate.Check.ToString().ToLower())
);
}
if (!BinderHelper.IsDefault(matchingTable.SqlDelete.Sql))
{
join.SetCustomSQLDelete(matchingTable.SqlDelete.Sql.Trim(),
matchingTable.SqlDelete.Callable,
ExecuteUpdateResultCheckStyle.Parse(matchingTable.SqlDelete.Check.ToString().ToLower())
);
}
}
else
{
//default
join.IsSequentialSelect = false;
join.IsInverse = false;
join.IsOptional = false; //perhaps not quite per-spec, but a Good Thing anyway
}
if (noDelayInPkColumnCreation)
{
CreatePrimaryColumnsToSecondaryTable(joinColumns, propertyHolder, join);
}
else
{
secondaryTables.Add(table, join);
secondaryTableJoins.Add(table, joinColumns);
}
return(join);
}
public override IEnumerable <CodeComponent <TAttribute> > GetComponents <TAttribute>()
{
if (Items != null)
{
foreach (PObject item in Items
.SelectMany(host => host.GetExpressions())
.Select(e => e.Output.Host)
.Distinct())
{
if (!item.HasAttribute <TAttribute>())
{
continue;
}
var attr = item.GetAttribute <TAttribute>();
var component = new CodeComponent <TAttribute>(item, attr);
var stack = new Stack <CodeComponent <TAttribute> >(new[] { component });
component.ElementType = CodeComponentType.Node;
while (stack.Count > 0)
{
var cc = stack.Pop();
if (cc.ElementType == CodeComponentType.Node)
{
var host = cc.Element as PBinderHost;
var zeroNodes = new List <PBinderHost>();
// 호스트와 연결된 모든 노드를 BFS알고리즘을 사용하여 가져오고
// 생성된 Output Binder의 갯수가 1개인 것만 노드로 인정함
// 갯수가 2개이상인 노드에서 멈춤 (2개이상은 스코프가 분기된다고 가정)
zeroNodes.AddRange(
BinderHelper.FindZeroLevelNodes(
new[] { host },
childNode =>
{
return(!(childNode is PTrigger));
}));
foreach (PBinderHost zeroNode in zeroNodes)
{
var childComponent = new CodeComponent <TAttribute>(
zeroNode,
zeroNode.GetAttribute <TAttribute>())
{
Depth = cc.Depth + 1,
ElementType = CodeComponentType.Node
};
cc.Add(childComponent);
if (zeroNode[BindOptions.Output].Count() > 1 || zeroNode is PTrigger)
{
stack.Push(childComponent);
}
}
}
}
yield return(component);
}
}
}