private string GetFunctions(FunctionDefinitionCollection functionDefinitionCollection) { List <string> values = new List <string>(); foreach (FunctionDefinition fd in functionDefinitionCollection) { values.Add(fd.Name); } return(String.Join(", ", values.ToArray())); }
/// <summary> /// Parses the type of the expression. /// </summary> /// <param name="exprStr">The expr STR.</param> /// <param name="conn">The conn.</param> /// <returns></returns> public static FdoPropertyType?ParseExpressionType(string exprStr, FdoConnection conn) { Expression expr = null; try { expr = Expression.Parse(exprStr); } catch (OSGeo.FDO.Common.Exception) { return(null); } if (expr.GetType() == typeof(Function)) { Function func = expr as Function; FunctionDefinitionCollection funcDefs = (FunctionDefinitionCollection)conn.Capability.GetObjectCapability(CapabilityType.FdoCapabilityType_ExpressionFunctions); FunctionDefinition funcDef = null; //Try to get the return type foreach (FunctionDefinition fd in funcDefs) { if (fd.Name == func.Name) { funcDef = fd; break; } } if (funcDef == null) { return(null); } switch (funcDef.ReturnPropertyType) { case PropertyType.PropertyType_AssociationProperty: return(FdoPropertyType.Association); case PropertyType.PropertyType_GeometricProperty: return(FdoPropertyType.Geometry); case PropertyType.PropertyType_ObjectProperty: return(FdoPropertyType.Object); case PropertyType.PropertyType_RasterProperty: return(FdoPropertyType.Raster); case PropertyType.PropertyType_DataProperty: { return(ValueConverter.GetPropertyType(funcDef.ReturnType)); } } } else if (expr.GetType() == typeof(BinaryExpression)) { return(FdoPropertyType.Boolean); } else if (expr.GetType() == typeof(DataValue)) { DataValue dv = (DataValue)expr; return(ValueConverter.GetPropertyType(dv.DataType)); } return(null); }
private string GetFunctions(FunctionDefinitionCollection functionDefinitionCollection) { List<string> values = new List<string>(); foreach (FunctionDefinition fd in functionDefinitionCollection) { values.Add(fd.Name); } return String.Join(", ", values.ToArray()); }
internal static PropertyDefinition CreatePropertyFromExpressionType(string exprText, ClassDefinition clsDef, FunctionDefinitionCollection functionDefs, string defaultSpatialContextName) { string name = string.Empty; using (var expr = Expression.Parse(exprText)) { var et = expr.GetType(); if (typeof(ComputedIdentifier).IsAssignableFrom(et)) { var subExpr = ((ComputedIdentifier)expr).Expression; return CreatePropertyFromExpressionType(subExpr.ToString(), clsDef, functionDefs, defaultSpatialContextName); } else if (typeof(Identifier).IsAssignableFrom(et)) { var id = (Identifier)expr; return CloneProperty(clsDef.Properties[id.Name]); } else if (typeof(Function).IsAssignableFrom(et)) { var func = (Function)expr; if (functionDefs != null) { var fidx = functionDefs.IndexOf(func.Name); if (fidx >= 0) { var funcDef = functionDefs[fidx]; switch (funcDef.ReturnPropertyType) { case PropertyType.PropertyType_DataProperty: { var dp = new DataPropertyDefinition(name, ""); dp.DataType = funcDef.ReturnType; dp.Nullable = true; if (dp.DataType == DataType.DataType_String) dp.Length = 255; return dp; } break; case PropertyType.PropertyType_GeometricProperty: { var geom = new GeometricPropertyDefinition(name, ""); geom.SpatialContextAssociation = defaultSpatialContextName; geom.GeometryTypes = (int)GeometricType.GeometricType_All; return geom; } break; } } } } else if (typeof(BinaryExpression).IsAssignableFrom(et)) { var dp = new DataPropertyDefinition(name, ""); dp.DataType = DataType.DataType_Boolean; dp.Nullable = true; return dp; } else if (typeof(DataValue).IsAssignableFrom(et)) { var dv = (DataValue)expr; var dp = new DataPropertyDefinition(name, ""); dp.DataType = dv.DataType; if (dp.DataType == DataType.DataType_String) dp.Length = 255; dp.Nullable = true; return dp; } else if (typeof(GeometryValue).IsAssignableFrom(et)) { var geom = new GeometricPropertyDefinition(name, ""); geom.GeometryTypes = (int)GeometricType.GeometricType_All; return geom; } } return null; }
internal static PropertyDefinition CreatePropertyFromExpressionType(string exprText, ClassDefinition clsDef, FunctionDefinitionCollection functionDefs, string defaultSpatialContextName) { string name = string.Empty; using (var expr = Expression.Parse(exprText)) { var et = expr.GetType(); if (typeof(ComputedIdentifier).IsAssignableFrom(et)) { var subExpr = ((ComputedIdentifier)expr).Expression; return(CreatePropertyFromExpressionType(subExpr.ToString(), clsDef, functionDefs, defaultSpatialContextName)); } else if (typeof(Identifier).IsAssignableFrom(et)) { var id = (Identifier)expr; return(CloneProperty(clsDef.Properties[id.Name])); } else if (typeof(Function).IsAssignableFrom(et)) { var func = (Function)expr; if (functionDefs != null) { var fidx = functionDefs.IndexOf(func.Name); if (fidx >= 0) { var funcDef = functionDefs[fidx]; switch (funcDef.ReturnPropertyType) { case PropertyType.PropertyType_DataProperty: { var dp = new DataPropertyDefinition(name, ""); dp.DataType = funcDef.ReturnType; dp.Nullable = true; if (dp.DataType == DataType.DataType_String) { dp.Length = 255; } return(dp); } break; case PropertyType.PropertyType_GeometricProperty: { var geom = new GeometricPropertyDefinition(name, ""); geom.SpatialContextAssociation = defaultSpatialContextName; geom.GeometryTypes = (int)GeometricType.GeometricType_All; return(geom); } break; } } } } else if (typeof(BinaryExpression).IsAssignableFrom(et)) { var dp = new DataPropertyDefinition(name, ""); dp.DataType = DataType.DataType_Boolean; dp.Nullable = true; return(dp); } else if (typeof(DataValue).IsAssignableFrom(et)) { var dv = (DataValue)expr; var dp = new DataPropertyDefinition(name, ""); dp.DataType = dv.DataType; if (dp.DataType == DataType.DataType_String) { dp.Length = 255; } dp.Nullable = true; return(dp); } else if (typeof(GeometryValue).IsAssignableFrom(et)) { var geom = new GeometricPropertyDefinition(name, ""); geom.GeometryTypes = (int)GeometricType.GeometricType_All; return(geom); } } return(null); }
internal static FdoClassCopyOptions FromElement(FdoCopyTaskElement el, FeatureSchemaCache cache, FdoConnection sourceConn, FdoConnection targetConn, out TargetClassModificationItem mod) { mod = null; if (!cache.HasConnection(el.Source.connection)) { throw new TaskLoaderException("The referenced source connection is not defined"); } if (!cache.HasConnection(el.Target.connection)) { throw new TaskLoaderException("The referenced target connection is not defined"); } FdoClassCopyOptions opts = new FdoClassCopyOptions(el.Source.connection, el.Target.connection, el.Source.schema, el.Source.@class, el.Target.schema, el.Target.@class); opts.DeleteTarget = el.Options.DeleteTarget; opts.SourceFilter = el.Options.Filter; if (!el.Options.FlattenGeometriesSpecified) { opts.FlattenGeometries = false; } else { opts.FlattenGeometries = el.Options.FlattenGeometries; } if (!el.Options.ForceWKBSpecified) { opts.ForceWkb = false; } else { opts.ForceWkb = el.Options.ForceWKB; } if (!string.IsNullOrEmpty(el.Options.BatchSize)) { opts.BatchSize = Convert.ToInt32(el.Options.BatchSize); } opts.Name = el.name; opts.CreateIfNotExists = el.createIfNotExists; ClassDefinition srcClass = cache.GetClassByName(el.Source.connection, el.Source.schema, el.Source.@class); ClassDefinition dstClass = cache.GetClassByName(el.Target.connection, el.Target.schema, el.Target.@class); if (!el.createIfNotExists && dstClass == null) { throw new InvalidOperationException("Target class " + el.Target.@class + " does not exist and the createIfNotExist option is false"); } SpatialContextInfo defaultSc = null; FunctionDefinitionCollection availableFunctions = (FunctionDefinitionCollection)sourceConn.Capability.GetObjectCapability(CapabilityType.FdoCapabilityType_ExpressionFunctions); using (var svc = targetConn.CreateFeatureService()) { defaultSc = svc.GetActiveSpatialContext(); } if (dstClass != null) { foreach (FdoPropertyMappingElement propMap in el.PropertyMappings) { if (srcClass.Properties.IndexOf(propMap.source) < 0) { throw new TaskLoaderException("The property mapping (" + propMap.source + " -> " + propMap.target + ") in task (" + el.name + ") contains a source property not found in the source class definition (" + el.Source.@class + ")"); } //Add to list of properties to check for if (propMap.createIfNotExists && dstClass.Properties.IndexOf(propMap.target) < 0) { if (mod == null) { mod = new UpdateTargetClass(dstClass.Name); } opts.AddSourcePropertyToCheck(propMap.source); //Clone copy of source property of same name var srcProp = srcClass.Properties[srcClass.Properties.IndexOf(propMap.source)]; srcProp = FdoSchemaUtil.CloneProperty(srcProp); mod.AddProperty(srcProp); } else { if (dstClass.Properties.IndexOf(propMap.target) < 0) { throw new TaskLoaderException("The property mapping (" + propMap.source + " -> " + propMap.target + ") in task (" + el.name + ") contains a target property not found in the target class definition (" + el.Target.@class + ")"); } PropertyDefinition sp = srcClass.Properties[propMap.source]; PropertyDefinition tp = dstClass.Properties[propMap.target]; if (sp.PropertyType != tp.PropertyType) { throw new TaskLoaderException("The properties in the mapping (" + propMap.source + " -> " + propMap.target + ") are of different types"); } //if (sp.PropertyType != PropertyType.PropertyType_DataProperty) // throw new TaskLoaderException("One or more properties in the mapping (" + propMap.source + " -> " + propMap.target + ") is not a data property"); DataPropertyDefinition sdp = sp as DataPropertyDefinition; DataPropertyDefinition tdp = tp as DataPropertyDefinition; opts.AddPropertyMapping(propMap.source, propMap.target); //Property mapping is between two data properties if (sdp != null && tdp != null) { //Types not equal, so add a conversion rule if (sdp.DataType != tdp.DataType) { FdoDataPropertyConversionRule rule = new FdoDataPropertyConversionRule( propMap.source, propMap.target, sdp.DataType, tdp.DataType, propMap.nullOnFailedConversion, propMap.truncate); opts.AddDataConversionRule(propMap.source, rule); } } } } // foreach (FdoExpressionMappingElement exprMap in el.ExpressionMappings) { if (string.IsNullOrEmpty(exprMap.target)) { continue; } opts.AddSourceExpression(exprMap.alias, exprMap.Expression, exprMap.target); //Add to list of properties to check for if (exprMap.createIfNotExists) { //Class exists but property doesn't if (dstClass.Properties.IndexOf(exprMap.target) < 0) { if (mod == null) { mod = new UpdateTargetClass(el.Target.@class); } var prop = FdoSchemaUtil.CreatePropertyFromExpressionType(exprMap.Expression, srcClass, availableFunctions, defaultSc.Name); if (prop == null) { throw new InvalidOperationException("Could not derive a property definition from the expression: " + exprMap.Expression); } prop.Name = exprMap.target; mod.AddProperty(prop); } } else //Conversion rules can only apply if both properties exist. { FdoPropertyType?pt = ExpressionUtility.ParseExpressionType(exprMap.Expression, sourceConn); if (pt.HasValue) { DataType?srcDt = ValueConverter.GetDataType(pt.Value); if (srcDt.HasValue) { PropertyDefinition tp = dstClass.Properties[exprMap.target]; DataPropertyDefinition tdp = tp as DataPropertyDefinition; if (tdp != null) { if (srcDt.Value != tdp.DataType) { FdoDataPropertyConversionRule rule = new FdoDataPropertyConversionRule( exprMap.alias, exprMap.target, srcDt.Value, tdp.DataType, exprMap.nullOnFailedConversion, exprMap.truncate); opts.AddDataConversionRule(exprMap.alias, rule); } } } } } } } else //class doesn't exist { mod = new CreateTargetClassFromSource(el.Source.schema, el.Target.@class); foreach (var propMap in el.PropertyMappings) { opts.AddPropertyMapping(propMap.source, propMap.target); if (propMap.createIfNotExists) { opts.AddSourcePropertyToCheck(propMap.source); } } foreach (var exprMap in el.ExpressionMappings) { opts.AddSourceExpression(exprMap.alias, exprMap.Expression, exprMap.target); if (exprMap.createIfNotExists) { opts.AddSourcePropertyToCheck(exprMap.alias); } var prop = FdoSchemaUtil.CreatePropertyFromExpressionType(exprMap.Expression, srcClass, availableFunctions, defaultSc.Name); if (prop == null) { throw new InvalidOperationException("Could not derive a property definition from the expression: " + exprMap.Expression); } prop.Name = exprMap.target; mod.AddProperty(prop); } } return(opts); }
public void MapExpression(string srcAlias, string destProperty, bool createIfNotExists) { var dstCls = Parent.TargetClass; TreeNode exprNode = _node.Nodes[srcAlias]; ExpressionMappingInfo map = (ExpressionMappingInfo)exprNode.Tag; if (destProperty != null) { if (dstCls != null) { PropertyDefinition dst = dstCls.Properties[destProperty]; DataPropertyDefinition dp = dst as DataPropertyDefinition; if (string.IsNullOrEmpty(map.Expression)) { throw new MappingException("Cannot map alias. There is no expression defined"); } Expression expr = null; try { expr = Expression.Parse(map.Expression); } catch (OSGeo.FDO.Common.Exception ex) { throw new MappingException("Cannot map alias. Invalid expression: " + ex.Message); } if (typeof(Function).IsAssignableFrom(expr.GetType())) { Function func = expr as Function; FdoConnection conn = Parent.GetSourceConnection(); FunctionDefinitionCollection funcDefs = (FunctionDefinitionCollection)conn.Capability.GetObjectCapability(CapabilityType.FdoCapabilityType_ExpressionFunctions); FunctionDefinition funcDef = null; //Shouldn't happen because Expression Editor ensures a valid function if (!funcDefs.Contains(func.Name)) { throw new MappingException("Cannot map alias. Expression contains unsupported function: " + func.Name); } //Try to get the return type foreach (FunctionDefinition fd in funcDefs) { if (fd.Name == func.Name) { funcDef = fd; break; } } if (funcDef.ReturnPropertyType != dst.PropertyType) { throw new MappingException("Cannot map alias. Expression evaluates to an un-mappable property type"); } if (funcDef.ReturnPropertyType == PropertyType.PropertyType_GeometricProperty) { } else if (funcDef.ReturnPropertyType == PropertyType.PropertyType_DataProperty) { if (!ValueConverter.IsConvertible(funcDef.ReturnType, dp.DataType)) { throw new MappingException("Cannot map alias to property " + dst.Name + ". Expression evaluates to a data type that cannot be mapped to " + dp.DataType); } } else //Association, Object, Raster { throw new MappingException("Cannot map alias. Expression evaluates to an un-mappable property type"); } } else if (typeof(BinaryExpression).IsAssignableFrom(expr.GetType())) { if (dp == null) { throw new MappingException("Cannot map alias. Expression evaluates to an un-mappable property type"); } //We're assuming that this evalutes to a boolean value if (!ValueConverter.IsConvertible(DataType.DataType_Boolean, dp.DataType)) { throw new MappingException("Cannot map alias to property " + dst.Name + ". Expression evaluates to a data type that cannot be mapped to " + dp.DataType); } } else if (typeof(DataValue).IsAssignableFrom(expr.GetType())) { if (dp == null) { throw new MappingException("Cannot map alias. Expression evaluates to an un-mappable property type"); } DataValue dv = (DataValue)expr; if (!ValueConverter.IsConvertible(dv.DataType, dp.DataType)) { throw new MappingException("Cannot map alias to property " + dst.Name + ". Expression evaluates to a data type that cannot be mapped to " + dp.DataType); } } //else if (expr.GetType() == typeof(Identifier)) //{ // //TODO: use the property type of the referenced property //} else //Cannot be evaluated { throw new MappingException("Cannot map alias. Expression evaluates to an un-mappable value"); } } else { if (!createIfNotExists) { throw new MappingException("Cannot map alias. The specified target property " + destProperty + " does not exist and the \"create if necessary\" option was not specified"); } } } //All good exprNode.Text = srcAlias + " ( => " + destProperty + " )"; map.TargetProperty = destProperty; if (destProperty != null) { exprNode.Text = exprNode.Name + " => " + destProperty; } else { exprNode.Text = exprNode.Name; } GetConversionRule(srcAlias).CreateIfNotExists = createIfNotExists; }
private void LoadFunctionDefinitions(FunctionDefinitionCollection funcs) { foreach (FunctionDefinition funcDef in funcs) { ToolStripMenuItem item = new ToolStripMenuItem(); item.Text = item.Name = funcDef.Name; item.ToolTipText = funcDef.Description; item.Tag = funcDef; item.Click += new EventHandler(function_Click); _FunctionMenuItems[funcDef.FunctionCategoryType].DropDown.Items.Add(item); _autoCompleteItems[funcDef.Name] = new FunctionItem(funcDef); } }