Convert dbf file to xml. Opening and Converting a DBF File to EXCEL

Probably you often need to convert an XML file or a folder with XML files into one or several DBF files. The problem is that the XML structure, its hierarchy and nesting levels differ from file to file. In this article, we"ll take a detailed look on how to import an XML file of ANY structure to a flat DBF table.

A new feature called Import Custom XML was implemented in DBF Commander Professional version 2.7 (build 40). This command is available via the command line interface. The syntax is as follows:

dbfcommander.exe -icx [<-attr>]

As you can see, there are four parameters:

-icx– means Import Custom XML.
– the full name of the file (including path), or the name of the folder containing the XML files to be imported. You can also load certain only files by using a mask, e.g. " D:\xml\some_prefix_*.xml". In this case, only the files whose extension is XML and whose name starts with " some_prefix"will be converted to DBF. If you want to convert all files in the folder, use the following mask: " D:\xml\*.xml".
– the destination folder, e.g. " D:\dbf\". In this case, all existing DBF files will be rewritten. If you want to import the source XML files into one DBF file, use the exact file name, e.g. " D:\dbf\result.dbf". But in this case, the resulting file should be created before the conversion process starts, otherwise an error will occur. If a single DBF file is used for the resulting data, it will not be rewritten, and each new record will be inserted into the same file.
– the full name of the so-called " map-file", which is a simple DBF file containing the definition of the source and resulting file fields. Below we"ll consider the process of creating a map-file.
<-attr> - use this parameter if you"d like to import tags with certain attributes.

DBF fields definition, or How to create a map-file

It is always better to learn something by using an example. In our situation, we need some well-known XML. Let's take an RSS news feed XML file (available):

As you can see, there are four<item> elements nested in the<channel> element, which is itself nested in the top-level<rss> element. There are also elements of the same nesting level as the<item>elements:<generator>, <title>, <description>, etc.

Suppose that each<item> element should be represented as one row in the resulting DBF file. So our file will contain four records.

To create a map-file, first let"s create the resulting DBF file. We need it because then we"ll be able to create a map-file in a few clicks. Launch DBF Commander Professional, click File -> New, and create a DBF file. In the case of the RSS XML file, the structure is as follows:

Click OK. The DBF file will be created, and now it can be used as a resulting file for our import from the XML process. You can use any available field types: Character, Integer, Numeric, Date, etc.

To create a map-file based on the resulting file, click the Export Structure tool button (see the picture above). When the Save dialog opens, choose the path and filename, and then save the structure as a DBF file.

Matching XML tags to DBF fields

We have to do one more thing yet: define the XML tags that should be inserted in the fields of the resulting DBF file.

Open the DBF file you"ve just saved. Click File -> Structure and add a new field named " xmltagname"of the Character type. You can add more fields in the map-file if you want to. For example, let"s add a field named " comment". Click OK to save the changes.

Now fill every row of the new "xmltagname"field with the XML nodes path (separated by " -> ") that should be inserted into the corresponding field in the DBF file:

It means that the value of the XML node<title> nested in the<channel> node, which is nested in the top-level<rss>, will be inserted into the " title" field; the XML tag " rss -> channel -> description"will be inserted into the" desc" field, and so on.

In case of using " -attr" parameter, paths of the map-file must contain corresponding attributes as well, e.g.: " rss version="2.0" -> channel -> title".

Pay attention to the " item_desc" field. The XML tag " rss -> channel -> item -> description" contains the CDATA section with HTML markup. So its tag path should be finished with the " #cdata-section" string.

The last row that you can see in the picture above is the so-called " row-tag". This tag path allows DBF Commander to know which XML tag should be used as a new row in the resulting DBF file. In our case, it is " rss -> channel -> item".

Note that the value of the " name" field should be empty for the record containing the row-tag, so that the program can recognize the row-tag.

Well, that's all. Now we can run the import from XML to DBF itself. Execute the following command from the command line, or from a BAT file:

dbfcommander.exe -icx "D:\xml\rss.xml" "D:\dbf\" "D:\map-file.dbf"

As a result, we"ll get the new file" D:\dbf\rss.dbf" that contains the imported XML data:

You can download all the files used in this conversion from .

DBF is a database file, the ability to work with which was previously integrated into the Microsoft Office environment. Access and Excel applications worked with the format, later Access was removed from the package and became a separate program, and in Excel, since 2007, DataBaseFile support has been significantly limited.

If it is not possible to open a DBF file directly in Excel, you must first convert it.

However, DBF, although considered by many to be an outdated format, is still widely used in specialized programs in business, design, and engineering. Wherever it is necessary to work with large amounts of information, their structuring and processing, and executing queries. For example, the 1C Enterprise software package is entirely based on database management. And given that a lot of office documentation and data is processed in Excel, the issue of integrated work with these formats is relevant and in demand.

Excel problems when working with DBF

Excel 2003 had the ability to open and edit DBF, as well as save XLS documents in this format:

Select "File" from the menu bar.
Next, click “Save As”.
Select “*.dbf” from the drop-down list.

IMPORTANT. Since 2007, you can open and view the database format in Excel, but you cannot make changes or save .xls documents in it. Standard program tools no longer provide this option.

However, there are special add-ons for the application that add such a function to it. Programmers post their developments online on various forums, and you can find different options. The most popular add-on, called XslToDBF, can be downloaded from the developer’s website http://basile-m.narod.ru/xlstodbf/download.html. The download is free, but if you wish, you can support the project by transferring any amount to your wallet or card.

Installation and use:

