International Journal of Computer Trends and Technology (IJCTT) volume4Issue8August 2013

ISSN: 2231-2803 http://www.ijcttjournal.org Page 2805

Mashup Tool for Automatic Query Generation for
Data Web
K Annapurna Madhavi
1
, Prof.S.V.Achutha Rao
2

1
Pursuing M.Tech(CSE), Vikas College of Engineering and Technology, Nunna, Vijayawada.Affliated to JNTUK, Kakinada,
A.P., India
2
S.V. Achuta Rao is working as a Professor & Head, Department of CSE at Vikas College of Engineering and Technology ,
Nunna, Vijayawada, India.



Abstract : In real world we know the people who dont know
about that system are called as computer illiterates these people
doesnt know about the system and applications if any
application that is giving some services to them that they dont
know about the Query language of application which can help
to application in providing service and here if anything that
they want extra other than that service then they need to face
problem and to overcome this problem we are proposing this
solution that provides the custom defined services in this
proposed approach We present a query formulation language
(called MashQL) in order to easily query and fuse structured
data on the web. Here it is very usefull for the people who are
not having at having technical knowledge and here they are
having the option to get their own service by creating the
custom services by them own. Mashups are applications that
aggregate functionality, presentation, and/or contents from
existing sources to create a new application. Contents are
usually generated either using web feeds or an application
programming interface (API). Both approaches have limitations
as web feeds do not provide powerful data models for complex
data structures and lack powerful features of database systems.
On the other hand, APIs are usually limited to a specific
application thus requiring different implementations for each of
the sources used in the mashups. We propose a query based
aggregation of multiple heterogeneous data sources by
combining powerful querying features of XQuery and SPARQL
with an easy interface of a mashup tool for data sources in XML
and RDF. Our mashup editor allows for automatic generation
of mashups with an easy to use visual interface.

Index Terms Query Formulation, Semantic Web, Data
Web, RDF, SPARQL, Indexing Methods, Query
Optimization, Mash up.

I-INTRODUCTION
The amount of structured and semi-structured data available
on the internet has been steadily increasing and many
companies are now providing their data publicly accessible
through APIs, querying interfaces, RESTful web services, or
data services .
The rapid growth of Web 2.0 technologies has motivated
many big companies to make their contents reusable for the
creation of new applications using existing data. Many
publicly accessible APIs such as Google Maps3, Amazon4
and DBPedia5 are available for the users to generate their
own new applications using their existing contents. A typical
example of such a scenario is the combination of the list of
hotels in a particular city with Google Maps to generate an
interactive map of hotels or data collected fromseveral news
sites and merged together to provide a single access point to
the user. Mashups are web applications that consume the
available data fromthird parties and combine/reuse themto
build a new application. Mostly the contents are in the form
of web feeds or APIs. All the contents are combined either
on client side using clientside scripts or on server-side using
some available server-side technology such as ASP. JSP, etc.
Mashups are different from traditional web applications
because they are usually dynamically created to serve a very
specific and short lived task. Several mashup editors have
been launched to encourage people to build new applications
using the massive amount of publicly available contents.
Yahoo Pipes6, Google Mashups7 and IBM Mashup Center8
are a few examples of the popular mashup editors. However,
the limitation of existing mashup editors is that they focus
only on web feeds or APIs. These web feeds can represent
simple information but lack the capability to represent or
query data items provided by querying interfaces or data
services . On the other hand, APIs are usually limited to a
specific application thus requiring different implementations
for each of the sources used in the mashups. Currently, the
development of data mashups to deal with complex data
structures requires strong programming skills making
mashups hard to create for novice users. We utilize the
concept of data mashups and use it to dynamically integrate
heterogeneous web data sources by using the extension of
XQuery proposed in . All the available data sources over the
internet are considered as a huge database and each data
International Journal of Computer Trends and Technology (IJCTT) volume4Issue8August 2013

ISSN: 2231-2803 http://www.ijcttjournal.org Page 2806


