Exemple #1
0
        /// <summary>
        /// Set the current element's content from the current XML node
        /// </summary>
        /// <param name="node"></param>
        /// <param name="mgr"></param>
        public void ReadXml(XmlNode node, XmlNamespaceManager mgr)
        {
            if (!node.Name.Equals("fdo:DataStore"))                                                           //NOXLATE
            {
                throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedElement, "fdo:DataStore")); //NOXLATE
            }
            _spatialContexts.Clear();
            _schemas.Clear();

            XmlNodeList csNodes = node.SelectNodes("gml:DerivedCRS", mgr); //NOXLATE

            foreach (XmlNode cs in csNodes)
            {
                var context = new FdoSpatialContextListSpatialContext();
                context.ReadXml(cs, mgr);

                AddSpatialContext(context);
            }

            XmlNodeList schemaNodes = node.SelectNodes("xs:schema", mgr); //NOXLATE

            foreach (XmlNode sn in schemaNodes)
            {
                FeatureSchema fs = new FeatureSchema();
                fs.ReadXml(sn, mgr);
                AddSchema(fs);
            }

            ReadSchemaMappings(node, mgr);
        }
        internal string[] AddClassesToSchema(string schemaName, ClassCollection classCollection)
        {
            List <string> notAdded = new List <string>();
            FeatureSchema fsc      = null;
            var           fidx     = _schemas.IndexOf(schemaName);

            if (fidx >= 0)
            {
                fsc = _schemas[fidx];
            }
            else
            {
                fsc = new FeatureSchema(schemaName, "");
                AddSchema(fsc);
            }

            foreach (ClassDefinition cls in classCollection)
            {
                var cidx = fsc.Classes.IndexOf(cls.Name);
                if (cidx >= 0)
                {
                    notAdded.Add(cls.Name);
                }
                else
                {
                    ClassDefinition copy = FdoSchemaUtil.CloneClass(cls, false);
                    AddClass(fsc.Name, copy);
                }
            }

            return(notAdded.ToArray());
        }
        /// <summary>
        /// Initializes this instance.
        /// </summary>
        protected override void Initialize()
        {
            SendMessage("Creating target data source");
            if (!ExpressUtility.CreateFlatFileDataSource(_outputFile))
            {
                throw new FdoETLException(ResourceUtil.GetStringFormatted("ERR_CANNOT_CREATE_DATA_FILE", _outputFile));
            }

            _outConn = ExpressUtility.CreateFlatFileConnection(_outputFile);
            _outConn.Open();

            ClassDefinition cd = _table.CreateClassDefinition(true);

            using (FdoFeatureService service = _outConn.CreateFeatureService())
            {
                SendMessage("Applying schema to target");
                FeatureSchema schema = new FeatureSchema("Schema1", "Default schema");
                schema.Classes.Add(cd);
                service.ApplySchema(schema);
            }

            SendMessage("Copying any attached spatial contexts");
            ExpressUtility.CopyAllSpatialContexts(_table.SpatialContexts, _outConn, true);

            Register(new FdoFeatureTableInputOperation(_table));
            Register(new FdoOutputOperation(_outConn, cd.Name));
        }
        public virtual void TestDeleteFeatures()
        {
            Skip.If(_fixture.Skip, _fixture.SkipReason);

            var             conn   = _fixture.CreateTestConnection();
            var             fsId   = "Library://UnitTests/Data/Test" + GetTestPrefix() + "DeleteFeatures.FeatureSource";
            ClassDefinition cls    = null;
            FeatureSchema   schema = null;

            PopulateTestDataStore(conn, fsId, ref schema, ref cls);

            IDeleteFeatures delete = (IDeleteFeatures)conn.CreateCommand((int)CommandType.DeleteFeatures);

            delete.ClassName       = cls.Name;
            delete.FeatureSourceId = fsId;
            delete.Filter          = "NAME = 'Test4'";

            Assert.Equal(1, delete.Execute());

            int count = 0;

            using (var rdr = conn.FeatureService.QueryFeatureSource(fsId, cls.Name))
            {
                while (rdr.ReadNext())
                {
                    count++;
                }
            }

            Assert.Equal(3, count);
        }
        public void WriteXmlTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.AreEqual("Foo", fs.Name);
            Assert.AreEqual("Bar", fs.Description);
            Assert.AreEqual(0, fs.Classes.Count);

            var cls = new ClassDefinition("Class1", "Test Class");
            var id  = new DataPropertyDefinition("ID", "");

            id.DataType        = DataPropertyType.Int32;
            id.IsAutoGenerated = true;
            var name = new DataPropertyDefinition("Name", "");

            cls.AddProperty(id, true);
            cls.AddProperty(name);
            fs.AddClass(cls);

            var doc = new XmlDocument();

            fs.WriteXml(doc, doc);

            string xml = doc.ToXmlString();

            Assert.False(String.IsNullOrEmpty(xml));
        }
        public virtual void TestCreateDataStore()
        {
            Skip.If(_fixture.Skip, _fixture.SkipReason);

            var             conn   = _fixture.CreateTestConnection();
            var             fsId   = "Library://UnitTests/Data/Test" + GetTestPrefix() + "CreateDataStore.FeatureSource";
            ClassDefinition cls    = null;
            FeatureSchema   schema = null;

            CreateTestDataStore(conn, fsId, ref schema, ref cls);

            ClassDefinition cls2 = conn.FeatureService.GetClassDefinition(fsId, "Class1");

            Assert.NotNull(cls2);
            Assert.False(ClassDefinition.ReferenceEquals(cls, cls2));

            Assert.Equal(cls.Name, cls2.Name);
            Assert.Equal(cls.DefaultGeometryPropertyName, cls2.DefaultGeometryPropertyName);
            Assert.Equal(cls.Properties.Count, cls2.Properties.Count);
            Assert.Equal(cls.IdentityProperties.Count, cls2.IdentityProperties.Count);
            foreach (var prop in cls.Properties)
            {
                var prop2 = cls2.FindProperty(prop.Name);
                Assert.Equal(prop.Name, prop2.Name);
                Assert.Equal(prop.Type, prop2.Type);
            }
        }
        public void CloneTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.AreEqual("Foo", fs.Name);
            Assert.AreEqual("Bar", fs.Description);
            Assert.AreEqual(0, fs.Classes.Count);

            var cls = new ClassDefinition("Class1", "Test Class");
            var id  = new DataPropertyDefinition("ID", "");

            id.DataType        = DataPropertyType.Int32;
            id.IsAutoGenerated = true;
            var name = new DataPropertyDefinition("Name", "");

            cls.AddProperty(id, true);
            cls.AddProperty(name);
            fs.AddClass(cls);

            var fs2 = FeatureSchema.Clone(fs);

            Assert.AreEqual(fs.Name, fs2.Name);
            Assert.AreEqual(fs.Description, fs2.Description);
            Assert.AreEqual(fs.Classes.Count, fs2.Classes.Count);
            Assert.AreNotSame(fs, fs2);
        }
        protected void CreateTestDataStore(IServerConnection conn, string fsId, ref FeatureSchema schema, ref ClassDefinition cls)
        {
            schema = new FeatureSchema("Default", "");
            cls    = new ClassDefinition("Class1", "");

            try
            {
                if (conn.ResourceService.ResourceExists(fsId))
                {
                    conn.ResourceService.DeleteResource(fsId);
                }

                cls.DefaultGeometryPropertyName = "GEOM";
                cls.AddProperty(new DataPropertyDefinition("KEY", "")
                {
                    DataType        = DataPropertyType.Int32,
                    IsAutoGenerated = true,
                    IsReadOnly      = true,
                    IsNullable      = false
                }, true);

                cls.AddProperty(new DataPropertyDefinition("NAME", "")
                {
                    DataType   = DataPropertyType.String,
                    Length     = 255,
                    IsNullable = true,
                    IsReadOnly = false
                });

                cls.AddProperty(new GeometricPropertyDefinition("GEOM", "")
                {
                    GeometricTypes            = FeatureGeometricType.Point,
                    SpatialContextAssociation = "Default"
                });

                schema.AddClass(cls);

                ICreateDataStore create = (ICreateDataStore)conn.CreateCommand((int)CommandType.CreateDataStore);
                CoordinateSystemDefinitionBase coordSys = conn.CoordinateSystemCatalog.FindCoordSys("LL84");
                create.FeatureSourceId     = fsId;
                create.CoordinateSystemWkt = coordSys.WKT;
                create.Name        = "Default";
                create.ExtentType  = OSGeo.MapGuide.ObjectModels.Common.FdoSpatialContextListSpatialContextExtentType.Dynamic;
                create.FileName    = "Test.sdf";
                create.Provider    = "OSGeo.SDF";
                create.Schema      = schema;
                create.XYTolerance = 0.001;
                create.ZTolerance  = 0.001;

                create.Execute();
            }
            catch
            {
                schema = null;
                cls    = null;
                throw;
            }
        }
        public void TestSchemaClone()
        {
            FeatureSchemaCollection schemas = new FeatureSchemaCollection(null);

            schemas.ReadXml(Path.Combine(TestHelper.CurrentPath, "Test.xml"));

            FeatureSchema cloned = FdoSchemaUtil.CloneSchema(schemas[0]);

            AssertHelper.EqualSchemas(schemas[0], cloned);
        }
