Ejemplo n.º 1
0
        internal void ClassChanged(JoinSourceType type)
        {
            if (type == JoinSourceType.Target)
            {
                return;
            }

            _view.ClearJoins();

            FdoConnection conn = GetConnection(type);

            if (conn != null)
            {
                using (FdoFeatureService service = conn.CreateFeatureService())
                {
                    switch (type)
                    {
                    case JoinSourceType.Left:
                    {
                        string schema    = _view.SelectedLeftSchema;
                        string className = _view.SelectedLeftClass;

                        ClassDefinition cd = service.GetClassByName(schema, className);
                        if (cd != null)
                        {
                            List <string> properties = new List <string>();
                            foreach (PropertyDefinition pd in cd.Properties)
                            {
                                properties.Add(pd.Name);
                            }
                            _view.LeftProperties = properties;
                        }
                    }
                    break;

                    case JoinSourceType.Right:
                    {
                        string schema    = _view.SelectedRightSchema;
                        string className = _view.SelectedRightClass;

                        ClassDefinition cd = service.GetClassByName(schema, className);
                        if (cd != null)
                        {
                            List <string> properties = new List <string>();
                            foreach (PropertyDefinition pd in cd.Properties)
                            {
                                properties.Add(pd.Name);
                            }
                            _view.RightProperties = properties;
                        }
                    }
                    break;
                    }
                }
            }

            SetTargetGeometries();
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Validates this instance.
        /// </summary>
        public void Validate()
        {
            foreach (FdoClassCopyOptions copt in this.ClassCopyOptions)
            {
                FdoConnection src = GetConnection(copt.SourceConnectionName);
                FdoConnection dst = GetConnection(copt.TargetConnectionName);

                if (src == null)
                {
                    throw new TaskValidationException("The specified source connection name does not exist");
                }

                if (dst == null)
                {
                    throw new TaskValidationException("The specified target connection name does not exist");
                }

                using (FdoFeatureService srcSvc = src.CreateFeatureService())
                    using (FdoFeatureService dstSvc = dst.CreateFeatureService())
                    {
                        ClassDefinition srcCls = srcSvc.GetClassByName(copt.SourceSchema, copt.SourceClassName);
                        ClassDefinition dstCls = dstSvc.GetClassByName(copt.TargetSchema, copt.TargetClassName);

                        if (srcCls == null)
                        {
                            throw new TaskValidationException("The specified source feature class does not exist");
                        }

                        if (dstCls == null)
                        {
                            throw new TaskValidationException("The specified target feature class does not exist");
                        }
                    }
            }
        }
        public void Init()
        {
            _view.InitializeGrid();
            _view.UseTransactionEnabled = (_conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsTransactions));

            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                ClassDefinition cd = service.GetClassByName(_className);
                if (cd != null)
                {
                    _view.ClassName = cd.Name;
                    foreach (PropertyDefinition pd in cd.Properties)
                    {
                        switch (pd.PropertyType)
                        {
                        case PropertyType.PropertyType_DataProperty:
                            _view.AddDataProperty((DataPropertyDefinition)pd);
                            break;

                        case PropertyType.PropertyType_GeometricProperty:
                            _view.AddGeometricProperty((GeometricPropertyDefinition)pd);
                            break;
                        }
                    }
                }
            }
        }
        public override int Execute()
        {
            IConnection conn = null;
            try
            {
                conn = CreateConnection(_provider, _connstr);
                conn.Open();
            }
            catch (OSGeo.FDO.Common.Exception ex)
            {
                WriteException(ex);
                return (int)CommandStatus.E_FAIL_CONNECT;
            }

            using (FdoFeatureService service = new FdoFeatureService(conn))
            {
                ClassDefinition cd = service.GetClassByName(_schema, _class);
                if (cd == null)
                {
                    Console.Error.WriteLine("Class {0} not found in schema {1}", _class, _schema);
                    return (int)CommandStatus.E_FAIL_CLASS_NOT_FOUND;
                }
                else
                {
                    using (cd)
                    {
                        foreach (PropertyDefinition propDef in cd.Properties)
                        {
                            bool isIdentity = (propDef.PropertyType == PropertyType.PropertyType_DataProperty && cd.IdentityProperties.Contains((DataPropertyDefinition)propDef));
                            Console.WriteLine("\nName: {0} ({1}) {2}\n", propDef.Name, propDef.PropertyType, isIdentity ? "(IDENTITY)" : "");
                            Console.WriteLine("\tQualified Name: {0}\n\tIs System: {1}", propDef.QualifiedName, propDef.IsSystem);
                            switch (propDef.PropertyType)
                            {
                                case PropertyType.PropertyType_DataProperty:
                                    WriteDataProperty(propDef as DataPropertyDefinition);
                                    break;
                                case PropertyType.PropertyType_GeometricProperty:
                                    WriteGeometricProperty(propDef as GeometricPropertyDefinition);
                                    break;
                                case PropertyType.PropertyType_AssociationProperty:
                                    WriteAssociationProperty(propDef as AssociationPropertyDefinition);
                                    break;
                                case PropertyType.PropertyType_ObjectProperty:
                                    WriteObjectProperty(propDef as ObjectPropertyDefinition);
                                    break;
                                case PropertyType.PropertyType_RasterProperty:
                                    WriteRasterProperty(propDef as RasterPropertyDefinition);
                                    break;
                            }
                        }
                    }
                }
            }

            conn.Close();
            return (int)CommandStatus.E_OK;
        }
        public void Init(string initSchema, string initClass)
        {
            List <QueryMode> modes = new List <QueryMode>();

            if (!string.IsNullOrEmpty(initSchema) && !string.IsNullOrEmpty(initClass))
            {
                if (_service.SupportsCommand(OSGeo.FDO.Commands.CommandType.CommandType_Select))
                {
                    using (FdoFeatureService service = _connection.CreateFeatureService())
                    {
                        ClassDefinition classDef = service.GetClassByName(initSchema, initClass);
                        if (!ExpressUtility.HasRaster(classDef))
                        {
                            modes.Add(QueryMode.Standard);
                            _queryViews.Add(QueryMode.Standard, new FdoStandardQueryCtl(_connection, initSchema, initClass));
                        }
                    }
                }
                if (_service.SupportsCommand(OSGeo.FDO.Commands.CommandType.CommandType_SelectAggregates))
                {
                    modes.Add(QueryMode.Aggregate);
                    _queryViews.Add(QueryMode.Aggregate, new FdoAggregateQueryCtl(_connection, initSchema, initClass));
                }
            }
            else
            {
                if (_service.SupportsCommand(OSGeo.FDO.Commands.CommandType.CommandType_Select))
                {
                    modes.Add(QueryMode.Standard);
                    _queryViews.Add(QueryMode.Standard, new FdoStandardQueryCtl(_connection));
                }
                if (_service.SupportsCommand(OSGeo.FDO.Commands.CommandType.CommandType_SelectAggregates))
                {
                    modes.Add(QueryMode.Aggregate);
                    _queryViews.Add(QueryMode.Aggregate, new FdoAggregateQueryCtl(_connection));
                }
            }
            if (_service.SupportsCommand(OSGeo.FDO.Commands.CommandType.CommandType_SQLCommand))
            {
                modes.Add(QueryMode.SQL);
                _queryViews.Add(QueryMode.SQL, new FdoSqlQueryCtl());
            }
            foreach (IQuerySubView qv in _queryViews.Values)
            {
                qv.MapPreviewStateChanged += new MapPreviewStateEventHandler(OnMapPreviewStateChanged);
                qv.SetRestrictions(_connection.Capability);
            }
            _view.QueryModes = modes;

            _view.InsertEnabled = (_view.SelectedQueryMode != QueryMode.SQL) && insertSupported;
        }
        internal CopyTaskNodeDecorator(TreeNode root, string srcConnName, string srcSchema, string srcClass, string dstConnName, string dstSchema, string dstClass, string taskName, bool createIfNotExists)
        {
            _node = new TreeNode();
            root.Nodes.Add(_node);

            _node.Nodes.Add(new TreeNode("Description"));
            _node.Nodes.Add(new TreeNode("Options"));
            _node.Nodes.Add(new TreeNode("Property Mappings"));
            _node.Nodes.Add(new TreeNode("Expression Mappings (Right click to add)"));

            this.Name        = taskName;
            this.Description = "Copies features from " + srcClass + " to " + dstClass;

            InitDescription(srcConnName, srcSchema, srcClass, dstConnName, dstSchema, dstClass, createIfNotExists);

            _connMgr = ServiceManager.Instance.GetService <FdoConnectionManager>();

            _srcConnName           = srcConnName;
            _dstConnName           = dstConnName;
            this.CreateIfNotExists = createIfNotExists;

            using (FdoFeatureService srcSvc = GetSourceConnection().CreateFeatureService())
                using (FdoFeatureService dstSvc = GetTargetConnection().CreateFeatureService())
                {
                    ClassDefinition sourceClass = srcSvc.GetClassByName(srcSchema, srcClass);
                    Debug.Assert(sourceClass != null);

                    ClassDefinition targetClass = dstSvc.GetClassByName(dstSchema, dstClass);
                    if (targetClass == null && !this.CreateIfNotExists)
                    {
                        throw new InvalidOperationException("Target class " + dstClass + " does not exist. If you want this class created make sure you checked \"Create class of the name name\" when creating a new copy task");
                    }

                    _srcClass = sourceClass;
                    _dstClass = targetClass;
                }

            _options      = new OptionsNodeDecorator(this, _node.Nodes[1]);
            _propMappings = new PropertyMappingsNodeDecorator(this, _node.Nodes[2]);
            _exprMappings = new ExpressionMappingsNodeDecorator(this, _node.Nodes[3]);

            _node.ExpandAll();
        }
