· Web viewManual method doesn’t allow to use the model for improving the abstraction layer by...

Smarty-objects for heterogeneous data sources in situation-oriented databases

Submitted: August 28, 2013; Accepted: September 28, 2013; Published: December 9, 2013. UDC 004.65

Subject MSC mathematical classification: 90C35, 90C39 Subject ACM computer classification: I.6.5

AbstractThere are currently actively developing NoSQL type of databases and as a part of it

document-oriented databases. XML-database solves specific problems in the processing and storage of data in XML and JSON as documents. This article focuses on NoSQL data-bases, and specifically SODB (Situationally-oriented databases), and development tools for its processing data using Smarty-objects. The article proposes a model for automatic gener-ation content from the JSON- sources and automatically templates data using Smarty tem-plate engine. SODB has no special tools for processing JSON-documents, it is necessary to develop tools for processing such data sources. This article operates gained popularity tool-kits server templating Smarty, and JSON-sources. At the core of the database is a dynamic model, which is processed by the interpreter of dynamic models. We consider two options for handling JSON-data sources first of these is the Smarty-objects, the second Smarty-ar-rays. As a result, at the conceptual layer are encouraged to develop tools to automatically create objects and arrays Smarty for loading and processing of its data. For SODB formed concept of Smarty-objects, which proposes a dynamic model to equip a special model of Smarty-objects during its interpretation tied to states of the model objects are automatically created, supplemented the data is processed and the resulting generated content. Discussed filling and filtering data in Smarty-objects and its automatic creation. An example of using objects Smarty that is considered as an example of the source data and the user interface, as well as the dynamic model of the underlying example of a Web application. At the final stage of the work shows a diagram for the templating of the finished data from Smarty-ob-ject. Finally, in article discuss the contribution of the work in the direction of developing SODB. For this article introduces new Smarty-elements for dynamic model. These ele-ments are processed by the interpreter automatically, without manual programming of rou-tine operations.

Keywords: NoSQL, interpretation, XML databases, JSON, dynamic model, Smarty.

Cloud Journal of Science and Technology (www.cloudjcup.com) 1(1) (2014), #C1 1

Mironov V. V. Doctor of Technical Sciences, prof.

dep. ACS, FSEE HPE Ufa State Aviation Technical University

450000, Ufa, st. Karl Marks, h. 12phone +79174290226,

e-mail: [email protected]

Gusarenko A. S. postgraduate, junior researcher.FSEE HPE Ufa State Aviation

Technical University 450000, Ufa, st. Karl Marks, h. 12

phone +79174290226, e-mail: [email protected]

mailto:[email protected]

mailto:[email protected]

1 IntroductionBy developing the concept of situationally-oriented databases (SODB) proposed