Exemple #10
0
 private TreeNode CreateSchemaNode(FeatureSchema schema)
 {
     return(new TreeNode()
     {
         Name = schema.Name,
         Text = schema.Name,
         Tag = schema,
         ImageIndex = IDX_SCHEMA,
         SelectedImageIndex = IDX_SCHEMA,
         ContextMenuStrip = ctxSchema
     });
 }
        internal void AddSchema(FeatureSchema schema)
        {
            _schemas.Add(schema);
            //Broadcast

            var handler = this.SchemaAdded;

            if (handler != null)
            {
                handler(schema);
            }
        }
        public void TestSchemaCannotBeApplied()
        {
            FeatureSchema schema = new FeatureSchema("Default", "");
            FeatureClass  fc     = new FeatureClass("Class1", "");

            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");

            id.DataType        = DataType.DataType_Int32;
            id.IsAutoGenerated = true;

            fc.Properties.Add(id);
            fc.IdentityProperties.Add(id);

            //Unsupported property in SHP
            DataPropertyDefinition d1 = new DataPropertyDefinition("Unsupported", "");

            d1.DataType = DataType.DataType_Int64;
            d1.Nullable = true;

            fc.Properties.Add(d1);

            GeometricPropertyDefinition geom = new GeometricPropertyDefinition("Geometry", "");

            geom.GeometryTypes = (int)GeometryType.GeometryType_Point;

            fc.Properties.Add(geom);
            schema.Classes.Add(fc);

            /*
             * IConnection conn = FeatureAccessManager.GetConnectionManager().CreateConnection("OSGeo.SHP");
             * conn.ConnectionString = "DefaultFileLocation=" + AppGateway.RunningApplication.AppPath;
             * using (conn)
             * {
             *  conn.Open();
             *  using (FeatureService service = new FeatureService(conn))
             *  {
             *      IncompatibleSchema incSchema = null;
             *      bool result = service.CanApplySchema(schema, out incSchema);
             *      Assert.IsNotNull(incSchema);
             *      Assert.IsFalse(result);
             *
             *      foreach (IncompatibleClass incClass in incSchema.Classes)
             *      {
             *          foreach (IncompatibleProperty incProp in incClass.Properties)
             *          {
             *              Assert.AreEqual(incProp.Reasons.Count, incProp.ReasonCodes.Count);
             *          }
             *      }
             *  }
             *  conn.Close();
             * }*/
        }
Exemple #13
0
        public void AddClassTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.Equal("Foo", fs.Name);
            Assert.Equal("Bar", fs.Description);
            Assert.Empty(fs.Classes);

            var cls = new ClassDefinition("Class1", "Test Class");

            fs.AddClass(cls);
            Assert.Single(fs.Classes);
        }
Exemple #14
0
            internal void AddSchema()
            {
                string name = _context.GenerateName("Schema");

                while (_context.SchemaNameExists(name))
                {
                    name = _context.GenerateName("Schema");
                }

                FeatureSchema schema = new FeatureSchema(name, "");

                _context.AddSchema(schema);
            }
Exemple #15
0
        public void FeatureSchemaTest()
        {
            var fs = new FeatureSchema("Foo", "");

            Assert.Equal("Foo", fs.Name);
            Assert.True(String.IsNullOrEmpty(fs.Description));
            Assert.Empty(fs.Classes);

            fs = new FeatureSchema("Foo", "Bar");
            Assert.Equal("Foo", fs.Name);
            Assert.Equal("Bar", fs.Description);
            Assert.Empty(fs.Classes);
        }
        public void AddClassTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.AreEqual("Foo", fs.Name);
            Assert.AreEqual("Bar", fs.Description);
            Assert.AreEqual(0, fs.Classes.Count);

            var cls = new ClassDefinition("Class1", "Test Class");

            fs.AddClass(cls);
            Assert.AreEqual(1, fs.Classes.Count);
        }
        public override void Run()
        {
            TreeNode node = Workbench.Instance.ObjectExplorer.GetSelectedNode();

            if (node.Level == 2) //Schema
            {
                TreeNode             schemaNode = node;
                TreeNode             connNode   = node.Parent;
                FdoConnectionManager mgr        = ServiceManager.Instance.GetService <FdoConnectionManager>();
                FdoConnection        conn       = mgr.GetConnection(connNode.Name);
                using (FdoFeatureService service = conn.CreateFeatureService())
                {
                    FeatureSchema schema = service.GetSchemaByName(schemaNode.Name);
                    if (schema != null)
                    {
                        PartialSchemaSaveDialog dialog = new PartialSchemaSaveDialog(schema);
                        dialog.ShowDialog();
                    }
                }
            }


            //string path = FileService.SaveFile(Res.GetString("TITLE_SAVE_SCHEMA"), Res.GetString("FILTER_SCHEMA_FILE"));
            //if (!string.IsNullOrEmpty(path))
            //{
            //    TreeNode node = Workbench.Instance.ObjectExplorer.GetSelectedNode();
            //    if (node.Level == 1) //Connection
            //    {
            //        TreeNode connNode = node;
            //        FdoConnectionManager mgr = ServiceManager.Instance.GetService<FdoConnectionManager>();
            //        FdoConnection conn = mgr.GetConnection(connNode.Name);
            //        using (FdoFeatureService service = conn.CreateFeatureService())
            //        {
            //            service.WriteSchemaToXml(path);
            //            Log.InfoFormatted(Res.GetString("LOG_SCHEMA_SAVED"), path);
            //        }
            //    }
            //    else if (node.Level == 2) //Schema
            //    {
            //        TreeNode schemaNode = node;
            //        TreeNode connNode = node.Parent;
            //        FdoConnectionManager mgr = ServiceManager.Instance.GetService<FdoConnectionManager>();
            //        FdoConnection conn = mgr.GetConnection(connNode.Name);
            //        using (FdoFeatureService service = conn.CreateFeatureService())
            //        {
            //            service.WriteSchemaToXml(schemaNode.Name, path);
            //            Log.InfoFormatted(Res.GetString("LOG_SCHEMA_SAVED_2"), connNode.Name, path);
            //        }
            //    }
            //}
        }
Exemple #18
0
        public static void EqualSchemas(FeatureSchema schema, FeatureSchema schema2)
        {
            Assert.AreEqual(schema.Name, schema2.Name);
            Assert.AreEqual(schema.Classes.Count, schema2.Classes.Count);

            foreach (ClassDefinition classDef in schema.Classes)
            {
                int idx = schema2.Classes.IndexOf(classDef.Name);
                Assert.IsTrue(idx >= 0);

                ClassDefinition cd = schema2.Classes[idx];
                EqualClass(classDef, cd);
            }
        }
Exemple #19
0
        public static void EqualSchemas(FeatureSchema schema, FeatureSchema schema2)
        {
            Assert.AreEqual(schema.Name, schema2.Name);
            Assert.AreEqual(schema.Classes.Count, schema2.Classes.Count);

            foreach (ClassDefinition classDef in schema.Classes)
            {
                int idx = schema2.Classes.IndexOf(classDef.Name);
                Assert.IsTrue(idx >= 0);

                ClassDefinition cd = schema2.Classes[idx];
                EqualClass(classDef, cd);
            }
        }
Exemple #20
0
            void OnSchemaAdded(FeatureSchema item)
            {
                var node = CreateSchemaNode(item);

                _view.schemaTree.Nodes.Add(node);

                foreach (ClassDefinition cd in item.Classes)
                {
                    OnClassAdded(cd);
                }

                _view.EvaluateStates();
                _view.FlagUpdateState();
            }
 public override void ExecuteAction()
 {
     using (var svc = _conn.CreateFeatureService())
     {
         IncompatibleSchema schema;
         if (!svc.CanApplySchema(_schema, out schema))
         {
             Info("Fixing incompatibilities in schema");
             _schema = svc.AlterSchema(_schema, schema);
         }
         Info("Applying schema");
         svc.ApplySchema(_schema);
         Info("Schema applied");
     }
 }
 public override void ExecuteAction()
 {
     using (var svc = _conn.CreateFeatureService())
     {
         IncompatibleSchema schema;
         if (!svc.CanApplySchema(_schema, out schema))
         {
             Info("Fixing incompatibilities in schema");
             _schema = svc.AlterSchema(_schema, schema);
         }
         Info("Applying schema");
         svc.ApplySchema(_schema);
         Info("Schema applied");
     }
 }
Exemple #23
0
            private void OnSchemaSelected(TreeNode node)
            {
                FeatureSchema schema = (FeatureSchema)node.Tag;
                //C# Lambdas, making code and design compact and elegant since 2007
                NodeUpdateHandler update = () =>
                {
                    node.Text = schema.Name;
                    node.Name = schema.Name;
                };
                var c = new SchemaCtrl(new FeatureSchemaDecorator(schema), update);

                _view.SetLogicalControl(c);
                _view.PhysicalMappingsVisible = false;
                _view.RightPaneVisible        = true;
            }
Exemple #24
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))
            {
                FeatureSchema fs = service.GetSchemaByName(_schema);
                if (fs != null)
                {
                    using (fs)
                    {
                        Console.WriteLine("\nClasses in schema {0}: {1}\n", fs.Name, fs.Classes.Count);
                        foreach (ClassDefinition cd in fs.Classes)
                        {
                            Console.WriteLine("Name: {0} ({1})\n\n\tQualified Name: {2}", cd.Name, cd.ClassType, cd.QualifiedName);
                            Console.WriteLine("\tDescription: {0}", cd.Description);
                            Console.WriteLine("\tIs Abstract: {0}\n\tIs Computed: {1}", cd.IsAbstract, cd.IsComputed);
                            if (cd.BaseClass != null)
                            {
                                Console.WriteLine("\tBase Class: {0}", cd.BaseClass.Name);
                            }
                            Console.WriteLine("\tAttributes:");
                            WriteAttributes(cd.Attributes);
                            Console.WriteLine("");
                        }
                    }
                }
                else
                {
                    Console.Error.WriteLine("Could not find schema: {0}", _schema);
                    return((int)CommandStatus.E_FAIL_SCHEMA_NOT_FOUND);
                }
            }

            conn.Close();
            return((int)CommandStatus.E_OK);
        }
        public void IndexOfTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.AreEqual("Foo", fs.Name);
            Assert.AreEqual("Bar", fs.Description);
            Assert.AreEqual(0, fs.Classes.Count);

            var cls = new ClassDefinition("Class1", "Test Class");

            fs.AddClass(cls);

            Assert.GreaterOrEqual(fs.IndexOf(cls), 0);
            Assert.True(fs.RemoveClass(cls));
            Assert.Less(fs.IndexOf(cls), 0);
        }
        void GetClassNodesFull(FeatureSchema schema, TreeNode schemaNode)
        {
            //Pre-sort
            SortedList <string, ClassDefinition> sorted = new SortedList <string, ClassDefinition>();

            foreach (ClassDefinition classDef in schema.Classes)
            {
                sorted.Add(classDef.Name, classDef);
            }

            foreach (ClassDefinition classDef in sorted.Values)
            {
                TreeNode classNode = CreateClassNode(classDef);
                schemaNode.Nodes.Add(classNode);
            }
        }