Ejemplo n.º 7
0
        private void SetTargetGeometries()
        {
            if (!_init)
            {
                return;
            }

            _view.LeftGeometryName     = string.Empty;
            _view.RightGeometryName    = string.Empty;
            _view.LeftGeometryEnabled  = false;
            _view.RightGeometryEnabled = false;
            _view.LeftGeometryChecked  = false;
            _view.RightGeometryChecked = false;

            using (FdoFeatureService leftService = GetConnection(JoinSourceType.Left).CreateFeatureService())
                using (FdoFeatureService rightService = GetConnection(JoinSourceType.Right).CreateFeatureService())
                {
                    ClassDefinition leftClass  = leftService.GetClassByName(_view.SelectedLeftSchema, _view.SelectedLeftClass);
                    ClassDefinition rightClass = rightService.GetClassByName(_view.SelectedRightSchema, _view.SelectedRightClass);

                    if (leftClass.ClassType == ClassType.ClassType_FeatureClass)
                    {
                        string geomName = ((FeatureClass)leftClass).GeometryProperty.Name;
                        //targetGeoms.Add(geomName + " (Left)", geomName);
                        //_view.LeftGeometryEnabled = true;
                        _view.LeftGeometryName    = geomName;
                        _view.LeftGeometryChecked = true;
                    }

                    if (rightClass.ClassType == ClassType.ClassType_FeatureClass)
                    {
                        string geomName = ((FeatureClass)rightClass).GeometryProperty.Name;
                        //targetGeoms.Add(geomName + " (Right)", geomName);
                        //_view.RightGeometryEnabled = true;
                        _view.RightGeometryName = geomName;

                        if (!_view.LeftGeometryChecked)
                        {
                            _view.RightGeometryChecked = true;
                        }
                    }
                }
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Executes the operation
        /// </summary>
        /// <param name="rows"></param>
        /// <returns></returns>
        public override IEnumerable <FdoRow> Execute(IEnumerable <FdoRow> rows)
        {
            //We fetch the class def here instead of the ctor as the class in question
            //may have to be created by a pre-copy operation
            _clsDef = _service.GetClassByName(this.ClassName);

            IInsert insert = null;

            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                insert = service.CreateCommand <IInsert>(CommandType.CommandType_Insert);
            }
            this.Info("Set feature class to: {0}", this.ClassName);
            insert.SetFeatureClassName(this.ClassName);
            PropertyValueCollection propVals = insert.PropertyValues;

            Prepare(propVals);
            foreach (FdoRow row in rows)
            {
                Bind(row);
                insert.Prepare();
                try
                {
                    using (IFeatureReader reader = insert.Execute())
                    {
                        reader.Close();
                    }
                }
                catch (OSGeo.FDO.Common.Exception ex)
                {
                    ex.Data["Class/Table"] = this.ClassName;
                    RaiseFailedFeatureProcessed(row, ex);
                    RePrepare(propVals);
                }
                yield return(row);
            }
            insert.Dispose();
            //yield break;
        }