Download the archive from the above site.
Extract XlsToDBF.xla from it and save it on your computer.
In Excel, go to the menu with the Microsoft icon on the left, “Options”.
Under Excel Options, select Add-Ins.
In the Manage/Excel Add-ins row, click Go.
Click Browse and locate the saved XlsToDBF.xla.
The entry “XLS -> DBF” should appear in the list of add-ons with the check box checked. Check if it is not there.
Now you can save .xls to .dbf format. You can download from the same site detailed instructions by use. The main thing is to prepare tabular data correctly.
Once the table is ready, select any filled cell and press Alt and F
In the macro window that opens, type XlsToDBF in the field, case is not important.
Click Run.
If you have prepared and formatted the data correctly, the database file will also be saved in the folder where the source XLS is located.

If you don't want to change anything in Office, don't trust add-ins, and third party applications, then we can suggest a more time-consuming way to convert the XLS file to DBF:

Purchase and install Microsoft Access.
In Excel, prepare and save the document.
Click the "Open" button in MS Access and select the file.
Now you need to configure the import correctly.
Select the sheet to start with. If there are several of them, you still have to do one at a time.
If the table has a header row, check the appropriate box.
Next, you can change the table name.
Now click on "External Data".
Click the “Export”, “Advanced” button.
Select dBase File.
Specify a name and save location.

This method does not always work successfully; errors often occur in data processing and subsequent saving. And it is very long and inconvenient.

Conversion

In order not to suffer with office programs yourself, many applications have been created that allow you to convert data from one format to another. Firstly, almost all powerful DBMS programs offer the ability to export to XLS and load from it. Secondly, there are small utilities that specialize in conversion. Here are some of them:

In all of these programs, conversion boils down to opening the source file and then running the "Convert" or "Export" command.

There are also free online conversion services. On such sites you are asked to send (download) the source file, click “Convert”, after which a link to the converted document will appear. To what extent you can trust such services, the decision is individual, at your own peril and risk.

Thus, you can open the DBF in Excel, but if its version is 2007 or newer, then you won’t be able to do anything more with it, just look. There are special add-ons or programs for editing and saving in XLS, as well as for converting in the opposite direction. If you have experience converting and working with DBF to different applications, share your tips in the comments.

Submitting your good work to the knowledge base is easy. Use the form below

Students, graduate students, young scientists who use the knowledge base in their studies and work will be very grateful to you.

Posted on http://www.allbest.ru/

Transnistrian state university them. T.G. Shevchenko

Engineering and Technical Institute

Department of Information Technologies and Automated Control of Production Processes

GRADUATE QUALIFICATION WORK

in the direction 230100 “Informatics and Computer Science”

topic: “DATABASE CONVERTER PROGRAM FROM DBF FILES TO XML FORMAT FILE”

Student Maksimov Dmitry Olegovich

Tiraspol, 2013

INTRODUCTION

1. RESEARCH AND ANALYSIS OF THE SUBJECT DOMAIN

1.1 Description of the task

1.2 Justification of the relevance of the problem under study

1.3 Review of methods for solving similar problems

1.4 Statement of the problem, system requirements, requirements for input data and output forms

2. DESIGNING THE STRUCTURE AND ARCHETECTURE OF A SOFTWARE PRODUCT

2.1 Selection of methods and means for implementation, its justification

2.2 Description of the algorithms used

2.3 Structure, architecture software product

2.4 Functional diagram, functional structure of the software product

3. IMPLEMENTATION AND TESTING OF THE SOFTWARE PRODUCT

3.1 Implementation description

3.2 Description of the user interface

3.3 Testing and assessing the reliability of a software product

3.4 Cost calculation

3.5 Occupational safety

CONCLUSION

LIST OF CONVENTIONS, SYMBOLS, UNITS AND TERMS

LIST OF REFERENCES USED

APPLICATION

INTRODUCTION

Throughout the existence of computers, many operating systems have been developed. Now their number is measured in dozens and in various families there are file formats used only in a certain line of operating systems. If, for example, for images there are universal editor programs that open any file format containing images supported by operating systems, then, for example, there are no such editors for databases.

To work with each database format, there is an individual database management system. There are a huge number of types of databases, differing according to various criteria:

1) Classification by data model:

a) hierarchical;

b) network;

c) relational;

d) object and object-oriented;

e) object-relational, functional.

2) Classification by permanent storage environment:

a) in secondary memory, or traditional;

b) in RAM;

c) in tertiary memory.

3) Classification according to the degree of distribution:

a) centralized or concentrated;

b) distributed.

4) Other types of databases

a) spatial;

b) temporary;

c) spatiotemporal;

d) cyclical.

The large number of different databases does not allow directly transferring the contents of the database from one type to another. To solve this problem, there are converter programs that convert one database format to another. As a rule, converters exist only for the most common database formats, which does not allow you to directly convert some outdated format to a modern one. It is not rational to use two converters, so the optimal solution is to store databases in XML files as an intermediate step.

XML files and files of other extensions based on the XML language have become very widespread; almost every modern operating system supports this file format. XML files store a variety of data - from application settings to databases. XML-based files are used to exchange information on the Internet and between programs (which is what the markup language was originally designed for). Since XML format files contain text data, they can be easily edited in any text editor, as well as set any user-friendly data encoding. In addition, there are a large number of XML document generators.

1 . RESEARCH AND ANALYSIS OF THE SUBJECT DOMAIN

1.1 Description of the task

In the final qualifying work, it is required to implement a converter program that creates, based on the contents of the transferred dbf files, an XML file according to a user-specified template. The number and structure of dbf files can be any; the output XML file must always be the same. Each dbf file has its own template, based on which the program writes information into an XML file. It is necessary to implement the ability to create templates in two ways: using code and using a constructor. In templates created using code, you must select exactly what data needs to be written to the output file. This feature is achieved using special code commands developed specifically for this program. In templates created using the designer, you need to implement a simple and convenient interface that will allow you to create custom templates, based on which the program writes information to an XML file.