Exemple #27
0
        public void IndexOfTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.Equal("Foo", fs.Name);
            Assert.Equal("Bar", fs.Description);
            Assert.Empty(fs.Classes);

            var cls = new ClassDefinition("Class1", "Test Class");

            fs.AddClass(cls);

            Assert.True(fs.IndexOf(cls) >= 0);
            Assert.True(fs.RemoveClass(cls));
            Assert.True(fs.IndexOf(cls) < 0);
        }
        public virtual void TestApplySchema()
        {
            Skip.If(_fixture.Skip, _fixture.SkipReason);

            var fsId = "Library://UnitTests/Data/TestMaestro" + GetTestPrefix() + "ApplySchema.FeatureSource";
            var conn = _fixture.CreateTestConnection();

            if (conn.ResourceService.ResourceExists(fsId))
            {
                conn.ResourceService.DeleteResource(fsId);
            }

            ClassDefinition cls    = null;
            FeatureSchema   schema = null;

            CreateTestDataStore(conn, fsId, ref schema, ref cls);

            cls.AddProperty(new DataPropertyDefinition("ExtraProp", "")
            {
                DataType   = DataPropertyType.String,
                IsNullable = false,
                Length     = 255
            });

            //Apply changes
            IApplySchema cmd = (IApplySchema)conn.CreateCommand((int)CommandType.ApplySchema);

            cmd.Schema          = schema;
            cmd.FeatureSourceId = fsId;
            cmd.Execute();

            ClassDefinition cls2 = conn.FeatureService.GetClassDefinition(cmd.FeatureSourceId, "Class1");

            Assert.NotNull(cls2);
            Assert.False(ClassDefinition.ReferenceEquals(cls, cls2));

            Assert.Equal(cls.Name, cls2.Name);
            Assert.Equal(cls.DefaultGeometryPropertyName, cls2.DefaultGeometryPropertyName);
            Assert.Equal(cls.Properties.Count, cls2.Properties.Count);
            Assert.Equal(cls.IdentityProperties.Count, cls2.IdentityProperties.Count);
            foreach (var prop in cls.Properties)
            {
                var prop2 = cls2.FindProperty(prop.Name);
                Assert.Equal(prop.Name, prop2.Name);
                Assert.Equal(prop.Type, prop2.Type);
            }
        }
Exemple #29
0
        private TreeNode CreateSchemaNode(FeatureSchema schema)
        {
            var node = new TreeNode();

            node.Name = schema.Name;
            node.Text = schema.Name;

            foreach (ClassDefinition cls in schema.Classes)
            {
                var clsNode = CreateClassNode(cls);
                node.Nodes.Add(clsNode);
            }

            node.Tag = schema;

            return(node);
        }
Exemple #30
0
        public override ClassDefinition GetClassDefinition(string schemaName, string className)
        {
            EnsureSchemaRetrieved();

            if (_schemas.IndexOf(schemaName) >= 0)
            {
                FeatureSchema   fs      = _schemas[schemaName];
                ClassCollection classes = fs.Classes;

                if (classes.IndexOf(className) >= 0)
                {
                    return(classes[className]);
                }
            }

            return(null);
        }
        public void GetItemTest()
        {
            var fs = new FeatureSchema("Foo", "Bar");

            Assert.AreEqual("Foo", fs.Name);
            Assert.AreEqual("Bar", fs.Description);
            Assert.AreEqual(0, fs.Classes.Count);

            var cls = new ClassDefinition("Class1", "Test Class");

            fs.AddClass(cls);

            Assert.Throws <ArgumentOutOfRangeException>(() => fs.GetItem(-1));
            Assert.Throws <ArgumentOutOfRangeException>(() => fs.GetItem(1));
            Assert.NotNull(fs.GetItem(0));
            Assert.True(fs.RemoveClass(cls));
            Assert.Throws <ArgumentOutOfRangeException>(() => fs.GetItem(0));
        }
Exemple #32
0
        public override ClassDescriptor[] GetClassNames(string schemaName)
        {
            EnsureSchemaRetrieved();

            List <ClassDescriptor> classNames = new List <ClassDescriptor>();

            if (_schemas.IndexOf(schemaName) >= 0)
            {
                FeatureSchema   fs      = _schemas[schemaName];
                ClassCollection classes = fs.Classes;

                for (int i = 0; i < classes.Count; i++)
                {
                    classNames.Add(new ClassDescriptor(fs.Name, classes[i].Name));
                }
            }

            return(classNames.ToArray());
        }
Exemple #33
0
 public static int SetDefaultSpatialContextAssociation(FeatureSchema fs, string name)
 {
     int modified = 0;
     foreach (ClassDefinition cls in fs.Classes)
     {
         foreach (PropertyDefinition prop in cls.Properties)
         {
             if (prop.PropertyType == PropertyType.PropertyType_GeometricProperty)
             {
                 GeometricPropertyDefinition geom = (GeometricPropertyDefinition)prop;
                 if (!geom.SpatialContextAssociation.Equals(name))
                 {
                     geom.SpatialContextAssociation = name;
                     modified++;
                 }
             }
         }
     }
     return modified;
 }
Exemple #34
0
 /// <summary>
 /// Utility method to clone a feature schema
 /// </summary>
 /// <param name="fs"></param>
 /// <returns></returns>
 public static FeatureSchema CloneSchema(FeatureSchema fs)
 {
     return CloneSchema(fs, false);
 }
        internal string[] AddClassesToSchema(string schemaName, ClassCollection classCollection)
        {
            List<string> notAdded = new List<string>();
            FeatureSchema fsc = null;
            var fidx = _schemas.IndexOf(schemaName);
            if (fidx >= 0)
            {
                fsc = _schemas[fidx];
            }
            else
            {
                fsc = new FeatureSchema(schemaName, "");
                AddSchema(fsc);
            }

            foreach (ClassDefinition cls in classCollection)
            {
                var cidx = fsc.Classes.IndexOf(cls.Name);
                if (cidx >= 0)
                {
                    notAdded.Add(cls.Name);
                }
                else
                {
                    ClassDefinition copy = FdoSchemaUtil.CloneClass(cls, false);
                    AddClass(fsc.Name, copy);
                }
            }

            return notAdded.ToArray();
        }
        internal void AddSchema(FeatureSchema schema)
        {
            _schemas.Add(schema);
            //Broadcast

            var handler = this.SchemaAdded;
            if (handler != null)
                handler(schema);
        }
        public void TestAlterSchemaBaseClass()
        {
            MockRepository mocks = new MockRepository();
            FeatureSchema schema = new FeatureSchema("Default", "");
            IConnection conn = mocks.DynamicMock<IConnection>();
            ISchemaCapabilities caps = mocks.DynamicMock<ISchemaCapabilities>();

            using (mocks.Record())
            {
                SetupResult.For(conn.ConnectionState).Return(ConnectionState.ConnectionState_Open);
                SetupResult.For(conn.SchemaCapabilities).Return(caps);
                SetupResult.For(caps.ClassTypes).Return((ClassType[])Enum.GetValues(typeof(ClassType)));
                SetupResult.For(caps.DataTypes).Return((DataType[])Enum.GetValues(typeof(DataType)));
                SetupResult.For(caps.MaximumDecimalPrecision).Return(20);
                SetupResult.For(caps.MaximumDecimalScale).Return(20);
                SetupResult.For(caps.ReservedCharactersForName).Return(string.Empty);
                SetupResult.For(caps.SupportedAutoGeneratedTypes).Return(new DataType[] { DataType.DataType_Int32, DataType.DataType_Int64 });
                SetupResult.For(caps.SupportedIdentityPropertyTypes).Return(new DataType[] { DataType.DataType_Int32, DataType.DataType_Int64 });
                SetupResult.For(caps.SupportsAssociationProperties).Return(false);
                SetupResult.For(caps.SupportsAutoIdGeneration).Return(true);
                SetupResult.For(caps.SupportsCompositeId).Return(false);
                SetupResult.For(caps.SupportsCompositeUniqueValueConstraints).Return(false);
                SetupResult.For(caps.SupportsDataStoreScopeUniqueIdGeneration).Return(false);
                SetupResult.For(caps.SupportsDefaultValue).Return(true);
                SetupResult.For(caps.SupportsExclusiveValueRangeConstraints).Return(false);
                SetupResult.For(caps.SupportsInclusiveValueRangeConstraints).Return(false);
                SetupResult.For(caps.SupportsMultipleSchemas).Return(false);
                SetupResult.For(caps.SupportsNetworkModel).Return(false);
                SetupResult.For(caps.SupportsNullValueConstraints).Return(true);
                SetupResult.For(caps.SupportsObjectProperties).Return(false);
                SetupResult.For(caps.SupportsSchemaModification).Return(true);
                SetupResult.For(caps.SupportsSchemaOverrides).Return(false);
                SetupResult.For(caps.SupportsUniqueValueConstraints).Return(false);
                SetupResult.For(caps.SupportsValueConstraintsList).Return(false);

                SetupResult.For(caps.SupportsInheritance).Return(false);
            }
            FdoFeatureService service = mocks.DynamicMock<FdoFeatureService>(conn);
            mocks.ReplayAll();

            ClassDefinition baseClass = new Class("Base", "");

            //ID
            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");
            id.DataType = DataType.DataType_Int64;
            id.Nullable = false;

            baseClass.Properties.Add(id);
            baseClass.IdentityProperties.Add(id);

            //Name
            DataPropertyDefinition name = new DataPropertyDefinition("Name", "");
            name.DataType = DataType.DataType_String;
            name.Nullable = true;
            name.Length = 100;

            baseClass.Properties.Add(name);

            ClassDefinition derivedClass = new Class("Derived", "");
            derivedClass.BaseClass = baseClass;

            //DOB
            DataPropertyDefinition dob = new DataPropertyDefinition("DOB", "");
            dob.DataType = DataType.DataType_DateTime;
            dob.Nullable = true;

            derivedClass.Properties.Add(dob);

            schema.Classes.Add(baseClass);
            schema.Classes.Add(derivedClass);

            IncompatibleSchema incSchema = null;
            bool canApply = service.CanApplySchema(schema, out incSchema);
            Assert.IsFalse(canApply);
            Assert.IsNotNull(incSchema);

            FeatureSchema newSchema = service.AlterSchema(schema, incSchema);

            ClassDefinition newClass = newSchema.Classes[newSchema.Classes.IndexOf("Derived")];

            //Base class properties should be copied to derived class
            Assert.AreEqual("BASE_ID", newClass.IdentityProperties[0].Name);
            Assert.AreEqual(3, newClass.Properties.Count);
            Assert.IsTrue(newClass.Properties.IndexOf("BASE_ID") >= 0);
            Assert.IsTrue(newClass.Properties.IndexOf("BASE_Name") >= 0);
        }