in (Mironov & Gusarenko, 2012a; Mironov & Gusarenko, 2012b), it should be noted that the basis of NoSQL databases (Benzaken et al., 2013; Takahashi et al., 2013; Kobayashi et al., 2011; O'Connor, Merriman & Nelson, 2010) are different types of sources (Strauch & Kriha, n.d.; Mironov & Gusarenko, 2012b; Mironov & Gusarenko, 2012a; Gusarenko, 2013; Mironov & Gusarenko, 2013a; Mironov & Gusarenko, 2013b). The current situation is such that the databases have in their structure JSON-type sources, it is an array or data object is not only used for data transferring between server and client web applications, and serves as the basis of databases. This format is an optional method of storing data on the server, it can be used to describe objects and complex hierarchical data structures, but SODB in your toolbox, do not have a tangible approach to connecting and processing sources of this type, as well as algorithms, the specific language and the built-in display methods of content to a user.

If the XML database to display content used XSLT-templating technology, the question of sources for JSON representation of the content will remain open through Smarty template engine gained popularity. Compiling PHP Smarty templates has basic and advanced features for displaying data structures such as arrays and objects, creation of templates has a structure similar to the PHP-program, as well as in the JSON-data de-scription similar to the description on the JavaScript-program.

In (Mironov & Gusarenko, 2012; Mironov & Gusarenko, 2013a) considered vari-ous aspects of the use of XML source and display dynamic content using XSLT, but not considered issues related to JSON and Smarty as a platform SODB. This led to the fact that now there are no special types of support for SODB to work with this functionality (Mironov & Gusarenko, 2012). This article considers questions of automatic content generation for associated JSON-objects and JSON-arrays with the states of the dynamic model SODB and mapping specification via Smarty model Web application.

2 Smarty-objects and Smarty-arrays for handling JSON-sourcesThis article is the development of work on the creation of tools, language tools

SODB (Mironov & Gusarenko, 2013a), which were developed by means of specs of dy-namic DOM-objects. In this case, there is a problem automatically create Smarty-ob-jects and filling them with content of JSON-sources. So as to create and handle new sources requires significant efforts, especially in an environment where JSON-source has a complex hierarchical structure, and SODB hasn’t implemented methods and ap-proaches to their treatment. Required to include in the model special elements that spec-ify a new type of source - JSON documents Fig. 1,2, in the process of interpretation, de-coding and loading into Smarty-objects/arrays. To use the resulting object / array in the state of the model is also required to provide elements of tpl-templates. To catch the re-sult output due to compile time are also required attributes indicating the resource type template with the path and name of the template. According to suggested approach in the model to conditions Smarty-elements are bound. Elements Smarty-objects are cre-ated when the state to which they are attached, it becomes the current one. Known ap-


Fig 2. The diagram dynamic model of specification JSON-documents

sta S0

J1 type=”json” path = "JSON/J1.json"docJ2 type=”json” path = "JSON/J2.json"doc

sta

sub

jmp

act

M

sta

jmp

A1 pass = "2"

act A2 pass = "2"

S1

S2

S2

S1

json J3 type=”json” path = "JSON/J3.json"

doc J4 type=”json” path = "JSON/J4.json"

Fig 1. The formation of Smarty-object based on information from the JSON-data sources

proach in comparison with the proposed consists in the specification of the template and programming of functions for processing JSON-sources in the program or subprogram. Manual method doesn’t allow to use the model for improving the abstraction layer by using typical operations of compound extraction and filtering data in processing JSON-sources and outputting the result using tpl-templates. In these circumstances, it is logical to equip by these functions SODB model:

• Elements in states of the dynamic model includes child Smarty-elements, child elements, the sources of which indicate loadable JSON-data and child elements re-ceivers – stored as a JSON-result;

• In the course of interpreting the dynamic model by means of the interpreter is an automatic generation Smarty-objects for the current states of the model and load JSON-data with the specified transformation.

Smarty-objects. Smarty object Fig. 3 are generated during interpreting the model and have a description of the programming language, filled with JSON-data, and then used in the tpl templates. Smarty object is the foundation for forming the resulting ob-ject based on information from the JSON-source. The resulting document Fig. 1 is

based on the extraction and filtering of the source document in relation to the resulting

source - the source document is a child.


sta S0

stasub M

sta

S1

S2

smt Sm0act A1 pass = "1"act A0 pass = "2"

act A2 pass = "1"

smt Sm1act A3 pass = "1"

act A4 pass = "1"

smt Sm2act A5 pass = "1"

act A6 pass = "1"

dom D1

dom D2

Fig 3. The diagram dynamic model of with the states, which are associated Smarty-objects

Smarty-arrays. The second feature, which has Smarty - the specification of asso-ciative arrays. That is why the resulting document represents the contents of confluence of two or more associative arrays, JSON data. In this case, defined data is extracted, fil-tered in according to the terms specified in the model. Using JSON-arrays and objects is provided by linguistic means (Mironov & Gusarenko, 2013a) and are justified, as there are realized by means of encoding / decoding of JSON-objects and arrays.

Model diagram in Fig. 3 provides for the use of a state with dynamic DOM-ob-jects (He & Zhai, 2013; Han, et al., 2014; Pokorný, 2013; Kaur & Rani, 2013) and Smarty-objects. Dynamic DOM-objects provide for automatic data loading XML-ori-gin, and facilitate the task specifications for processing such data, but don’t solve the problem of using JSON-content sources in situations of application. Therefore, a tool built into interpreter of the dynamic model (Mironov & Gusarenko, 2012b) implements the functionality of automatic loading and handling in the states of the dynamic model JSON-content along with the approach implemented in (Mironov & Gusarenko, 2013a) for processing XML-data sources.

3.1. Concept of Smarty-objects

Smarty elements. To, the interpretation automatically created Smarty-objects, which are loaded JSON-data associated with the states of the model should be provided in the model Smarty and JSON-elements. Elements JSON (Kobayashi, et al., 2011) de-scribe the source of the data received for processing. For the treatment of conditions specified in the data provided for in the model Smarty-elements and nested data sources into them. According to these specifications will add functionality to the interpreter to create a Smarty-objects, which allows you to create these objects when the parent be-comes the current state and remove them when the state no longer be current. This will reduce the complexity of the preparation Smarty-objects and arrays when handling JSON, as well as set the model transformation operations JSON-data for further pro-


smtsrc X1 type = "json" path=”J1”

sta SS1

smtsrc D1 type = "array" path=”J2”S2

smtsrc F1 type = "func" path=”J3”S3

Fig 4. Diagram dynamic model of in which Smarty-objects are defined using Smarty-elements

cessing to specify procedures for processing JSON. Specification example is shown in Fig. 4.

For specifications Smarty-objects need to enter a special symbol , denoting a graphical notation model description, it specifies the name of the object and the re-quired template to display the result. In the description of the source , the previ-ously entered for the sources of dynamic DOM-objects (Mironov & Gusarenko, 2012a; Mironov & Gusarenko, 2012b) add task construction source type type = "json" and type = "array", as well as links on the path to which the interpreter retrieves required content. Further implementation of the idea to reduce the complexity of the issues requires sub-sequent studies to provide the data sources.

JSON-content into Smarty-objects. Connecting JSON sources along with XML content actual if we consider this problem based on the fact that in comparison with XML it has a much more compact form of writing, the exchange of the results of executing HTTP-request object using XmlHttpRequest, technology used to implement AJAX, between client and the server, or just on the server. And it can be an array or an object in memory that is loaded via object XmlHttpRequest. If we use the JSON-content from the server, requires specification of the path on which the file resides. In such con-ditions SODB requires tools capable to handle and display the JSON documents stored in memory and the external memory. To illustrate the proposed concept as a practical example of using Smarty-objects provides an example solving the problem of using JSON, similar to that given in (Mironov & Gusarenko, 2012b) with the solution of task displaying information about students and submission subjects from SODB by using dy-namic DOM-objects (Dekeyser, Hidders & Paredaens, 2004; Herskovits & Chen, 2008; Jea, Chang & Chen, 2009; Kudrass & Conrad, 2002; Nassis, Dillon, Rajagopalapillai & Rahayu, 2006; Batory, 2006; Dejanovic, Milosavljevic, Perisic & Tumbas, 2010).

2.2. Example of using Smarty-objects

To illustrate the proposed concept as a practical example of using Smarty-objects provides an example solving the problem of using JSON, similar to that given in (Mironov & Gusarenko, 2012b) with the solution of task displaying information about students and submission subjects from SODB by using dynamic DOM-objects (Dekeyser, Hidders & Paredaens, 2004; Herskovits & Chen, 2008; Jea, Chang & Chen,


smt

src

2009; Kudrass & Conrad, 2002; Nassis, Dillon, Rajagopalapillai & Rahayu, 2006; Ba-tory, 2006; Dejanovic, Milosavljevic, Perisic & Tumbas, 2010).

Benchmark data. Data about students and passing subjects are stored in files JSON - stud.json, predm.json, sdacha.json, are located in the JSON server SODB. Fig-ure 5 shows the conceptual model of these documents and test instances of their con-tents. Document stud.json (Fig. 5a) in the root object "Students" can contain multiple nested instances of "student" with the attributes of the "code" (code for the student) and "name" (last name, first name of the student), and the attribute "code" is an identifier. Instance of this document (see Fig. 5, a) contains information about the three students: Ivanov, Petrov and Sidorov. Similarly, the JSON-document predm.json (Fig. 5b) in the root of the object "object" can contain multiple nested instances of "object" with at-tributes "code" (code of the object) and "titles" (the name of the object), and the at-tribute "code" is an identifier. Model instance of this document (Djukic, Lukovic, Popovic & Ivancevic, 2013; Panach, Juristo & Pastor, 2013; Strosnider, Nandi, Ku-maran, Ghosh & Arsanjani, 2008) (see Fig. 2.10b) contains information about three sub-jects: "systemstheory", "mathlogic" and "cryptography." Document sdacha.json (Fig. 5c) in the root object "Delivery" can contain multiple nested instances of "surrender", the relevant student sitting some particular subject, with the attributes of "codeSt" (code for the student), "codePr" (code of the object ) and "evaluation" (student's grade on the subject), and a pair of attributes "codeSt, codePr" is a composite identifier. Model in-stance of this document (see Fig. 5c) contains information about the five passings exam: three passings exam Ivanov and two Petrov's (Sidorov did not pass any subject).

User interface. The above example is the mapping of data generated by Smarty-object based on JSON-data. The initial state of the request form displays the names of the student for whom using Smarty-object data is requested from all passings the se-lected student. The result of the selection is displayed in the browser. Fig. 6 shows ex-amples of the forms that are generated by the choice of the student, in this case the se-lected student Ivanov, who has a choice of 3 results obtained with the passing scores on the "systems theory", " mathlogic " and "cryptography". The first form of Fig. 6 shows a list of students in a situation of "StudentsList" available in JSON-file, the second form is a result of pressing the "SelectStudent" button in a situation of "SelectedStudent". Re-turn to the previous situation occurs when you press the button to the "StudentsList". Button "ToSubject" in both forms are provided to move to the items and request infor-mation from the JSON-source to output the number of passings to the chosen subject. Similar forms are also provided for situations "SubjectsList" and "SelectedSubjects". To select one of the items provided for the radio buttons. The purpose of this interface the user to send the appropriate forms in each of the situations, as well as presentation of data connection information from the JSON-sources.


Fig 6. Examples of form views formed on the basis of test data from the JSON-source using Smarty-object

code = "s01"

student

fio = "Ivanov"

code = "s02"fio = "Petrov"

code = "s03"fio = "Sidorov"

code = "p01"

subject

name = "System theory"

code = "p02"name = "mathlogic"

code = "p03"name = "Cryptography"

codeSt = "s01"

passing

codeSb = "p01"scoring = "5"

codeSt = "s02"codeSb = "p01"scoring = "4"




json json json

Students Subjects Passings

spec = "ACS"group = "01"

@attributescode = "s01"spec = "ACS"group = "01"

@attributescode = "s02"spec = "PI"group = "02"

spec = "PI"group = "02"


spec = "ACS"Group = "03"

@attributescode = "p01"

spec = "ACS"cycle = "OND"



spec = "ACS"cycle = "SD"

spec = "ACS"cycle = "SD"


spec = "PI"cycle = "SD"

spec = "PI"cycle = "SD"

@attributescodeSt = "s01"codeSb = "p01"





a) b) c)Fig 5. Data for forming Smarty-object based on the test instances of JSON-objects