1.2 Justification of relevance problem under study

XML - recommended by the Consortium World Wide Web A markup language that is actually a set of general syntactic rules. XML is a text format designed for storing structured data (instead of existing database files), for exchanging information between programs, and also for creating more specialized markup languages based on it (for example, XHTML).

An XML document is a database only in the most general sense of the word, that is, it is a collection of data. This is no different from many other files - ultimately, all files consist of data of a certain type. As a "database" format, XML has some advantages, such as being self-describing (the markup describes the data). It is easy to ensure that it can be processed by various software because the data is stored in Unicode, it stores the data in a tree or graph-like structure. But it also has some disadvantages, for example, it is too verbose and relatively slow to access data due to the need to parse and convert text.

TO positive aspects It can be attributed to the fact that XML allows you to implement much of what can be found in conventional databases: storage (XML documents), schemas (DTD, XML Schema language), query languages (XQuery, XPath, XQL, XML-QL, QUILT, etc.), programming interfaces (SAX, DOM, JDOM), etc. The disadvantages include the lack of many opportunities available in modern bases data: storage efficiency, indexes, security, transactions and data integration, multi-user access, triggers, queries on multiple documents, etc.

So, although it is possible to use XML documents as a database in environments with a small amount data, a small number of users and low performance requirements, this cannot be done in most business environments where there are many users, strict data integration requirements and high performance requirements.

An example of a "database" for which an XML document is suitable is an .ini file - that is, a file that contains application configuration information. It is much easier to come up with a programming language with a small set of XML-based features and write a SAX application to interpret it than to create a parser for comma-separated files. XML also allows data elements to be nested within each other, something that is quite difficult to do when separating data with commas. However, such files can hardly be called databases in the full sense of the word, since they are read and written linearly and only when the application is opened or closed.

The most interesting example of data sets where it is convenient to use an XML document as a database is a personal list of contacts (names, phone numbers, addresses, etc.). However, due to the low cost and ease of use of databases such as dBASE and Access, even in these cases there is little reason to use an XML document as the database. The only real advantage of XML is that data is easily portable from one application to another, but this advantage is not so important since tools for serializing databases into XML format are already widespread.

Software development is relevant for the following reasons:

The dbf database format is outdated and does not meet modern requirements;

The XML format does not have strict requirements for content; the user can store data in any order and create tags with any name;

No converter program allows you to create your own XML file structure and write data from several dbf format files.

1.3 Review of methods for solving similar problems

"White Town" makes it possible to convert dbf files to XML format. The program can convert dbf files of dBase III, dBase IV, FoxPro, VFP and dBase Level 7 formats. The program supports a command line interface. Thus, it can be launched from a .BAT or .LNK file by first specifying the necessary parameters or on a schedule from the Windows scheduler. The disadvantage of this software product is the inability to customize the output file format. The main application window is shown in Figure 1.1.

Figure 1.1 - Main window of the “White Town” program

DBF Converter is a versatile yet easy to use conversion program. This program has a Wizard-like interface, but can also be used as a command line utility to process a group of files. "DBF Converter" supports all modern data exchange formats, such as XML, CSV, TXT, HTML, RTF, PRG and others. Implemented the ability to convert DBF tables into SQL scripts that can be imported into any SQL database.

In addition to simple conversions, DBF Converter allows you to manipulate data by selecting only certain columns and applying filters. Unlike the simplified filter rules that are usually found in other DBF applications, DBF Converter dynamically composes simple shapes database records. The ability to set advanced mask and rules to any field of a simple record is one of the most valuable features available in DBF Converter. The main disadvantage of this software is its cost of 29.95 USD.

The main application window is shown in Figure 1.2.

Figure 1.2 - Main window of the “DBF Converter” program

"DBF View" is a free, compact and convenient program for working with DBF files. Does not require installation, works without additional drivers and libraries.

The main advantage is its versatility, fast and flexible linear search, which surpasses many SQL in speed.

Additional features:

Search by mask (pattern);

Editing, replacing, deleting, creating, adding data;

Sorting fields;

Multilingualism and creation of new dictionaries;

Import and export DBF, TXT, CSV, SQL, XML;

Conversion to DOS, Windows, transliteration and others;

Startup password;

Recording history.

The main disadvantage of this software is the inability to create templates during conversion. The main window of the program is shown in Figure 1.3.

Figure 1.3 - Main window of the “DBF View” program

1.4 Statement of the problem, system requirements, requirements for output data and output forms

Having studied the task, researched its relevance and analyzed existing converter programs, a list was compiled necessary requirements for the software being developed.

The following functions must be implemented in the software product:

Reading the contents of dbf files;

Creating templates in one of two editors;

Editing templates;

Selecting the order of converting dbf files;

Execution of templates;

Error logging;

Saving the results of the program to an XML file.

The software is written in Microsoft Visual Studio 2008 and requires:

Operating system of the Windows family of one of the versions: Windows Vista, Windows 7 or Windows 8;

Microsoft .NET Framework 4;

Visual FoxPro ODBC Drivers.

The minimum system requirements for the software product correspond to the minimum requirements for the operating system.

The input data can be dbf format files of dBase II, dBase III or dBase IV.

The output files must be an XML file with language version 1.x and support for any browser.

The path to the input and output files can be arbitrary.

2 . DESIGNING THE STRUCTURE AND ARCHITECTURE OF A SOFTWARE PRODUCT

2.1 Selection of methods and means for implementation, its rationale

To develop the software product, the integrated development environment Microsoft Visual Studio 2008 was chosen.

Visual Studio 2008 - released November 19, 2007, along with the .NET Framework 3.5. Aimed at creating applications for the Windows Vista operating system (but also supports XP), Office 2007 and web applications. Includes LINQ, new versions of C# and Visual Basic. Visual J# was not included in the studio. One of its advantages is the completely Russian interface.