Ejemplo n.º 9
0
 private void txtUpdateFilter_Click(object sender, EventArgs e)
 {
     if (_classDef == null)
     {
         using (FdoFeatureService service = _conn.CreateFeatureService())
         {
             _classDef = service.GetClassByName(this.ClassName);
         }
     }
     if (!string.IsNullOrEmpty(this.Filter))
     {
         string filter = ExpressionEditor.EditExpression(_conn, _classDef, null, this.Filter, ExpressionMode.Filter);
         if (filter != null)
         {
             this.Filter = filter;
         }
     }
     else
     {
         this.Filter = ExpressionEditor.NewExpression(_conn, _classDef, null, ExpressionMode.Filter);
     }
 }
Ejemplo n.º 10
0
        /// <summary>
        /// Initializes this instance
        /// </summary>
        /// <param name="pipelineExecuter"></param>
        public override void PrepareForExecution(IPipelineExecuter pipelineExecuter)
        {
            //Omit read-only properties
            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                ClassDefinition c = service.GetClassByName(this.ClassName);
                foreach (PropertyDefinition p in c.Properties)
                {
                    string name = p.Name;
                    if (p.PropertyType != PropertyType.PropertyType_DataProperty && p.PropertyType != PropertyType.PropertyType_GeometricProperty)
                    {
                        _unWritableProperties.Add(name);
                    }
                    else
                    {
                        if (p.PropertyType == PropertyType.PropertyType_GeometricProperty)
                        {
                            GeometricPropertyDefinition g = p as GeometricPropertyDefinition;
                            if (g.ReadOnly)
                            {
                                _unWritableProperties.Add(name);
                            }
                        }
                        else
                        {
                            DataPropertyDefinition d = p as DataPropertyDefinition;
                            if (d.ReadOnly) //|| d.IsAutoGenerated)
                            {
                                _unWritableProperties.Add(name);
                            }
                        }
                    }
                }
                c.Dispose();
            }

            base.PrepareForExecution(pipelineExecuter);
        }
        public void Init()
        {
            _view.InitializeGrid();
            _view.UseTransactionEnabled = (_conn.Capability.GetBooleanCapability(CapabilityType.FdoCapabilityType_SupportsTransactions));

            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                ClassDefinition cd = service.GetClassByName(_className);
                if (cd != null)
                {
                    _view.ClassName = cd.Name;
                    foreach (PropertyDefinition pd in cd.Properties)
                    {
                        switch (pd.PropertyType)
                        {
                        case PropertyType.PropertyType_DataProperty:
                            _view.AddDataProperty((DataPropertyDefinition)pd, _feature[pd.Name]);
                            break;

                        case PropertyType.PropertyType_GeometricProperty:
                            if (null != (_feature[pd.Name] as FdoGeometry))                                     // else throws exeption with the ".Text" null reference
                            {
                                _view.AddGeometricProperty((GeometricPropertyDefinition)pd, (_feature[pd.Name] as FdoGeometry).Text);
                            }
                            break;

                        case PropertyType.PropertyType_AssociationProperty:
                            AssociationPropertyDefinition pdAssoc = (AssociationPropertyDefinition)pd;

                            ClassDefinition cdAssoc = service.GetClassByName(pdAssoc.AssociatedClass.Name);
                            foreach (PropertyDefinition pdThis in cdAssoc.Properties)
                            {
                                String szPropertyName = pd.Name + "." + pdThis.Name;

                                // TODO: iterate associations and objects
                                switch (pdThis.PropertyType)
                                {
                                case PropertyType.PropertyType_DataProperty:
                                    // TODO: fix this issue of reverse association
                                    // at the moment can get geom from parent to child - but throws error from child to parent
                                    try
                                    {
                                        _view.AddDataProperty((DataPropertyDefinition)pdThis, _feature[szPropertyName], pd.Name);
                                    }
                                    catch (Exception exThis)
                                    {
                                        // System.Windows.Forms.MessageBox.Show("Cannot Edit Association Property\n\n" + exThis.Message);
                                    }
                                    break;

                                case PropertyType.PropertyType_GeometricProperty:
                                    // TODO: fix this issue of reverse association
                                    // at the moment can get geom from parent to child - but throws error from child to parent
                                    try
                                    {
                                        if (null != (_feature[szPropertyName] as FdoGeometry))                                                          // else throws exeption with the ".Text" null reference
                                        {
                                            _view.AddGeometricProperty((GeometricPropertyDefinition)pdThis, (_feature[szPropertyName] as FdoGeometry).Text, pd.Name);
                                        }
                                    }
                                    catch (Exception exThis)
                                    {
                                        System.Windows.Forms.MessageBox.Show("Cannot Edit Association Geometry\n\n" + exThis.Message);
                                    }
                                    break;
                                }
                            }
                            break;

                        case PropertyType.PropertyType_ObjectProperty:
                            ObjectPropertyDefinition pdObject = (ObjectPropertyDefinition)pd;

                            ClassDefinition cdObject = service.GetClassByName(pdObject.Class.Name);
                            foreach (PropertyDefinition pdThis in cdObject.Properties)
                            {
                                String szPropertyName = pd.Name + "." + pdThis.Name;

                                // TODO: iterate associations and objects
                                switch (pdThis.PropertyType)
                                {
                                case PropertyType.PropertyType_DataProperty:
                                    _view.AddDataProperty((DataPropertyDefinition)pdThis, _feature[szPropertyName], pd.Name);
                                    break;

                                case PropertyType.PropertyType_GeometricProperty:
                                    if (null != (_feature[szPropertyName] as FdoGeometry))                                                      // else throws exeption with the ".Text" null reference
                                    {
                                        _view.AddGeometricProperty((GeometricPropertyDefinition)pdThis, (_feature[szPropertyName] as FdoGeometry).Text, pd.Name);
                                    }
                                    break;
                                }
                            }
                            break;
                        }
                    }
                }
            }
        }