Dynamic model. The basis of the application is a model of a new layer of ab-

straction, which is equipped by new elements and attributes.The dynamic model of this

application was considered in (Mironov & Gusarenko, 2012a; Mironov & Gusarenko, 2012b), the main distinguishing features of the Web application model is described in this paper is to define the JSON-documents with elements of "doc", before using this structure describes only the XML-documents in external memory server SODB. Intro-duced a new type of specification tpl-templates Smarty to display objects.Examples of these agents are shown in Fig. 7 in a "Students-Subjects". The design, denoted by the symbol , tells the interpreter that the template is requested in the sub-state "Selected-


sta Students-Subjects

Students-Subjectsdiv

StudentsList path = "JSON/stud.json"doc

Acadachievements path = "JSON/sdacha.json"

SubjecsList path = "JSON/predm.json"

StudentsList path = "TPL/stud.tpl"tpl

Studentsacadachievement path = "TPL/uspevstud.tpl"tpl

SubjecsList path = "TPL/predm.tpl"tpl

SubjectAcadachievements path = "TPL/uspevpredm.tpl"tpl

sta Students

Students

sub

jmp Subjectsbtn Subjects caption = "To subjects"

act

div

Students-Subjects

sta

Students

Subjects

jmp

Subjects

btn Students caption = "To students"div