Visual Studio includes a source code editor with support for IntelliSense technology and the ability to easily refactor code. The built-in debugger can work as a source-level debugger or as a machine-level debugger. Other built-in tools include a form editor to make it easy to create an application's GUI, a web editor, a class designer, and a database schema designer. Visual Studio allows you to create and connect third-party add-ons (plugins) to extend functionality at almost every level, including adding support for source code version control systems (such as Subversion and Visual SourceSafe), adding new toolkits (for example, for editing and visual design of code in domain-specific programming languages or tools for other aspects of the software development process (for example, the Team Explorer client for working with Team Foundation Server).

All C#-based Visual Studio 2008 workbench systems have the following features:

The ability to formulate tasks in the language of object interaction;

High modularity of the program code;

Adaptability to user desires;

High degree of program reuse;

A large number of plug-in libraries.

2. 2 Description of the algorithms used

In the development of this software, two main difficulties can be identified: building a recognizer for programmable templates and creating a software model that would be used in templates created using the constructor.

1. Programmable templates. Since the code used in templates is somewhat similar to the code used in programming languages, it is necessary for this resolver to adopt some functions of the code compiler, or rather its parsing functions. In the compiler structure, the analyzing part consists of lexical, syntactic and semantic analysis. A lexical analyzer reads program characters in the source language and constructs source language tokens from them. The result of its work is a table of identifiers. The parser performs the selection syntactic constructions in the text of the source program, processed by a lexical analyzer. Brings the syntactic rules of the program into conformity with the grammar of the language. The parser is a text recognizer input language. A semantic analyzer checks the correctness of the source program text in terms of the meaning of the input language.

The code should implement the following capabilities: creating a loop, obtaining and displaying data on the number of rows and columns, obtaining the data type and column names, as well as obtaining the contents of database cells. To do this, first of all, it is necessary to compile a list of all possible states of the machine. Possible states of the recognizer are presented in Table 2.1.

Table 2.1 - List of possible recognizer states

Condition index	State	Description
	Variable	Cycle counter
		A service word indicating the beginning of a cycle
		A service word denoting the loop exit condition
		An auxiliary word indicating that further reference will be made to the database columns
		An auxiliary word indicating that further reference will be made to the database rows
	Quantity	A service word denoting the number of rows or columns, depending on what the previous call was.
		A service word denoting the output of the data type of the column to be accessed
	Name	An auxiliary word indicating the output of the name of the column to be accessed
		Special character separating function words
	= (equal sign)	A special character indicating what value will be assigned to the variable when the loop starts
	[ (opening rectangular bracket)
	] (closing rectangular bracket)	A special character indicating that a specific column or row was accessed
		Any integer

Based on the compiled table, you can build a finite automaton of possible state transitions. Figure 2.1 shows a finite state machine.

Figure 2.1 - Finite machine of possible transitions

Based on the constructed automaton, you can build a top-down recognizer with return (with selection of alternatives). A top-down backtracking resolver is used to determine whether a string belongs to a grammar. He analyzes current state, searches for a rule for transition from the current state to the next one, if the next state matches, then the procedure is repeated for the next one. If the recognizer cannot find a rule for transition from the current state to the next, then this chain does not belong to this grammar, that is, the line of code is written with a logical error. If there are several transition options, then the recognizer remembers the state in which the alternative arose and returns to it if the chain does not belong to the grammar. Figure 2.2 shows a top-down resolver with backtracking.

Figure 2.2 - Top-down resolver with return