Ejemplo n.º 12
0
        public override int Execute()
        {
            IConnection conn = null;

            try
            {
                conn = CreateConnection(_provider, _connstr);
                conn.Open();
            }
            catch (OSGeo.FDO.Common.Exception ex)
            {
                WriteException(ex);
                return((int)CommandStatus.E_FAIL_CONNECT);
            }

            using (FdoFeatureService service = new FdoFeatureService(conn))
            {
                ClassDefinition cd = service.GetClassByName(_schema, _class);
                if (cd == null)
                {
                    Console.Error.WriteLine("Class {0} not found in schema {1}", _class, _schema);
                    return((int)CommandStatus.E_FAIL_CLASS_NOT_FOUND);
                }
                else
                {
                    using (cd)
                    {
                        foreach (PropertyDefinition propDef in cd.Properties)
                        {
                            bool isIdentity = (propDef.PropertyType == PropertyType.PropertyType_DataProperty && cd.IdentityProperties.Contains((DataPropertyDefinition)propDef));
                            Console.WriteLine("\nName: {0} ({1}) {2}\n", propDef.Name, propDef.PropertyType, isIdentity ? "(IDENTITY)" : "");
                            Console.WriteLine("\tQualified Name: {0}\n\tIs System: {1}", propDef.QualifiedName, propDef.IsSystem);
                            switch (propDef.PropertyType)
                            {
                            case PropertyType.PropertyType_DataProperty:
                                WriteDataProperty(propDef as DataPropertyDefinition);
                                break;

                            case PropertyType.PropertyType_GeometricProperty:
                                WriteGeometricProperty(propDef as GeometricPropertyDefinition);
                                break;

                            case PropertyType.PropertyType_AssociationProperty:
                                WriteAssociationProperty(propDef as AssociationPropertyDefinition);
                                break;

                            case PropertyType.PropertyType_ObjectProperty:
                                WriteObjectProperty(propDef as ObjectPropertyDefinition);
                                break;

                            case PropertyType.PropertyType_RasterProperty:
                                WriteRasterProperty(propDef as RasterPropertyDefinition);
                                break;
                            }
                        }
                    }
                }
            }

            conn.Close();
            return((int)CommandStatus.E_OK);
        }