Students pass = "2"rcv Echo method = "label" value = "Students"

act Subjects pass = "2"rcv Echo method = "label" value = "Subjects"

codeSt mode = "prolog"att

rcv

sta StudentsListStudentssub

jmp SelectedStudentbtn Studentsacadachievement

caption = "Studentsacadachievement"

smt StudentsListsrc StudentsList type = "array"

Echo pass = "2" method = "tpl" tpl = "StudentsList"

sta SelectedStudent

src codeSt method = "post"

jmpbtn Students caption = "To students"StudentsList

rcv

smt Studentsacadachievement

Echo pass = "2" method = "tpl" tpl = "Studentsacadachievement"

src StudentPassings mcrLib = "Sources"

codeSb mode = "prolog"att

rcv

sta SubjectsListSubjectssub

jmp SelectedSubjectbtn SubjectAcadachievements

caption = "SubjectAcadachievements"

smt SubjectsListsrc SubjectsList type = "array"

Echo pass = "2" method = "tpl" tpl = "SubjectsList"

sta SelectedSubject

src codeSb method = "post"

jmpbtn Subjects caption = "To subjects"

rcv

smt SubjectAcadachievements

Echo pass = "2" method = "tpl" tpl = "SubjectAcadachievements"

src SubjectPassings mcrLib = "Sources"