source is considered as a table. Data mashups can generate
queries in extended XQuery
syntax and can execute the sub-queries on any available data
source contributing to the mashup. XML and RDF are the
prevailing data formats for web data sources. To query these
data sources, one can use XQuery and SPARQL their
respective query languages. The novelty of our tool is that it
integrates the powerful features of database querying into a
data mashup tool. It provides an easy to use interface of a
mashup editor to generate complex queries visually for the
integration of a multitude of distributed autonomous, and
heterogeneous data sources.
Mashups demonstrate a more programmatic, workflow-like
integration approach, complementary to the query- and
search-based data integration approaches. In fact, mashups
are massively built on the idea of reusing and combining
existing services so that they can also use existing search
engines and query services. However, current mashups are
mostly very simple and do not yet exploit the full potential of
workflowlike data integration, e.g. as needed for enterprise
applications or to analyze larger sets of web data. Hence, we
see the need for a more powerful workflow-like data fusion
approach which preserves mashup features like Web2.0
GUIs, support for reuse and fast development. Providing
such an approach incurs several challenges, including the
definition of
an architecture supporting mashups for integration at three
levels, i.e. data, application, and presentation level.
Furthermore, a powerful workflow and programming model
is needed supporting the execution of existing web services
and generic services (or operators) for information extraction,
entity search, database queries, and object matching. The set
of usable services and data sources should be listed and
semantically described in a metadata repository similar as
proposed in . A limiting factor for interactive mashups is
runtime. Hence, techniques are needed to solve more
complex integration tasks, e.g. involving query, search and
object matching of larger datasets, within a short time.
Here we are going to present an efficient and effective
tool for Query formulation language and it is called as
MashQL. The standerd of MashQL can be compared by that
fact that it combines all the assumption which was already
implemented to provide a effiecient Query formulation
tool.MashQl is a not a interface , it is a language and it
assumes that data should be schema free will be a core idea
behind design and development of MashQl. We taken web as
a Database and each data is in the form of table. Here we
assume there is no loss of generalityin context of web data.
Hence we can say that in this point of scenario MashQl
become a query which have involvement with number of
database. For illustrating MashQl we took RDF as a resource
for quering it because RDF is the most primitive data model.
When our technique will apply on this RDF successfully we
can map other data model like XML and many more on it. In
case of Relational database we will choose the SQL for
querying the data and here we are inviting the MashQL for
getting the user intended search and here the new thing we
are adding is that reducing the user burden and providing
efficient service to the end user.


II-MashQL SYSTEM ARCHITECTURE

A mashup application comprises three major components,
which are data level, process level, and presentation level .
The data level is mainly concerned with accessing and
integrating heterogeneous web data sources. These sources
can provide structured, semi-structured or unstructured data.
Existing data mashup tools cannot deal with structural and
semantic diversities of heterogeneous data sources. Recently,
the importance of using data mashups for data integration
using database oriented mashups has been realized. Inspired
by Yahoo pipes, there are a few attempts such as MashQL
and Deri Pipes to generate semantic queries from data
mashups. However, to the best of our knowledge, there exists
no data mashup tool which allows the user to formulate
queries over web data sources using their respective query
languages and at
the same time deals with the heterogeneity of the data
sources. Our tool is similar to MashQL and Deri Pipes, but
we focus on the XQuery extension of with additional support
of the SPARQL query language. Using our approach,
existing data integration support for mashups is further
enhanced to formulate a single query containing inside sub-
queries of different query languages to deal with
heterogeneous data integration.
The algorithmdoes not require the data to contain specific
information or tags, bellow screenshots represents the
procedure of a query formulation scenario.
MashQL Algorithm:

International Journal of Computer Trends and Technology (IJCTT) volume4Issue8August 2013

ISSN: 2231-2803 http://www.ijcttjournal.org Page 2807




The above screen shots represents the algorithmand here the
description of algorithmis following
Step1:
Here in step 1 if any end user wants a book for
download this is the main object he wants and the subject we
are providing in different ways
Step2:
Here we are going to provide an another option for taking his
object with out giving all credentials that he wants and here
this subject is called periodical subject
Step3:
Here again we are doing same thing as like in step2 and
here we are adding a filter for filtering the object step by step
Step4:
Here the way we are getting our object like a pot and crow
story here also we are doing same thing the benefit behind
this algorithm is that an end user doesnt know about the
object that either it exist in database or not so it annoying to
himto search by all his required credentials and also it is a
time consuming process here by doing like this end user feel
free and also accurate results will come as an object.
Step5:
Finally an end user gets an effective and accurate results of
the objective what he wants.