During template analysis, an error log is kept, containing information about which template contains the error, which specific line of code and the type of error. Errors can be of the following types: unrecognized identifier (an attempt to use function words or special characters not provided for by the given code), violation of logical meaning (the line of code did not pass the recognizer's check), an attempt to access a non-existent variable (referring a variable to an uncreated variable or accessing a variable outside the loop), the beginning of the loop is not specified (the beginning and end of the loop must be indicated in the form of opening and closing curly braces).

2. Templates created using the designer. One solution is a structure used in logic programming languages: apply condition filters to common input information, which in this case is the contents of the database table. Figure 2.3 shows the general structure of a database table.

Figure 2.3 - General structure of the database table

3. A solution using the “Truth Table” was chosen as an implementation. This table is a table with n+1 columns and m+1 rows, where n and m are the number of columns and rows in the input table. Each table cell stores the value true or false. Figure 2.4 shows the “Truth Table”.

Figure 2.4 - “Truth table”

When a filter is applied, true values are replaced with false depending on what the filter was applied to. If the filter was applied to the contents of cells, then the values will change for each cell specifically, and if to rows or columns, then only in additional rows or columns.

When working with a database, the following entities can be distinguished: row index, column index, number of rows, number of columns, column type, column name, cell contents.

The following conditions were also highlighted: “<», «>", "=", "contains", "matches".

4. The selected entities and conditions are sufficient to display all possible data or impose all possible conditions. Figure 2.5 shows a “Truth Table” using filters.

Figure 2.5 - “Truth table” using filters

When outputting information to an XML file, the program determines what needs to be output, and then, using the “Truth Table”, outputs only those values that correspond to the value true.

To create the template layout, we created following types tags: main, simple, global, block. The main one is a tag; there can be only one of this type in a document and it is required; it contains information about the XML document. Simple - Tags of this type are the only way to output data and impose conditions on the “Truth Table”. They consist of the following parts: title, source and condition. Previously selected entities are used as the source and condition. If the tag has empty name, its contents will not be displayed, but the condition to the “Truth Table” will be applied.

Global - tags of this type do not carry any logical load, they are simply needed for output.

Block - tags of this type are necessary to combine the logic of simple tags, and also everything that is written in a block tag will be output for each cell that satisfies the “Truth Table”. The block tag itself is not displayed in the XML document.

2.3 Structure, architecture of the software product

Central to object-oriented programming is the development of a logical model of the system in the form of a class diagram. A class diagram is used to represent the static structure of a system model in the terminology of object-oriented programming classes. A class diagram can reflect, in particular, various relationships between individual domain entities, such as objects and subsystems, as well as describe their internal structure and types of relationships.

A class in this diagram is used to denote a set of objects that share the same structure, behavior, and relationships with objects of other classes. Graphically, the class is depicted as a rectangle, which can additionally be divided horizontal lines into sections or sections. These sections can include the class name, attributes (variables), and operations (methods).

In addition to the internal structure or structure of classes, the corresponding diagram indicates the relationships between classes:

For this application, the classes described in Table 2.2 were identified.

Table 2.2 - Description of classes used in the software product

The class diagram of the converter application is shown in Figure 2.6. From the diagram you can see that the MyCode class is a variable of the Template class. The Template class contains the following fields: dt, lv, thisTemplate, mycode, fs, sr, sw, correct, masCode, masPerem, masPeremCount, masSost, masCodeLength. dt is a DataTable type variable containing information stored in the database; lv - a ListView type variable, an interface object into which error messages in templates are written; thisTemplate - variable type string, indicating the name of the template that is currently being processed; mycode - an array of the MyCode class that stores information about all code fragments found in this template; fs is a FileStream type variable that determines which file the program will work with; sr is a StreamReader type variable that determines which file the information will be read from; sw - a StreamWriter type variable that determines which file the information will be written to; correct - a bool variable indicating whether the current code fragment was processed correctly; masCode - an array of string type containing all found lines of code in the template; masCodeLength - an int variable indicating how many lines of code are found in the template; masPerem is a two-dimensional array of string type containing the name and value of the created variables; masPeremCount - an int variable indicating how many variables are currently created; masSost is an int array containing a list of machine states for the current line of code.

The class also contains following methods: Connect, Search, Analyze, Check, ExecuteCode. The Connect method connects to the template along the specified path. The Search method finds code snippets in the template. The Analyze method determines the states for a line of code. The Check method is recursive; it determines whether a string is logically correct. The ExecuteCode method executes the current template. You can create a class diagram for the classes described. Figure 2.6 shows a class diagram.

Figure 2.6 - Class diagram

2.4 Functional diagram, functional purpose of the software product

The software product has two possible options for processing information with unique algorithms.

If the user uses code templates, he first needs to specify the input files, then either create a new template or select an existing one. Next, the user specifies the directory and name of the output file and starts the conversion process. During this process, code sections in the template are initially selected, then tokens are allocated in each section, after which their logical meaning is determined and the template is executed. If errors occur at any of these stages, information about them is recorded in the error log. After all templates have been executed, the user can use the output file.

If you use templates created using the designer, the user must specify the database that needs to be converted, then specify the output file directory, create a template and start the conversion process. The conversion itself consists of two parts: creating a truth table based on the template and executing the conversion according to the truth table. The output file can then be used by the user for its intended purpose.

In the second chapter, graduation qualifying work development tools were selected, namely Microsoft Visual Studio 2008, the main methods for implementing the software product were described, and its structure was also described. It was also described functional diagram software product.

The main points of consideration in the second chapter were:

The choice of methods and means for implementation, its justification;

Description of the algorithms used;

Structure, architecture of the software product;

Functional diagram, functional purpose of the software product.

3 . IMPLEMENTATIONAND TESTINGSOFTWARE PRODUCT

3.1 Implementation Description

One of the difficulties in implementing this software product is writing a recognizer algorithm. The entire algorithm is described by the following methods: Search, Analyze, Check, ExecuteCode.

The Search method reads the pattern and finds the code fragments separated by "*" characters on both sides and writes them to the array.

public void Search()

bool sign = false;

while (!sr.EndOfStream)

if ((c != "*") && (sign == true))

( s += c.ToString(); )

if ((c == "*") && (sign == false))

if ((c == "*") && (sign == true))

masCode = s;

masCodeLength++; )

s += c.ToString(); ))

mycode = new MyCode;)

The Analyze method splits a line of code into individual tokens and determines the state for each of them; if symbols or words not provided by the language are used, or incorrect variable names are used, a corresponding error message is added to the error log. Full list The lexemes used are presented in Table 2.1.

public void Analyze()

( string masIdent = new string;

int masIdentLength = 0;

bool sign = true;

for (int a = 0; a< masCodeLength; a++)

( correct = false;

masIdentLength = 0;

masCode[a] = masCode[a].Trim();

masCode[a] = masCode[a].ToLower();

for (int b = 0; b< masCode[a].Length; b++)

( c = masCode[a][b];

masIdentLength++; )

masIdent = ".";

masIdentLength++;

if ((c == " ") && (s != ""))

( masIdent = s;

masIdentLength++;

( masIdent = s;

masIdentLength++; )

mycode[a] = new MyCode("", null);

for (int z = 0; z< masIdentLength; z++)

mycode[a].code += masIdent[z] + " ";

masSost = new int;

In the previous part of the method, all found lexemes were written to the masIdent array, then a cycle is initialized in which the state is determined for all found lexemes and written to the masSost array.

for (int b = 0; b< masIdentLength; b++)

if (masIdent[b] == "for")

else if (masIdent[b] == "before")

else if (masIdent[b] == "column")

else if (masIdent[b] == "string")

if (Char.IsLetter(masIdent[b]))

( bool f = true;

for (int d = 1; d< masIdent[b].Length; d++)

if (!Char.IsLetterOrDigit(masIdent[b][d]))

if (f == true) masSost[b] = 1; else

Adding an error entry to the error log if the found identifier does not exist.

lv.Items.SubItems.Add("Unidentified identifier " + masIdent[b]); )) else

lv.Items.SubItems.Add(mycode[a].code);

lv.Items.SubItems.Add("Unidentified identifier " + masIdent[b]);))