SubjectsList

doc

doc

Fig 7. Dynamic web-application model equipped with JSON-sources and Smarty-objects

Student" submodels "Students" demands the withdrawal of Smarty-object "Studademi-cachievement" using tpl-template "Studademicachievement", which is on the external memory in the folder templates Smarty TPL/uspevstud.tpl. Each Smarty-object may be one or more nested JSON-sources, in addition, they may be of different origin, for this type of data has been entered in the type which indicates where it can be accepted for processing content. The most common type of data is source used in the application, is an array, in the model it is referred to as the array. As extra type used in the application has decoded JSON-object in Smarty and output by the receiver content designates a symbol which provides for a new method of data output method = "tpl". Output tpl-method assumes output as tpl Smarty-object using the compiled template tpl.

Content model for loading Smarty-object. Content loaded into Smarty-object based on data JSON-sources. The data model is shown in Fig. 8 Data for download Smarty-object "StudentsList" for students to choose from a document doc "Stu-dentsList" link path = "JSON/stud.json". Information for loading into Smarty-object "SubjectsList" for students to choose from a document doc "SubjectsList" link path = "JSON/ predm.json". To form the final content (see Fig. 8 c, d), the information trans-

ferred in the situation of the selected students are selected by the student code and sub-


rcv

ject to these codes are selected as needed to execute the query for information delivery, such as the name of the student specialty group, the score for the situation "StudentSe-lected" (see Fig. 8 a, b), as to the situation "SubjectSelected" selected titles for more in-formation, cycle specials. Key elements can be moved in JSON-array of attributes, re-ferred to @attributes in this case the choice of may be produced by attributes in more detail is shown in (Fig. 5 a, b, c).