Ejemplo n.º 13
0
        private void Prepare(PropertyValueCollection propVals)
        {
            propVals.Clear();
            currentValues.Clear();

            // I do not trust the long-term stability of the PropertyValueCollection
            //
            // So what we do is load it up once with LiteralValue references and manipulate these
            // outside of the collection (via a cached dictionary). We cache everything from the wrapper API
            // that can be cached in the managed world so that we only have minimal contact with it

            // Omit read-only properties
            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                ClassDefinition c = service.GetClassByName(this.ClassName);
                foreach (PropertyDefinition p in c.Properties)
                {
                    string        name = p.Name;
                    PropertyValue pv   = new PropertyValue(name, null);
                    if (p.PropertyType == PropertyType.PropertyType_DataProperty)
                    {
                        DataPropertyDefinition d = p as DataPropertyDefinition;
                        if (!d.ReadOnly && !d.IsAutoGenerated)
                        {
                            DataValue dv = null;
                            switch (d.DataType)
                            {
                            case DataType.DataType_BLOB:
                                dv = new BLOBValue();
                                break;

                            case DataType.DataType_Boolean:
                                dv = new BooleanValue();
                                break;

                            case DataType.DataType_Byte:
                                dv = new ByteValue();
                                break;

                            case DataType.DataType_CLOB:
                                dv = new CLOBValue();
                                break;

                            case DataType.DataType_DateTime:
                                dv = new DateTimeValue();
                                break;

                            case DataType.DataType_Decimal:
                                dv = new DecimalValue();
                                break;

                            case DataType.DataType_Double:
                                dv = new DoubleValue();
                                break;

                            case DataType.DataType_Int16:
                                dv = new Int16Value();
                                break;

                            case DataType.DataType_Int32:
                                dv = new Int32Value();
                                break;

                            case DataType.DataType_Int64:
                                dv = new Int64Value();
                                break;

                            case DataType.DataType_Single:
                                dv = new SingleValue();
                                break;

                            case DataType.DataType_String:
                                dv = new StringValue();
                                break;
                            }
                            if (dv != null)
                            {
                                pv.Value = dv;
                                propVals.Add(pv);
                            }
                        }
                    }
                    else if (p.PropertyType == PropertyType.PropertyType_GeometricProperty)
                    {
                        GeometricPropertyDefinition g = p as GeometricPropertyDefinition;
                        if (!g.ReadOnly)
                        {
                            GeometryValue gv = new GeometryValue();
                            pv.Value = gv;
                            propVals.Add(pv);
                        }
                    }
                }
                c.Dispose();
            }

            //Load property values into temp dictionary
            foreach (PropertyValue p in propVals)
            {
                currentValues[p.Name.Name] = p.Value as LiteralValue;
            }

            if (propertySnapshot == null)
            {
                propertySnapshot = new List <string>();
                foreach (PropertyValue p in propVals)
                {
                    propertySnapshot.Add(p.Name.Name);
                }
            }
        }
        void DoWork(object sender, DoWorkEventArgs e)
        {
            IFdoReader reader = null;

            using (FdoFeatureService service = _connection.CreateFeatureService())
            {
                try
                {
                    if (e.Argument is FeatureAggregateOptions)
                    {
                        reader = service.SelectAggregates((FeatureAggregateOptions)e.Argument);
                    }
                    else if (e.Argument is StandardQuery)
                    {
                        var stdArg = (e.Argument as StandardQuery);
                        reader = service.SelectFeatures(stdArg.query, stdArg.Limit, stdArg.UseExtendedSelect);
                    }
                    else if (e.Argument is string)
                    {
                        reader = service.ExecuteSQLQuery(e.Argument.ToString());
                    }

                    //Init the data grid view
                    FdoFeatureTable table = new FdoFeatureTable();

                    table.RequestSpatialContext += delegate(object o, string name)
                    {
                        SpatialContextInfo c = service.GetSpatialContext(name);
                        if (c != null)
                        {
                            table.AddSpatialContext(c);
                        }
                    };

                    ClassDefinition clsDef   = null;
                    bool            hasJoins = false;
                    if (e.Argument is StandardQuery)
                    {
                        var qry = ((StandardQuery)e.Argument).query;
                        clsDef   = service.GetClassByName(qry.ClassName); //TODO: Should really qualify this, but our input parameters do not specify a schema
                        hasJoins = qry.JoinCriteria.Count > 0;
                    }
                    table.InitTable(reader, clsDef, hasJoins);

                    // need to store object class defn outside loop
                    ClassDefinition classDefObject = null;
                    ClassDefinition classDefAssoc  = null;

                    while (reader.ReadNext() && !_queryWorker.CancellationPending)
                    {
                        //Pass processed feature to data grid view
                        FdoFeature feat = table.NewRow();
                        for (int i = 0; i < reader.FieldCount; i++)
                        {
                            string name = reader.GetName(i);
                            if (!reader.IsNull(name))
                            {
                                FdoPropertyType pt = reader.GetFdoPropertyType(name);

                                switch (pt)
                                {
                                case FdoPropertyType.Association:
                                    // TODO: how to handle for non-StandardQuery
                                    if (e.Argument is StandardQuery)
                                    {
                                        // because the original code used an iterator over the reader.FieldCount
                                        // it is a bit of a hack to get another definition of the class and check
                                        // we are at the right property with a name comparison
                                        // TODO: code review to see if this can be implemented better
                                        FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
                                        ClassDefinition  classDef      = readerFeature.GetClassDefinition();

                                        foreach (PropertyDefinition propertyDef in classDef.Properties)
                                        {
                                            // only looking for the right association
                                            if ((PropertyType.PropertyType_AssociationProperty == propertyDef.PropertyType) &&
                                                (propertyDef.Name.Equals(name)))
                                            {
                                                AssociationPropertyDefinition assocProp = (AssociationPropertyDefinition)propertyDef;
                                                ClassDefinition classAssoc = assocProp.AssociatedClass;

                                                // get a reader from the association - nice!
                                                IFeatureReader readerAssoc = readerFeature.GetFeatureObject(name);
                                                if ((null != readerAssoc) && (readerAssoc.ReadNext()))
                                                {
                                                    // TODO: this should be an iterative function

                                                    // the simple reassignment on each instance fails
                                                    //  (classDefObject.Properties is always zero after first record)
                                                    //  so have set classDefObject higher-up and re-use/
                                                    //   - problem will occur if more than one association
                                                    // ClassDefinition classDefObject = readerObject.GetClassDefinition();
                                                    if (null == classDefAssoc)
                                                    {
                                                        classDefAssoc = readerAssoc.GetClassDefinition();
                                                    }

                                                    foreach (PropertyDefinition propertyDefAssoc in classDefAssoc.Properties)
                                                    {
                                                        String nameAssoc = propertyDefAssoc.Name;

                                                        // TODO: only "data" type handled at present
                                                        if (PropertyType.PropertyType_DataProperty == propertyDefAssoc.PropertyType)
                                                        {
                                                            DataPropertyDefinition datapropertyDefAssoc = (DataPropertyDefinition)propertyDefAssoc;

                                                            String   szFullName = name + "." + nameAssoc;
                                                            DataType ptAssoc    = datapropertyDefAssoc.DataType;
                                                            // TODO: handle all types
                                                            switch (ptAssoc)
                                                            {
                                                            case DataType.DataType_String:
                                                                feat[szFullName] = readerAssoc.GetString(nameAssoc);
                                                                break;

                                                            case DataType.DataType_Int16:
                                                                feat[szFullName] = readerAssoc.GetInt16(nameAssoc);
                                                                break;

                                                            case DataType.DataType_Int32:
                                                                feat[szFullName] = readerAssoc.GetInt32(nameAssoc);
                                                                break;

                                                            case DataType.DataType_Int64:
                                                                feat[szFullName] = readerAssoc.GetInt64(nameAssoc);
                                                                break;
                                                            }
                                                        }
                                                    }
                                                    readerAssoc.Close();
                                                }
                                            }
                                        }
                                    }
                                    break;

                                case FdoPropertyType.BLOB:
                                    feat[name] = reader.GetLOB(name).Data;
                                    break;

                                case FdoPropertyType.Boolean:
                                    feat[name] = reader.GetBoolean(name);
                                    break;

                                case FdoPropertyType.Byte:
                                    feat[name] = reader.GetByte(name);
                                    break;

                                case FdoPropertyType.CLOB:
                                    feat[name] = reader.GetLOB(name).Data;
                                    break;

                                case FdoPropertyType.DateTime:
                                {
                                    try
                                    {
                                        feat[name] = reader.GetDateTime(name);
                                    }
                                    catch         //Unrepresentable dates
                                    {
                                        feat[name] = DBNull.Value;
                                    }
                                }
                                break;

                                case FdoPropertyType.Decimal:     //We should probably remove this as FDO coerces decimals to doubles (otherwise why is there not a GetDecimal() method in FdoIReader?)
                                {
                                    double val = reader.GetDouble(name);
                                    if (Double.IsNaN(val))
                                    {
                                        feat[name] = DBNull.Value;
                                    }
                                    else
                                    {
                                        feat[name] = Convert.ToDecimal(val);
                                    }
                                }
                                break;

                                case FdoPropertyType.Double:
                                    feat[name] = reader.GetDouble(name);
                                    break;

                                case FdoPropertyType.Geometry:
                                {
                                    try
                                    {
                                        byte[] fgf = reader.GetGeometry(name);
                                        OSGeo.FDO.Geometry.IGeometry geom = service.GeometryFactory.CreateGeometryFromFgf(fgf);
                                        var fg = new FdoGeometry(geom);
                                        //OGR geometry trap
                                        using (var env = fg.Envelope) { }
                                        feat[name] = fg;
                                    }
                                    catch
                                    {
                                        feat[name] = DBNull.Value;
                                    }
                                }
                                break;

                                case FdoPropertyType.Int16:
                                    feat[name] = reader.GetInt16(name);
                                    break;

                                case FdoPropertyType.Int32:
                                    feat[name] = reader.GetInt32(name);
                                    break;

                                case FdoPropertyType.Int64:
                                    feat[name] = reader.GetInt64(name);
                                    break;

                                case FdoPropertyType.Object:
                                    // TODO: how to handle for non-StandardQuery
                                    if (e.Argument is StandardQuery)
                                    {
                                        // because the original code used an iterator over the reader.FieldCount
                                        // it is a bit of a hack to get another definition of the class and check
                                        // we are at the right property with a name comparison
                                        // TODO: code review to see if this can be implemented better
                                        FdoFeatureReader readerFeature = (FdoFeatureReader)reader;
                                        ClassDefinition  classDef      = readerFeature.GetClassDefinition();

                                        foreach (PropertyDefinition propertyDef in classDef.Properties)
                                        {
                                            // only looking for the right object
                                            if ((PropertyType.PropertyType_ObjectProperty == propertyDef.PropertyType) &&
                                                (propertyDef.Name.Equals(name)))
                                            {
                                                ObjectPropertyDefinition assocProp  = (ObjectPropertyDefinition)propertyDef;
                                                ClassDefinition          classAssoc = assocProp.Class;

                                                // get a reader from the object - nice!
                                                IFeatureReader readerObject = readerFeature.GetFeatureObject(name);
                                                if ((null != readerObject) && (readerObject.ReadNext()))
                                                {
                                                    // TODO: this should be an iterative function

                                                    // the simple reassignment on each instance fails
                                                    //  (classDefObject.Properties is always zero after first record)
                                                    //  so have set classDefObject higher-up and re-use/
                                                    //   - problem will occur if more than one association
                                                    // ClassDefinition classDefObject = readerObject.GetClassDefinition();
                                                    if (null == classDefObject)
                                                    {
                                                        classDefObject = readerObject.GetClassDefinition();
                                                    }

                                                    foreach (PropertyDefinition propertyDefObject in classDefObject.Properties)
                                                    {
                                                        String nameObject = propertyDefObject.Name;

                                                        // TODO: only "data" type handled at present
                                                        if (PropertyType.PropertyType_DataProperty == propertyDefObject.PropertyType)
                                                        {
                                                            DataPropertyDefinition datapropertyDefObject = (DataPropertyDefinition)propertyDefObject;

                                                            String   szFullName = name + "." + nameObject;
                                                            DataType ptAssoc    = datapropertyDefObject.DataType;
                                                            // TODO: handle all types
                                                            switch (ptAssoc)
                                                            {
                                                            case DataType.DataType_String:
                                                                feat[szFullName] = readerObject.GetString(nameObject);
                                                                break;

                                                            case DataType.DataType_Int16:
                                                                feat[szFullName] = readerObject.GetInt16(nameObject);
                                                                break;

                                                            case DataType.DataType_Int32:
                                                                feat[szFullName] = readerObject.GetInt32(nameObject);
                                                                break;

                                                            case DataType.DataType_Int64:
                                                                feat[szFullName] = readerObject.GetInt64(nameObject);
                                                                break;
                                                            }
                                                        }
                                                    }
                                                    readerObject.Close();
                                                    readerObject = null;
                                                }
                                            }
                                        }
                                    }
                                    break;

                                //case FdoPropertyType.Raster:
                                case FdoPropertyType.Single:
                                    feat[name] = reader.GetSingle(name);
                                    break;

                                case FdoPropertyType.String:
                                    feat[name] = reader.GetString(name);
                                    break;
                                }
                            }
                            else
                            {
                                feat[name] = DBNull.Value;
                            }
                        }
                        table.AddRow(feat);

                        if (table.Rows.Count % 50 == 0)
                        {
                            System.Threading.Thread.Sleep(50);
                        }
                    }

                    if (_queryWorker.CancellationPending)
                    {
                        e.Cancel      = true;
                        _cancelResult = table;
                    }
                    else
                    {
                        e.Result = table;
                    }
                }
                finally
                {
                    if (reader != null)
                    {
                        reader.Close();
                    }
                }
            }
        }