mycode[a] = new MyCode(mycode[a].code, masSost);

Check(0, masSost, a); )

The Check method is based on the work of a top-down recognizer with a return: the current state is determined, if it is possible, then a transition is made to the next one. If this is not possible, then the state switches to an alternative one; if this is not the case, then an error message is added to the error log.

public void Check(int a, int s, int indc)

( if (masSost[a] == s)

( if ((s == 1) && (a == 0))

correct = true; ) else

if ((s == 2) && (a == 0)) s = 1; else

if (((s == 4) || (s == 5)) && (a == 0)) s = 8; else

if ((s == 1) && (a == 1)) s = 9; else

if ((s == 8) && (a == 1)) s = 6; else

if ((s == 10) && (a == 1)) s = 1; else

if ((s == 9) && (a == 2)) s = 12; else

if ((s == 6) && (a == 2))

( if (a == masSost.Length - 1)

correct = true; ) else

if (((s == 1) || (s == 12)) && (a == 2)) s = 11; else

if ((s == 12) && (a == 3)) s = 3; else

if ((s == 11) && (a == 3)) s = 8; else

if ((s == 3) && (a == 4)) s = 12; else

if ((s == 8) && (a == 4))

( if (masSost == 4)

if ((s == 6) && (a == 7))

( if (a == masSost.Length - 1)

correct = true; )

if (((s == 12) || (s == 1)) && (a == 7))

if ((s == 11) && (a == 8))

( if (a == masSost.Length - 1)

correct = true; )

If the array of input states has been checked by the recognizer and all states match, the correct variable is assigned the value true, and if a mismatch is found somewhere, it is returned and checked for an alternative state.

if (correct == false)

Check(a, s, indc); ) )

if ((s == 8) && (a == 1))

Check(a, s, indc); )

if ((s == 1) && (a == 2))

Check(a, s, indc);)

if ((s == 1) && (a == 7))

Check(a, s, indc); )

If the transition being made was not recognized, then the line of code being processed is considered logically incorrect and a corresponding error entry is added to the error log.

if (correct == false)

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(masCode);

lv.Items.SubItems.Add("The logical meaning of the line is violated");

mycode.correct = false;

The ExecuteCode method writes the contents of the template to an output file by executing program lines. If a loop is encountered, a temporary file is created in which the contents of the loop are written, and until the loop ends, the contents of this file are executed. This is necessary to perform nested loops.

public void ExecuteCode(int NCode, bool cikcle, StreamReader sr, StreamWriter sw, int tempF)

while (!sr.EndOfStream)

c = Convert.ToChar(sr.Read());

The algorithm reads the input file character by character if it encounters a closing brace, meaning the end of the loop, and the cikcle variable is true, then this means that the method was nested and terminates it.

if ((c == ")") && (cikcle == true))

If the read character was not “*”, then this means that the character does not belong to code commands and must simply be output.

If the read character was “*”, the algorithm reads the next character, if it is also “*”, then this means that the user wanted to output this character to the output file.

( c = Convert.ToChar(sr.Read());

If the next character was not “*”, then this means that all subsequent characters before “*” refer to code commands.

if (mycode.correct == true)

if (mycode.masSost == 1)

( bool creat = false;

for (int a = 0; a< masPeremCount; a++)

( if (masPerem == mycode.code)

sw.Write(masPerem);

while (sr.Read() != "*")

If, in the code, the user tries to output a variable that has not been declared before, then an error is recorded in the error log and the distant code is no longer executed.

if (creat == false)

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add("Attempt to display a non-existent variable");

mycode.code = ""; )

while (sr.Read() != "*")

if (mycode.masSost == 4)

( if (mycode.masSost == 6)

sw.Write(dt.Columns.Count.ToString());

while (sr.Read() != "*")

if (Convert.ToInt32(mycode.masValue)< dt.Columns.Count)

( if (mycode.masSost == 7)

sw.Write(dt.Columns.masValue)].DataType.Name);

sw.Write(dt.Columns.masValue)].ColumnName);)

If the user attempts to access a column or row that does not exist, a corresponding error entry is added to the error log.

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

mycode.code = ""; )

while (sr.Read() != "*")

( bool creat = false;

for (int a = 0; a< masPeremCount; a++)

if (Convert.ToInt32(masPerem)< dt.Columns.Count)

( if (mycode.masSost == 13)

sw.Write(dt.Columns)].ColumnName);

sw.Write(dt.Columns)].DataType.Name);

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("Index is outside the scope of the array");

mycode.code = ""; )

while (sr.Read() != "*")

