private static int CompareConstraints(IConstraint lft, IConstraint rgt)
{
var nl = lft.Name;
var nr = rgt.Name;
if (lft.GetType() != rgt.GetType())
{
return(String.Compare(lft.GetType().FullName, rgt.GetType().FullName));
}
if (nl != null && nr != null)
{
return(String.Compare(nl, nr));
}
return(0);
}
private void Visit(IConstraint constraint)
{
var constrainType = constraint.GetType().Name;
switch (constrainType)
{
case "QConClass":
Visit(constraint as QConClass);
break;
case "QConObject":
Visit(constraint as QConObject);
break;
case "QConJoin":
Visit(constraint as QConJoin);
break;
case "QConPath":
Visit(constraint as QConPath);
break;
default:
throw new ArgumentException(constrainType);
}
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Adds a constraint to 'constraint'.
/// </summary>
/// <param name="property">
/// The property.
/// </param>
/// <param name="constraint">
/// The constraint.
/// </param>
///-------------------------------------------------------------------------------------------------
public void AddConstraint(ISchemaProperty property, IConstraint constraint)
{
var owner = property.Owner as ISchemaElement;
if (owner == null)
{
return;
}
var interfaces = ReflectionHelper.GetInterfaces(constraint.GetType());
var constraintElementType = interfaces.Where(i => ReflectionHelper.IsGenericType(i, typeof(IValidationValueObjectConstraint <>)))
.Select(i => ReflectionHelper.GetGenericArguments(i).First())
.FirstOrDefault();
if (constraintElementType != null)
{
var category = ((IValidationValueObjectConstraint)constraint).Category;
AddConstraint(owner, new CheckPropertyConstraintProxy(property, constraintElementType, constraint, ConstraintKind.Validate, category));
}
else
{
constraintElementType = interfaces.Where(i => ReflectionHelper.IsGenericType(i, typeof(ICheckValueObjectConstraint <>)))
.Select(i => ReflectionHelper.GetGenericArguments(i).First())
.FirstOrDefault();
if (constraintElementType != null)
{
AddConstraint(owner, new CheckPropertyConstraintProxy(property, constraintElementType, constraint, ConstraintKind.Check, null));
}
else
{
throw new HyperstoreException("Invalid constraint type for property " + property.Name);
}
}
}
public InstanceRegistration(IConstraint constraint, ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, FilterScope scope1)
: base(actionDescriptor, controllerDescriptor, scope1)
{
if (constraint == null)
{
throw new ArgumentNullException("constraint", "Constraint instance can not be null.");
}
Constraint = constraint;
ConstraintType = Constraint.GetType();
}
public InstanceRegistration(IConstraint constraint, ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, FilterScope scope1)
: base(actionDescriptor, controllerDescriptor, scope1)
{
if (constraint == null)
{
throw new ArgumentNullException("constraint", "Constraint instance can not be null.");
}
Constraint = constraint;
ConstraintType = Constraint.GetType();
}
private QConClass ClassConstraint()
{
if (i_constraints.Size() != 1)
{
return(null);
}
IConstraint constr = SingleConstraint();
if (constr.GetType() != typeof(QConClass))
{
return(null);
}
return((QConClass)constr);
}
public static Constraint CreateCopy(IConstraint cnt)
{
if (cnt is IIndex)
{
return(new IndexConstraint((IIndex)cnt));
}
if (cnt is IPrimaryKey)
{
return(new PrimaryKey((IPrimaryKey)cnt));
}
if (cnt is IForeignKey)
{
return(new ForeignKey((IForeignKey)cnt));
}
if (cnt is IUnique)
{
return(new UniqueConstraint((IUnique)cnt));
}
if (cnt is ICheck)
{
return(new CheckConstraint((ICheck)cnt));
}
throw new InternalError("DAE-00036 Unknown constraint type:" + cnt.GetType().ToString());
}
private static ExtendedConstraint ExtendConstraint(IConstraint constraint, ReadOnlyCollection <DimensionWithValues> dimensionValues)
{
List <int> dimensionIndexes = GetDimensionIndexes(constraint, dimensionValues).ToList();
if (dimensionIndexes.Count == 0)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Constraint {0} doesn't have any required dimensions.", constraint.GetType().Name));
}
ReadOnlyCollection <DimensionWithValues> dimensionValuesSubset = dimensionIndexes.Select(di => dimensionValues[di]).ToList().AsReadOnly();
ExtendedConstraint ret = new ExtendedConstraint(dimensionIndexes, dimensionValues);
foreach (ReadOnlyCollection <int> indexes in CombinatorialUtilities.GetAllIndexCombinations(dimensionValuesSubset.Select(dv => dv.Values.Count)))
{
Vector v = CombinatorialUtilities.ConstructVector(dimensionValuesSubset, indexes);
if (constraint.IsValid(v))
{
ret.AddNewValueCombinations(indexes);
}
}
return(ret);
}
private static int GetIndexOfConstraintDimension(IConstraint constraint, ReadOnlyCollection <DimensionWithValues> dimensionValues,
QualifiedDimension dimension)
{
int ret = 0;
foreach (DimensionWithValues dv in dimensionValues)
{
if (IsSubset(dimension, dv.Dimension))
{
return(ret);
}
ret++;
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Dimension {0} from constraint {1} was not found in the matrix (all dimensions: {2}).",
dimension.FullyQualifiedName, constraint.GetType().Name, string.Join(",", dimensionValues.Select(dv => dv.Dimension.FullyQualifiedName))));
}
private static ExtendedConstraint ExtendConstraint(IConstraint constraint, ReadOnlyCollection<DimensionWithValues> dimensionValues)
{
List<int> dimensionIndexes = GetDimensionIndexes(constraint, dimensionValues).ToList();
if (dimensionIndexes.Count == 0)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Constraint {0} doesn't have any required dimensions.", constraint.GetType().Name));
}
ReadOnlyCollection<DimensionWithValues> dimensionValuesSubset = dimensionIndexes.Select(di => dimensionValues[di]).ToList().AsReadOnly();
ExtendedConstraint ret = new ExtendedConstraint(dimensionIndexes, dimensionValues);
foreach (ReadOnlyCollection<int> indexes in CombinatorialUtilities.GetAllIndexCombinations(dimensionValuesSubset.Select(dv => dv.Values.Count)))
{
Vector v = CombinatorialUtilities.ConstructVector(dimensionValuesSubset, indexes);
if (constraint.IsValid(v))
{
ret.AddNewValueCombinations(indexes);
}
}
return ret;
}
private static int GetIndexOfConstraintDimension(IConstraint constraint, ReadOnlyCollection<DimensionWithValues> dimensionValues,
QualifiedDimension dimension)
{
int ret = 0;
foreach (DimensionWithValues dv in dimensionValues)
{
if (IsSubset(dimension, dv.Dimension))
{
return ret;
}
ret++;
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Dimension {0} from constraint {1} was not found in the matrix (all dimensions: {2}).",
dimension.FullyQualifiedName, constraint.GetType().Name, string.Join(",", dimensionValues.Select(dv => dv.Dimension.FullyQualifiedName))));
}
public static bool EqualsConstraints(IConstraint csrc, IConstraint cdst, DbDiffOptions options, bool checkNames, DbObjectPairing pairing)
{
if (checkNames && !options.IgnoreConstraintNames)
{
if (!EqualNames(csrc.Name, cdst.Name, options))
{
if (csrc is IPrimaryKey && cdst is IPrimaryKey && (pairing.Source.Dialect.DialectCaps.AnonymousPrimaryKey || pairing.Target.Dialect.DialectCaps.AnonymousPrimaryKey))
{
// do nothing
}
else
{
return(false);
}
}
}
if (csrc.GetType() != cdst.GetType())
{
return(false);
}
if (csrc is ColumnsConstraint)
{
ITableStructure tsrc = pairing.Source.FindTable(csrc.Table.FullName);
ITableStructure tdst = pairing.Target.FindTable(cdst.Table.FullName);
if (!EqualsColumnRefs(tsrc, tdst, ((ColumnsConstraint)csrc).Columns, ((ColumnsConstraint)cdst).Columns))
{
return(false);
}
//if (!((ColumnsConstraint)csrc).Columns.EqualSequence(((ColumnsConstraint)cdst).Columns)) return false;
if (csrc is ForeignKey)
{
var fsrc = (ForeignKey)csrc;
var fdst = (ForeignKey)cdst;
if (!EqualFullNames(fsrc.PrimaryKeyTable, fdst.PrimaryKeyTable, options))
{
return(false);
}
ITableStructure psrc = pairing.Source.FindTable(fsrc.PrimaryKeyTable);
ITableStructure pdst = pairing.Target.FindTable(fdst.PrimaryKeyTable);
if (!EqualsColumnRefs(psrc, pdst, fsrc.PrimaryKeyColumns, fdst.PrimaryKeyColumns))
{
return(false);
}
if (fsrc.OnDeleteAction != fdst.OnDeleteAction)
{
return(false);
}
if (fsrc.OnUpdateAction != fdst.OnUpdateAction)
{
return(false);
}
}
if (csrc is IIndex)
{
var isrc = (IndexConstraint)csrc;
var idst = (IndexConstraint)cdst;
if (isrc.IsUnique != idst.IsUnique)
{
return(false);
}
}
}
if (csrc is CheckConstraint)
{
if (((CheckConstraint)csrc).Expression != ((CheckConstraint)cdst).Expression)
{
return(false);
}
}
return(true);
}
public void ChangeConstraint(IConstraint csrc, IConstraint cdst)
{
PutCmd("/* RECREATE %i TO %i (%s) */", csrc.Name, cdst.Name, cdst.GetType().Name);
}