Using tpl-templates to display content Smarty-object The essence use of tpl-patterns is Smarty-forming object and bring it to the final status of content, the desired content, this means that in the situation when all processing procedures are completed and the content is adjusted to the level desired result is its output. Displays results in the client's browser is done by rendering the object in the tpl-template. Tpl-template con-tains the specifications in the programming language PHP. For interpreter model struc-ture used instead stylesheet construction tpl, which specifies the name of the template to be used for content display. Method tpl used as an alternative method for xslt-transfor-mation. Initial situation contains a list of students, among which we selected the correct student, for detailed information on delivery and subjects. List of students formed on the basis of document doc:StudentsList. For the initial situation "Students" there is a tem-plate tpl:StudentsList. The template is compiled, showing each student conceptual model compilation template tpl:StudentsList shown in Fig. 9a. Student code can be se-lected from both the attributes and properties of the object "Student".

In carrying out each of a FOREACH template element is added to INPUT, which contains the identification information of each student. INPUT element is of type type = "radio", which is displayed in the browser as a set of radio buttons to select one of the students and the button BUTTON to move to the next state "SelectedStudent" reflects the information on the performance of the selected student for this situation, there is a template tpl:Studademicachievement.

Template tpl:Studademicachievement displays the contents of Smarty-object for the selected student conceptual model template compilation is shown in Fig. 9b. The re-sult of the compilation of the second template "Studademicachievement" is a list of ele-ments to partition LI donations in each subject separated from the assessment for each subject triple dash.


json

code = "att:codeSt"student

fio

codeStpassing

scoring codeSb

codesubject

name

=

=

specgroup

cyclespec

json

code = "att:codeSb"subject

name

codeSbpassing

scoring codeSt

codestudent

fio

=

=

cyclespec

specgroup

code = "s01"student

fio = "Ivanov"

json

codeSt = "s01"passing

codeSb = "p01"passing = "5"





code = "p01"subject


code = "p02"subject

name = "Mathlogic"

code = "p03"предмет

name = "Criptography"



spec = "ACS"cicle = "SD"

spec = "PI"cicle = "SD"

json

code = "p01"subject




code = "s01"student

fio = "Ivanov"



code = "s02"student

fio = "Petrov"



spec = "PI"group = "02"

a, b) c)Fig 8. Contents Smarty-object formed on the basis of information about students, subjects and submission from JSON-sources

json

Students

BUTTON name = "backpredmet" type = "submit"

checked = "checked"

tpl

[ 1 ]

B = "{$fio}"--- acievements:

tplSPAN Students

value = "To subjects"

To subjects

BRFORM

method = "post" action = "index.php" {FOREACH}

from = "$stud_output" item = "students"{FOREACH}

from = "$students.student" item = "student"INPUT

name = "codSt"

value = "{$student.code}" type = "radio"

{$student.fio}

BRBUTTON

name = "backpredmet" type = "submit"

Select student

code = "s01"

student

fio = "Ivanov"spec = "ACS"group = "01"


json

code = "att:codeSt"student

fio

codeStpassing

scoring codeSb

codesubject

name

specgroup

cyclespec

SPAN Students FORM

method = "post" action = "index.php" BUTTON

name = "student" type = "submit" value = "To subjects"

To subjects

{FOREACH} from = "$stud_output" item = "item"

LI = "{$item.name}"--- "{$item.ocenka}"

BUTTON name = "back" type = "submit"

To students list