if (creat == false) (

If the user specifies a non-existent variable as a column or row index, a corresponding error entry is added to the error log.

lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("Attempt to access a non-existent variable");

while (sr.Read() != "*")

if (mycode.masSost == 5)

( int n1 = 0, n2 = 0, nn = 0;

if (mycode.masSost == 6)

( sw.Write(dt.Rows.Count.ToString());

while (sr.Read() != "*")

( if (mycode.masSost == 12)

( ( n1 = Convert.ToInt32(mycode.masValue);

if (mycode.masSost == 12)

( n2 = Convert.ToInt32(mycode.masValue);

( bool creat = false;

for (int a = 0; a< masPeremCount; a++)

if (masPerem == mycode.masValue)

n2 = Convert.ToInt32(masPerem);

If a variable was used as a column or row index and its value exceeds the number of columns or rows in the table, respectively, an entry about this error is added to the error log.

Else ( if (n1 >= dt.Rows.Count)

( if (mycode.code != "")

(lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("Index " + n1 + " is outside the scope of the array");))

if (n2 >= dt.Columns.Count)

( if (mycode.code != "")

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("Index " + n2 + " is outside the scope of the array"); ))

mycode.code = ""; )

while ((sr.Read() != "*") && (!sr.EndOfStream))

if (mycode.masSost == 2)

masPerem = mycode.masValue;

nk = masPeremCount;

masPeremCount++;

if (mycode.masSost == 12)

k = Convert.ToInt32(mycode.masValue); else

if (mycode.masSost == 4) k = dt.Columns.Count;

else k = dt.Rows.Count;

while (sr.Read() != "*") ( )

If the user declared a loop and then did not indicate its beginning by not putting “(”, this is regarded as an error and an entry about this is added to the error log.

c = Convert.ToChar(sr.Read());

( lv.Items.Add(thisTemplate, thisTemplate);

lv.Items.SubItems.Add(mycode.code);

lv.Items.SubItems.Add("Loop start not specified");

mycode.correct = false;

NCode++; ) else (

If the beginning of the loop is specified correctly, then the variable responsible for the nesting depth of the loops is increased by one, the contents of the loop, up to the “)” sign, are written to a temporary file, a duplicate array containing the values of the variables is created, and this recursive method is launched for this temporary file.

Directory.CreateDirectory("Temp");

StreamWriter sw1=new StreamWriter("Temp\\Temp"+tempF.ToString()+".txt", false, Encoding.UTF8);

c = Convert.ToChar(sr.Read());

c = Convert.ToChar(sr.Read()); )

int cickleCount = 0;

while (c != ")")

if (sr.EndOfStream)

c = Convert.ToChar(sr.Read());

if ((c == ")") && (cickleCount != 0))

(cickleCount--;

c = Convert.ToChar(sr.Read()); ) )

StreamReader sr1 = new StreamReader("Temp\\Temp" + tempF.ToString() + ".txt", Encoding.UTF8);

int CickleCode = 0;

bool sign2 = false;

while (!sr1.EndOfStream)

( c = Convert.ToChar(sr1.Read());

if ((c != "*") && (sign2 == true))

( s1 += c.ToString(); )

if ((c == "*") && (sign2 == false))

if ((c == "*") && (sign2 == true))

( sign2 = false;

else s1 += c.ToString(); ) )

for (int a = Convert.ToInt32(mycode.masValue); a< k; a++)

( masPerem = a.ToString();

ExecuteCode(NCode + 1, true, new StreamReader("Temp\\Temp" + tempF.ToString() + ".txt", Encoding.UTF8), sw, tempF);)

After the loop is completed, the temporary file is deleted, and the nesting depth of the loops is reduced by one.

masPerem = "";

NCode = CickleCode + 1;

File.Delete("Temp\\Temp" + tempF.ToString() + ".txt");

The algorithm for working with templates created using the constructor is described by the following methods: Execute, GetTruthTable, ExecuteTag.

The Execute method is called once when template processing starts. This method is external and other methods are called from it. Initially, the method produces an output file and a "Truth Table".

DataTable truthdt=new DataTable();

StreamWriter sw=new StreamWriter(textBox4.Text+"Output file.xml",false,Encoding.UTF8);

for (int a = 0; a<= dt.Columns.Count;a++)

truthdt.Columns.Add("",typeof(bool));

for (int a = 0; a<= dt.Rows.Count; a++)

( DataRow dr = truthdt.NewRow();

for (int b = 0; b< dr.ItemArray.Length; b++)

truthdt.Rows.Add(dr); )

After this, a loop begins to execute, selecting each tag that determines its type, and depending on this, execute it.

while (!complete)

( tagind = GetTagIndex(Iitems);

if (mastag.type == types.global || mastag.type == types.main)

if (mastag.type == types.block)

if (Items >= itemscount)

complete = true; )

If the tag type is global or primary, the contents of the tag are simply written to a file.

if (mastag.name != "")

sw.WriteLine(items);

If the tag type is block, then the list of all tags belonging to this fragment is written into a separate array, and it is also determined whether this list contains tags that require string indexing to display values.

bool haveRow = false;

tag blocktag = new tag.indF - mastag.indS - 1];

for (int a = matag.indS + 1, b = 0; a< mastag.indF; a++, b++)

( blocktag[b] = mastag;

if (blocktag[b].type == types.simple)

if (blocktag[b].source == "row index" || blocktag[b].source == "cell contents")

haveRow = true;)

After this, a “truth table” is created and all the conditions of the simple tags found in the list are applied to it.

truthdt=CreateTable(truthdt,dt);

for (int a = 0; a< blocktag.Length; a++)

if (blocktag[a].type == types.simple)

truthdt = GetTruthTable(dt, truthdt, blocktag[a]);

Further, depending on whether tags using string indexing were found, either only a cycle through columns, or cycles through columns and rows, in which all encountered tags are executed, with the exception of block ones, are created.

for (int a = 0; a< dt.Rows.Count; a++)

for (int b = 0; b< dt.Columns.Count; b++)

bool wasEx = false;

StreamWriter swt = new StreamWriter("temp.txt", false, Encoding.UTF8);

for (int c = 0; c< blocktag.Length; c++)

if (blocktag[c].type == types.global)

if (blocktag[c].name != "")

swt.WriteLine(items.indS + c + 1]);

if (blocktag[c].name != "")

wasEx=ExecuteTag(dt, truthdt, blocktag[c], a, b, swt); )

( StreamReader sr = new StreamReader("temp.txt", Encoding.UTF8);

sw.Write(sr.ReadToEnd());

File.Delete("temp.txt");

( for (int a=0;a

for (int c = 0; c< blocktag.Length; c++)

( if (blocktag[c].type == types.global)

if (blocktag[c].name != "")

sw.WriteLine(items.indS + c + 1]);

if (blocktag[c].type == types.simple)

if (blocktag[c].name != "")

ExecuteTag(dt, truthdt, blocktag[c], 0, a, sw);

If the tag type is simple, then a new “Truth Table” is created for it and the tag is executed.

if (mastag.type == types.simple)

( truthdt=CreateTable(truthdt,dt);

DataTable tempdt = GetTruthTable(dt, truthdt, mastag);

if(mastag.name!="")

ExecuteTag(dt, tempdt, matag, 0, 0, sw);

The GetTruthTable method applies conditions to the Truth Table. It takes as arguments a table with values from the database, an already created “Truth Table” and a tag whose condition needs to be processed.

The ExecutTag method executes a simple tag. It takes as arguments a data table, a Truth Table, a tag, a row index, a column index, and a file write stream.

3.2 User Interface Description

The main program window is divided into several parts: “.dbf”, “Templates”, “.xml” and error log. In all parts, except for the journal, there are elements responsible for selecting directories containing files or in which files should be saved. The error log is presented as a list of three columns: “pattern”, “line”, “error”. The first column contains the name of the template in which the error was found. In the second, the line where the error occurred. Third, the type of error.

The form also contains elements that do not belong to any of the groups. Some of them reflect the progress of work, while others start the process itself.

Figure 3.1 shows the main form - the main program window.

Figure 3.1 - Main window of the program

When working with templates, an additional program window opens, consisting of a field for the name of the template, an element containing the template code, and buttons for saving the template and closing the window.

Figure 3.2 shows the view of the additional program window (template editor).

Figure 3.2 - Template editor window

Also on the main form there is a control element that opens the form for creating templates using the designer.

The constructor form contains the following controls: a list of already created tags, a field for entering the name of a new tag, a drop-down list for selecting a tag type, a drop-down list for selecting a tag source, a panel with elements for creating a tag condition, a field for defining a database file, a field for defining location of the output file, buttons for adding and deleting a tag, a button for starting processing. Figure 3.3 shows the template designer window.

Figure 3.3 - Template designer window

As a result of the software, XML files of various versions of the XML language were obtained. The input data was dbf format databases of versions dBase II, dBase III and dBase IV. The converted files were opened correctly using the following browsers: Internet Explorer 10, Mozilla Firefox 19, Google Chrome version 27.0.1453.93, Opera 12.15. In addition to browsers, files could be viewed and edited with any text editor. Based on the results obtained, we can conclude that the XML files obtained during the program’s operation meet the customer’s requirements.

3. 3 Testing and assessing the reliability of a software product

When testing the software product, the following errors were identified:

Indexing error for database table cell;

Loop variable output error;

An error that occurs when the index of a row or column exceeds its number.

1. Indexing error for a database table cell. Occurs when you specify code of the form “*row[x].column[y]*” in the template, where x and y are numbers or variables. The problem was solved by adding an additional condition in the program code when processing similar strings in the template.

2. Loop variable output error. Occurs when a code of the form “*x*” is specified in the template, where x is a variable. The problem was resolved by changing the composition of the identifier table.

3. An error that occurs when the index of a row or column exceeds its number. Occurs when you specify code of the form “*column[x].name*” in the template, where x is a number or variable whose value exceeds the number of columns. The problem was solved by comparing the index value and the number of rows or columns; if the index exceeds, an entry about this is added to the error log and the program continues to execute.

3. 4 Cost calculation

Businesses that constantly work with different database formats need to automate the process of converting from one database format to another. This will increase the productivity of workers and also reduce the requirements for their education.

In addition to the software part, a software product also consists of accompanying documentation, which is the result of the intellectual activity of the developers.

The structure of capital investments related to control automation includes capital investments for the development of an automation project (pre-production costs) and capital investments for the implementation of the project (implementation costs):

where K p - capital investments for design; Kr - capital investments for the implementation of the project.

Calculation of capital investments for design. Capital investments for software design are determined by drawing up cost estimates and are determined by the formula:

where K m is the cost of materials; To pr - basic and additional wages with social security contributions for engineering and technical personnel directly involved in the development of the project; Kmash - costs associated with the use of computer time for debugging the program; K s - payment for services to third parties, if the design is carried out with the involvement of third parties; Kn - overhead costs of the design department. All calculations will be made in conventional units (cu), which corresponds to the cost of one US dollar in the Pridnestrovian Republican Bank at the time of software development.

Material costs. We will determine the cost estimate and calculate the cost of materials K m used for software development. The list of materials is determined by the topic of the thesis. They include the following: storage media (paper, magnetic disks) and wearable items (pen, pencil, eraser). The cost estimate for materials is presented in Table 3.1.

Table 3.1 - Cost estimate for materials

Convert dbf file to xml. Opening and Converting a DBF File to EXCEL

DBF fields definition, or How to create a map-file

Matching XML tags to DBF fields

Excel problems when working with DBF

Conversion

Submitting your good work to the knowledge base is easy. Use the form below

Similar documents

Converter starter (for single installation and start-up)

	The latest version of Advanced XML Converter provides a simple, fast and highly efficient way to extract data from XML files and save it in popular HTML, DBF, CSV, Excel and SQL formats.
	With Advanced XML Converter you can:
	extract all XML data or data only from specific tags, switch between different data presentation options (no need to re-parse data), configure custom converter parameters for each output format (for example, HTML style sheets or CSV delimiters, as well as other parameters), save all tables extracted from XML in one file or in several output files.

	Download Advanced XML Converter