Ejemplo n.º 15
0
        void OnAfterNodeExpansion(object sender, TreeViewEventArgs e)
        {
            if (e.Action == TreeViewAction.Expand)
            {
                TreeNode node = e.Node;
                TreeNode root = _explorer.GetRootNode(RootNodeName);
                //Is a FDO data source node
                if (IsChild(root.Nodes, node, NODE_LEVEL_CLASS))
                {
                    //Find the connection node
                    TreeNode connNode = node;
                    while (connNode.Level > 1)
                    {
                        connNode = connNode.Parent;
                    }
                    string connName = connNode.Name;

                    using (new TempCursor(Cursors.WaitCursor))
                    {
                        switch (node.Level)
                        {
                        case NODE_LEVEL_CONNECTION:     //Connection node
                        {
                            if (!(bool)node.Tag)        //Not loaded, load it now
                            {
                                //Clear out dummy node
                                node.Nodes.Clear();
                                CreateSchemaNodes(node);
                                node.Tag = true;         //Schema is loaded
                            }
                        }
                        break;

                        case NODE_LEVEL_SCHEMA:     //Schema Node
                        {
                            bool isPartial = Convert.ToBoolean(node.Tag);
                            if (isPartial)
                            {
                                Debug.Assert(node.Nodes.Count == 1);         //Has a dummy node
                                string        schemaName = node.Name;
                                FdoConnection conn       = _connMgr.GetConnection(connName);

                                using (FdoFeatureService svc = conn.CreateFeatureService())
                                {
                                    Debug.Assert(svc.SupportsPartialSchemaDiscovery());
                                    List <string> classNames = svc.GetClassNames(schemaName);
                                    GetClassNodesPartial(classNames, node);
                                    node.Tag = false;         //This node is no longer partial
                                    node.Expand();
                                }
                            }
                        }
                        break;

                        case NODE_LEVEL_CLASS:     //Class Node
                        {
                            bool isPartial = Convert.ToBoolean(node.Tag);
                            if (isPartial)
                            {
                                Debug.Assert(node.Nodes.Count == 1);         //Has a dummy node
                                string        schemaName = node.Parent.Name;
                                FdoConnection conn       = _connMgr.GetConnection(connName);
                                using (FdoFeatureService svc = conn.CreateFeatureService())
                                {
                                    Debug.Assert(svc.SupportsPartialSchemaDiscovery());
                                    ClassDefinition cd = svc.GetClassByName(schemaName, node.Name);
                                    if (cd != null)
                                    {
                                        UpdateClassNode(node, cd);
                                    }
                                }
                            }
                        }
                        break;
                        }
                    }
                }
            }
        }