Example description :
Here in the above example the five steps are
illustrated as follows and here the Query formulation is done
by taking both subject and object of a query into
consideration. here in our example the main object of an end
user is book for download and the book is having lot of
properties i.e book name, author, publications etc..
we are providing a subject that is book name which
is main constraint of the query if the no of books are more
with that name by differed in author and publications so it
again make a sub-constraint for getting accurate results and
here the user chooses the next thing that is author of a book
again it displays the different kinds of authors for that book
and different types of publications of that book in this way
the required object can get accurately by the end user.

The main window is divided into three panels, namely data
source selection, mashup editor, and query results.
Data Source Selection. All available/registered data services
will be shown in the left panel. Data services can be arranged
in different categories based on their functionality as shown
in Figure in the left top corner. This categorization is based
on metadata provided while registering a data source.
Mashup Editor. The central panel in Figure is the mashup
editor. The user can select any data service from the list and
can easily drag and drop it into the mashup editor. Each data
service describes its available data source, its functionality
and schema (if provided) which help the user to select the
most suitable data service. Once data sources have been
selected, several data operations can be applied to generate
the results. The operations can be selected from the list
shown in the left bottom corner of Figure . The mashup
editor has both a design view and a querying interface for
generating mashups. The design view provides an easy
graphical interface while the querying interface is used by an
expert user to write queries in the extended XQuery syntax
described in .
Queries Generation. Once the user has selected the data items
required froma particular data source, data results can be
constructed by dragging and dropping the selected items into
the result box. An extended XQuery expression will be
generated with subqueries in SPARQL or XQuery depending
on the type of the selected data sources,
the mashup editor after integrating XML and RDF data
sources. Hence, the query contains a SPARQL query as a
sub-query inside XQuery. For the creation of the queries
fromthe graphical interface we use the approach.

ALGORITHM DEMO