a) b)Fig 9. Conceptual models compile time TPL sent to the browser based on the test data from the JSON-Smarty-object: a - Creating a list of students; b - Creating a list of selected student passings


ConclusionIn this paper we consider the problem of using JSON-content in situationally-ori-

ented databases, and introduced into the dynamic model needed for the process forma-tion of JSON-content. Formed the essence of the concept, which is to use the model of a higher level of abstraction for designing applications using states in Smarty-objects to display the JSON-function results. The examples described and used in the model are considered, excluding the particular implementation in the server platform.

Concept also provides bind Smarty-objects to the states of the dynamic model, and their creation, the interpretation is performed automatically, it loads filtering and purification, as well as merging with the defined conditions. JSON-final result is dis-played using a prepared tpl-template. The main distinguishing features of this concept are:

• The elements of the state of the dynamic model of situational-oriented data-bases contain the associated Smarty-objects specifiable by means of introduced in this paper, smarty-elements;

• During interpretation of the dynamic model objects are created automatically, JSON-loaded content, then in accordance with the specified processing conditions formed the resulting content;

• Dynamic model supplemented by additional means for connecting and pro-cessing JSON-content situationally-oriented database. According with this concept will lead to the fact that the analyst without involving a programmer will be able to design applications without manual programming, connecting in a dynamic model of JSON-sources and specify the conditions for them to get the result of processing the content and set the template to display it. Further development and implementation of this con-cept is related to a software implementation on a platform HSMI, to handle HSM dy-namic model SODB.

AcknowledgmentsThis work was supported by RFBR grant 10-07-00167.

ReferencesBatory, D. (2006). Multilevel models in model-driven engineering, product lines, and

metaprogramming. Ibm Systems Journal, 45(3), 527–539.Benzaken, V. (2013). Static and dynamic semantics of NoSQL languages (pp. 101–

113). Presented at the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages POPL’ 2013, Rome, Italy.

Chen, Y. J., & Huck, G. (2001). On the evaluation of path-oriented queries in document databases. Database and Expert Systems Applications, 2113, 953–962.

Dejanovic, I., Milosavljevic, G., Perisic, B., & Tumbas, M. A. (2010). Domain-Specific Language for Defining Static Structure of Database Applications. Computer Sci-ence and Information Systems, 7(3), 409–440.

Dekeyser, S., Hidders, J., & Paredaens, J. (2004). A transaction model for XML data-bases. World Wide Web-Internet and Web Information Systems, 7(1), 29–57.


Djukic, V., Lukovic, I., Popovic, A., & Ivancevic, V. (2013). Model Execution: An Ap-proach based on extending Domain-Specific Modeling with Action Reports. Computer Science and Information Systems, 10(4), 1585–1620.

Gusarenko, A. S. (2013). Handling XML-documents in situationally-oriented databases based on dynamic DOM-objects (thesis abstract). Ufa State Aviation Technical University, Ufa.

Gusarenko, A. S., & Mironov, V. V. (2013a). Algorithmic and and linguistic support of situationally-oriented databases based on dynamic DOM-objects (Vol. 1, pp. 119–122). Presented at the Proc. 8th Workshop of winter school postgraduates and young researchers, Ufa: USATU.

Gusarenko, A. S., & Mironov, V. V. (2013b). Profiling algorithm of situationally-ori-ented database based on dynamic DOM-objects (Vol. 1, pp. 115–118). Presented at the Proc. 8th Workshop of winter school postgraduates and young researchers, Уфа: УГАТУ.

Han, W. (2014). Leveraging spatial join for robust tuple extraction from web pages (Vol. 261, pp. 132–148). Presented at the Information Sciences.

Herskovits, E. H., & Chen, R. (2008). Integrating Data-Mining Support into a Brain-Im-age Database Using Open-Source Components. Advances in Medical Sciences, 53(2), 172–181.