Exemple #38
0
 private TreeNode CreateSchemaNode(FeatureSchema schema)
 {
     return new TreeNode()
     {
         Name = schema.Name,
         Text = schema.Name,
         Tag = schema,
         ImageIndex = IDX_SCHEMA,
         SelectedImageIndex = IDX_SCHEMA,
         ContextMenuStrip = ctxSchema
     };
 }
Exemple #39
0
            internal void AddSchema()
            {
                string name = _context.GenerateName("Schema");
                while(_context.SchemaNameExists(name))
                {
                    name = _context.GenerateName("Schema");
                }

                FeatureSchema schema = new FeatureSchema(name, "");
                _context.AddSchema(schema);
            }
 public PartialSchemaSaveDialog(FeatureSchema schema)
     : this()
 {
     _schema = FdoSchemaUtil.CloneSchema(schema); //Operate on a clone
     InitTree();
 }
Exemple #41
0
        /// <summary>
        /// Initializes this instance.
        /// </summary>
        protected override void Initialize()
        {
            var sw = new Stopwatch();
            sw.Start();
            _options.Validate();

            SendMessage("Setting up left and right sides of the join");

            // Abstract:
            //
            // The current built-in join infrastructure is very naive as it uses nested
            // loops. Being a O(m*n) operation, the slowdown becomes readily apparent
            // as the size of the data you're working with increases. As such, the
            // current infrastructure is woefully inadequate for large datasets.
            //
            // How can we fix this problem? We could try to implement various join
            // algorithms for different scenarios, which would be a laborious exercise
            // in itself.
            //
            // Or, we can just delegate this problem to the universal swiss army-knife of
            // databases, SQLite.
            //
            // SQLite has many things going for it, including:
            //  - Support for common types of joins (important!)
            //  - LIGHTING FAST insert performance. The current FdoInputOperation is already optimised for SQLite
            //  - LIGHTING FAST read performance
            //  - Ability to use SQL to modify the database internals, such as creating indexes (FDO provider supports SQL commands)
            //
            // As such, SQLite is the perfect candidate for a temp data store to merge two
            // disparate data sources. The time spent setting up this temp SQLite database (ie. Copying "left" and
            // "right" side data into it) is negligible in the grand scheme of things.
            //
            // Process Overview:
            //
            // 1. Create temp SQLite database
            // 2. Pump left and right sides into this database
            // 3. Create indexes on join columns of both tables (IMPORTANT)
            // 4. Create a view encapsulating our join
            // 5. Copy this view out to our target
            //
            // Additional Notes:
            //
            // We will have to change our supported join types to line up with what SQLite supports, which
            // are:
            //  - INNER JOIN
            //  - LEFT OUTER JOIN
            //
            // SQLite does not support RIGHT OUTER JOINs but these could be emulated by inverting the
            // "left" and "right" tables for the LEFT OUTER JOIN. FULL OUTER JOIN is not supporte by
            // SQLite so this will be removed from our API.
            //
            // Since this SQLite database is temporary, we don't bother with putting
            // the right spatial context in there. Spatial contexts do not (should not) affect
            // the underlying coordinates of any geometries moving to and from the data store.
            //
            // SQLite views by default are represented as non-Feature classes. Geometry properties
            // default to BLOB data types. To "fix" this we need to add a new entry to the geometry_columns
            // metadata table. This may produce an incorrect feature class (ie. Has 1-n geometry properties
            // but no designated one), this is okay as we only care that the properties are there and the
            // temp-target property mappings check out.
            //
            // Although the implementation will change, the requirements remain the same, which are:
            //
            // 1. The target class must not already exist (as it will be created)
            // 2. If no designated geometry is specified, then the class definition will be FdoClass and not FdoFeatureClass

            ClassDefinition leftCls = null;
            ClassDefinition rightCls = null;
            ClassDefinition mergedCls = null;

            using (var leftSvc = _options.Left.Connection.CreateFeatureService())
            using (var rightSvc = _options.Right.Connection.CreateFeatureService())
            {
                leftCls = leftSvc.GetClassByName(_options.Left.SchemaName, _options.Left.ClassName);
                rightCls = rightSvc.GetClassByName(_options.Right.SchemaName, _options.Right.ClassName);

                if (leftCls == null)
                    throw new FdoETLException("Left class not found " + _options.Left.SchemaName + ":" + _options.Left.ClassName);

                if (rightCls == null)
                    throw new FdoETLException("Right class not found " + _options.Right.SchemaName + ":" + _options.Right.ClassName);

                var leftJoinProps = new List<string>(_options.JoinPairs.AllKeys);
                var rightJoinProps = new List<string>();
                foreach (var p in leftJoinProps)
                {
                    rightJoinProps.Add(_options.JoinPairs[p]);
                }

                var leftGeom = (!string.IsNullOrEmpty(_options.GeometryProperty) && _options.Side == JoinSide.Left) ? _options.GeometryProperty : null;
                var rightGeom = (!string.IsNullOrEmpty(_options.GeometryProperty) && _options.Side == JoinSide.Right) ? _options.GeometryProperty : null;

                PrepareClass(leftCls, _options.LeftProperties, leftJoinProps, _options.LeftPrefix, leftGeom);
                PrepareClass(rightCls, _options.RightProperties, rightJoinProps, _options.RightPrefix, rightGeom);

                mergedCls = CreateMergedClass(leftCls, rightCls);
            }

            var dprops = new NameValueCollection();
            dprops["File"] = Path.GetTempFileName();

            var tempSchema = new FeatureSchema("Default", "");
            var leftCopy = FdoSchemaUtil.CloneClass(leftCls);
            var rightCopy = FdoSchemaUtil.CloneClass(rightCls);

            string leftClassName = "LEFT_SIDE";
            string rightClassName = "RIGHT_SIDE";

            leftCopy.Name = leftClassName;
            rightCopy.Name = rightClassName;

            tempSchema.Classes.Add(leftCopy);
            tempSchema.Classes.Add(rightCopy);

            //Create SQLite database
            Register(new FdoCreateDataStoreOperation("OSGeo.SQLite", dprops, null));

            //Apply temp schema
            var tempConn = new FdoConnection("OSGeo.SQLite", "File=" + dprops["File"]);
            Register(new FdoApplySchemaOperation(tempConn, tempSchema));

            #if DEBUG
            Register(new FdoSingleActionOperation(() => { SendMessage("Temp db created in: " + dprops["File"]); }));
            #endif

            //Prep property mappings for bulk copy
            var leftMaps = new NameValueCollection();
            var rightMaps = new NameValueCollection();

            var leftQuery = new FeatureQueryOptions(leftCls.Name);
            var rightQuery = new FeatureQueryOptions(rightCls.Name);

            foreach (var leftp in _options.LeftProperties)
            {
                if (string.IsNullOrEmpty(_options.LeftPrefix))
                    leftMaps.Add(leftp, leftp);
                else
                    leftMaps.Add(leftp, _options.LeftPrefix + leftp);
                leftQuery.AddFeatureProperty(leftp);
            }
            foreach (var rightp in _options.RightProperties)
            {
                if (string.IsNullOrEmpty(_options.RightPrefix))
                    rightMaps.Add(rightp, rightp);
                else
                    rightMaps.Add(rightp, _options.RightPrefix + rightp);
                rightQuery.AddFeatureProperty(rightp);
            }

            if (!string.IsNullOrEmpty(_options.LeftFilter))
                leftQuery.Filter = _options.LeftFilter;

            if (!string.IsNullOrEmpty(_options.RightFilter))
                rightQuery.Filter = _options.RightFilter;

            //don't forget join keys
            foreach (string l in _options.JoinPairs.Keys)
            {
                string r = _options.JoinPairs[l];

                if (!_options.LeftProperties.Contains(l))
                {
                    leftQuery.AddFeatureProperty(l);

                    if (string.IsNullOrEmpty(_options.LeftPrefix))
                        leftMaps.Add(l, l);
                    else
                        leftMaps.Add(l, _options.LeftPrefix + l);
                }

                if (!_options.RightProperties.Contains(r))
                {
                    rightQuery.AddFeatureProperty(r);

                    if (string.IsNullOrEmpty(_options.RightPrefix))
                        rightMaps.Add(r, r);
                    else
                        rightMaps.Add(r, _options.RightPrefix + r);
                }

            }

            //don't forget geometry!
            if (!string.IsNullOrEmpty(_options.GeometryProperty))
            {
                if (_options.Side == JoinSide.Left)
                {
                    if (!leftQuery.PropertyList.Contains(_options.GeometryProperty))
                    {
                        leftQuery.AddFeatureProperty(_options.GeometryProperty);

                        if (string.IsNullOrEmpty(_options.LeftPrefix))
                            leftMaps.Add(_options.GeometryProperty, _options.GeometryProperty);
                        else
                            leftMaps.Add(_options.GeometryProperty, _options.LeftPrefix + _options.GeometryProperty);
                    }
                }
                else
                {
                    if (!rightQuery.PropertyList.Contains(_options.GeometryProperty))
                    {
                        rightQuery.AddFeatureProperty(_options.GeometryProperty);

                        if (string.IsNullOrEmpty(_options.RightPrefix))
                            rightMaps.Add(_options.GeometryProperty, _options.GeometryProperty);
                        else
                            rightMaps.Add(_options.GeometryProperty, _options.RightPrefix + _options.GeometryProperty);
                    }
                }
            }

            var copyLeftErrors = new List<Exception>();
            var copyRightErrors = new List<Exception>();
            var copyTargetErrors = new List<Exception>();

            //Copy left source
            ParameterlessAction copyLeft = () =>
            {
                SendMessage("Copying left source with filter: " + _options.LeftFilter);
                var copy = ExpressUtility.CreateBulkCopy(
                    _options.Left.Connection,
                    tempConn,
                    _options.Left.SchemaName,
                    leftQuery,
                    tempSchema.Name,    //temp sqlite schema name
                    leftClassName,      //sqlite "left" class name
                    leftMaps);

                copy.ProcessMessage += delegate(object sender, MessageEventArgs e)
                {
                    SendMessage(e.Message);
                };
                copy.Execute();
                copyLeftErrors.AddRange(copy.GetAllErrors());
            };
            Register(new FdoSingleActionOperation(copyLeft));

            //Register(new FdoInputOperation(_options.Left.Connection, leftQuery));
            //Register(new FdoOutputOperation(tempConn, leftClassName, leftMaps));

            //Copy right source
            ParameterlessAction copyRight = () =>
            {
                SendMessage("Copying right source with filter: " + _options.RightFilter);
                var copy = ExpressUtility.CreateBulkCopy(
                    _options.Right.Connection,
                    tempConn,
                    _options.Right.SchemaName,
                    rightQuery,
                    tempSchema.Name,    //temp sqlite schema name
                    rightClassName,      //sqlite "right" class name
                    rightMaps);

                copy.ProcessMessage += delegate(object sender, MessageEventArgs e)
                {
                    SendMessage(e.Message);
                };
                copy.Execute();
                copyRightErrors.AddRange(copy.GetAllErrors());
            };
            Register(new FdoSingleActionOperation(copyRight));

            //Register(new FdoInputOperation(_options.Right.Connection, rightQuery));
            //Register(new FdoOutputOperation(tempConn, rightClassName, rightMaps));

            string srcClass = "VIEW_INPUT";

            //Create indexes on left and right sides to optimize read performance
            ParameterlessAction indexLeft = () =>
            {
                using (var svc = tempConn.CreateFeatureService())
                {
                    SendMessage("Creating left side index in temp db");
                    string sql = "CREATE INDEX IDX_LEFT_ID ON " + leftClassName + "(";
                    var tokens = new List<string>();
                    foreach (string p in _options.JoinPairs.Keys)
                    {
                        if (!string.IsNullOrEmpty(_options.LeftPrefix))
                            tokens.Add(_options.LeftPrefix + p);
                        else
                            tokens.Add(p);
                    }
                    sql = sql + string.Join(", ", tokens.ToArray()) + ")";
                    SendMessage("Executing SQL: " + sql);
                    svc.ExecuteSQLNonQuery(sql);
                }
            };
            ParameterlessAction indexRight = () =>
            {
                using (var svc = tempConn.CreateFeatureService())
                {
                    SendMessage("Creating right side index in temp db");
                    string sql = "CREATE INDEX IDX_RIGHT_ID ON " + rightClassName + "(";
                    var tokens = new List<string>();
                    foreach (string p in _options.JoinPairs.Keys)
                    {
                        string prop = _options.JoinPairs[p];
                        if (!string.IsNullOrEmpty(_options.RightPrefix))
                            tokens.Add(_options.RightPrefix + prop);
                        else
                            tokens.Add(prop);
                    }
                    sql = sql + string.Join(", ", tokens.ToArray()) + ")";
                    SendMessage("Executing SQL: " + sql);
                    svc.ExecuteSQLNonQuery(sql);
                }
            };
            Register(new FdoSingleActionOperation(indexLeft));
            Register(new FdoSingleActionOperation(indexRight));

            //Create view
            ParameterlessAction createView = () =>
            {
                using (var svc = tempConn.CreateFeatureService())
                {
                    SendMessage("Creating view in temp db");
                    StringBuilder sql = new StringBuilder("CREATE VIEW ");
                    sql.Append(srcClass + " AS SELECT ");
                    foreach (var p in _options.LeftProperties)
                    {
                        if (!string.IsNullOrEmpty(_options.LeftPrefix))
                            sql.Append("l." + _options.LeftPrefix + p + ", ");
                        else
                            sql.Append("l." + p + ", ");
                    }

                    if (!string.IsNullOrEmpty(_options.GeometryProperty))
                    {
                        if (_options.Side == JoinSide.Left)
                        {
                            if (!_options.LeftProperties.Contains(_options.GeometryProperty))
                            {
                                if (!string.IsNullOrEmpty(_options.LeftPrefix))
                                    sql.Append("l." + _options.LeftPrefix + _options.GeometryProperty + ", ");
                                else
                                    sql.Append("l." + _options.GeometryProperty + ", ");
                            }
                        }
                        else
                        {
                            if (!_options.RightProperties.Contains(_options.GeometryProperty))
                            {
                                if (!string.IsNullOrEmpty(_options.RightPrefix))
                                    sql.Append("r." + _options.RightPrefix + _options.GeometryProperty + ", ");
                                else
                                    sql.Append("r." + _options.GeometryProperty + ", ");
                            }
                        }
                    }

                    int rc = _options.RightProperties.Count;
                    int i = 0;
                    foreach (var p in _options.RightProperties)
                    {
                        string pn = p;
                        if (!string.IsNullOrEmpty(_options.RightPrefix))
                            pn = _options.RightPrefix + pn;

                        if (i == rc - 1)
                            sql.Append("r." + pn + " FROM ");
                        else
                            sql.Append("r." + pn + ", ");
                        i++;
                    }
                    sql.Append(leftClassName + " l ");

                    switch (_options.JoinType)
                    {
                        case FdoJoinType.Inner:
                            sql.Append("INNER JOIN " + rightClassName + " r ON ");
                            break;
                        case FdoJoinType.Left:
                            sql.Append("LEFT OUTER JOIN " + rightClassName + " r ON ");
                            break;
                        default:
                            throw new FdoETLException("Unsupported join type: " + _options.JoinType);
                    }

                    rc = _options.JoinPairs.Count;
                    i = 0;
                    foreach (string l in _options.JoinPairs.Keys)
                    {
                        string r = _options.JoinPairs[l];

                        string left = l;
                        string right = r;

                        if (!string.IsNullOrEmpty(_options.LeftPrefix))
                            left = _options.LeftPrefix + left;

                        if (!string.IsNullOrEmpty(_options.RightPrefix))
                            right = _options.RightPrefix + right;

                        if (i == rc - 1)
                            sql.Append("l." + left + " = r." + right);
                        else
                            sql.Append("l." + left + " = r." + right + " AND ");

                        i++;
                    }
                    SendMessage("Executing SQL: " + sql.ToString());
                    svc.ExecuteSQLNonQuery(sql.ToString());
                }
            };
            Register(new FdoSingleActionOperation(createView));

            //Hack FDO metadata to make this a feature class
            if (!string.IsNullOrEmpty(_options.GeometryProperty))
            {
                ParameterlessAction reg = () =>
                {
                    using (var svc = tempConn.CreateFeatureService())
                    {
                        SendMessage("Exposing view as a FDO feature class");
                        string sql = "INSERT INTO geometry_columns(f_table_name, f_geometry_column, geometry_type, geometry_dettype, coord_dimension, srid, geometry_format) VALUES('" + srcClass + "','" + _options.GeometryProperty + "',15,7743,0,0,'FGF')";
                        SendMessage("Executing SQL: " + sql.ToString());
                        svc.ExecuteSQLNonQuery(sql);
                    }
                };
                Register(new FdoSingleActionOperation(reg));
            }

            //Copy view to target
            ParameterlessAction applyTarget = () =>
            {
                using (var svc = _options.Target.Connection.CreateFeatureService())
                {
                    SendMessage("Fetching target schema");
                    var schema = svc.GetSchemaByName(_options.Target.SchemaName);

                    IncompatibleClass cls;
                    if (!svc.CanApplyClass(mergedCls, out cls))
                    {
                        SendMessage("Fixing incompatibilities in merged class");
                        mergedCls = svc.AlterClassDefinition(mergedCls, cls);
                    }

                    SendMessage("Adding merged class to target schema");
                    schema.Classes.Add(mergedCls);
                    SendMessage("Applying modified target schema");
                    svc.ApplySchema(schema);
                }
            };
            Register(new FdoSingleActionOperation(applyTarget));

            var tempQuery = new FeatureQueryOptions("VIEW_INPUT");
            var targetMapping = new NameValueCollection();
            foreach(PropertyDefinition p in mergedCls.Properties)
            {
                tempQuery.AddFeatureProperty(p.Name);
                //Target class is a replica of the temp one, so all properties
                //have the same name in both source and target
                targetMapping[p.Name] = p.Name;
            }

            ParameterlessAction copyToTarget = () =>
            {
                var copy = ExpressUtility.CreateBulkCopy(
                    tempConn,
                    _options.Target.Connection,
                    tempSchema.Name,
                    tempQuery,
                    _options.Target.SchemaName,
                    _options.Target.ClassName,
                    targetMapping);

                copy.ProcessMessage += delegate(object sender, MessageEventArgs e)
                {
                    SendMessage(e.Message);
                };
                copy.Execute();
                copyTargetErrors.AddRange(copy.GetAllErrors());
                sw.Stop();
            };
            Register(new FdoSingleActionOperation(copyToTarget));

            //Log all errors
            ParameterlessAction logErrors = () =>
            {
                SendMessage(copyLeftErrors.Count + " errors encountered copying left source to temp db");
                _allErrors.AddRange(copyLeftErrors);
                SendMessage(copyRightErrors.Count + " errors encountered copying right source to temp db");
                _allErrors.AddRange(copyRightErrors);
                SendMessage(copyTargetErrors.Count + " errors encountered copying merged source to target");
                _allErrors.AddRange(copyTargetErrors);
                SendMessage("Join Operation completed in " + sw.Elapsed.ToString());
            };
            Register(new FdoSingleActionOperation(logErrors));
        }