FOR
$a i n doc ( h t t p : / / WISIRISFuzzySearch / Li c e
n s e . xml ) / agreement ,
$b in SPARQLQuery (SELECT?Availability?
ExecutionTime WHERE

{
? x <http : / /www.w3. org / 2001/sub #avai l >?
Availability
? x <http : / /www.w3.org / 2001/sub #QoS> ?
ExecutionTime
International Journal of Computer Trends and Technology (IJCTT) volume4Issue8August 2013

ISSN: 2231-2803 http://www.ijcttjournal.org Page 2808


}

RETURN

<Result>
<Service Title >{$a / t i t l e }</ Service Title>
<Requirement>{$a / requirement }</Requirement>
<Availability >{$b / availability }</ Availability >
<ExecutionTime>{$b/ExecutionTime}</ExecutionTim
e>
</Result>



III-IMPLEMENTATION

Implementation of MashQL is proposed by an online server
side Query maker. Here we took an example of Query
generator. Query generation means automatic generation of
query on server when a end user place some data it
automatically going to convert into most specific query. For
implementing this our system should have no of
functionality.
Some of the basic functionality we are going to describe
below.
1-The first one is MashQL language component.

2-The presentation part either user interface for end user.

3-Automatic background queries dispatching in order to
support MashQl when it communicate with RDF databases.

4-Translator module which translate formulated MashQl
query to SPARKAL and submit it for execution and the
formulated MashQl query stored into XML.

5- Resulting Module which should represent the outcome
after retrieval or merging of the submitted SPARKAL
query.According to need MashQL query also can be
published or customized.

.


System Model :



Fig- Implementation scenario of MashQL


When we implemented our MashQl architecture some of the
issues came across,we are going to discuss about those issue
here itself.
A. The first one and major issue in implementation of
MashQl is URI Normalisation. RDF data having
unknowingly URI which can inelegant the MashQL
queries.Thus it is responsibility of ours that we should
have to normalized the MashQL. The normalization
technique is based on the common namespace
repository. Ones those RDF do not belongs to that
namespace , than we have to normalized these RDF
for making our MashQl resultant Query elegant. But it
is not totally sure that query coming after URI
normalization should be elegant , it also can inelegant.

B. The second issue in implementation of MashQL is
verbalization .This issue is used for improving the
elegancy of mashQL.here we use verbalize or edit
mode.In this when a user moves the mouse over a
restriction , that user will get the edit modeand rest of
the restriction that point of time going to verbalise.
This phenomena made redability of query much closer
to naturel language. And it also help out the user to
what they searching for and what they actually needed.


C. Third issue in implementation of MashQL is Scalable
set. When we quering large database by using our
MashQl architecture the normal Drop Down list
becoming unscalable. Here we developed a scalable
list which is more effective and efficient than all
previous one.This Scalable list support search, auto
complete and ranked based or int the order of
ascending or descending. This list also having
properties of scrolling. This List firstly showing top
International Journal of Computer Trends and Technology (IJCTT) volume4Issue8August 2013

ISSN: 2231-2803 http://www.ijcttjournal.org Page 2809


100 result which are scrollable and next 100 to 200
after clicking on next button and those are also
scrollable .


We proposed a query formulation language, called MashQL.
We have specified four assumptions that a Data Web query
language should have, and shown how MashQL implements
all of them. The language-design and the performance
complexities of MashQL are fundamentally tackled. We have
designed and formally specified the syntax and the semantics
of MashQL, as a language, not merely a single-purpose
interface. We have also specified the query formulation
algorithm, by which the complexity of understanding a data
source (even it is schema-free) are moved to the query editor.
We addressed the challenge of achieving interactive
performance during query formulation by introducing a new
approach for indexing RDF data. We presented two different
implementation scenarios of MashQL and evaluated our
implementation on two large datasets.


IV-CONCLUSION

We provide a database oriented mashup tool for integrating
heterogeneous data sources with a visual interface which
allows for an easy definition of complex data mashups. This
tool can be used as plug-in for web applications to generate
powerful and efficient data integration mashups.In this
proposed systemof MashQL we used SPARKAL technique .
We have designed and formally specified the syntax and the
semantics of MashQL, as a language, not merely a single-
purpose interface. We have also specified the query
formulation algorithm, by which the complexity of
understanding a data source (even it is schema-free) are
moved to the query editor. We introduced here by
introducing a new approach for indexing RDF data. We
presented two different implementation scenarios of MashQL
and evaluated our implementation on two large datasets.this
technique is behave as a language better than the interface.


REFFERENCES

AltovaXMLSpy: http://www.altova.com/solutions/xquery-
tools.html (Feb. 2010)

StylusStudio:http://www.stylusstudio.com/xquery_editor.ht
ml (Feb. 2010)

Isparql: http://lod.openlinksw.com/isparql (Feb. 2010)

RDB2RDF: http://www.w3.org/2005/Incubator/rdb2rdf (Feb.
2010)

SPARQLExtensions:http://esw.w3.org/SPARQL/Extensions?
(Feb. 2010)

SparqlMotion: http://www.topquadrant.com/sparqlmotion
(Feb. 2010)

Yahoo Pipes: http://pipes.yahoo.com/pipes (Feb. 2010)

Abadi D, Marcus A, Madden S, Hollenbach K: Scalable
semantic web data management using vertical partitioning.
VLDB, 2007.

Athanasis N, Christophides V, Kotzinos D: Generating On
the FlyQueries for the Semantic Web. ISWC2004.

BEA Systems, Inc.: BEA AquaLogic Data Services
Platform -




AUTHORS PROFILE



K Annapurna Madhavi,
Pursuing M.Tech(CSE) from
Vikas College of Engineering
and Technology, Nunna,
Vijayawada. Affiliated to
JNTU-Kakinada, A.P., India


Prof S.V.Achutha Rao, is
working as an HOD of CSE
at Vikas College of
Engineering and Technlogy,
Nunna, Vijayawada,
Affliated to JNTU-
Kakinada, A.P., India