He, W., & Zhai, J. (2013). Application of the indent conversion based on XML and DOM (Vol. 1, pp. 411–413). Presented at the Proceedings - 2013 International Conference on Computational and Information Sciences (ICCIS’ 2013).

Jea, K. F., Chang, T. P., & Chen, S. Y. (2009). A Semantic-Based Protocol for Concur-rency Control in DOM Database Systems. Journal of Information Science and Engineering, 25(5), 1617–1639.

Kaur, K., & Rani, R. (2013). Modeling and querying data in NoSQL databases (pp. 1–7). Presented at the Proc. of IEEE International Conference on Big Data 2013, Santa Clara, CA, United States.

Kobayashi, N., Ishii, M., Takahashi, S., Mochizuki, Y., Matsushima, A., & Toyoda, T. (2011). Semantic-JSON: a lightweight web service interface for Semantic Web contents integrating multiple life science databases. Nucleic Acids Research, 39, W533–W540.

Kudrass, T., & Conrad, M. (2002). Management of XML documents in object-relational databases (Vol. 2490, pp. 210–227). Presented at the Xml-Based Data Manage-ment and Multimedia Engineering-Edbt 2002 Workshops.

Mironov, V. V., & Gusarenko, A. S. (2012a). Dynamic DOM-objects in the situation-ally-oriented databases: a linguistic and algorithmic support of data sources. Vest-nik UGATU, 16(3), 167–176.

Mironov, V. V., & Gusarenko, A. S. (2012b). Situationally-oriented databases: the con-cept of managing XML-data based on dynamic DOM-objects. Vestnik UGATU, 16(3), 159–172.

Nassis, V., Dillon, T. S., Rajagopalapillai, R., & Rahayu, W. (2006). An XML Docu-ment Warehouse model (Vol. 3882, pp. 513–529). Presented at the Database Sys-tems for Advanced Applications, Proceedings.

O’Connor, B. D., Merriman, B., & Nelson, S. F. (2010). SeqWare Query Engine: stor-


ing and searching sequence data in the cloud. Bmc Bioinformatics, 11, 9.Panach, J. I., Juristo, N., & Pastor, O. (2013). Including Functional Usability Features in

a Model-Driven Development Method. Computer Science and Information Sys-tems, 10(3), 999–1024.

Pokorný, J. (2013). New database architectures: Steps towards big data processing (pp. 3–10). Presented at the Proceedings of the IADIS International Conference Intel-ligent Systems and Agents 2013 ECDM’ 2013, Prague, Czech Republic.

Sladic, G., Milosavljevic, B., Konjovic, Z., & Vidakovic, M. (2011). Access Control Framework for XML Document Collections. Computer Science and Information Systems, 8(3), 591–609.

Strauch, C., & Kriha, W. (n.d.). NoSQL databases. Retrieved from http://www.christof-strauch.de/nosqldbs.pdf

Strosnider, J. K., Nandi, P., Kumaran, S., Ghosh, S., & Arsanjani, A. (2008). Model-driven synthesis of SOA solutions. Ibm Systems Journal, 47(3), 415–432.

Sudarsan, R., & Gray, J. (2006). Metamodel search: Using XPath to search domain-spe-cific models. Journal of Research and Practice in Information Technology, 38(4), 337–351.

Takahashi, K. (2013). Design and evaluation of lifelog mashup platform with NoSQL database (pp. 133–139). Presented at the Proc. of 15th International Conference on Information Integration and Web-Based Applications and Services, iiWAS’2013, Vienna, Austria.

Tang, N., Yu, J. X., Wong, K. F., & Li, J. X. (2008). Fast XML structural join algo-rithms by partitioning. Journal of Research and Practice in Information Technol-ogy, 40(1), 33–53.


· Web viewManual method doesn’t allow to use the model for improving the abstraction layer by...

Documents

Transcript of · Web viewManual method doesn’t allow to use the model for improving the abstraction layer by...