Exemple #42
0
        /// <summary>
        /// Utility method to create a feature class dump bulk copy
        /// </summary>
        /// <param name="source"></param>
        /// <param name="schemaName"></param>
        /// <param name="className"></param>
        /// <param name="provider"></param>
        /// <param name="savePath"></param>
        /// <returns></returns>
        public static FdoBulkCopy CreateBulkCopy(FdoConnection source, string schemaName, string className, string provider, string savePath)
        {
            if (!ExpressUtility.CreateFlatFileDataSource(provider, savePath))
                throw new FdoException("Could not create " + savePath);

            ClassDefinition srcClass = null;
            using (var svc = source.CreateFeatureService())
            {
                srcClass = svc.GetClassByName(schemaName, className);
            }

            //Apply a copy of the source class to target
            ClassDefinition clone = FdoSchemaUtil.CloneClass(srcClass, true);
            FeatureSchema fs = null;

            FdoConnection target = ExpressUtility.CreateFlatFileConnection(provider, savePath);
            using (var svc = target.CreateFeatureService())
            {
                var schemas = svc.DescribeSchema();
                if (schemas != null && schemas.Count == 1)
                    fs = schemas[0];

                if (fs == null)
                    fs = new FeatureSchema("Default", "");

                var classes = fs.Classes;
                classes.Add(clone);

                svc.ApplySchema(fs, null, true);
            }

            //Setup mappings
            var mappings = new NameValueCollection();
            foreach (PropertyDefinition prop in srcClass.Properties)
            {
                if (prop.PropertyType == PropertyType.PropertyType_DataProperty ||
                    prop.PropertyType == PropertyType.PropertyType_GeometricProperty)
                {
                    mappings.Add(prop.Name, prop.Name);
                }
            }

            //Compile query
            var query = new FeatureQueryOptions(className);

            var bcp = CreateBulkCopy(source, target, schemaName, query, fs.Name, clone.Name, mappings);

            //The target connection needs to be cleaned up when done
            bcp.Options.MarkOwnerOfConnection("TARGET");

            return bcp;
        }
        void RunExport(string fileName)
        {
            CadastralMapModel mapModel = CadastralMapModel.Current;

            using (ICreateDataStore cmd = m_Connection.CreateCommand(CommandType.CommandType_CreateDataStore) as ICreateDataStore)
            {
                try
                {
                    cmd.DataStoreProperties.SetProperty("File", fileName);
                    cmd.Execute();
                }
                catch (OSGeo.FDO.Common.Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }

            // The connection after the created is ConnectionState_Closed, so open it!
            m_Connection.ConnectionInfo.ConnectionProperties.SetProperty("File", fileName);
            m_Connection.Open();

            // Define coordinate system
            using (ICreateSpatialContext cmd = m_Connection.CreateCommand(CommandType.CommandType_CreateSpatialContext) as ICreateSpatialContext)
            {
                ISpatialSystem ss = mapModel.SpatialSystem;
                cmd.CoordinateSystem = ss.Name; // CSMap key name
                cmd.ExtentType = SpatialContextExtentType.SpatialContextExtentType_Static;
                IWindow mapExtent = mapModel.Extent;
                IDirectPosition minxy = m_Factory.CreatePositionXY(mapExtent.Min.X, mapExtent.Min.Y);
                IDirectPosition maxxy = m_Factory.CreatePositionXY(mapExtent.Max.X, mapExtent.Max.Y);
                IEnvelope extent = m_Factory.CreateEnvelope(minxy, maxxy);
                IGeometry gx = m_Factory.CreateGeometry(extent);
                cmd.Extent = m_Factory.GetFgf(gx);
                cmd.XYTolerance = 0.000001; // resolution?
                cmd.CoordinateSystemWkt = EditingController.Current.GetCoordinateSystemText();
                cmd.Execute();
            }

            // Define feature schema
            FeatureSchema fs = new FeatureSchema("Steve", "This is a test");

            FeatureClass fc = new FeatureClass("FC", "Test feature class");
            fs.Classes.Add(fc);
            GeometricPropertyDefinition gp = new GeometricPropertyDefinition("Geometry", "Polygon property");

            // When you stick more than one geometric type into the output, you can't
            // convert to SHP (not with FDO Toolbox anyway).
            //gp.GeometryTypes = (int)GeometricType.GeometricType_Surface;
            gp.GeometryTypes = (int)GeometricType.GeometricType_All;
            fc.Properties.Add(gp);
            fc.GeometryProperty = gp;

            // c.f. FdoToolbox ExpressUtility
            DataPropertyDefinition dp = new DataPropertyDefinition("ID", "Test ID");
            dp.DataType = DataType.DataType_Int32;
            dp.Nullable = false;
            dp.ReadOnly = true;
            dp.IsAutoGenerated = true;
            fc.Properties.Add(dp);

            // Feature class requires an identity column for the insert
            fc.IdentityProperties.Add(dp);

            using (IApplySchema cmd = m_Connection.CreateCommand(CommandType.CommandType_ApplySchema) as IApplySchema)
            {
                cmd.FeatureSchema = fs;
                cmd.Execute();
            }

            mapModel.Index.QueryWindow(null, SpatialType.Polygon | SpatialType.Point, ExportFeature);

            m_Connection.Flush();
            m_Connection.Close();
        }
Exemple #44
0
        /// <summary>
        /// Utility method to clone a feature schema
        /// </summary>
        /// <param name="fs"></param>
        /// <param name="ignoreDeleted"></param>
        /// <returns></returns>
        public static FeatureSchema CloneSchema(FeatureSchema fs, bool ignoreDeleted)
        {
            if (fs == null)
                throw new ArgumentNullException("fs");

            /*
             * This method is BIG. So it needs some explanation.
             * 
             * Because Association and Object Properties reference other classes, the classes
             * containing such properties are processed *last*. Everything else is assumed to
             * be cloned (without problems) and cached in a temp dictionary for processing these
             * classes w/ Association/Object properties.
             * 
             * When processing these remaining classes, we iteratively attempt to clone each class.
             * Each successfully cloned class will be added to the temp dictionary. Eventually all
             * references will be satisfied, that's when we can finally return the cloned schema.
             */

            Dictionary<string, ClassDefinition> cloned = new Dictionary<string,ClassDefinition>();
            List<ClassDefinition> classesWithReferences = new List<ClassDefinition>();
            
            FeatureSchema fsc = new FeatureSchema(fs.Name, fs.Description);
            CopyElementAttributes(fs.Attributes, fsc.Attributes);

            if (ignoreDeleted)
            {
                foreach (ClassDefinition cls in fs.Classes)
                {
                    if (cls.ElementState != SchemaElementState.SchemaElementState_Deleted)
                    {
                        ICollection<string> refs = GetReferencedClasses(cls);
                        if (refs.Count == 0)
                        {
                            var klass = CloneClass(cls, ignoreDeleted);
                            fsc.Classes.Add(klass);
                            cloned.Add(klass.QualifiedName, klass);
                        }
                        else
                        {
                            //Check for self-references
                            classesWithReferences.Add(cls);
                        }
                    }
                }
            }
            else
            {
                foreach (ClassDefinition cls in fs.Classes)
                {
                    ICollection<string> refs = GetReferencedClasses(cls);
                    if (refs.Count == 0)
                    {
                        var klass = CloneClass(cls, ignoreDeleted);
                        fsc.Classes.Add(klass);
                        cloned.Add(klass.QualifiedName, klass);
                    }
                    else
                    {
                        //Check for self-references
                        classesWithReferences.Add(cls);
                    }
                }
            }

            //TODO: Does the FDO spec allow self-referenced Association/Object
            //properties? If not, it would simplify this code greatly.

            //Repeat until all references satisfied
            while (classesWithReferences.Count > 0)
            {
                List<ClassDefinition> successfullyCloned = new List<ClassDefinition>();
                foreach (ClassDefinition cls in classesWithReferences)
                {
                    bool bSuccess = false;

                    ClassDefinition klass = null;
                    switch (cls.ClassType)
                    {
                        case ClassType.ClassType_Class:
                            klass = new Class(cls.Name, cls.Description);
                            break;
                        case ClassType.ClassType_FeatureClass:
                            klass = new FeatureClass(cls.Name, cls.Description);
                            break;
                    }

                    Dictionary<AssociationPropertyDefinition, AssociationPropertyDefinition> processAp = new Dictionary<AssociationPropertyDefinition, AssociationPropertyDefinition>();
                    Dictionary<ObjectPropertyDefinition, ObjectPropertyDefinition> processOp = new Dictionary<ObjectPropertyDefinition, ObjectPropertyDefinition>();
                    var props = cls.Properties;
                    for (int i = 0; i < props.Count; i++)
                    {
                        var prop = props[i];
                        if (prop.PropertyType == PropertyType.PropertyType_AssociationProperty)
                        {
                            var ap = (AssociationPropertyDefinition)prop;
                            var apClone = new AssociationPropertyDefinition(ap.Name, ap.Description);

                            ClassDefinition associatedClass = null;
                            associatedClass = cloned[ap.AssociatedClass.QualifiedName];
                            if (associatedClass == null)
                            { 
                                //could be a self-reference
                                if (klass.Name.Equals(ap.AssociatedClass.Name))
                                    associatedClass = klass;
                            }

                            if (associatedClass != null)
                            {
                                apClone.AssociatedClass = associatedClass;
                                apClone.DeleteRule = ap.DeleteRule;
                                //Process identity properties. Shelve for later processing if
                                //any property can't be found
                                var idProps = ap.IdentityProperties;
                                bool foundAll = true;
                                foreach (DataPropertyDefinition dp in idProps)
                                {
                                    if (!props.Contains(dp))
                                        foundAll = false;
                                }
                                if (foundAll)
                                {
                                    foreach (DataPropertyDefinition dp in idProps)
                                    {
                                        apClone.IdentityProperties.Add((DataPropertyDefinition)props[dp.Name]);
                                    }
                                }
                                else
                                {
                                    processAp.Add(apClone, ap);
                                }

                                apClone.LockCascade = ap.LockCascade;
                                apClone.Multiplicity = ap.Multiplicity;
                                //Process reverse identity properties. Shelve for later processing if
                                //any property can't be found
                                var ridProps = ap.ReverseIdentityProperties;
                                foundAll = true;
                                foreach (DataPropertyDefinition dp in ridProps)
                                {
                                    if (!props.Contains(dp))
                                        foundAll = false;
                                }
                                if (foundAll)
                                {
                                    foreach (DataPropertyDefinition dp in ridProps)
                                    {
                                        apClone.ReverseIdentityProperties.Add((DataPropertyDefinition)apClone.AssociatedClass.Properties[dp.Name]);
                                    }
                                }
                                else
                                {
                                    processAp.Add(apClone, ap);
                                }

                                apClone.ReverseMultiplicity = ap.ReverseMultiplicity;
                                apClone.ReverseName = ap.ReverseName;

                                klass.Properties.Add(apClone);
                            }
                            else 
                            {
                                break;
                            }
                        }
                        else if (prop.PropertyType == PropertyType.PropertyType_ObjectProperty)
                        {
                            var op = (ObjectPropertyDefinition)prop;
                            var opClone = new ObjectPropertyDefinition(op.Name, op.Description);

                            if (cloned.ContainsKey(op.Class.QualifiedName))
                            {
                                ClassDefinition associatedClass = cloned[op.Class.QualifiedName];
                                opClone.Class = associatedClass;
                                //Process identity property. Shelve for later processing if none found
                                if (props.Contains(op.IdentityProperty.Name))
                                {
                                    opClone.IdentityProperty = (DataPropertyDefinition)op.Class.Properties[op.IdentityProperty.Name];
                                }
                                else
                                {
                                    processOp.Add(opClone, op);
                                }
                                opClone.ObjectType = op.ObjectType;
                                opClone.OrderType = op.OrderType;
                                klass.Properties.Add(opClone);
                            }
                            else
                            {
                                break;
                            }
                        }
                        else
                        {
                            bool identity = false;
                            bool geometry = false;
                            var dp = prop as DataPropertyDefinition;
                            var gp = prop as GeometricPropertyDefinition;
                            identity = (dp != null && cls.IdentityProperties.Contains(dp));
                            geometry = (gp != null && cls.ClassType == ClassType.ClassType_FeatureClass && ((FeatureClass)cls).GeometryProperty == gp);

                            //Clone property and add to cloned class
                            var cp = CloneProperty(prop);
                            klass.Properties.Add(cp);
                            if (identity)
                            {
                                Debug.Assert(cp.PropertyType == PropertyType.PropertyType_DataProperty);
                                klass.IdentityProperties.Add((DataPropertyDefinition)cp);
                            }
                            if (geometry)
                            {
                                Debug.Assert(cp.PropertyType == PropertyType.PropertyType_GeometricProperty);
                                Debug.Assert(klass.ClassType == ClassType.ClassType_FeatureClass);
                                ((FeatureClass)klass).GeometryProperty = (GeometricPropertyDefinition)cp;
                            }
                        }
                    }

                    if (processAp.Count > 0)
                    {
                        foreach (AssociationPropertyDefinition apClone in processAp.Keys)
                        {
                            var ap = processAp[apClone];
                            //Retry identity properties
                            apClone.IdentityProperties.Clear();
                            var idProps = ap.IdentityProperties;
                            foreach (DataPropertyDefinition dp in idProps)
                            {
                                apClone.IdentityProperties.Add((DataPropertyDefinition)props[dp.Name]);
                            }
                            //Retry reverse identity properties
                            apClone.ReverseIdentityProperties.Clear();
                            var ridProps = ap.ReverseIdentityProperties;
                            foreach (DataPropertyDefinition dp in ridProps)
                            {
                                apClone.ReverseIdentityProperties.Add((DataPropertyDefinition)apClone.AssociatedClass.Properties[dp.Name]);
                            }
                        }
                    }

                    if (processOp.Count > 0)
                    {
                        foreach (ObjectPropertyDefinition opClone in processOp.Keys)
                        {
                            var op = processOp[opClone];
                            //Retry identity property
                            opClone.IdentityProperty = (DataPropertyDefinition)op.Class.Properties[op.IdentityProperty.Name];
                        }
                    }

                    //All properties accounted for
                    if (klass.Properties.Count == cls.Properties.Count &&
                        klass.IdentityProperties.Count == cls.IdentityProperties.Count)
                    {
                        bSuccess = true;
                    }

                    if (bSuccess)
                    {
                        fsc.Classes.Add(klass);
                        successfullyCloned.Add(cls);
                    }
                }

                //Purge successfully cloned entries
                foreach (ClassDefinition cls in successfullyCloned)
                {
                    int ridx = classesWithReferences.IndexOf(cls);
                    if (ridx >= 0)
                        classesWithReferences.RemoveAt(ridx);
                }
            }

            return fsc;
        }
Exemple #45
0
            void OnSchemaAdded(FeatureSchema item)
            {
                var node = CreateSchemaNode(item);
                _view.schemaTree.Nodes.Add(node);

                foreach (ClassDefinition cd in item.Classes)
                {
                    OnClassAdded(cd);
                }

                _view.EvaluateStates();
                _view.FlagUpdateState();
            }
        void GetClassNodesFull(FeatureSchema schema, TreeNode schemaNode)
        {
            //Pre-sort
            SortedList<string, ClassDefinition> sorted = new SortedList<string, ClassDefinition>();
            foreach (ClassDefinition classDef in schema.Classes)
                sorted.Add(classDef.Name, classDef);

            foreach (ClassDefinition classDef in sorted.Values)
            {
                TreeNode classNode = CreateClassNode(classDef);
                schemaNode.Nodes.Add(classNode);
            }
        }
        public void TestAlterSchemaPassValueConstraints()
        {
            MockRepository mocks = new MockRepository();
            IConnection conn = mocks.DynamicMock<IConnection>();
            ISchemaCapabilities caps = mocks.DynamicMock<ISchemaCapabilities>();

            using (mocks.Record())
            {
                SetupResult.For(conn.ConnectionState).Return(ConnectionState.ConnectionState_Open);
                SetupResult.For(conn.SchemaCapabilities).Return(caps);
                SetupResult.For(caps.ClassTypes).Return((ClassType[])Enum.GetValues(typeof(ClassType)));
                SetupResult.For(caps.DataTypes).Return((DataType[])Enum.GetValues(typeof(DataType)));
                SetupResult.For(caps.MaximumDecimalPrecision).Return(20);
                SetupResult.For(caps.MaximumDecimalScale).Return(20);
                SetupResult.For(caps.ReservedCharactersForName).Return(string.Empty);
                SetupResult.For(caps.SupportedAutoGeneratedTypes).Return(new DataType[] { DataType.DataType_Int64 });
                SetupResult.For(caps.SupportedIdentityPropertyTypes).Return(new DataType[] { DataType.DataType_Int32, DataType.DataType_Int64 });
                SetupResult.For(caps.SupportsAssociationProperties).Return(false);
                SetupResult.For(caps.SupportsAutoIdGeneration).Return(true);
                SetupResult.For(caps.SupportsCompositeId).Return(false);
                SetupResult.For(caps.SupportsCompositeUniqueValueConstraints).Return(false);
                SetupResult.For(caps.SupportsDataStoreScopeUniqueIdGeneration).Return(false);
                SetupResult.For(caps.SupportsDefaultValue).Return(true);
                //--
                SetupResult.For(caps.SupportsExclusiveValueRangeConstraints).Return(false);
                SetupResult.For(caps.SupportsInclusiveValueRangeConstraints).Return(false);
                //--
                SetupResult.For(caps.SupportsMultipleSchemas).Return(false);
                SetupResult.For(caps.SupportsNetworkModel).Return(false);
                SetupResult.For(caps.SupportsNullValueConstraints).Return(true);
                SetupResult.For(caps.SupportsObjectProperties).Return(false);
                SetupResult.For(caps.SupportsSchemaModification).Return(true);
                SetupResult.For(caps.SupportsSchemaOverrides).Return(false);
                SetupResult.For(caps.SupportsUniqueValueConstraints).Return(false);
                //--
                SetupResult.For(caps.SupportsValueConstraintsList).Return(false);
                //--
                SetupResult.For(caps.SupportsInheritance).Return(false);
            }
            FdoFeatureService service = mocks.StrictMock<FdoFeatureService>(conn);
            mocks.ReplayAll();

            FeatureSchema schema = new FeatureSchema("Default", "");

            ClassDefinition cls = new Class("Test", "");

            //ID
            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");
            id.DataType = DataType.DataType_Int64;
            id.IsAutoGenerated = true; //Should be converted to int64
            id.ReadOnly = true;
            id.Nullable = false;

            cls.Properties.Add(id);
            cls.IdentityProperties.Add(id);

            //Age
            DataPropertyDefinition age = new DataPropertyDefinition("Age", "");
            PropertyValueConstraintRange range = new PropertyValueConstraintRange();
            range.MinValue = new Int32Value(0);
            range.MinInclusive = true;
            range.MaxValue = new Int32Value(100);
            range.MaxInclusive = true;
            age.ValueConstraint = range;
            age.DataType = DataType.DataType_Int32;
            age.Nullable = true;

            cls.Properties.Add(age);

            //Gender
            DataPropertyDefinition gender = new DataPropertyDefinition("Gender", "");
            PropertyValueConstraintList list = new PropertyValueConstraintList();
            list.ConstraintList.Add(new StringValue("M"));
            list.ConstraintList.Add(new StringValue("F"));
            gender.ValueConstraint = list;
            age.DataType = DataType.DataType_String;
            age.Nullable = false;
            age.Length = 1;

            cls.Properties.Add(gender);

            schema.Classes.Add(cls);

            IncompatibleSchema incSchema = null;
            bool canApply = service.CanApplySchema(schema, out incSchema);
            Assert.IsFalse(canApply);
            Assert.IsNotNull(incSchema);

            FeatureSchema newSchema = service.AlterSchema(schema, incSchema);

            ClassDefinition newClass = newSchema.Classes[0];

            DataPropertyDefinition age2 = newClass.Properties[newClass.Properties.IndexOf("Age")] as DataPropertyDefinition;

            //Should have constraint removed
            Assert.IsNull(age2.ValueConstraint);

            DataPropertyDefinition gender2 = newClass.Properties[newClass.Properties.IndexOf("Gender")] as DataPropertyDefinition;
            //Should have constraint removed
            Assert.IsNull(gender2.ValueConstraint);
        }
        public void TestSchemaCannotBeApplied()
        {
            FeatureSchema schema = new FeatureSchema("Default", "");
            FeatureClass fc = new FeatureClass("Class1", "");

            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");
            id.DataType = DataType.DataType_Int32;
            id.IsAutoGenerated = true;

            fc.Properties.Add(id);
            fc.IdentityProperties.Add(id);

            //Unsupported property in SHP
            DataPropertyDefinition d1 = new DataPropertyDefinition("Unsupported", "");
            d1.DataType = DataType.DataType_Int64;
            d1.Nullable = true;

            fc.Properties.Add(d1);

            GeometricPropertyDefinition geom = new GeometricPropertyDefinition("Geometry", "");
            geom.GeometryTypes = (int)GeometryType.GeometryType_Point;

            fc.Properties.Add(geom);
            schema.Classes.Add(fc);

            /*
            IConnection conn = FeatureAccessManager.GetConnectionManager().CreateConnection("OSGeo.SHP");
            conn.ConnectionString = "DefaultFileLocation=" + AppGateway.RunningApplication.AppPath;
            using (conn)
            {
                conn.Open();
                using (FeatureService service = new FeatureService(conn))
                {
                    IncompatibleSchema incSchema = null;
                    bool result = service.CanApplySchema(schema, out incSchema);
                    Assert.IsNotNull(incSchema);
                    Assert.IsFalse(result);

                    foreach (IncompatibleClass incClass in incSchema.Classes)
                    {
                        foreach (IncompatibleProperty incProp in incClass.Properties)
                        {
                            Assert.AreEqual(incProp.Reasons.Count, incProp.ReasonCodes.Count);
                        }
                    }
                }
                conn.Close();
            }*/
        }
        public void TestAlterSchemaPassIdentityType()
        {
            MockRepository mocks = new MockRepository();
            IConnection conn = mocks.DynamicMock<IConnection>();
            ISchemaCapabilities caps = mocks.DynamicMock<ISchemaCapabilities>();

            using (mocks.Record())
            {
                SetupResult.For(conn.ConnectionState).Return(ConnectionState.ConnectionState_Open);
                SetupResult.For(conn.SchemaCapabilities).Return(caps);
                SetupResult.For(caps.ClassTypes).Return((ClassType[])Enum.GetValues(typeof(ClassType)));
                SetupResult.For(caps.DataTypes).Return((DataType[])Enum.GetValues(typeof(DataType)));
                SetupResult.For(caps.MaximumDecimalPrecision).Return(20);
                SetupResult.For(caps.MaximumDecimalScale).Return(20);
                SetupResult.For(caps.ReservedCharactersForName).Return(string.Empty);
                SetupResult.For(caps.SupportedAutoGeneratedTypes).Return(new DataType[] { DataType.DataType_Int64 });
                //--
                SetupResult.For(caps.SupportedIdentityPropertyTypes).Return(new DataType[] { DataType.DataType_Int32, DataType.DataType_Int64, DataType.DataType_String });
                //--
                SetupResult.For(caps.SupportsAssociationProperties).Return(false);
                SetupResult.For(caps.SupportsAutoIdGeneration).Return(true);
                SetupResult.For(caps.SupportsCompositeId).Return(false);
                SetupResult.For(caps.SupportsCompositeUniqueValueConstraints).Return(false);
                SetupResult.For(caps.SupportsDataStoreScopeUniqueIdGeneration).Return(false);
                SetupResult.For(caps.SupportsDefaultValue).Return(true);
                SetupResult.For(caps.SupportsExclusiveValueRangeConstraints).Return(false);
                SetupResult.For(caps.SupportsInclusiveValueRangeConstraints).Return(false);
                SetupResult.For(caps.SupportsMultipleSchemas).Return(false);
                SetupResult.For(caps.SupportsNetworkModel).Return(false);
                SetupResult.For(caps.SupportsNullValueConstraints).Return(true);
                SetupResult.For(caps.SupportsObjectProperties).Return(false);
                SetupResult.For(caps.SupportsSchemaModification).Return(true);
                SetupResult.For(caps.SupportsSchemaOverrides).Return(false);
                SetupResult.For(caps.SupportsUniqueValueConstraints).Return(false);
                SetupResult.For(caps.SupportsValueConstraintsList).Return(false);

                SetupResult.For(caps.SupportsInheritance).Return(false);
            }
            FdoFeatureService service = mocks.StrictMock<FdoFeatureService>(conn);
            mocks.ReplayAll();

            FeatureSchema schema = new FeatureSchema("Default", "");

            ClassDefinition cls = new Class("Test", "");

            //ID - float
            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");
            id.DataType = DataType.DataType_Single;
            id.Nullable = false;

            cls.Properties.Add(id);
            cls.IdentityProperties.Add(id);

            //Name
            DataPropertyDefinition name = new DataPropertyDefinition("Name", "");
            name.DataType = DataType.DataType_String;
            name.Nullable = true;
            name.Length = 100;

            cls.Properties.Add(name);

            schema.Classes.Add(cls);

            IncompatibleSchema incSchema = null;
            bool canApply = service.CanApplySchema(schema, out incSchema);
            Assert.IsFalse(canApply);
            Assert.IsNotNull(incSchema);

            FeatureSchema newSchema = service.AlterSchema(schema, incSchema);

            ClassDefinition newClass = newSchema.Classes[0];

            //Should have been "promoted" to string
            Assert.AreEqual(DataType.DataType_String, newClass.IdentityProperties[0].DataType);
        }
        public void TestSchemaCanBeApplied()
        {
            FeatureSchema schema = new FeatureSchema("Default", "");
            FeatureClass fc = new FeatureClass("Class1", "");

            DataPropertyDefinition id = new DataPropertyDefinition("ID", "");
            id.DataType = DataType.DataType_Int32;
            id.IsAutoGenerated = true;

            fc.Properties.Add(id);
            fc.IdentityProperties.Add(id);

            GeometricPropertyDefinition geom = new GeometricPropertyDefinition("Geometry", "");
            geom.GeometryTypes = (int)GeometryType.GeometryType_Point;

            fc.Properties.Add(geom);
            schema.Classes.Add(fc);

            /*
            IConnection conn = FeatureAccessManager.GetConnectionManager().CreateConnection("OSGeo.SHP");
            conn.ConnectionString = "DefaultFileLocation=" + AppGateway.RunningApplication.AppPath;
            using (conn)
            {
                conn.Open();
                using (FeatureService service = new FeatureService(conn))
                {
                    IncompatibleSchema incSchema = null;
                    bool result = service.CanApplySchema(schema, out incSchema);
                    Assert.IsNull(incSchema);
                    Assert.IsTrue(result);
                }
                conn.Close();
            }*/
        }
 public FdoApplySchemaOperation(FdoConnection conn, FeatureSchema schema)
 {
     _conn = conn;
     _schema = schema;
 }
        /// <summary>
        /// Initializes this instance.
        /// </summary>
        protected override void Initialize()
        {
            SendMessage("Creating target data source");
            if (!ExpressUtility.CreateFlatFileDataSource(_outputFile))
                throw new FdoETLException(ResourceUtil.GetStringFormatted("ERR_CANNOT_CREATE_DATA_FILE", _outputFile));

            _outConn = ExpressUtility.CreateFlatFileConnection(_outputFile);
            _outConn.Open();

            ClassDefinition cd = _table.CreateClassDefinition(true);

            using (FdoFeatureService service = _outConn.CreateFeatureService())
            {
                SendMessage("Applying schema to target");
                FeatureSchema schema = new FeatureSchema("Schema1", "Default schema");
                schema.Classes.Add(cd);
                service.ApplySchema(schema);
            }

            SendMessage("Copying any attached spatial contexts");
            ExpressUtility.CopyAllSpatialContexts(_table.SpatialContexts, _outConn, true);

            Register(new FdoFeatureTableInputOperation(_table));
            Register(new FdoOutputOperation(_outConn, cd.Name));
        }